[mirror_qemu.git] / scripts / xml-preprocess.py

#!/usr/bin/env python3
#
# Copyright (c) 2017-2019 Tony Su
# Copyright (c) 2023 Red Hat, Inc.
#
# SPDX-License-Identifier: MIT
#
# Adapted from https://github.com/peitaosu/XML-Preprocessor
#
"""This is a XML Preprocessor which can be used to process your XML file before
you use it, to process conditional statements, variables, iteration
statements, error/warning, execute command, etc.

## XML Schema

### Include Files
```
<?include path/to/file ?>
```

### Variables
```
$(env.EnvironmentVariable)

$(sys.SystemVariable)

$(var.CustomVariable)
```

### Conditional Statements
```
<?if ?>

<?ifdef ?>

<?ifndef ?>

<?else?>

<?elseif ?>

<?endif?>
```

### Iteration Statements
```
<?foreach VARNAME in 1;2;3?>
    $(var.VARNAME)
<?endforeach?>
```

### Errors and Warnings
```
<?error "This is error message!" ?>

<?warning "This is warning message!" ?>
```

### Commands
```
<? cmd "echo hello world" ?>
```
"""

import os
import platform
import re
import subprocess
import sys
from typing import Optional
from xml.dom import minidom


class Preprocessor():
    """This class holds the XML preprocessing state"""

    def __init__(self):
        self.sys_vars = {
            "ARCH": platform.architecture()[0],
            "SOURCE": os.path.abspath(__file__),
            "CURRENT": os.getcwd(),
        }
        self.cus_vars = {}

    def _pp_include(self, xml_str: str) -> str:
        include_regex = r"(<\?include([\w\s\\/.:_-]+)\s*\?>)"
        matches = re.findall(include_regex, xml_str)
        for group_inc, group_xml in matches:
            inc_file_path = group_xml.strip()
            with open(inc_file_path, "r", encoding="utf-8") as inc_file:
                inc_file_content = inc_file.read()
                xml_str = xml_str.replace(group_inc, inc_file_content)
        return xml_str

    def _pp_env_var(self, xml_str: str) -> str:
        envvar_regex = r"(\$\(env\.(\w+)\))"
        matches = re.findall(envvar_regex, xml_str)
        for group_env, group_var in matches:
            xml_str = xml_str.replace(group_env, os.environ[group_var])
        return xml_str

    def _pp_sys_var(self, xml_str: str) -> str:
        sysvar_regex = r"(\$\(sys\.(\w+)\))"
        matches = re.findall(sysvar_regex, xml_str)
        for group_sys, group_var in matches:
            xml_str = xml_str.replace(group_sys, self.sys_vars[group_var])
        return xml_str

    def _pp_cus_var(self, xml_str: str) -> str:
        define_regex = r"(<\?define\s*(\w+)\s*=\s*([\w\s\"]+)\s*\?>)"
        matches = re.findall(define_regex, xml_str)
        for group_def, group_name, group_var in matches:
            group_name = group_name.strip()
            group_var = group_var.strip().strip("\"")
            self.cus_vars[group_name] = group_var
            xml_str = xml_str.replace(group_def, "")
        cusvar_regex = r"(\$\(var\.(\w+)\))"
        matches = re.findall(cusvar_regex, xml_str)
        for group_cus, group_var in matches:
            xml_str = xml_str.replace(
                group_cus,
                self.cus_vars.get(group_var, "")
            )
        return xml_str

    def _pp_foreach(self, xml_str: str) -> str:
        foreach_regex = r"(<\?foreach\s+(\w+)\s+in\s+([\w;]+)\s*\?>(.*)<\?endforeach\?>)"
        matches = re.findall(foreach_regex, xml_str)
        for group_for, group_name, group_vars, group_text in matches:
            group_texts = ""
            for var in group_vars.split(";"):
                self.cus_vars[group_name] = var
                group_texts += self._pp_cus_var(group_text)
            xml_str = xml_str.replace(group_for, group_texts)
        return xml_str

    def _pp_error_warning(self, xml_str: str) -> str:
        error_regex = r"<\?error\s*\"([^\"]+)\"\s*\?>"
        matches = re.findall(error_regex, xml_str)
        for group_var in matches:
            raise RuntimeError("[Error]: " + group_var)
        warning_regex = r"(<\?warning\s*\"([^\"]+)\"\s*\?>)"
        matches = re.findall(warning_regex, xml_str)
        for group_wrn, group_var in matches:
            print("[Warning]: " + group_var)
            xml_str = xml_str.replace(group_wrn, "")
        return xml_str

    def _pp_if_eval(self, xml_str: str) -> str:
        ifelif_regex = (
            r"(<\?(if|elseif)\s*([^\"\s=<>!]+)\s*([!=<>]+)\s*\"*([^\"=<>!]+)\"*\s*\?>)"
        )
        matches = re.findall(ifelif_regex, xml_str)
        for ifelif, tag, left, operator, right in matches:
            if "<" in operator or ">" in operator:
                result = eval(f"{left} {operator} {right}")
            else:
                result = eval(f'"{left}" {operator} "{right}"')
            xml_str = xml_str.replace(ifelif, f"<?{tag} {result}?>")
        return xml_str

    def _pp_ifdef_ifndef(self, xml_str: str) -> str:
        ifndef_regex = r"(<\?(ifdef|ifndef)\s*([\w]+)\s*\?>)"
        matches = re.findall(ifndef_regex, xml_str)
        for group_ifndef, group_tag, group_var in matches:
            if group_tag == "ifdef":
                result = group_var in self.cus_vars
            else:
                result = group_var not in self.cus_vars
            xml_str = xml_str.replace(group_ifndef, f"<?if {result}?>")
        return xml_str

    def _pp_if_elseif(self, xml_str: str) -> str:
        if_elif_else_regex = (
            r"(<\?if\s(True|False)\?>"
            r"(.*?)"
            r"<\?elseif\s(True|False)\?>"
            r"(.*?)"
            r"<\?else\?>"
            r"(.*?)"
            r"<\?endif\?>)"
        )
        if_else_regex = (
            r"(<\?if\s(True|False)\?>"
            r"(.*?)"
            r"<\?else\?>"
            r"(.*?)"
            r"<\?endif\?>)"
        )
        if_regex = r"(<\?if\s(True|False)\?>(.*?)<\?endif\?>)"
        matches = re.findall(if_elif_else_regex, xml_str, re.DOTALL)
        for (group_full, group_if, group_if_elif, group_elif,
             group_elif_else, group_else) in matches:
            result = ""
            if group_if == "True":
                result = group_if_elif
            elif group_elif == "True":
                result = group_elif_else
            else:
                result = group_else
            xml_str = xml_str.replace(group_full, result)
        matches = re.findall(if_else_regex, xml_str, re.DOTALL)
        for group_full, group_if, group_if_else, group_else in matches:
            result = ""
            if group_if == "True":
                result = group_if_else
            else:
                result = group_else
            xml_str = xml_str.replace(group_full, result)
        matches = re.findall(if_regex, xml_str, re.DOTALL)
        for group_full, group_if, group_text in matches:
            result = ""
            if group_if == "True":
                result = group_text
            xml_str = xml_str.replace(group_full, result)
        return xml_str

    def _pp_command(self, xml_str: str) -> str:
        cmd_regex = r"(<\?cmd\s*\"([^\"]+)\"\s*\?>)"
        matches = re.findall(cmd_regex, xml_str)
        for group_cmd, group_exec in matches:
            output = subprocess.check_output(
                group_exec, shell=True,
                text=True, stderr=subprocess.STDOUT
            )
            xml_str = xml_str.replace(group_cmd, output)
        return xml_str

    def _pp_blanks(self, xml_str: str) -> str:
        right_blank_regex = r">[\n\s\t\r]*"
        left_blank_regex = r"[\n\s\t\r]*<"
        xml_str = re.sub(right_blank_regex, ">", xml_str)
        xml_str = re.sub(left_blank_regex, "<", xml_str)
        return xml_str

    def preprocess(self, xml_str: str) -> str:
        fns = [
            self._pp_blanks,
            self._pp_include,
            self._pp_foreach,
            self._pp_env_var,
            self._pp_sys_var,
            self._pp_cus_var,
            self._pp_if_eval,
            self._pp_ifdef_ifndef,
            self._pp_if_elseif,
            self._pp_command,
            self._pp_error_warning,
        ]

        while True:
            changed = False
            for func in fns:
                out_xml = func(xml_str)
                if not changed and out_xml != xml_str:
                    changed = True
                xml_str = out_xml
            if not changed:
                break

        return xml_str


def preprocess_xml(path: str) -> str:
    with open(path, "r", encoding="utf-8") as original_file:
        input_xml = original_file.read()

        proc = Preprocessor()
        return proc.preprocess(input_xml)


def save_xml(xml_str: str, path: Optional[str]):
    xml = minidom.parseString(xml_str)
    with open(path, "w", encoding="utf-8") if path else sys.stdout as output_file:
        output_file.write(xml.toprettyxml())


def main():
    if len(sys.argv) < 2:
        print("Usage: xml-preprocessor input.xml [output.xml]")
        sys.exit(1)

    output_file = None
    if len(sys.argv) == 3:
        output_file = sys.argv[2]

    input_file = sys.argv[1]
    output_xml = preprocess_xml(input_file)
    save_xml(output_xml, output_file)


if __name__ == "__main__":
    main()
Commit	Line	Data
9b286e76 MAL	1	#!/usr/bin/env python3
	2	#
	3	# Copyright (c) 2017-2019 Tony Su
	4	# Copyright (c) 2023 Red Hat, Inc.
	5	#
	6	# SPDX-License-Identifier: MIT
	7	#
	8	# Adapted from https://github.com/peitaosu/XML-Preprocessor
	9	#
	10	"""This is a XML Preprocessor which can be used to process your XML file before
	11	you use it, to process conditional statements, variables, iteration
	12	statements, error/warning, execute command, etc.
	13
	14	## XML Schema
	15
	16	### Include Files
	17	```
	18	<?include path/to/file ?>
	19	```
	20
	21	### Variables
	22	```
	23	$(env.EnvironmentVariable)
	24
	25	$(sys.SystemVariable)
	26
	27	$(var.CustomVariable)
	28	```
	29
	30	### Conditional Statements
	31	```
	32	<?if ?>
	33
	34	<?ifdef ?>
	35
	36	<?ifndef ?>
	37
	38	<?else?>
	39
	40	<?elseif ?>
	41
	42	<?endif?>
	43	```
	44
	45	### Iteration Statements
	46	```
	47	<?foreach VARNAME in 1;2;3?>
	48	$(var.VARNAME)
	49	<?endforeach?>
	50	```
	51
	52	### Errors and Warnings
	53	```
	54	<?error "This is error message!" ?>
	55
	56	<?warning "This is warning message!" ?>
	57	```
	58
	59	### Commands
	60	```
	61	<? cmd "echo hello world" ?>
	62	```
	63	"""
	64
65	import os
66	import platform
67	import re
68	import subprocess
69	import sys
70	from typing import Optional
71	from xml.dom import minidom
72
73
74	class Preprocessor():
75	"""This class holds the XML preprocessing state"""
76
77	def __init__(self):
78	self.sys_vars = {
79	"ARCH": platform.architecture()[0],
80	"SOURCE": os.path.abspath(__file__),
81	"CURRENT": os.getcwd(),
82	}
83	self.cus_vars = {}
84
85	def _pp_include(self, xml_str: str) -> str:
86	include_regex = r"(<\?include([\w\s\\/.:_-]+)\s*\?>)"
87	matches = re.findall(include_regex, xml_str)
88	for group_inc, group_xml in matches:
89	inc_file_path = group_xml.strip()
90	with open(inc_file_path, "r", encoding="utf-8") as inc_file:
91	inc_file_content = inc_file.read()
92	xml_str = xml_str.replace(group_inc, inc_file_content)
93	return xml_str
94
95	def _pp_env_var(self, xml_str: str) -> str:
96	envvar_regex = r"(\$\(env\.(\w+)\))"
97	matches = re.findall(envvar_regex, xml_str)
98	for group_env, group_var in matches:
99	xml_str = xml_str.replace(group_env, os.environ[group_var])
100	return xml_str
101
102	def _pp_sys_var(self, xml_str: str) -> str:
103	sysvar_regex = r"(\$\(sys\.(\w+)\))"
104	matches = re.findall(sysvar_regex, xml_str)
105	for group_sys, group_var in matches:
106	xml_str = xml_str.replace(group_sys, self.sys_vars[group_var])
107	return xml_str
108
109	def _pp_cus_var(self, xml_str: str) -> str:
110	define_regex = r"(<\?define\s(\w+)\s=\s([\w\s\"]+)\s\?>)"
111	matches = re.findall(define_regex, xml_str)
112	for group_def, group_name, group_var in matches:
113	group_name = group_name.strip()
114	group_var = group_var.strip().strip("\"")
115	self.cus_vars[group_name] = group_var
116	xml_str = xml_str.replace(group_def, "")
117	cusvar_regex = r"(\$\(var\.(\w+)\))"
118	matches = re.findall(cusvar_regex, xml_str)
119	for group_cus, group_var in matches:
120	xml_str = xml_str.replace(
121	group_cus,
122	self.cus_vars.get(group_var, "")
123	)
124	return xml_str
125
126	def _pp_foreach(self, xml_str: str) -> str:
127	foreach_regex = r"(<\?foreach\s+(\w+)\s+in\s+([\w;]+)\s\?>(.)<\?endforeach\?>)"
128	matches = re.findall(foreach_regex, xml_str)
129	for group_for, group_name, group_vars, group_text in matches:
130	group_texts = ""
131	for var in group_vars.split(";"):
132	self.cus_vars[group_name] = var
133	group_texts += self._pp_cus_var(group_text)
134	xml_str = xml_str.replace(group_for, group_texts)
135	return xml_str
136
137	def _pp_error_warning(self, xml_str: str) -> str:
138	error_regex = r"<\?error\s\"([^\"]+)\"\s\?>"
139	matches = re.findall(error_regex, xml_str)
140	for group_var in matches:
141	raise RuntimeError("[Error]: " + group_var)
142	warning_regex = r"(<\?warning\s\"([^\"]+)\"\s\?>)"
143	matches = re.findall(warning_regex, xml_str)
144	for group_wrn, group_var in matches:
145	print("[Warning]: " + group_var)
146	xml_str = xml_str.replace(group_wrn, "")
147	return xml_str
148
149	def _pp_if_eval(self, xml_str: str) -> str:
150	ifelif_regex = (
151	r"(<\?(if\|elseif)\s([^\"\s=<>!]+)\s([!=<>]+)\s\"([^\"=<>!]+)\"\s\?>)"
152	)
153	matches = re.findall(ifelif_regex, xml_str)
154	for ifelif, tag, left, operator, right in matches:
155	if "<" in operator or ">" in operator:
156	result = eval(f"{left} {operator} {right}")
157	else:
158	result = eval(f'"{left}" {operator} "{right}"')
159	xml_str = xml_str.replace(ifelif, f"<?{tag} {result}?>")
160	return xml_str
161
162	def _pp_ifdef_ifndef(self, xml_str: str) -> str:
163	ifndef_regex = r"(<\?(ifdef\|ifndef)\s([\w]+)\s\?>)"
164	matches = re.findall(ifndef_regex, xml_str)
165	for group_ifndef, group_tag, group_var in matches:
166	if group_tag == "ifdef":
167	result = group_var in self.cus_vars
168	else:
169	result = group_var not in self.cus_vars
170	xml_str = xml_str.replace(group_ifndef, f"<?if {result}?>")
171	return xml_str
172
173	def _pp_if_elseif(self, xml_str: str) -> str:
174	if_elif_else_regex = (
175	r"(<\?if\s(True\|False)\?>"
176	r"(.*?)"
177	r"<\?elseif\s(True\|False)\?>"
178	r"(.*?)"
179	r"<\?else\?>"
180	r"(.*?)"
181	r"<\?endif\?>)"
182	)
183	if_else_regex = (
184	r"(<\?if\s(True\|False)\?>"
185	r"(.*?)"
186	r"<\?else\?>"
187	r"(.*?)"
188	r"<\?endif\?>)"
189	)
190	if_regex = r"(<\?if\s(True\|False)\?>(.*?)<\?endif\?>)"
191	matches = re.findall(if_elif_else_regex, xml_str, re.DOTALL)
192	for (group_full, group_if, group_if_elif, group_elif,
193	group_elif_else, group_else) in matches:
194	result = ""
195	if group_if == "True":
196	result = group_if_elif
197	elif group_elif == "True":
198	result = group_elif_else
199	else:
200	result = group_else
201	xml_str = xml_str.replace(group_full, result)
202	matches = re.findall(if_else_regex, xml_str, re.DOTALL)
203	for group_full, group_if, group_if_else, group_else in matches:
204	result = ""
205	if group_if == "True":
206	result = group_if_else
207	else:
208	result = group_else
209	xml_str = xml_str.replace(group_full, result)
210	matches = re.findall(if_regex, xml_str, re.DOTALL)
211	for group_full, group_if, group_text in matches:
212	result = ""
213	if group_if == "True":
214	result = group_text
215	xml_str = xml_str.replace(group_full, result)
216	return xml_str
217
218	def _pp_command(self, xml_str: str) -> str:
219	cmd_regex = r"(<\?cmd\s\"([^\"]+)\"\s\?>)"
220	matches = re.findall(cmd_regex, xml_str)
221	for group_cmd, group_exec in matches:
222	output = subprocess.check_output(
223	group_exec, shell=True,
224	text=True, stderr=subprocess.STDOUT
225	)
226	xml_str = xml_str.replace(group_cmd, output)
227	return xml_str
228
229	def _pp_blanks(self, xml_str: str) -> str:
230	right_blank_regex = r">[\n\s\t\r]*"
231	left_blank_regex = r"[\n\s\t\r]*<"
232	xml_str = re.sub(right_blank_regex, ">", xml_str)
233	xml_str = re.sub(left_blank_regex, "<", xml_str)
234	return xml_str
235
236	def preprocess(self, xml_str: str) -> str:
237	fns = [
238	self._pp_blanks,
239	self._pp_include,
240	self._pp_foreach,
241	self._pp_env_var,
242	self._pp_sys_var,
243	self._pp_cus_var,
244	self._pp_if_eval,
245	self._pp_ifdef_ifndef,
246	self._pp_if_elseif,
247	self._pp_command,
248	self._pp_error_warning,
249	]
250
251	while True:
252	changed = False
253	for func in fns:
254	out_xml = func(xml_str)
255	if not changed and out_xml != xml_str:
256	changed = True
257	xml_str = out_xml
258	if not changed:
259	break
260
261	return xml_str
262
263
264	def preprocess_xml(path: str) -> str:
265	with open(path, "r", encoding="utf-8") as original_file:
266	input_xml = original_file.read()
267
268	proc = Preprocessor()
269	return proc.preprocess(input_xml)
270
271
272	def save_xml(xml_str: str, path: Optional[str]):
273	xml = minidom.parseString(xml_str)
274	with open(path, "w", encoding="utf-8") if path else sys.stdout as output_file:
275	output_file.write(xml.toprettyxml())
276
277
278	def main():
279	if len(sys.argv) < 2:
280	print("Usage: xml-preprocessor input.xml [output.xml]")
281	sys.exit(1)
282
283	output_file = None
284	if len(sys.argv) == 3:
285	output_file = sys.argv[2]
286
287	input_file = sys.argv[1]
288	output_xml = preprocess_xml(input_file)
289	save_xml(output_xml, output_file)
290
291
292	if __name__ == "__main__":
293	main()