[deliverable/linux.git] / arch / powerpc / boot / dtc-src / dtc-lexer.l

/*
 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 *                                                                   USA
 */

%option noyywrap nounput yylineno

%x INCLUDE
%x BYTESTRING
%x PROPNODENAME
%s V1

PROPNODECHAR	[a-zA-Z0-9,._+*#?@-]
PATHCHAR	({PROPNODECHAR}|[/])
LABEL		[a-zA-Z_][a-zA-Z0-9_]*

%{
#include "dtc.h"
#include "srcpos.h"
#include "dtc-parser.tab.h"


/*#define LEXDEBUG	1*/

#ifdef LEXDEBUG
#define DPRINT(fmt, ...)	fprintf(stderr, fmt, ##__VA_ARGS__)
#else
#define DPRINT(fmt, ...)	do { } while (0)
#endif

static int dts_version; /* = 0 */

#define BEGIN_DEFAULT()	if (dts_version == 0) { \
				DPRINT("<INITIAL>\n"); \
				BEGIN(INITIAL); \
			} else { \
				DPRINT("<V1>\n"); \
				BEGIN(V1); \
			}
%}

%%
<*>"/include/"		BEGIN(INCLUDE);

<INCLUDE>\"[^"\n]*\"	{
			yytext[strlen(yytext) - 1] = 0;
			if (!push_input_file(yytext + 1)) {
				/* Some unrecoverable error.*/
				exit(1);
			}
			BEGIN_DEFAULT();
		}


<*><<EOF>>		{
			if (!pop_input_file()) {
				yyterminate();
			}
		}

<*>\"([^\\"]|\\.)*\"	{
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			DPRINT("String: %s\n", yytext);
			yylval.data = data_copy_escape_string(yytext+1,
					yyleng-2);
			yylloc.first_line = yylineno;
			return DT_STRING;
		}

<*>"/dts-v1/"	{
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			DPRINT("Keyword: /dts-v1/\n");
			dts_version = 1;
			BEGIN_DEFAULT();
			return DT_V1;
		}

<*>"/memreserve/"	{
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			DPRINT("Keyword: /memreserve/\n");
			BEGIN_DEFAULT();
			return DT_MEMRESERVE;
		}

<*>{LABEL}:	{
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			DPRINT("Label: %s\n", yytext);
			yylval.labelref = strdup(yytext);
			yylval.labelref[yyleng-1] = '\0';
			return DT_LABEL;
		}

<INITIAL>[bodh]# {
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			if (*yytext == 'b')
				yylval.cbase = 2;
			else if (*yytext == 'o')
				yylval.cbase = 8;
			else if (*yytext == 'd')
				yylval.cbase = 10;
			else
				yylval.cbase = 16;
			DPRINT("Base: %d\n", yylval.cbase);
			return DT_BASE;
		}

<INITIAL>[0-9a-fA-F]+	{
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			yylval.literal = strdup(yytext);
			DPRINT("Literal: '%s'\n", yylval.literal);
			return DT_LEGACYLITERAL;
		}

<V1>[0-9]+|0[xX][0-9a-fA-F]+      {
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			yylval.literal = strdup(yytext);
			DPRINT("Literal: '%s'\n", yylval.literal);
			return DT_LITERAL;
		}

\&{LABEL}	{	/* label reference */
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			DPRINT("Ref: %s\n", yytext+1);
			yylval.labelref = strdup(yytext+1);
			return DT_REF;
		}

"&{/"{PATHCHAR}+\}	{	/* new-style path reference */
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			yytext[yyleng-1] = '\0';
			DPRINT("Ref: %s\n", yytext+2);
			yylval.labelref = strdup(yytext+2);
			return DT_REF;
		}

<INITIAL>"&/"{PATHCHAR}+ {	/* old-style path reference */
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			DPRINT("Ref: %s\n", yytext+1);
			yylval.labelref = strdup(yytext+1);
			return DT_REF;
		}

<BYTESTRING>[0-9a-fA-F]{2} {
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			yylval.byte = strtol(yytext, NULL, 16);
			DPRINT("Byte: %02x\n", (int)yylval.byte);
			return DT_BYTE;
		}

<BYTESTRING>"]"	{
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			DPRINT("/BYTESTRING\n");
			BEGIN_DEFAULT();
			return ']';
		}

<PROPNODENAME>{PROPNODECHAR}+ {
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			DPRINT("PropNodeName: %s\n", yytext);
			yylval.propnodename = strdup(yytext);
			BEGIN_DEFAULT();
			return DT_PROPNODENAME;
		}


<*>[[:space:]]+	/* eat whitespace */

<*>"/*"([^*]|\*+[^*/])*\*+"/"	{
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			DPRINT("Comment: %s\n", yytext);
			/* eat comments */
		}

<*>"//".*\n	/* eat line comments */

<*>.		{
			yylloc.filenum = srcpos_filenum;
			yylloc.first_line = yylineno;
			DPRINT("Char: %c (\\x%02x)\n", yytext[0],
				(unsigned)yytext[0]);
			if (yytext[0] == '[') {
				DPRINT("<BYTESTRING>\n");
				BEGIN(BYTESTRING);
			}
			if ((yytext[0] == '{')
			    || (yytext[0] == ';')) {
				DPRINT("<PROPNODENAME>\n");
				BEGIN(PROPNODENAME);
			}
			return yytext[0];
		}

%%


/*
 * Stack of nested include file contexts.
 */

struct incl_file {
	int filenum;
	FILE *file;
	YY_BUFFER_STATE yy_prev_buf;
	int yy_prev_lineno;
	struct incl_file *prev;
};

struct incl_file *incl_file_stack;


/*
 * Detect infinite include recursion.
 */
#define MAX_INCLUDE_DEPTH	(100)

static int incl_depth = 0;


int push_input_file(const char *filename)
{
	FILE *f;
	struct incl_file *incl_file;

	if (!filename) {
		yyerror("No include file name given.");
		return 0;
	}

	if (incl_depth++ >= MAX_INCLUDE_DEPTH) {
		yyerror("Includes nested too deeply");
		return 0;
	}

	f = dtc_open_file(filename);

	incl_file = malloc(sizeof(struct incl_file));
	if (!incl_file) {
		yyerror("Can not allocate include file space.");
		return 0;
	}

	/*
	 * Save current context.
	 */
	incl_file->yy_prev_buf = YY_CURRENT_BUFFER;
	incl_file->yy_prev_lineno = yylineno;
	incl_file->filenum = srcpos_filenum;
	incl_file->file = yyin;
	incl_file->prev = incl_file_stack;

	incl_file_stack = incl_file;

	/*
	 * Establish new context.
	 */
	srcpos_filenum = lookup_file_name(filename, 0);
	yylineno = 1;
	yyin = f;
	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));

	return 1;
}


int pop_input_file(void)
{
	struct incl_file *incl_file;

	if (incl_file_stack == 0)
		return 0;

	fclose(yyin);

	/*
	 * Pop.
	 */
	--incl_depth;
	incl_file = incl_file_stack;
	incl_file_stack = incl_file->prev;

	/*
	 * Recover old context.
	 */
	yy_delete_buffer(YY_CURRENT_BUFFER);
	yy_switch_to_buffer(incl_file->yy_prev_buf);
	yylineno = incl_file->yy_prev_lineno;
	srcpos_filenum = incl_file->filenum;
	yyin = incl_file->file;

	/*
	 * Free old state.
	 */
	free(incl_file);

	if (YY_CURRENT_BUFFER == 0)
		return 0;

	return 1;
}
Commit	Line	Data
a4da2e3e DG	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 yylineno
	22
	23	%x INCLUDE
	24	%x BYTESTRING
	25	%x PROPNODENAME
	26	%s V1
	27
	28	PROPNODECHAR [a-zA-Z0-9,._+*#?@-]
	29	PATHCHAR ({PROPNODECHAR}\|[/])
	30	LABEL [a-zA-Z_][a-zA-Z0-9_]*
	31
	32	%{
	33	#include "dtc.h"
	34	#include "srcpos.h"
	35	#include "dtc-parser.tab.h"
	36
	37
	38	/#define LEXDEBUG 1/
	39
	40	#ifdef LEXDEBUG
	41	#define DPRINT(fmt, ...) fprintf(stderr, fmt, ##__VA_ARGS__)
	42	#else
	43	#define DPRINT(fmt, ...) do { } while (0)
	44	#endif
	45
	46	static int dts_version; /* = 0 */
	47
	48	#define BEGIN_DEFAULT() if (dts_version == 0) { \
	49	DPRINT("<INITIAL>\n"); \
	50	BEGIN(INITIAL); \
	51	} else { \
	52	DPRINT("<V1>\n"); \
	53	BEGIN(V1); \
	54	}
	55	%}
	56
	57	%%
	58	<*>"/include/" BEGIN(INCLUDE);
	59
	60	<INCLUDE>\"[^"\n]*\" {
	61	yytext[strlen(yytext) - 1] = 0;
	62	if (!push_input_file(yytext + 1)) {
	63	/* Some unrecoverable error.*/
	64	exit(1);
65	}
66	BEGIN_DEFAULT();
67	}
68
69
70	<*><<EOF>> {
71	if (!pop_input_file()) {
72	yyterminate();
73	}
74	}
75
76	<>\"([^\\"]\|\\.)\" {
77	yylloc.filenum = srcpos_filenum;
78	yylloc.first_line = yylineno;
79	DPRINT("String: %s\n", yytext);
80	yylval.data = data_copy_escape_string(yytext+1,
81	yyleng-2);
82	yylloc.first_line = yylineno;
83	return DT_STRING;
84	}
85
86	<*>"/dts-v1/" {
87	yylloc.filenum = srcpos_filenum;
88	yylloc.first_line = yylineno;
89	DPRINT("Keyword: /dts-v1/\n");
90	dts_version = 1;
91	BEGIN_DEFAULT();
92	return DT_V1;
93	}
94
95	<*>"/memreserve/" {
96	yylloc.filenum = srcpos_filenum;
97	yylloc.first_line = yylineno;
98	DPRINT("Keyword: /memreserve/\n");
99	BEGIN_DEFAULT();
100	return DT_MEMRESERVE;
101	}
102
103	<*>{LABEL}: {
104	yylloc.filenum = srcpos_filenum;
105	yylloc.first_line = yylineno;
106	DPRINT("Label: %s\n", yytext);
107	yylval.labelref = strdup(yytext);
108	yylval.labelref[yyleng-1] = '\0';
109	return DT_LABEL;
110	}
111
112	<INITIAL>[bodh]# {
113	yylloc.filenum = srcpos_filenum;
114	yylloc.first_line = yylineno;
115	if (*yytext == 'b')
116	yylval.cbase = 2;
117	else if (*yytext == 'o')
118	yylval.cbase = 8;
119	else if (*yytext == 'd')
120	yylval.cbase = 10;
121	else
122	yylval.cbase = 16;
123	DPRINT("Base: %d\n", yylval.cbase);
124	return DT_BASE;
125	}
126
127	<INITIAL>[0-9a-fA-F]+ {
128	yylloc.filenum = srcpos_filenum;
129	yylloc.first_line = yylineno;
130	yylval.literal = strdup(yytext);
131	DPRINT("Literal: '%s'\n", yylval.literal);
132	return DT_LEGACYLITERAL;
133	}
134
135	<V1>[0-9]+\|0[xX][0-9a-fA-F]+ {
136	yylloc.filenum = srcpos_filenum;
137	yylloc.first_line = yylineno;
138	yylval.literal = strdup(yytext);
139	DPRINT("Literal: '%s'\n", yylval.literal);
140	return DT_LITERAL;
141	}
142
143	\&{LABEL} { /* label reference */
144	yylloc.filenum = srcpos_filenum;
145	yylloc.first_line = yylineno;
146	DPRINT("Ref: %s\n", yytext+1);
147	yylval.labelref = strdup(yytext+1);
148	return DT_REF;
149	}
150
151	"&{/"{PATHCHAR}+\} { /* new-style path reference */
152	yylloc.filenum = srcpos_filenum;
153	yylloc.first_line = yylineno;
154	yytext[yyleng-1] = '\0';
155	DPRINT("Ref: %s\n", yytext+2);
156	yylval.labelref = strdup(yytext+2);
157	return DT_REF;
158	}
159
160	<INITIAL>"&/"{PATHCHAR}+ { /* old-style path reference */
161	yylloc.filenum = srcpos_filenum;
162	yylloc.first_line = yylineno;
163	DPRINT("Ref: %s\n", yytext+1);
164	yylval.labelref = strdup(yytext+1);
165	return DT_REF;
166	}
167
168	<BYTESTRING>[0-9a-fA-F]{2} {
169	yylloc.filenum = srcpos_filenum;
170	yylloc.first_line = yylineno;
171	yylval.byte = strtol(yytext, NULL, 16);
172	DPRINT("Byte: %02x\n", (int)yylval.byte);
173	return DT_BYTE;
174	}
175
176	<BYTESTRING>"]" {
177	yylloc.filenum = srcpos_filenum;
178	yylloc.first_line = yylineno;
179	DPRINT("/BYTESTRING\n");
180	BEGIN_DEFAULT();
181	return ']';
182	}
183
184	<PROPNODENAME>{PROPNODECHAR}+ {
185	yylloc.filenum = srcpos_filenum;
186	yylloc.first_line = yylineno;
187	DPRINT("PropNodeName: %s\n", yytext);
188	yylval.propnodename = strdup(yytext);
189	BEGIN_DEFAULT();
190	return DT_PROPNODENAME;
191	}
192
193
194	<>[[:space:]]+ / eat whitespace */
195
196	<>"/"([^]\|\+[^/])\*+"/" {
197	yylloc.filenum = srcpos_filenum;
198	yylloc.first_line = yylineno;
199	DPRINT("Comment: %s\n", yytext);
200	/* eat comments */
201	}
202
203	<>"//".\n /* eat line comments */
204
205	<*>. {
206	yylloc.filenum = srcpos_filenum;
207	yylloc.first_line = yylineno;
208	DPRINT("Char: %c (\\x%02x)\n", yytext[0],
209	(unsigned)yytext[0]);
210	if (yytext[0] == '[') {
211	DPRINT("<BYTESTRING>\n");
212	BEGIN(BYTESTRING);
213	}
214	if ((yytext[0] == '{')
215	\|\| (yytext[0] == ';')) {
216	DPRINT("<PROPNODENAME>\n");
217	BEGIN(PROPNODENAME);
218	}
219	return yytext[0];
220	}
221
222	%%
223
224
225	/*
226	* Stack of nested include file contexts.
227	*/
228
229	struct incl_file {
230	int filenum;
231	FILE *file;
232	YY_BUFFER_STATE yy_prev_buf;
233	int yy_prev_lineno;
234	struct incl_file *prev;
235	};
236
237	struct incl_file *incl_file_stack;
238
239
240	/*
241	* Detect infinite include recursion.
242	*/
243	#define MAX_INCLUDE_DEPTH (100)
244
245	static int incl_depth = 0;
246
247
248	int push_input_file(const char *filename)
249	{
250	FILE *f;
251	struct incl_file *incl_file;
252
253	if (!filename) {
254	yyerror("No include file name given.");
255	return 0;
256	}
257
258	if (incl_depth++ >= MAX_INCLUDE_DEPTH) {
259	yyerror("Includes nested too deeply");
260	return 0;
261	}
262
263	f = dtc_open_file(filename);
264
265	incl_file = malloc(sizeof(struct incl_file));
266	if (!incl_file) {
267	yyerror("Can not allocate include file space.");
268	return 0;
269	}
270
271	/*
272	* Save current context.
273	*/
274	incl_file->yy_prev_buf = YY_CURRENT_BUFFER;
275	incl_file->yy_prev_lineno = yylineno;
276	incl_file->filenum = srcpos_filenum;
277	incl_file->file = yyin;
278	incl_file->prev = incl_file_stack;
279
280	incl_file_stack = incl_file;
281
282	/*
283	* Establish new context.
284	*/
285	srcpos_filenum = lookup_file_name(filename, 0);
286	yylineno = 1;
287	yyin = f;
288	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
289
290	return 1;
291	}
292
293
294	int pop_input_file(void)
295	{
296	struct incl_file *incl_file;
297
298	if (incl_file_stack == 0)
299	return 0;
300
301	fclose(yyin);
302
303	/*
304	* Pop.
305	*/
306	--incl_depth;
307	incl_file = incl_file_stack;
308	incl_file_stack = incl_file->prev;
309
310	/*
311	* Recover old context.
312	*/
313	yy_delete_buffer(YY_CURRENT_BUFFER);
314	yy_switch_to_buffer(incl_file->yy_prev_buf);
315	yylineno = incl_file->yy_prev_lineno;
316	srcpos_filenum = incl_file->filenum;
317	yyin = incl_file->file;
318
319	/*
320	* Free old state.
321	*/
322	free(incl_file);
323
324	if (YY_CURRENT_BUFFER == 0)
325	return 0;
326
327	return 1;
328	}