xref: /openbmc/u-boot/scripts/dtc/dtc-lexer.l (revision 3ba98ed8)
1 /*
2  * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
3  *
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation; either version 2 of the
8  * License, or (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  General Public License for more details.
14  *
15  *  You should have received a copy of the GNU General Public License
16  *  along with this program; if not, write to the Free Software
17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
18  *                                                                   USA
19  */
20 
21 %option noyywrap nounput noinput never-interactive
22 
23 %x BYTESTRING
24 %x PROPNODENAME
25 %s V1
26 
27 PROPNODECHAR	[a-zA-Z0-9,._+*#?@-]
28 PATHCHAR	({PROPNODECHAR}|[/])
29 LABEL		[a-zA-Z_][a-zA-Z0-9_]*
30 STRING		\"([^\\"]|\\.)*\"
31 CHAR_LITERAL	'([^']|\\')*'
32 WS		[[:space:]]
33 COMMENT		"/*"([^*]|\*+[^*/])*\*+"/"
34 LINECOMMENT	"//".*\n
35 
36 %{
37 #include "dtc.h"
38 #include "srcpos.h"
39 #include "dtc-parser.tab.h"
40 
41 extern bool treesource_error;
42 
43 /* CAUTION: this will stop working if we ever use yyless() or yyunput() */
44 #define	YY_USER_ACTION \
45 	{ \
46 		srcpos_update(&yylloc, yytext, yyleng); \
47 	}
48 
49 /*#define LEXDEBUG	1*/
50 
51 #ifdef LEXDEBUG
52 #define DPRINT(fmt, ...)	fprintf(stderr, fmt, ##__VA_ARGS__)
53 #else
54 #define DPRINT(fmt, ...)	do { } while (0)
55 #endif
56 
57 static int dts_version = 1;
58 
59 #define BEGIN_DEFAULT()		DPRINT("<V1>\n"); \
60 				BEGIN(V1); \
61 
62 static void push_input_file(const char *filename);
63 static bool pop_input_file(void);
64 static void PRINTF(1, 2) lexical_error(const char *fmt, ...);
65 
66 %}
67 
68 %%
69 <*>"/include/"{WS}*{STRING} {
70 			char *name = strchr(yytext, '\"') + 1;
71 			yytext[yyleng-1] = '\0';
72 			push_input_file(name);
73 		}
74 
75 <*>^"#"(line)?[ \t]+[0-9]+[ \t]+{STRING}([ \t]+[0-9]+)? {
76 			char *line, *fnstart, *fnend;
77 			struct data fn;
78 			/* skip text before line # */
79 			line = yytext;
80 			while (!isdigit((unsigned char)*line))
81 				line++;
82 
83 			/* regexp ensures that first and list "
84 			 * in the whole yytext are those at
85 			 * beginning and end of the filename string */
86 			fnstart = memchr(yytext, '"', yyleng);
87 			for (fnend = yytext + yyleng - 1;
88 			     *fnend != '"'; fnend--)
89 				;
90 			assert(fnstart && fnend && (fnend > fnstart));
91 
92 			fn = data_copy_escape_string(fnstart + 1,
93 						     fnend - fnstart - 1);
94 
95 			/* Don't allow nuls in filenames */
96 			if (memchr(fn.val, '\0', fn.len - 1))
97 				lexical_error("nul in line number directive");
98 
99 			/* -1 since #line is the number of the next line */
100 			srcpos_set_line(xstrdup(fn.val), atoi(line) - 1);
101 			data_free(fn);
102 		}
103 
104 <*><<EOF>>		{
105 			if (!pop_input_file()) {
106 				yyterminate();
107 			}
108 		}
109 
110 <*>{STRING}	{
111 			DPRINT("String: %s\n", yytext);
112 			yylval.data = data_copy_escape_string(yytext+1,
113 					yyleng-2);
114 			return DT_STRING;
115 		}
116 
117 <*>"/dts-v1/"	{
118 			DPRINT("Keyword: /dts-v1/\n");
119 			dts_version = 1;
120 			BEGIN_DEFAULT();
121 			return DT_V1;
122 		}
123 
124 <*>"/plugin/"	{
125 			DPRINT("Keyword: /plugin/\n");
126 			return DT_PLUGIN;
127 		}
128 
129 <*>"/memreserve/"	{
130 			DPRINT("Keyword: /memreserve/\n");
131 			BEGIN_DEFAULT();
132 			return DT_MEMRESERVE;
133 		}
134 
135 <*>"/bits/"	{
136 			DPRINT("Keyword: /bits/\n");
137 			BEGIN_DEFAULT();
138 			return DT_BITS;
139 		}
140 
141 <*>"/delete-property/"	{
142 			DPRINT("Keyword: /delete-property/\n");
143 			DPRINT("<PROPNODENAME>\n");
144 			BEGIN(PROPNODENAME);
145 			return DT_DEL_PROP;
146 		}
147 
148 <*>"/delete-node/"	{
149 			DPRINT("Keyword: /delete-node/\n");
150 			DPRINT("<PROPNODENAME>\n");
151 			BEGIN(PROPNODENAME);
152 			return DT_DEL_NODE;
153 		}
154 
155 <*>{LABEL}:	{
156 			DPRINT("Label: %s\n", yytext);
157 			yylval.labelref = xstrdup(yytext);
158 			yylval.labelref[yyleng-1] = '\0';
159 			return DT_LABEL;
160 		}
161 
162 <V1>([0-9]+|0[xX][0-9a-fA-F]+)(U|L|UL|LL|ULL)? {
163 			char *e;
164 			DPRINT("Integer Literal: '%s'\n", yytext);
165 
166 			errno = 0;
167 			yylval.integer = strtoull(yytext, &e, 0);
168 
169 			if (*e && e[strspn(e, "UL")]) {
170 				lexical_error("Bad integer literal '%s'",
171 					      yytext);
172 			}
173 
174 			if (errno == ERANGE)
175 				lexical_error("Integer literal '%s' out of range",
176 					      yytext);
177 			else
178 				/* ERANGE is the only strtoull error triggerable
179 				 *  by strings matching the pattern */
180 				assert(errno == 0);
181 			return DT_LITERAL;
182 		}
183 
184 <*>{CHAR_LITERAL}	{
185 			struct data d;
186 			DPRINT("Character literal: %s\n", yytext);
187 
188 			d = data_copy_escape_string(yytext+1, yyleng-2);
189 			if (d.len == 1) {
190 				lexical_error("Empty character literal");
191 				yylval.integer = 0;
192 			} else {
193 				yylval.integer = (unsigned char)d.val[0];
194 
195 				if (d.len > 2)
196 					lexical_error("Character literal has %d"
197 						      " characters instead of 1",
198 						      d.len - 1);
199 			}
200 
201 			data_free(d);
202 			return DT_CHAR_LITERAL;
203 		}
204 
205 <*>\&{LABEL}	{	/* label reference */
206 			DPRINT("Ref: %s\n", yytext+1);
207 			yylval.labelref = xstrdup(yytext+1);
208 			return DT_REF;
209 		}
210 
211 <*>"&{/"{PATHCHAR}*\}	{	/* new-style path reference */
212 			yytext[yyleng-1] = '\0';
213 			DPRINT("Ref: %s\n", yytext+2);
214 			yylval.labelref = xstrdup(yytext+2);
215 			return DT_REF;
216 		}
217 
218 <BYTESTRING>[0-9a-fA-F]{2} {
219 			yylval.byte = strtol(yytext, NULL, 16);
220 			DPRINT("Byte: %02x\n", (int)yylval.byte);
221 			return DT_BYTE;
222 		}
223 
224 <BYTESTRING>"]"	{
225 			DPRINT("/BYTESTRING\n");
226 			BEGIN_DEFAULT();
227 			return ']';
228 		}
229 
230 <PROPNODENAME>\\?{PROPNODECHAR}+ {
231 			DPRINT("PropNodeName: %s\n", yytext);
232 			yylval.propnodename = xstrdup((yytext[0] == '\\') ?
233 							yytext + 1 : yytext);
234 			BEGIN_DEFAULT();
235 			return DT_PROPNODENAME;
236 		}
237 
238 "/incbin/"	{
239 			DPRINT("Binary Include\n");
240 			return DT_INCBIN;
241 		}
242 
243 <*>{WS}+	/* eat whitespace */
244 <*>{COMMENT}+	/* eat C-style comments */
245 <*>{LINECOMMENT}+ /* eat C++-style comments */
246 
247 <*>"<<"		{ return DT_LSHIFT; };
248 <*>">>"		{ return DT_RSHIFT; };
249 <*>"<="		{ return DT_LE; };
250 <*>">="		{ return DT_GE; };
251 <*>"=="		{ return DT_EQ; };
252 <*>"!="		{ return DT_NE; };
253 <*>"&&"		{ return DT_AND; };
254 <*>"||"		{ return DT_OR; };
255 
256 <*>.		{
257 			DPRINT("Char: %c (\\x%02x)\n", yytext[0],
258 				(unsigned)yytext[0]);
259 			if (yytext[0] == '[') {
260 				DPRINT("<BYTESTRING>\n");
261 				BEGIN(BYTESTRING);
262 			}
263 			if ((yytext[0] == '{')
264 			    || (yytext[0] == ';')) {
265 				DPRINT("<PROPNODENAME>\n");
266 				BEGIN(PROPNODENAME);
267 			}
268 			return yytext[0];
269 		}
270 
271 %%
272 
273 static void push_input_file(const char *filename)
274 {
275 	assert(filename);
276 
277 	srcfile_push(filename);
278 
279 	yyin = current_srcfile->f;
280 
281 	yypush_buffer_state(yy_create_buffer(yyin, YY_BUF_SIZE));
282 }
283 
284 
285 static bool pop_input_file(void)
286 {
287 	if (srcfile_pop() == 0)
288 		return false;
289 
290 	yypop_buffer_state();
291 	yyin = current_srcfile->f;
292 
293 	return true;
294 }
295 
296 static void lexical_error(const char *fmt, ...)
297 {
298 	va_list ap;
299 
300 	va_start(ap, fmt);
301 	srcpos_verror(&yylloc, "Lexical error", fmt, ap);
302 	va_end(ap);
303 
304 	treesource_error = true;
305 }
306