[deliverable/linux.git] / scripts / dtc / 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 noinput never-interactive

%x BYTESTRING
%x PROPNODENAME
%s V1

PROPNODECHAR	[a-zA-Z0-9,._+*#?@-]
PATHCHAR	({PROPNODECHAR}|[/])
LABEL		[a-zA-Z_][a-zA-Z0-9_]*
STRING		\"([^\\"]|\\.)*\"
CHAR_LITERAL	'([^']|\\')*'
WS		[[:space:]]
COMMENT		"/*"([^*]|\*+[^*/])*\*+"/"
LINECOMMENT	"//".*\n

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

YYLTYPE yylloc;
extern bool treesource_error;

/* CAUTION: this will stop working if we ever use yyless() or yyunput() */
#define	YY_USER_ACTION \
	{ \
		srcpos_update(&yylloc, yytext, yyleng); \
	}

/*#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 = 1;

#define BEGIN_DEFAULT()		DPRINT("<V1>\n"); \
				BEGIN(V1); \

static void push_input_file(const char *filename);
static bool pop_input_file(void);
static void lexical_error(const char *fmt, ...);
%}

%%
<*>"/include/"{WS}*{STRING} {
			char *name = strchr(yytext, '\"') + 1;
			yytext[yyleng-1] = '\0';
			push_input_file(name);
		}

<*>^"#"(line)?[ \t]+[0-9]+[ \t]+{STRING}([ \t]+[0-9]+)? {
			char *line, *fnstart, *fnend;
			struct data fn;
			/* skip text before line # */
			line = yytext;
			while (!isdigit((unsigned char)*line))
				line++;

			/* regexp ensures that first and list "
			 * in the whole yytext are those at
			 * beginning and end of the filename string */
			fnstart = memchr(yytext, '"', yyleng);
			for (fnend = yytext + yyleng - 1;
			     *fnend != '"'; fnend--)
				;
			assert(fnstart && fnend && (fnend > fnstart));

			fn = data_copy_escape_string(fnstart + 1,
						     fnend - fnstart - 1);

			/* Don't allow nuls in filenames */
			if (memchr(fn.val, '\0', fn.len - 1))
				lexical_error("nul in line number directive");

			/* -1 since #line is the number of the next line */
			srcpos_set_line(xstrdup(fn.val), atoi(line) - 1);
			data_free(fn);
		}

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

<*>{STRING}	{
			DPRINT("String: %s\n", yytext);
			yylval.data = data_copy_escape_string(yytext+1,
					yyleng-2);
			return DT_STRING;
		}

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

<*>"/memreserve/"	{
			DPRINT("Keyword: /memreserve/\n");
			BEGIN_DEFAULT();
			return DT_MEMRESERVE;
		}

<*>"/bits/"	{
			DPRINT("Keyword: /bits/\n");
			BEGIN_DEFAULT();
			return DT_BITS;
		}

<*>"/delete-property/"	{
			DPRINT("Keyword: /delete-property/\n");
			DPRINT("<PROPNODENAME>\n");
			BEGIN(PROPNODENAME);
			return DT_DEL_PROP;
		}

<*>"/delete-node/"	{
			DPRINT("Keyword: /delete-node/\n");
			DPRINT("<PROPNODENAME>\n");
			BEGIN(PROPNODENAME);
			return DT_DEL_NODE;
		}

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

<V1>([0-9]+|0[xX][0-9a-fA-F]+)(U|L|UL|LL|ULL)? {
			char *e;
			DPRINT("Integer Literal: '%s'\n", yytext);

			errno = 0;
			yylval.integer = strtoull(yytext, &e, 0);

			if (*e && e[strspn(e, "UL")]) {
				lexical_error("Bad integer literal '%s'",
					      yytext);
			}

			if (errno == ERANGE)
				lexical_error("Integer literal '%s' out of range",
					      yytext);
			else
				/* ERANGE is the only strtoull error triggerable
				 *  by strings matching the pattern */
				assert(errno == 0);
			return DT_LITERAL;
		}

<*>{CHAR_LITERAL}	{
			struct data d;
			DPRINT("Character literal: %s\n", yytext);

			d = data_copy_escape_string(yytext+1, yyleng-2);
			if (d.len == 1) {
				lexical_error("Empty character literal");
				yylval.integer = 0;
				return DT_CHAR_LITERAL;
			}

			yylval.integer = (unsigned char)d.val[0];

			if (d.len > 2)
				lexical_error("Character literal has %d"
					      " characters instead of 1",
					      d.len - 1);

			return DT_CHAR_LITERAL;
		}

<*>\&{LABEL}	{	/* label reference */
			DPRINT("Ref: %s\n", yytext+1);
			yylval.labelref = xstrdup(yytext+1);
			return DT_REF;
		}

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

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

<BYTESTRING>"]"	{
			DPRINT("/BYTESTRING\n");
			BEGIN_DEFAULT();
			return ']';
		}

<PROPNODENAME>\\?{PROPNODECHAR}+ {
			DPRINT("PropNodeName: %s\n", yytext);
			yylval.propnodename = xstrdup((yytext[0] == '\\') ?
							yytext + 1 : yytext);
			BEGIN_DEFAULT();
			return DT_PROPNODENAME;
		}

"/incbin/"	{
			DPRINT("Binary Include\n");
			return DT_INCBIN;
		}

<*>{WS}+	/* eat whitespace */
<*>{COMMENT}+	/* eat C-style comments */
<*>{LINECOMMENT}+ /* eat C++-style comments */

<*>"<<"		{ return DT_LSHIFT; };
<*>">>"		{ return DT_RSHIFT; };
<*>"<="		{ return DT_LE; };
<*>">="		{ return DT_GE; };
<*>"=="		{ return DT_EQ; };
<*>"!="		{ return DT_NE; };
<*>"&&"		{ return DT_AND; };
<*>"||"		{ return DT_OR; };

<*>.		{
			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];
		}

%%

static void push_input_file(const char *filename)
{
	assert(filename);

	srcfile_push(filename);

	yyin = current_srcfile->f;

	yypush_buffer_state(yy_create_buffer(yyin, YY_BUF_SIZE));
}


static bool pop_input_file(void)
{
	if (srcfile_pop() == 0)
		return false;

	yypop_buffer_state();
	yyin = current_srcfile->f;

	return true;
}

static void lexical_error(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	srcpos_verror(&yylloc, "Lexical error", fmt, ap);
	va_end(ap);

	treesource_error = true;
}
Commit	Line	Data
	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	YYLTYPE yylloc;
	42	extern bool treesource_error;
	43
	44	/* CAUTION: this will stop working if we ever use yyless() or yyunput() */
	45	#define YY_USER_ACTION \
	46	{ \
	47	srcpos_update(&yylloc, yytext, yyleng); \
	48	}
	49
	50	/#define LEXDEBUG 1/
	51
	52	#ifdef LEXDEBUG
	53	#define DPRINT(fmt, ...) fprintf(stderr, fmt, ##__VA_ARGS__)
	54	#else
	55	#define DPRINT(fmt, ...) do { } while (0)
	56	#endif
	57
	58	static int dts_version = 1;
	59
	60	#define BEGIN_DEFAULT() DPRINT("<V1>\n"); \
	61	BEGIN(V1); \
	62
	63	static void push_input_file(const char *filename);
	64	static bool pop_input_file(void);
	65	static void lexical_error(const char *fmt, ...);
	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	<*>"/memreserve/" {
	125	DPRINT("Keyword: /memreserve/\n");
	126	BEGIN_DEFAULT();
	127	return DT_MEMRESERVE;
	128	}
	129
	130	<*>"/bits/" {
	131	DPRINT("Keyword: /bits/\n");
	132	BEGIN_DEFAULT();
	133	return DT_BITS;
	134	}
	135
	136	<*>"/delete-property/" {
	137	DPRINT("Keyword: /delete-property/\n");
	138	DPRINT("<PROPNODENAME>\n");
	139	BEGIN(PROPNODENAME);
	140	return DT_DEL_PROP;
	141	}
	142
	143	<*>"/delete-node/" {
	144	DPRINT("Keyword: /delete-node/\n");
	145	DPRINT("<PROPNODENAME>\n");
	146	BEGIN(PROPNODENAME);
	147	return DT_DEL_NODE;
	148	}
	149
	150	<*>{LABEL}: {
	151	DPRINT("Label: %s\n", yytext);
	152	yylval.labelref = xstrdup(yytext);
	153	yylval.labelref[yyleng-1] = '\0';
	154	return DT_LABEL;
	155	}
	156
	157	<V1>([0-9]+\|0[xX][0-9a-fA-F]+)(U\|L\|UL\|LL\|ULL)? {
	158	char *e;
	159	DPRINT("Integer Literal: '%s'\n", yytext);
	160
	161	errno = 0;
	162	yylval.integer = strtoull(yytext, &e, 0);
	163
	164	if (*e && e[strspn(e, "UL")]) {
	165	lexical_error("Bad integer literal '%s'",
	166	yytext);
	167	}
	168
	169	if (errno == ERANGE)
	170	lexical_error("Integer literal '%s' out of range",
	171	yytext);
	172	else
	173	/* ERANGE is the only strtoull error triggerable
	174	* by strings matching the pattern */
	175	assert(errno == 0);
	176	return DT_LITERAL;
	177	}
	178
	179	<*>{CHAR_LITERAL} {
	180	struct data d;
	181	DPRINT("Character literal: %s\n", yytext);
	182
	183	d = data_copy_escape_string(yytext+1, yyleng-2);
	184	if (d.len == 1) {
	185	lexical_error("Empty character literal");
	186	yylval.integer = 0;
	187	return DT_CHAR_LITERAL;
	188	}
	189
	190	yylval.integer = (unsigned char)d.val[0];
	191
	192	if (d.len > 2)
	193	lexical_error("Character literal has %d"
	194	" characters instead of 1",
	195	d.len - 1);
	196
	197	return DT_CHAR_LITERAL;
	198	}
	199
	200	<>\&{LABEL} { / label reference */
	201	DPRINT("Ref: %s\n", yytext+1);
	202	yylval.labelref = xstrdup(yytext+1);
	203	return DT_REF;
	204	}
	205
	206	<>"&{/"{PATHCHAR}\} { /* new-style path reference */
	207	yytext[yyleng-1] = '\0';
	208	DPRINT("Ref: %s\n", yytext+2);
	209	yylval.labelref = xstrdup(yytext+2);
	210	return DT_REF;
	211	}
	212
	213	<BYTESTRING>[0-9a-fA-F]{2} {
	214	yylval.byte = strtol(yytext, NULL, 16);
	215	DPRINT("Byte: %02x\n", (int)yylval.byte);
	216	return DT_BYTE;
	217	}
	218
	219	<BYTESTRING>"]" {
	220	DPRINT("/BYTESTRING\n");
	221	BEGIN_DEFAULT();
	222	return ']';
	223	}
	224
	225	<PROPNODENAME>\\?{PROPNODECHAR}+ {
	226	DPRINT("PropNodeName: %s\n", yytext);
	227	yylval.propnodename = xstrdup((yytext[0] == '\\') ?
	228	yytext + 1 : yytext);
	229	BEGIN_DEFAULT();
	230	return DT_PROPNODENAME;
	231	}
	232
	233	"/incbin/" {
	234	DPRINT("Binary Include\n");
	235	return DT_INCBIN;
	236	}
	237
	238	<>{WS}+ / eat whitespace */
	239	<>{COMMENT}+ / eat C-style comments */
	240	<>{LINECOMMENT}+ / eat C++-style comments */
	241
	242	<*>"<<" { return DT_LSHIFT; };
	243	<*>">>" { return DT_RSHIFT; };
	244	<*>"<=" { return DT_LE; };
	245	<*>">=" { return DT_GE; };
	246	<*>"==" { return DT_EQ; };
	247	<*>"!=" { return DT_NE; };
	248	<*>"&&" { return DT_AND; };
	249	<*>"\|\|" { return DT_OR; };
	250
	251	<*>. {
	252	DPRINT("Char: %c (\\x%02x)\n", yytext[0],
	253	(unsigned)yytext[0]);
	254	if (yytext[0] == '[') {
	255	DPRINT("<BYTESTRING>\n");
	256	BEGIN(BYTESTRING);
	257	}
	258	if ((yytext[0] == '{')
	259	\|\| (yytext[0] == ';')) {
	260	DPRINT("<PROPNODENAME>\n");
	261	BEGIN(PROPNODENAME);
	262	}
	263	return yytext[0];
	264	}
	265
	266	%%
	267
	268	static void push_input_file(const char *filename)
	269	{
	270	assert(filename);
	271
	272	srcfile_push(filename);
	273
	274	yyin = current_srcfile->f;
	275
	276	yypush_buffer_state(yy_create_buffer(yyin, YY_BUF_SIZE));
	277	}
	278
	279
	280	static bool pop_input_file(void)
	281	{
	282	if (srcfile_pop() == 0)
	283	return false;
	284
	285	yypop_buffer_state();
	286	yyin = current_srcfile->f;
	287
	288	return true;
	289	}
	290
	291	static void lexical_error(const char *fmt, ...)
	292	{
	293	va_list ap;
	294
	295	va_start(ap, fmt);
	296	srcpos_verror(&yylloc, "Lexical error", fmt, ap);
	297	va_end(ap);
	298
	299	treesource_error = true;
	300	}