1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
4 */
5
6#include "dtc.h"
7#include "srcpos.h"
8
9extern FILE *yyin;
10extern int yyparse(void);
11extern YYLTYPE yylloc;
12
13struct dt_info *parser_output;
14bool treesource_error;
15
16struct dt_info *dt_from_source(const char *fname)
17{
18	parser_output = NULL;
19	treesource_error = false;
20
21	srcfile_push(fname);
22	yyin = current_srcfile->f;
23	yylloc.file = current_srcfile;
24
25	if (yyparse() != 0)
26		die("Unable to parse input tree\n");
27
28	if (treesource_error)
29		die("Syntax error parsing input tree\n");
30
31	return parser_output;
32}
33
34static void write_prefix(FILE *f, int level)
35{
36	int i;
37
38	for (i = 0; i < level; i++)
39		fputc('\t', f);
40}
41
42static bool isstring(char c)
43{
44	return (isprint((unsigned char)c)
45		|| (c == '\0')
46		|| strchr("\a\b\t\n\v\f\r", c));
47}
48
49static void write_propval_string(FILE *f, const char *s, size_t len)
50{
51	const char *end = s + len - 1;
52
53	if (!len)
54		return;
55
56	assert(*end == '\0');
57
58	fprintf(f, "\"");
59	while (s < end) {
60		char c = *s++;
61		switch (c) {
62		case '\a':
63			fprintf(f, "\\a");
64			break;
65		case '\b':
66			fprintf(f, "\\b");
67			break;
68		case '\t':
69			fprintf(f, "\\t");
70			break;
71		case '\n':
72			fprintf(f, "\\n");
73			break;
74		case '\v':
75			fprintf(f, "\\v");
76			break;
77		case '\f':
78			fprintf(f, "\\f");
79			break;
80		case '\r':
81			fprintf(f, "\\r");
82			break;
83		case '\\':
84			fprintf(f, "\\\\");
85			break;
86		case '\"':
87			fprintf(f, "\\\"");
88			break;
89		case '\0':
90			fprintf(f, "\\0");
91			break;
92		default:
93			if (isprint((unsigned char)c))
94				fprintf(f, "%c", c);
95			else
96				fprintf(f, "\\x%02"PRIx8, c);
97		}
98	}
99	fprintf(f, "\"");
100}
101
102static void write_propval_int(FILE *f, const char *p, size_t len, size_t width)
103{
104	const char *end = p + len;
105	assert(len % width == 0);
106
107	for (; p < end; p += width) {
108		switch (width) {
109		case 1:
110			fprintf(f, "%02"PRIx8, *(const uint8_t*)p);
111			break;
112		case 2:
113			fprintf(f, "0x%02"PRIx16, dtb_ld16(p));
114			break;
115		case 4:
116			fprintf(f, "0x%02"PRIx32, dtb_ld32(p));
117			break;
118		case 8:
119			fprintf(f, "0x%02"PRIx64, dtb_ld64(p));
120			break;
121		}
122		if (p + width < end)
123			fputc(' ', f);
124	}
125}
126
127static const char *delim_start[] = {
128	[TYPE_UINT8] = "[",
129	[TYPE_UINT16] = "/bits/ 16 <",
130	[TYPE_UINT32] = "<",
131	[TYPE_UINT64] = "/bits/ 64 <",
132	[TYPE_STRING] = "",
133};
134static const char *delim_end[] = {
135	[TYPE_UINT8] = "]",
136	[TYPE_UINT16] = ">",
137	[TYPE_UINT32] = ">",
138	[TYPE_UINT64] = ">",
139	[TYPE_STRING] = "",
140};
141
142static enum markertype guess_value_type(struct property *prop)
143{
144	int len = prop->val.len;
145	const char *p = prop->val.val;
146	struct marker *m = prop->val.markers;
147	int nnotstring = 0, nnul = 0;
148	int nnotstringlbl = 0, nnotcelllbl = 0;
149	int i;
150
151	for (i = 0; i < len; i++) {
152		if (! isstring(p[i]))
153			nnotstring++;
154		if (p[i] == '\0')
155			nnul++;
156	}
157
158	for_each_marker_of_type(m, LABEL) {
159		if ((m->offset > 0) && (prop->val.val[m->offset - 1] != '\0'))
160			nnotstringlbl++;
161		if ((m->offset % sizeof(cell_t)) != 0)
162			nnotcelllbl++;
163	}
164
165	if ((p[len-1] == '\0') && (nnotstring == 0) && (nnul <= (len-nnul))
166	    && (nnotstringlbl == 0)) {
167		return TYPE_STRING;
168	} else if (((len % sizeof(cell_t)) == 0) && (nnotcelllbl == 0)) {
169		return TYPE_UINT32;
170	}
171
172	return TYPE_UINT8;
173}
174
175static void write_propval(FILE *f, struct property *prop)
176{
177	size_t len = prop->val.len;
178	struct marker *m = prop->val.markers;
179	struct marker dummy_marker;
180	enum markertype emit_type = TYPE_NONE;
181	char *srcstr;
182
183	if (len == 0) {
184		fprintf(f, ";");
185		if (annotate) {
186			srcstr = srcpos_string_first(prop->srcpos, annotate);
187			if (srcstr) {
188				fprintf(f, " /* %s */", srcstr);
189				free(srcstr);
190			}
191		}
192		fprintf(f, "\n");
193		return;
194	}
195
196	fprintf(f, " =");
197
198	if (!next_type_marker(m)) {
199		/* data type information missing, need to guess */
200		dummy_marker.type = guess_value_type(prop);
201		dummy_marker.next = prop->val.markers;
202		dummy_marker.offset = 0;
203		dummy_marker.ref = NULL;
204		m = &dummy_marker;
205	}
206
207	for_each_marker(m) {
208		size_t chunk_len = (m->next ? m->next->offset : len) - m->offset;
209		size_t data_len = type_marker_length(m) ? : len - m->offset;
210		const char *p = &prop->val.val[m->offset];
211		struct marker *m_phandle;
212
213		if (is_type_marker(m->type)) {
214			emit_type = m->type;
215			fprintf(f, " %s", delim_start[emit_type]);
216		} else if (m->type == LABEL)
217			fprintf(f, " %s:", m->ref);
218
219		if (emit_type == TYPE_NONE || chunk_len == 0)
220			continue;
221
222		switch(emit_type) {
223		case TYPE_UINT16:
224			write_propval_int(f, p, chunk_len, 2);
225			break;
226		case TYPE_UINT32:
227			m_phandle = prop->val.markers;
228			for_each_marker_of_type(m_phandle, REF_PHANDLE)
229				if (m->offset == m_phandle->offset)
230					break;
231
232			if (m_phandle) {
233				if (m_phandle->ref[0] == '/')
234					fprintf(f, "&{%s}", m_phandle->ref);
235				else
236					fprintf(f, "&%s", m_phandle->ref);
237				if (chunk_len > 4) {
238					fputc(' ', f);
239					write_propval_int(f, p + 4, chunk_len - 4, 4);
240				}
241			} else {
242				write_propval_int(f, p, chunk_len, 4);
243			}
244			break;
245		case TYPE_UINT64:
246			write_propval_int(f, p, chunk_len, 8);
247			break;
248		case TYPE_STRING:
249			write_propval_string(f, p, chunk_len);
250			break;
251		default:
252			write_propval_int(f, p, chunk_len, 1);
253		}
254
255		if (chunk_len == data_len) {
256			size_t pos = m->offset + chunk_len;
257			fprintf(f, pos == len ? "%s" : "%s,",
258			        delim_end[emit_type] ? : "");
259			emit_type = TYPE_NONE;
260		}
261	}
262	fprintf(f, ";");
263	if (annotate) {
264		srcstr = srcpos_string_first(prop->srcpos, annotate);
265		if (srcstr) {
266			fprintf(f, " /* %s */", srcstr);
267			free(srcstr);
268		}
269	}
270	fprintf(f, "\n");
271}
272
273static void write_tree_source_node(FILE *f, struct node *tree, int level)
274{
275	struct property *prop;
276	struct node *child;
277	struct label *l;
278	char *srcstr;
279
280	write_prefix(f, level);
281	for_each_label(tree->labels, l)
282		fprintf(f, "%s: ", l->label);
283	if (tree->name && (*tree->name))
284		fprintf(f, "%s {", tree->name);
285	else
286		fprintf(f, "/ {");
287
288	if (annotate) {
289		srcstr = srcpos_string_first(tree->srcpos, annotate);
290		if (srcstr) {
291			fprintf(f, " /* %s */", srcstr);
292			free(srcstr);
293		}
294	}
295	fprintf(f, "\n");
296
297	for_each_property(tree, prop) {
298		write_prefix(f, level+1);
299		for_each_label(prop->labels, l)
300			fprintf(f, "%s: ", l->label);
301		fprintf(f, "%s", prop->name);
302		write_propval(f, prop);
303	}
304	for_each_child(tree, child) {
305		fprintf(f, "\n");
306		write_tree_source_node(f, child, level+1);
307	}
308	write_prefix(f, level);
309	fprintf(f, "};");
310	if (annotate) {
311		srcstr = srcpos_string_last(tree->srcpos, annotate);
312		if (srcstr) {
313			fprintf(f, " /* %s */", srcstr);
314			free(srcstr);
315		}
316	}
317	fprintf(f, "\n");
318}
319
320void dt_to_source(FILE *f, struct dt_info *dti)
321{
322	struct reserve_info *re;
323
324	fprintf(f, "/dts-v1/;\n\n");
325
326	for (re = dti->reservelist; re; re = re->next) {
327		struct label *l;
328
329		for_each_label(re->labels, l)
330			fprintf(f, "%s: ", l->label);
331		fprintf(f, "/memreserve/\t0x%016llx 0x%016llx;\n",
332			(unsigned long long)re->address,
333			(unsigned long long)re->size);
334	}
335
336	write_tree_source_node(f, dti->dt, 0);
337}
338