[deliverable/linux.git] / scripts / genksyms / lex.l

/* Lexical analysis for genksyms.
   Copyright 1996, 1997 Linux International.

   New implementation contributed by Richard Henderson <rth@tamu.edu>
   Based on original work by Bjorn Ekwall <bj0rn@blox.se>

   Taken from Linux modutils 2.4.22.

   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.  */


%{

#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include "genksyms.h"
#include "parse.tab.h"

/* We've got a two-level lexer here.  We let flex do basic tokenization
   and then we categorize those basic tokens in the second stage.  */
#define YY_DECL		static int yylex1(void)

%}

IDENT			[A-Za-z_\$][A-Za-z0-9_\$]*

O_INT			0[0-7]*
D_INT			[1-9][0-9]*
X_INT			0[Xx][0-9A-Fa-f]+
I_SUF			[Uu]|[Ll]|[Uu][Ll]|[Ll][Uu]
INT			({O_INT}|{D_INT}|{X_INT}){I_SUF}?

FRAC			([0-9]*\.[0-9]+)|([0-9]+\.)
EXP			[Ee][+-]?[0-9]+
F_SUF			[FfLl]
REAL			({FRAC}{EXP}?{F_SUF}?)|([0-9]+{EXP}{F_SUF}?)

STRING			L?\"([^\\\"]*\\.)*[^\\\"]*\"
CHAR			L?\'([^\\\']*\\.)*[^\\\']*\'

MC_TOKEN		([~%^&*+=|<>/-]=)|(&&)|("||")|(->)|(<<)|(>>)

/* We don't do multiple input files.  */
%option noyywrap

%option noinput

%%


 /* Keep track of our location in the original source files.  */
^#[ \t]+{INT}[ \t]+\"[^\"\n]+\".*\n	return FILENAME;
^#.*\n					cur_line++;
\n					cur_line++;

 /* Ignore all other whitespace.  */
[ \t\f\v\r]+				;


{STRING}				return STRING;
{CHAR}					return CHAR;
{IDENT}					return IDENT;

 /* The Pedant requires that the other C multi-character tokens be
    recognized as tokens.  We don't actually use them since we don't
    parse expressions, but we do want whitespace to be arranged
    around them properly.  */
{MC_TOKEN}				return OTHER;
{INT}					return INT;
{REAL}					return REAL;

"..."					return DOTS;

 /* All other tokens are single characters.  */
.					return yytext[0];


%%

/* Bring in the keyword recognizer.  */

#include "keywords.hash.c"


/* Macros to append to our phrase collection list.  */

/*
 * We mark any token, that that equals to a known enumerator, as
 * SYM_ENUM_CONST. The parser will change this for struct and union tags later,
 * the only problem is struct and union members:
 *    enum e { a, b }; struct s { int a, b; }
 * but in this case, the only effect will be, that the ABI checksums become
 * more volatile, which is acceptable. Also, such collisions are quite rare,
 * so far it was only observed in include/linux/telephony.h.
 */
#define _APP(T,L)	do {						   \
			  cur_node = next_node;				   \
			  next_node = xmalloc(sizeof(*next_node));	   \
			  next_node->next = cur_node;			   \
			  cur_node->string = memcpy(xmalloc(L+1), T, L+1); \
			  cur_node->tag =				   \
			    find_symbol(cur_node->string, SYM_ENUM_CONST, 1)?\
			    SYM_ENUM_CONST : SYM_NORMAL ;		   \
			  cur_node->in_source_file = in_source_file;       \
			} while (0)

#define APP		_APP(yytext, yyleng)


/* The second stage lexer.  Here we incorporate knowledge of the state
   of the parser to tailor the tokens that are returned.  */

int
yylex(void)
{
  static enum {
    ST_NOTSTARTED, ST_NORMAL, ST_ATTRIBUTE, ST_ASM, ST_TYPEOF, ST_TYPEOF_1,
    ST_BRACKET, ST_BRACE, ST_EXPRESSION,
    ST_TABLE_1, ST_TABLE_2, ST_TABLE_3, ST_TABLE_4,
    ST_TABLE_5, ST_TABLE_6
  } lexstate = ST_NOTSTARTED;

  static int suppress_type_lookup, dont_want_brace_phrase;
  static struct string_list *next_node;

  int token, count = 0;
  struct string_list *cur_node;

  if (lexstate == ST_NOTSTARTED)
    {
      next_node = xmalloc(sizeof(*next_node));
      next_node->next = NULL;
      lexstate = ST_NORMAL;
    }

repeat:
  token = yylex1();

  if (token == 0)
    return 0;
  else if (token == FILENAME)
    {
      char *file, *e;

      /* Save the filename and line number for later error messages.  */

      if (cur_filename)
	free(cur_filename);

      file = strchr(yytext, '\"')+1;
      e = strchr(file, '\"');
      *e = '\0';
      cur_filename = memcpy(xmalloc(e-file+1), file, e-file+1);
      cur_line = atoi(yytext+2);

      if (!source_file) {
        source_file = xstrdup(cur_filename);
        in_source_file = 1;
      } else {
        in_source_file = (strcmp(cur_filename, source_file) == 0);
      }

      goto repeat;
    }

  switch (lexstate)
    {
    case ST_NORMAL:
      switch (token)
	{
	case IDENT:
	  APP;
	  {
	    const struct resword *r = is_reserved_word(yytext, yyleng);
	    if (r)
	      {
		switch (token = r->token)
		  {
		  case ATTRIBUTE_KEYW:
		    lexstate = ST_ATTRIBUTE;
		    count = 0;
		    goto repeat;
		  case ASM_KEYW:
		    lexstate = ST_ASM;
		    count = 0;
		    goto repeat;
		  case TYPEOF_KEYW:
		    lexstate = ST_TYPEOF;
		    count = 0;
		    goto repeat;

		  case STRUCT_KEYW:
		  case UNION_KEYW:
		  case ENUM_KEYW:
		    dont_want_brace_phrase = 3;
		    suppress_type_lookup = 2;
		    goto fini;

		  case EXPORT_SYMBOL_KEYW:
		      goto fini;
		  }
	      }
	    if (!suppress_type_lookup)
	      {
		if (find_symbol(yytext, SYM_TYPEDEF, 1))
		  token = TYPE;
	      }
	  }
	  break;

	case '[':
	  APP;
	  lexstate = ST_BRACKET;
	  count = 1;
	  goto repeat;

	case '{':
	  APP;
	  if (dont_want_brace_phrase)
	    break;
	  lexstate = ST_BRACE;
	  count = 1;
	  goto repeat;

	case '=': case ':':
	  APP;
	  lexstate = ST_EXPRESSION;
	  break;

	case DOTS:
	default:
	  APP;
	  break;
	}
      break;

    case ST_ATTRIBUTE:
      APP;
      switch (token)
	{
	case '(':
	  ++count;
	  goto repeat;
	case ')':
	  if (--count == 0)
	    {
	      lexstate = ST_NORMAL;
	      token = ATTRIBUTE_PHRASE;
	      break;
	    }
	  goto repeat;
	default:
	  goto repeat;
	}
      break;

    case ST_ASM:
      APP;
      switch (token)
	{
	case '(':
	  ++count;
	  goto repeat;
	case ')':
	  if (--count == 0)
	    {
	      lexstate = ST_NORMAL;
	      token = ASM_PHRASE;
	      break;
	    }
	  goto repeat;
	default:
	  goto repeat;
	}
      break;

    case ST_TYPEOF:
      switch (token)
	{
	case '(':
	  if ( ++count == 1 )
	    lexstate = ST_TYPEOF_1;
	  else
	    APP;
	  goto repeat;
	case ')':
	  APP;
	  if (--count == 0)
	    {
	      lexstate = ST_NORMAL;
	      token = TYPEOF_PHRASE;
	      break;
	    }
	  goto repeat;
	default:
	  APP;
	  goto repeat;
	}
      break;

    case ST_TYPEOF_1:
      if (token == IDENT)
	{
	  if (is_reserved_word(yytext, yyleng)
	      || find_symbol(yytext, SYM_TYPEDEF, 1))
	    {
	      yyless(0);
	      unput('(');
	      lexstate = ST_NORMAL;
	      token = TYPEOF_KEYW;
	      break;
	    }
	  _APP("(", 1);
	}
	APP;
	lexstate = ST_TYPEOF;
	goto repeat;

    case ST_BRACKET:
      APP;
      switch (token)
	{
	case '[':
	  ++count;
	  goto repeat;
	case ']':
	  if (--count == 0)
	    {
	      lexstate = ST_NORMAL;
	      token = BRACKET_PHRASE;
	      break;
	    }
	  goto repeat;
	default:
	  goto repeat;
	}
      break;

    case ST_BRACE:
      APP;
      switch (token)
	{
	case '{':
	  ++count;
	  goto repeat;
	case '}':
	  if (--count == 0)
	    {
	      lexstate = ST_NORMAL;
	      token = BRACE_PHRASE;
	      break;
	    }
	  goto repeat;
	default:
	  goto repeat;
	}
      break;

    case ST_EXPRESSION:
      switch (token)
	{
	case '(': case '[': case '{':
	  ++count;
	  APP;
	  goto repeat;
	case '}':
	  /* is this the last line of an enum declaration? */
	  if (count == 0)
	    {
	      /* Put back the token we just read so's we can find it again
		 after registering the expression.  */
	      unput(token);

	      lexstate = ST_NORMAL;
	      token = EXPRESSION_PHRASE;
	      break;
	    }
	  /* FALLTHRU */
	case ')': case ']':
	  --count;
	  APP;
	  goto repeat;
	case ',': case ';':
	  if (count == 0)
	    {
	      /* Put back the token we just read so's we can find it again
		 after registering the expression.  */
	      unput(token);

	      lexstate = ST_NORMAL;
	      token = EXPRESSION_PHRASE;
	      break;
	    }
	  APP;
	  goto repeat;
	default:
	  APP;
	  goto repeat;
	}
      break;

    case ST_TABLE_1:
      goto repeat;

    case ST_TABLE_2:
      if (token == IDENT && yyleng == 1 && yytext[0] == 'X')
	{
	  token = EXPORT_SYMBOL_KEYW;
	  lexstate = ST_TABLE_5;
	  APP;
	  break;
	}
      lexstate = ST_TABLE_6;
      /* FALLTHRU */

    case ST_TABLE_6:
      switch (token)
	{
	case '{': case '[': case '(':
	  ++count;
	  break;
	case '}': case ']': case ')':
	  --count;
	  break;
	case ',':
	  if (count == 0)
	    lexstate = ST_TABLE_2;
	  break;
	};
      goto repeat;

    case ST_TABLE_3:
      goto repeat;

    case ST_TABLE_4:
      if (token == ';')
	lexstate = ST_NORMAL;
      goto repeat;

    case ST_TABLE_5:
      switch (token)
	{
	case ',':
	  token = ';';
	  lexstate = ST_TABLE_2;
	  APP;
	  break;
	default:
	  APP;
	  break;
	}
      break;

    default:
      exit(1);
    }
fini:

  if (suppress_type_lookup > 0)
    --suppress_type_lookup;
  if (dont_want_brace_phrase > 0)
    --dont_want_brace_phrase;

  yylval = &next_node->next;

  return token;
}
Commit	Line	Data
1da177e4 LT	1	/* Lexical analysis for genksyms.
	2	Copyright 1996, 1997 Linux International.
	3
	4	New implementation contributed by Richard Henderson <rth@tamu.edu>
	5	Based on original work by Bjorn Ekwall <bj0rn@blox.se>
	6
	7	Taken from Linux modutils 2.4.22.
	8
	9	This program is free software; you can redistribute it and/or modify it
	10	under the terms of the GNU General Public License as published by the
	11	Free Software Foundation; either version 2 of the License, or (at your
	12	option) any later version.
	13
	14	This program is distributed in the hope that it will be useful, but
	15	WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with this program; if not, write to the Free Software Foundation,
	21	Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	22
	23
	24	%{
	25
	26	#include <limits.h>
	27	#include <stdlib.h>
	28	#include <string.h>
	29	#include <ctype.h>
	30
	31	#include "genksyms.h"
880f4499	32	#include "parse.tab.h"
1da177e4 LT	33
	34	/* We've got a two-level lexer here. We let flex do basic tokenization
	35	and then we categorize those basic tokens in the second stage. */
	36	#define YY_DECL static int yylex1(void)
	37
	38	%}
	39
	40	IDENT [A-Za-z_\$][A-Za-z0-9_\$]*
	41
	42	O_INT 0[0-7]*
	43	D_INT [1-9][0-9]*
	44	X_INT 0[Xx][0-9A-Fa-f]+
	45	I_SUF [Uu]\|[Ll]\|[Uu][Ll]\|[Ll][Uu]
	46	INT ({O_INT}\|{D_INT}\|{X_INT}){I_SUF}?
	47
	48	FRAC ([0-9]*\.[0-9]+)\|([0-9]+\.)
	49	EXP [Ee][+-]?[0-9]+
	50	F_SUF [FfLl]
	51	REAL ({FRAC}{EXP}?{F_SUF}?)\|([0-9]+{EXP}{F_SUF}?)
	52
	53	STRING L?\"([^\\\"]\\.)[^\\\"]*\"
	54	CHAR L?\'([^\\\']\\.)[^\\\']*\'
	55
	56	MC_TOKEN ([~%^&*+=\|<>/-]=)\|(&&)\|("\|\|")\|(->)\|(<<)\|(>>)
	57
1da177e4 LT	58	/* We don't do multiple input files. */
	59	%option noyywrap
	60
11ddad39 AB	61	%option noinput
11ddad39 AB	62
1da177e4 LT	63	%%
	64
	65
	66	/* Keep track of our location in the original source files. */
	67	^#[ \t]+{INT}[ \t]+\"[^\"\n]+\".*\n return FILENAME;
	68	^#.*\n cur_line++;
	69	\n cur_line++;
	70
	71	/* Ignore all other whitespace. */
	72	[ \t\f\v\r]+ ;
	73
	74
	75	{STRING} return STRING;
	76	{CHAR} return CHAR;
	77	{IDENT} return IDENT;
	78
	79	/* The Pedant requires that the other C multi-character tokens be
	80	recognized as tokens. We don't actually use them since we don't
	81	parse expressions, but we do want whitespace to be arranged
	82	around them properly. */
95f1d639 MM	83	{MC_TOKEN} return OTHER;
	84	{INT} return INT;
	85	{REAL} return REAL;
1da177e4 LT	86
	87	"..." return DOTS;
	88
	89	/* All other tokens are single characters. */
	90	. return yytext[0];
	91
	92
	93	%%
	94
	95	/* Bring in the keyword recognizer. */
	96
880f4499	97	#include "keywords.hash.c"
1da177e4 LT	98
	99
	100	/* Macros to append to our phrase collection list. */
	101
e37ddb82 MM	102	/*
	103	* We mark any token, that that equals to a known enumerator, as
	104	* SYM_ENUM_CONST. The parser will change this for struct and union tags later,
	105	* the only problem is struct and union members:
	106	* enum e { a, b }; struct s { int a, b; }
	107	* but in this case, the only effect will be, that the ABI checksums become
	108	* more volatile, which is acceptable. Also, such collisions are quite rare,
	109	* so far it was only observed in include/linux/telephony.h.
	110	*/
1da177e4 LT	111	#define _APP(T,L) do { \
	112	cur_node = next_node; \
	113	next_node = xmalloc(sizeof(*next_node)); \
	114	next_node->next = cur_node; \
	115	cur_node->string = memcpy(xmalloc(L+1), T, L+1); \
e37ddb82 MM	116	cur_node->tag = \
	117	find_symbol(cur_node->string, SYM_ENUM_CONST, 1)?\
	118	SYM_ENUM_CONST : SYM_NORMAL ; \
2c5925d6	119	cur_node->in_source_file = in_source_file; \
1da177e4 LT	120	} while (0)
	121
	122	#define APP _APP(yytext, yyleng)
	123
	124
	125	/* The second stage lexer. Here we incorporate knowledge of the state
	126	of the parser to tailor the tokens that are returned. */
	127
	128	int
	129	yylex(void)
	130	{
	131	static enum {
dc533240 JB	132	ST_NOTSTARTED, ST_NORMAL, ST_ATTRIBUTE, ST_ASM, ST_TYPEOF, ST_TYPEOF_1,
	133	ST_BRACKET, ST_BRACE, ST_EXPRESSION,
	134	ST_TABLE_1, ST_TABLE_2, ST_TABLE_3, ST_TABLE_4,
1da177e4 LT	135	ST_TABLE_5, ST_TABLE_6
	136	} lexstate = ST_NOTSTARTED;
	137
	138	static int suppress_type_lookup, dont_want_brace_phrase;
	139	static struct string_list *next_node;
	140
	141	int token, count = 0;
	142	struct string_list *cur_node;
	143
	144	if (lexstate == ST_NOTSTARTED)
	145	{
1da177e4 LT	146	next_node = xmalloc(sizeof(*next_node));
	147	next_node->next = NULL;
	148	lexstate = ST_NORMAL;
	149	}
	150
	151	repeat:
	152	token = yylex1();
	153
	154	if (token == 0)
	155	return 0;
	156	else if (token == FILENAME)
	157	{
	158	char file, e;
	159
	160	/* Save the filename and line number for later error messages. */
	161
	162	if (cur_filename)
	163	free(cur_filename);
	164
	165	file = strchr(yytext, '\"')+1;
	166	e = strchr(file, '\"');
	167	*e = '\0';
	168	cur_filename = memcpy(xmalloc(e-file+1), file, e-file+1);
	169	cur_line = atoi(yytext+2);
	170
2c5925d6 MM	171	if (!source_file) {
	172	source_file = xstrdup(cur_filename);
	173	in_source_file = 1;
	174	} else {
	175	in_source_file = (strcmp(cur_filename, source_file) == 0);
	176	}
	177
1da177e4 LT	178	goto repeat;
	179	}
	180
	181	switch (lexstate)
	182	{
	183	case ST_NORMAL:
	184	switch (token)
	185	{
	186	case IDENT:
	187	APP;
	188	{
	189	const struct resword *r = is_reserved_word(yytext, yyleng);
	190	if (r)
	191	{
	192	switch (token = r->token)
	193	{
	194	case ATTRIBUTE_KEYW:
	195	lexstate = ST_ATTRIBUTE;
	196	count = 0;
	197	goto repeat;
	198	case ASM_KEYW:
	199	lexstate = ST_ASM;
	200	count = 0;
	201	goto repeat;
dc533240 JB	202	case TYPEOF_KEYW:
	203	lexstate = ST_TYPEOF;
	204	count = 0;
	205	goto repeat;
1da177e4 LT	206
	207	case STRUCT_KEYW:
	208	case UNION_KEYW:
1da177e4	209	case ENUM_KEYW:
e37ddb82	210	dont_want_brace_phrase = 3;
1da177e4 LT	211	suppress_type_lookup = 2;
	212	goto fini;
	213
	214	case EXPORT_SYMBOL_KEYW:
	215	goto fini;
	216	}
	217	}
	218	if (!suppress_type_lookup)
	219	{
01762c4e	220	if (find_symbol(yytext, SYM_TYPEDEF, 1))
1da177e4 LT	221	token = TYPE;
	222	}
	223	}
	224	break;
	225
	226	case '[':
	227	APP;
	228	lexstate = ST_BRACKET;
	229	count = 1;
	230	goto repeat;
	231
	232	case '{':
	233	APP;
	234	if (dont_want_brace_phrase)
	235	break;
	236	lexstate = ST_BRACE;
	237	count = 1;
	238	goto repeat;
	239
	240	case '=': case ':':
	241	APP;
	242	lexstate = ST_EXPRESSION;
	243	break;
	244
	245	case DOTS:
	246	default:
	247	APP;
	248	break;
	249	}
	250	break;
	251
	252	case ST_ATTRIBUTE:
	253	APP;
	254	switch (token)
	255	{
	256	case '(':
	257	++count;
	258	goto repeat;
	259	case ')':
	260	if (--count == 0)
	261	{
	262	lexstate = ST_NORMAL;
	263	token = ATTRIBUTE_PHRASE;
	264	break;
	265	}
	266	goto repeat;
	267	default:
	268	goto repeat;
	269	}
	270	break;
	271
	272	case ST_ASM:
	273	APP;
	274	switch (token)
	275	{
	276	case '(':
	277	++count;
	278	goto repeat;
	279	case ')':
	280	if (--count == 0)
	281	{
	282	lexstate = ST_NORMAL;
	283	token = ASM_PHRASE;
	284	break;
285	}
286	goto repeat;
287	default:
288	goto repeat;
289	}
290	break;
291
dc533240 JB	292	case ST_TYPEOF:
	293	switch (token)
	294	{
	295	case '(':
	296	if ( ++count == 1 )
	297	lexstate = ST_TYPEOF_1;
	298	else
	299	APP;
	300	goto repeat;
	301	case ')':
	302	APP;
	303	if (--count == 0)
	304	{
	305	lexstate = ST_NORMAL;
	306	token = TYPEOF_PHRASE;
	307	break;
	308	}
	309	goto repeat;
	310	default:
	311	APP;
	312	goto repeat;
	313	}
	314	break;
	315
	316	case ST_TYPEOF_1:
	317	if (token == IDENT)
	318	{
	319	if (is_reserved_word(yytext, yyleng)
	320	\|\| find_symbol(yytext, SYM_TYPEDEF, 1))
	321	{
	322	yyless(0);
	323	unput('(');
	324	lexstate = ST_NORMAL;
	325	token = TYPEOF_KEYW;
	326	break;
	327	}
	328	_APP("(", 1);
	329	}
	330	APP;
	331	lexstate = ST_TYPEOF;
	332	goto repeat;
	333
1da177e4 LT	334	case ST_BRACKET:
	335	APP;
	336	switch (token)
	337	{
	338	case '[':
	339	++count;
	340	goto repeat;
	341	case ']':
	342	if (--count == 0)
	343	{
	344	lexstate = ST_NORMAL;
	345	token = BRACKET_PHRASE;
	346	break;
	347	}
	348	goto repeat;
	349	default:
	350	goto repeat;
	351	}
	352	break;
	353
	354	case ST_BRACE:
	355	APP;
	356	switch (token)
	357	{
	358	case '{':
	359	++count;
	360	goto repeat;
	361	case '}':
	362	if (--count == 0)
	363	{
	364	lexstate = ST_NORMAL;
	365	token = BRACE_PHRASE;
	366	break;
	367	}
	368	goto repeat;
	369	default:
	370	goto repeat;
	371	}
	372	break;
	373
	374	case ST_EXPRESSION:
	375	switch (token)
	376	{
	377	case '(': case '[': case '{':
	378	++count;
	379	APP;
	380	goto repeat;
e37ddb82 MM	381	case '}':
	382	/* is this the last line of an enum declaration? */
	383	if (count == 0)
	384	{
	385	/* Put back the token we just read so's we can find it again
	386	after registering the expression. */
	387	unput(token);
	388
	389	lexstate = ST_NORMAL;
	390	token = EXPRESSION_PHRASE;
	391	break;
	392	}
	393	/* FALLTHRU */
	394	case ')': case ']':
1da177e4 LT	395	--count;
	396	APP;
	397	goto repeat;
	398	case ',': case ';':
	399	if (count == 0)
	400	{
	401	/* Put back the token we just read so's we can find it again
	402	after registering the expression. */
	403	unput(token);
	404
	405	lexstate = ST_NORMAL;
	406	token = EXPRESSION_PHRASE;
	407	break;
	408	}
	409	APP;
	410	goto repeat;
	411	default:
	412	APP;
	413	goto repeat;
	414	}
	415	break;
	416
	417	case ST_TABLE_1:
	418	goto repeat;
	419
	420	case ST_TABLE_2:
	421	if (token == IDENT && yyleng == 1 && yytext[0] == 'X')
	422	{
	423	token = EXPORT_SYMBOL_KEYW;
	424	lexstate = ST_TABLE_5;
	425	APP;
	426	break;
	427	}
	428	lexstate = ST_TABLE_6;
	429	/* FALLTHRU */
	430
	431	case ST_TABLE_6:
	432	switch (token)
	433	{
	434	case '{': case '[': case '(':
	435	++count;
	436	break;
	437	case '}': case ']': case ')':
	438	--count;
	439	break;
	440	case ',':
	441	if (count == 0)
	442	lexstate = ST_TABLE_2;
	443	break;
	444	};
	445	goto repeat;
	446
	447	case ST_TABLE_3:
	448	goto repeat;
	449
	450	case ST_TABLE_4:
	451	if (token == ';')
	452	lexstate = ST_NORMAL;
	453	goto repeat;
	454
	455	case ST_TABLE_5:
	456	switch (token)
	457	{
	458	case ',':
459	token = ';';
460	lexstate = ST_TABLE_2;
461	APP;
462	break;
463	default:
464	APP;
465	break;
466	}
467	break;
468
469	default:
6803dc0e	470	exit(1);
1da177e4 LT	471	}
	472	fini:
	473
	474	if (suppress_type_lookup > 0)
	475	--suppress_type_lookup;
	476	if (dont_want_brace_phrase > 0)
	477	--dont_want_brace_phrase;
	478
	479	yylval = &next_node->next;
	480
	481	return token;
	482	}