[cparse] / c-lex.l

%{

  #include "cparse.h"
  
  static int yywrap(void) {
    BEGIN(INITIAL);
    return 1;
  }

  /* cheesy dynamic string stuff */
  static int stringtype;
  static int cppstring;
  static size_t stringlen;
  static char *string;
  static int stringcode;
  
  /* append some bytes to the string */
  static void morestring(const char *ptr, size_t len) {
    if(len > SIZE_MAX - stringlen)
      fatal(0, "string too long");
    string = xrealloc_noptr(string, stringlen + len);
    memcpy(string + stringlen, ptr, len);
    stringlen += len;
  }

  static void newstring(const char *ptr, size_t len) {
    stringlen = 0;
    string = 0;
    morestring(ptr, len);
  }

  /* validate a UCN - return 1 if valid, 0 if not, and report the error.
   * Assumes yylloc set. */
  static int ucnvalid(const char *s) {
    /* 6.4.3 range constraints for UCNs */
    unsigned long u;

    errno = 0;
    u = strtoul(s + 2, 0, 16);
    if(errno) {
      inputerror(&yylloc, "cannot convert UCN '%s'", yytext);
      return 0;
    } else switch(u) {
    case 0x0024:
    case 0x0040:
    case 0x0060:
      return 1;
    default:
      if(u < 0x00A0
	 || (u >= 0xD800 && u <= 0xDFFF)) {
	inputerror(&yylloc, "illegal UCN escape '%s'", yytext);
	return 0;
      } else
	return 1;
    }
  }

  /* set yylloc */
  static inline void loc(void) {
    yylloc.path = path;
    yylloc.line = line;
  }
  
%}

%option debug
%option batch
%option perf-report

%x CPP CPPSKIP LITERAL IDENT

HEXDIGIT [0-9a-fA-f]
UCN \\(u{HEXDIGIT}{4}|U{HEXDIGIT}{8})
BADUCN \\(u.{1,4}|U.{1,8})
DIGIT [0-9]
IDND ([a-zA-Z_]|{UCN})
WS [ \t\r\v\f]

%%

^#{WS}* { BEGIN(CPP); }

<CPP>[0-9]+ {
  long l;
  /* collect line number, crapping out if we can't represent it */
  errno = 0;
  l = strtol(yytext, 0, 10);
  if(errno)
    fatal(errno, "cannot convert line number '%s'", yytext);
  if(l > INT_MAX)
    fatal(0, "line number '%s' is too big", yytext);
  line = l;
}
<CPP,CPPSKIP>{WS}+ { }
<CPP>\" {
  /* collect filename */
  cppstring = 1;
  stringtype = yytext[0];
  BEGIN(LITERAL);
  newstring(0, 0);
}
<CPPSKIP>[0-9]+ { }
<CPP,CPPSKIP>\n { BEGIN(INITIAL); }

\n {
  if(line == INT_MAX)
    fatal(0, "cannot count beyond line %d", INT_MAX);
  ++line;
}
{WS}+ { }

[\"\'] {
  stringtype = yytext[0];
  stringcode = yytext[0] == '"' ? STRINGLIT : CHARLIT;
  loc();
  cppstring = 0;
  BEGIN(LITERAL);
  newstring(0, 0);
}
L[\"\'] {
  stringtype = yytext[1];
  stringcode = yytext[1] == '"' ? WSTRINGLIT : WCHARLIT;
  loc();
  cppstring = 0;
  BEGIN(LITERAL);
  newstring(0, 0);
}
<LITERAL>([^\'\"\\\n]|\\[\'\"\?\\abtnvfr])+ {
  morestring(yytext, yyleng);
}
<LITERAL>\\[0-7]{1,3} {
  /* 6.4.4.4 escapes must fit in an unsigned char */
  unsigned long n;

  errno = 0;
  n = strtoul(yytext + 1, 0, 8);
  if(errno)
    inputerror(&yylloc, "cannot convert octal escape sequence '%s'", yytext);
  else if(n > P_UCHAR_MAX)
    inputerror(&yylloc, "octal escape sequence '%s' out of range", yytext);
  morestring(yytext, yyleng);
}
<LITERAL>\\x[0-9a-fA-F]+ {
  /* 6.4.4.4 escapes must fit in an unsigned char */
  unsigned long n;

  errno = 0;
  n = strtoul(yytext + 2, 0, 16);
  if(errno)
    inputerror(&yylloc, "cannot convert hexadecimal escape sequence '%s'",
	       yytext);
  else if(n > P_UCHAR_MAX)
    inputerror(&yylloc, "hexadecimal escape sequence '%s' out of range",
	       yytext);
  morestring(yytext, yyleng);
}
<LITERAL>\\x. {
  inputerror(&yylloc, "invalid hexadecimal escape sequence '%s'", yytext);
  morestring(yytext, yyleng);
}
<LITERAL>{UCN} {
  ucnvalid(yytext);
  morestring(yytext, yyleng);
}
<LITERAL>{BADUCN} {
  inputerror(&yylloc, "invalid UCN '%s'", yytext);
  morestring(yytext, yyleng);
}
<LITERAL>[\"\'] {
  if(yytext[0] == stringtype) {
  finish_string:
    if(cppstring) {
      morestring("", 1);
      path = string;
      BEGIN(CPPSKIP);
    } else {
      BEGIN(INITIAL);
      /* XXX support strings with embedded 0s */
      yylval.s = xstrndup(string, stringlen);
      return stringcode;
    }
  } else
    morestring(yytext, 1);
}
<LITERAL>\\. {
  inputerror(&yylloc, "invalid escape sequence '%s'", yytext);
  morestring(yytext, yyleng);
}
<LITERAL>\n {
  inputerror(&yylloc, "unterminated literal");
  goto finish_string;
}
<LITERAL><<EOF>> {
  inputerror(&yylloc, "unterminated literal");
  goto finish_string;
}

\.?{DIGIT}({DIGIT}|{IDND}|[eEpP][+\-]|\.)* {
  yylval.s = xstrndup(yytext, yyleng);
  loc();
  return NUMBER;
}

-\> { loc(); return yylval.i = MEMBER; }
\+\+ { loc(); return yylval.i = INCR; }
-- { loc(); return yylval.i = DECR; }
\<\< { loc(); return yylval.i = SL; }
\>\> { loc(); return yylval.i = SR; }
\<= { loc(); return yylval.i = LE; }
\>= { loc(); return yylval.i = GE; }
== { loc(); return yylval.i = EQ; }
!= { loc(); return yylval.i = NE; }
&& { loc(); return yylval.i = AND; }
\|\| { loc(); return yylval.i = OR; }
\.\.\. { loc(); return yylval.i = VARARG; }
\*= { loc(); return yylval.i = MULEQ; }
\/= { loc(); return yylval.i = DIVEQ; }
%= { loc(); return yylval.i = MODEQ; }
\+= { loc(); return yylval.i = ADDEQ; }
-= { loc(); return yylval.i = SUBEQ; }
\<\<= { loc(); return yylval.i = SLEQ; }
\>\>= { loc(); return yylval.i = SREQ; }
&= { loc(); return yylval.i = ANDEQ; }
\^= { loc(); return yylval.i = XOREQ; }
\|= { loc(); return yylval.i = OREQ; }
\<: { loc(); return yylval.i = '['; }
:\> { loc(); return yylval.i = ']'; }
\<% { loc(); return yylval.i = '{'; }
%\> { loc(); return yylval.i = '}'; }
%: { loc(); return yylval.i = '#'; }

auto		{ yylval.u = SCS_AUTO; loc(); return AUTO; }
break		{ loc(); return BREAK; }
case		{ loc(); return CASE; }
char		{ yylval.u = TS_CHAR; loc(); return CHAR; }
const|__const|__const__ { yylval.u = TQ_CONST; loc(); return CONST; }
continue	{ loc(); return CONTINUE; }
default		{ loc(); return DEFAULT; }
do		{ loc(); return DO; }
double		{ yylval.u = TS_DOUBLE; loc(); return DOUBLE; }
else		{ loc(); return ELSE; }
enum		{ loc(); return ENUM; }
extern		{ yylval.u = SCS_EXTERN; loc(); return EXTERN; }
float		{ yylval.u = TS_FLOAT; loc(); return FLOAT; }
for		{ loc(); return FOR; }
goto		{ loc(); return GOTO; }
if		{ loc(); return IF; }
inline|__inline|__inline__	{ yylval.u = FS_INLINE; loc(); return INLINE; }
int		{ yylval.u = TS_INT; loc(); return INT; }
long		{ yylval.u = TS_LONG; loc(); return LONG; }
register	{ yylval.u = SCS_REGISTER; loc(); return REGISTER; }
restrict|__restrict|__restrict__	{ yylval.u = TQ_RESTRICT; loc(); return RESTRICT; }
return		{ loc(); return RETURN; }
short		{ yylval.u = TS_SHORT; loc(); return SHORT; }
signed		{ yylval.u = TS_SIGNED; loc(); return SIGNED; }
sizeof		{ loc(); return SIZEOF; }
static		{ yylval.u = SCS_STATIC; loc(); return STATIC; }
struct		{ yylval.u = TS_STRUCT; loc(); return STRUCT; }
switch		{ loc(); return SWITCH; }
typedef		{ yylval.u = SCS_TYPEDEF; loc(); return TYPEDEF; }
union		{ yylval.u = TS_UNION; loc(); return UNION; }
unsigned	{ yylval.u = TS_UNSIGNED; loc(); return UNSIGNED; }
void		{ yylval.u = TS_VOID; loc(); return VOID; }
volatile|__volatile|__volatile__	{ yylval.u = TQ_VOLATILE; loc(); return VOLATILE; }
while		{ loc(); return WHILE; }
_Bool		{ yylval.u = TS_BOOL; loc(); return BOOL; }
_Complex	{ yylval.u = TS_COMPLEX; loc(); return COMPLEX; }
_Imaginary	{ yylval.u = TS_IMAGINARY; loc(); return IMAGINARY; }

__extension__ { }
__attribute__ { loc(); return ATTRIBUTE; }

__builtin_va_list { yylval.u = TS_GCC_VA_LIST; loc(); return GCC_VA_LIST; }
__builtin_expect { loc(); return GCC_EXPECT; }

__builtin_va_arg {
  loc();
  return GCC_VA_ARG;
}

[a-zA-Z_][a-zA-Z0-9_]* {
  /* identifiers are complicated by our desire to strictly check any UCNs they
   * contain */
  loc();
  BEGIN(IDENT);
  newstring(yytext, yyleng);
}
{UCN} {
  loc();
  ucnvalid(yytext);
  BEGIN(IDENT);
  newstring(yytext, yyleng);
}
{BADUCN} {
  loc();
  inputerror(&yylloc, "invalid UCN '%s'", yytext);
  BEGIN(IDENT);
  newstring(yytext, yyleng);
}

<IDENT>[a-zA-Z0-9_]+ {
  morestring(yytext, yyleng);
}
<IDENT>{UCN} {
  ucnvalid(yytext);
  morestring(yytext, yyleng);
}
<IDENT>{BADUCN} {
  inputerror(&yylloc, "invalid UCN '%s'", yytext);
  morestring(yytext, yyleng);
}

<IDENT>.|\n {
  unput(yytext[0]);
got_id:
  BEGIN(INITIAL);
  /* we need to look up the declaration of each name anyway so we record the
   * type for all of them.  But we can't produce an error here as it might be a
   * struct member or something. */
  yylval.name.name = xstrndup(string, stringlen);
  yylval.name.declarator = lookup(yylval.name.name);
  if(yylval.name.declarator
     && yylval.name.declarator->declaration_specifiers
     && (yylval.name.declarator->declaration_specifiers->storage_class_specifiers
	 & SCS_TYPEDEF))
    return TYPEDEF_NAME;
  else
    return ID;
}

<IDENT><<EOF>> {
  goto got_id;
}

. {
  loc();
  return yylval.i = yytext[0];
}

%%

/*
Local Variables:
mode:c
c-basic-offset:2
comment-column:40
fill-column:79
End:
*/
Commit	Line	Data
3cd4b0f8 MW	1	%{
	2
	3	#include "cparse.h"
	4
	5	static int yywrap(void) {
	6	BEGIN(INITIAL);
	7	return 1;
	8	}
	9
	10	/* cheesy dynamic string stuff */
	11	static int stringtype;
	12	static int cppstring;
	13	static size_t stringlen;
	14	static char *string;
	15	static int stringcode;
	16
	17	/* append some bytes to the string */
	18	static void morestring(const char *ptr, size_t len) {
	19	if(len > SIZE_MAX - stringlen)
	20	fatal(0, "string too long");
	21	string = xrealloc_noptr(string, stringlen + len);
	22	memcpy(string + stringlen, ptr, len);
	23	stringlen += len;
	24	}
	25
	26	static void newstring(const char *ptr, size_t len) {
	27	stringlen = 0;
	28	string = 0;
	29	morestring(ptr, len);
	30	}
	31
	32	/* validate a UCN - return 1 if valid, 0 if not, and report the error.
	33	* Assumes yylloc set. */
	34	static int ucnvalid(const char *s) {
	35	/* 6.4.3 range constraints for UCNs */
	36	unsigned long u;
	37
	38	errno = 0;
	39	u = strtoul(s + 2, 0, 16);
	40	if(errno) {
	41	inputerror(&yylloc, "cannot convert UCN '%s'", yytext);
	42	return 0;
	43	} else switch(u) {
	44	case 0x0024:
	45	case 0x0040:
	46	case 0x0060:
	47	return 1;
	48	default:
	49	if(u < 0x00A0
	50	\|\| (u >= 0xD800 && u <= 0xDFFF)) {
	51	inputerror(&yylloc, "illegal UCN escape '%s'", yytext);
	52	return 0;
	53	} else
	54	return 1;
	55	}
	56	}
	57
	58	/* set yylloc */
	59	static inline void loc(void) {
	60	yylloc.path = path;
	61	yylloc.line = line;
	62	}
	63
	64	%}
65
66	%option debug
67	%option batch
68	%option perf-report
69
70	%x CPP CPPSKIP LITERAL IDENT
71
72	HEXDIGIT [0-9a-fA-f]
73	UCN \\(u{HEXDIGIT}{4}\|U{HEXDIGIT}{8})
74	BADUCN \\(u.{1,4}\|U.{1,8})
75	DIGIT [0-9]
76	IDND ([a-zA-Z_]\|{UCN})
77	WS [ \t\r\v\f]
78
79	%%
80
81	^#{WS}* { BEGIN(CPP); }
82
83	<CPP>[0-9]+ {
84	long l;
85	/* collect line number, crapping out if we can't represent it */
86	errno = 0;
87	l = strtol(yytext, 0, 10);
88	if(errno)
89	fatal(errno, "cannot convert line number '%s'", yytext);
90	if(l > INT_MAX)
91	fatal(0, "line number '%s' is too big", yytext);
92	line = l;
93	}
94	<CPP,CPPSKIP>{WS}+ { }
95	<CPP>\" {
96	/* collect filename */
97	cppstring = 1;
98	stringtype = yytext[0];
99	BEGIN(LITERAL);
100	newstring(0, 0);
101	}
102	<CPPSKIP>[0-9]+ { }
103	<CPP,CPPSKIP>\n { BEGIN(INITIAL); }
104
105	\n {
106	if(line == INT_MAX)
107	fatal(0, "cannot count beyond line %d", INT_MAX);
108	++line;
109	}
110	{WS}+ { }
111
112	[\"\'] {
113	stringtype = yytext[0];
114	stringcode = yytext[0] == '"' ? STRINGLIT : CHARLIT;
115	loc();
116	cppstring = 0;
117	BEGIN(LITERAL);
118	newstring(0, 0);
119	}
120	L[\"\'] {
121	stringtype = yytext[1];
122	stringcode = yytext[1] == '"' ? WSTRINGLIT : WCHARLIT;
123	loc();
124	cppstring = 0;
125	BEGIN(LITERAL);
126	newstring(0, 0);
127	}
128	<LITERAL>([^\'\"\\\n]\|\\[\'\"\?\\abtnvfr])+ {
129	morestring(yytext, yyleng);
130	}
131	<LITERAL>\\[0-7]{1,3} {
132	/* 6.4.4.4 escapes must fit in an unsigned char */
133	unsigned long n;
134
135	errno = 0;
136	n = strtoul(yytext + 1, 0, 8);
137	if(errno)
138	inputerror(&yylloc, "cannot convert octal escape sequence '%s'", yytext);
139	else if(n > P_UCHAR_MAX)
140	inputerror(&yylloc, "octal escape sequence '%s' out of range", yytext);
141	morestring(yytext, yyleng);
142	}
143	<LITERAL>\\x[0-9a-fA-F]+ {
144	/* 6.4.4.4 escapes must fit in an unsigned char */
145	unsigned long n;
146
147	errno = 0;
148	n = strtoul(yytext + 2, 0, 16);
149	if(errno)
150	inputerror(&yylloc, "cannot convert hexadecimal escape sequence '%s'",
151	yytext);
152	else if(n > P_UCHAR_MAX)
153	inputerror(&yylloc, "hexadecimal escape sequence '%s' out of range",
154	yytext);
155	morestring(yytext, yyleng);
156	}
157	<LITERAL>\\x. {
158	inputerror(&yylloc, "invalid hexadecimal escape sequence '%s'", yytext);
159	morestring(yytext, yyleng);
160	}
161	<LITERAL>{UCN} {
162	ucnvalid(yytext);
163	morestring(yytext, yyleng);
164	}
165	<LITERAL>{BADUCN} {
166	inputerror(&yylloc, "invalid UCN '%s'", yytext);
167	morestring(yytext, yyleng);
168	}
169	<LITERAL>[\"\'] {
170	if(yytext[0] == stringtype) {
171	finish_string:
172	if(cppstring) {
173	morestring("", 1);
174	path = string;
175	BEGIN(CPPSKIP);
176	} else {
177	BEGIN(INITIAL);
178	/* XXX support strings with embedded 0s */
179	yylval.s = xstrndup(string, stringlen);
180	return stringcode;
181	}
182	} else
183	morestring(yytext, 1);
184	}
185	<LITERAL>\\. {
186	inputerror(&yylloc, "invalid escape sequence '%s'", yytext);
187	morestring(yytext, yyleng);
188	}
189	<LITERAL>\n {
190	inputerror(&yylloc, "unterminated literal");
191	goto finish_string;
192	}
193	<LITERAL><<EOF>> {
194	inputerror(&yylloc, "unterminated literal");
195	goto finish_string;
196	}
197
198	\.?{DIGIT}({DIGIT}\|{IDND}\|[eEpP][+\-]\|\.)* {
199	yylval.s = xstrndup(yytext, yyleng);
200	loc();
201	return NUMBER;
202	}
203
204	-\> { loc(); return yylval.i = MEMBER; }
205	\+\+ { loc(); return yylval.i = INCR; }
206	-- { loc(); return yylval.i = DECR; }
207	\<\< { loc(); return yylval.i = SL; }
208	\>\> { loc(); return yylval.i = SR; }
209	\<= { loc(); return yylval.i = LE; }
210	\>= { loc(); return yylval.i = GE; }
211	== { loc(); return yylval.i = EQ; }
212	!= { loc(); return yylval.i = NE; }
213	&& { loc(); return yylval.i = AND; }
214	\\|\\| { loc(); return yylval.i = OR; }
215	\.\.\. { loc(); return yylval.i = VARARG; }
216	\*= { loc(); return yylval.i = MULEQ; }
217	\/= { loc(); return yylval.i = DIVEQ; }
218	%= { loc(); return yylval.i = MODEQ; }
219	\+= { loc(); return yylval.i = ADDEQ; }
220	-= { loc(); return yylval.i = SUBEQ; }
221	\<\<= { loc(); return yylval.i = SLEQ; }
222	\>\>= { loc(); return yylval.i = SREQ; }
223	&= { loc(); return yylval.i = ANDEQ; }
224	\^= { loc(); return yylval.i = XOREQ; }
225	\\|= { loc(); return yylval.i = OREQ; }
226	\<: { loc(); return yylval.i = '['; }
227	:\> { loc(); return yylval.i = ']'; }
228	\<% { loc(); return yylval.i = '{'; }
229	%\> { loc(); return yylval.i = '}'; }
230	%: { loc(); return yylval.i = '#'; }
231
232	auto { yylval.u = SCS_AUTO; loc(); return AUTO; }
233	break { loc(); return BREAK; }
234	case { loc(); return CASE; }
235	char { yylval.u = TS_CHAR; loc(); return CHAR; }
236	const\|__const\|__const__ { yylval.u = TQ_CONST; loc(); return CONST; }
237	continue { loc(); return CONTINUE; }
238	default { loc(); return DEFAULT; }
239	do { loc(); return DO; }
240	double { yylval.u = TS_DOUBLE; loc(); return DOUBLE; }
241	else { loc(); return ELSE; }
242	enum { loc(); return ENUM; }
243	extern { yylval.u = SCS_EXTERN; loc(); return EXTERN; }
244	float { yylval.u = TS_FLOAT; loc(); return FLOAT; }
245	for { loc(); return FOR; }
246	goto { loc(); return GOTO; }
247	if { loc(); return IF; }
248	inline\|__inline\|__inline__ { yylval.u = FS_INLINE; loc(); return INLINE; }
249	int { yylval.u = TS_INT; loc(); return INT; }
250	long { yylval.u = TS_LONG; loc(); return LONG; }
251	register { yylval.u = SCS_REGISTER; loc(); return REGISTER; }
252	restrict\|__restrict\|__restrict__ { yylval.u = TQ_RESTRICT; loc(); return RESTRICT; }
253	return { loc(); return RETURN; }
254	short { yylval.u = TS_SHORT; loc(); return SHORT; }
255	signed { yylval.u = TS_SIGNED; loc(); return SIGNED; }
256	sizeof { loc(); return SIZEOF; }
257	static { yylval.u = SCS_STATIC; loc(); return STATIC; }
258	struct { yylval.u = TS_STRUCT; loc(); return STRUCT; }
259	switch { loc(); return SWITCH; }
260	typedef { yylval.u = SCS_TYPEDEF; loc(); return TYPEDEF; }
261	union { yylval.u = TS_UNION; loc(); return UNION; }
262	unsigned { yylval.u = TS_UNSIGNED; loc(); return UNSIGNED; }
263	void { yylval.u = TS_VOID; loc(); return VOID; }
264	volatile\|__volatile\|__volatile__ { yylval.u = TQ_VOLATILE; loc(); return VOLATILE; }
265	while { loc(); return WHILE; }
266	_Bool { yylval.u = TS_BOOL; loc(); return BOOL; }
267	_Complex { yylval.u = TS_COMPLEX; loc(); return COMPLEX; }
268	_Imaginary { yylval.u = TS_IMAGINARY; loc(); return IMAGINARY; }
269
270	__extension__ { }
271	__attribute__ { loc(); return ATTRIBUTE; }
272
273	__builtin_va_list { yylval.u = TS_GCC_VA_LIST; loc(); return GCC_VA_LIST; }
274	__builtin_expect { loc(); return GCC_EXPECT; }
275
276	__builtin_va_arg {
277	loc();
278	return GCC_VA_ARG;
279	}
280
281	[a-zA-Z_][a-zA-Z0-9_]* {
282	/* identifiers are complicated by our desire to strictly check any UCNs they
283	* contain */
284	loc();
285	BEGIN(IDENT);
286	newstring(yytext, yyleng);
287	}
288	{UCN} {
289	loc();
290	ucnvalid(yytext);
291	BEGIN(IDENT);
292	newstring(yytext, yyleng);
293	}
294	{BADUCN} {
295	loc();
296	inputerror(&yylloc, "invalid UCN '%s'", yytext);
297	BEGIN(IDENT);
298	newstring(yytext, yyleng);
299	}
300
301	<IDENT>[a-zA-Z0-9_]+ {
302	morestring(yytext, yyleng);
303	}
304	<IDENT>{UCN} {
305	ucnvalid(yytext);
306	morestring(yytext, yyleng);
307	}
308	<IDENT>{BADUCN} {
309	inputerror(&yylloc, "invalid UCN '%s'", yytext);
310	morestring(yytext, yyleng);
311	}
312
313	<IDENT>.\|\n {
314	unput(yytext[0]);
315	got_id:
316	BEGIN(INITIAL);
317	/* we need to look up the declaration of each name anyway so we record the
318	* type for all of them. But we can't produce an error here as it might be a
319	* struct member or something. */
320	yylval.name.name = xstrndup(string, stringlen);
321	yylval.name.declarator = lookup(yylval.name.name);
322	if(yylval.name.declarator
323	&& yylval.name.declarator->declaration_specifiers
324	&& (yylval.name.declarator->declaration_specifiers->storage_class_specifiers
325	& SCS_TYPEDEF))
326	return TYPEDEF_NAME;
327	else
328	return ID;
329	}
330
331	<IDENT><<EOF>> {
332	goto got_id;
333	}
334
335	. {
336	loc();
337	return yylval.i = yytext[0];
338	}
339
340	%%
341
342	/*
343	Local Variables:
344	mode:c
345	c-basic-offset:2
346	comment-column:40
347	fill-column:79
348	End:
349	*/