From 095b11bc36fe0a564484971fb8f3554b75557ad2 Mon Sep 17 00:00:00 2001 From: Randy Heit Date: Wed, 31 Jan 2007 00:30:42 +0000 Subject: [PATCH] - Added an operator += for FString that takes an FName as input, since GCC is unable to synthesize one. - Converted xlatcc to use lemon during its build process. Now you don't need bison to rebuild everything anymore. SVN r470 (trunk) --- docs/rh-log.txt | 6 + src/name.h | 2 - src/zstring.h | 2 + tools/dehsupp/dehsupp.vcproj | 12 +- tools/dehsupp/parse.c | 130 +- tools/xlatcc/Makefile | 28 +- tools/xlatcc/gen.c | 2 +- tools/xlatcc/xlat-parse.c | 2090 +++++++++++++++++++++++++++ tools/xlatcc/xlat-parse.h | 36 + tools/xlatcc/xlat-parse.tab.c | 2548 --------------------------------- tools/xlatcc/xlat-parse.y | 1177 ++++++++------- tools/xlatcc/xlatcc.vcproj | 209 ++- wadsrc/xlat/defines.i | 2 +- 13 files changed, 2905 insertions(+), 3339 deletions(-) create mode 100644 tools/xlatcc/xlat-parse.c create mode 100644 tools/xlatcc/xlat-parse.h delete mode 100644 tools/xlatcc/xlat-parse.tab.c diff --git a/docs/rh-log.txt b/docs/rh-log.txt index 01d801100..940ef2ac8 100644 --- a/docs/rh-log.txt +++ b/docs/rh-log.txt @@ -1,3 +1,9 @@ +January 30, 2007 +- Added an operator += for FString that takes an FName as input, since GCC + is unable to synthesize one. +- Converted xlatcc to use lemon during its build process. Now you don't need + bison to rebuild everything anymore. + January 27, 2007 - Added support for damage-specific player pain sounds. - Removed the constraint that all $playerreserve SNDINFO commands must come diff --git a/src/name.h b/src/name.h index 6a3249419..161ae5dfe 100644 --- a/src/name.h +++ b/src/name.h @@ -34,8 +34,6 @@ #ifndef NAME_H #define NAME_H -#include "doomtype.h" - enum ENamedName { #define xx(n) NAME_##n, diff --git a/src/zstring.h b/src/zstring.h index 84eb73dc7..ffb1f4ae3 100644 --- a/src/zstring.h +++ b/src/zstring.h @@ -6,6 +6,7 @@ #include #include #include "tarray.h" +#include "name.h" #ifdef __GNUC__ #define PRINTFISH(x) __attribute__((format(printf, 2, x))) @@ -117,6 +118,7 @@ public: FString &operator += (const FString &tail); FString &operator += (const char *tail); FString &operator += (char tail); + FString &operator += (const FName &name) { return *this += name.GetChars(); } FString &AppendCStrPart (const char *tail, size_t tailLen); FString Left (size_t numChars) const; diff --git a/tools/dehsupp/dehsupp.vcproj b/tools/dehsupp/dehsupp.vcproj index e43f21705..6649be205 100644 --- a/tools/dehsupp/dehsupp.vcproj +++ b/tools/dehsupp/dehsupp.vcproj @@ -377,7 +377,7 @@ Name="VCCustomBuildTool" Description="Creating parse.c from parse.y" CommandLine="..\lemon\lemon.exe -s "$(InputFileName)" " - Outputs="$(InputDir)parse.c" + Outputs="$(InputDir)parse.c;$(InputDir)parse.h" /> @@ -434,7 +434,7 @@ @@ -444,7 +444,7 @@ @@ -454,7 +454,7 @@ diff --git a/tools/dehsupp/parse.c b/tools/dehsupp/parse.c index 4aeec0dc4..da7a6cbac 100644 --- a/tools/dehsupp/parse.c +++ b/tools/dehsupp/parse.c @@ -1,17 +1,15 @@ /* Driver template for the LEMON parser generator. ** The author disclaims copyright to this source code. */ -/* First off, code is include which follows the "include" declaration +/* First off, code is included which follows the "include" declaration ** in the input file. */ #include -#ifndef NDEBUG #include -#endif #line 1 "parse.y" #include #include "dehsupp.h" -#line 16 "parse.c" +#line 13 "parse.c" /* Next is all token values, in a form suitable for use by makeheaders. ** This section will be null unless lemon is run with the -m switch. */ @@ -210,7 +208,7 @@ static const YYACTIONTYPE yy_default[] = { /* 120 */ 146, 173, 211, 174, 171, 207, 145, 210, 209, 160, /* 130 */ 144, 143, 170, 216, 191, 169, 212, 142, 215, 214, }; -#define YY_SZ_ACTTAB (sizeof(yy_action)/sizeof(yy_action[0])) +#define YY_SZ_ACTTAB (int)(sizeof(yy_action)/sizeof(yy_action[0])) /* The next table maps tokens into fallback tokens. If a construct ** like the following: @@ -488,7 +486,7 @@ static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){ case 34: #line 8 "parse.y" { if ((yypminor->yy0).string) free((yypminor->yy0).string); } -#line 493 "parse.c" +#line 490 "parse.c" break; default: break; /* If no destructor action specified: do nothing */ } @@ -552,7 +550,7 @@ void ParseFree( */ static int yy_find_shift_action( yyParser *pParser, /* The parser */ - int iLookAhead /* The look-ahead token */ + YYCODETYPE iLookAhead /* The look-ahead token */ ){ int i; int stateno = pParser->yystack[pParser->yyidx].stateno; @@ -565,19 +563,35 @@ static int yy_find_shift_action( } i += iLookAhead; if( i<0 || i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){ + if( iLookAhead>0 ){ #ifdef YYFALLBACK - int iFallback; /* Fallback token */ - if( iLookAhead %s\n", - yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); + if( yyTraceFILE ){ + fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); + } +#endif + return yy_find_shift_action(pParser, iFallback); } #endif - return yy_find_shift_action(pParser, iFallback); +#ifdef YYWILDCARD + { + int j = i - iLookAhead + YYWILDCARD; + if( j>=0 && j %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]); + } +#endif /* NDEBUG */ + return yy_action[j]; + } + } +#endif /* YYWILDCARD */ } -#endif return yy_default[stateno]; }else{ return yy_action[i]; @@ -594,7 +608,7 @@ static int yy_find_shift_action( */ static int yy_find_reduce_action( int stateno, /* Current state number */ - int iLookAhead /* The look-ahead token */ + YYCODETYPE iLookAhead /* The look-ahead token */ ){ int i; /* int stateno = pParser->yystack[pParser->yyidx].stateno; */ @@ -635,7 +649,7 @@ static void yy_shift( #endif while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); /* Here code is inserted which will execute if the parser - ** stack every overflows */ + ** stack ever overflows */ ParseARG_STORE; /* Suppress warning about unused %extra_argument var */ return; } @@ -760,13 +774,12 @@ static void yy_reduce( yymsp = &yypParser->yystack[yypParser->yyidx]; #ifndef NDEBUG if( yyTraceFILE && yyruleno>=0 - && yyrulenoyyidx>= 0 && (yyact = yy_find_shift_action(yypParser,YYNOCODE)) < YYNSTATE + YYNRULE ){ + yy_reduce(yypParser,yyact-YYNSTATE); + } } }else if( yyact < YYNSTATE + YYNRULE ){ yy_reduce(yypParser,yyact-YYNSTATE); diff --git a/tools/xlatcc/Makefile b/tools/xlatcc/Makefile index be0fb2712..9f87a2807 100644 --- a/tools/xlatcc/Makefile +++ b/tools/xlatcc/Makefile @@ -1,11 +1,11 @@ -ifeq (Windows_NT,$(OS)) - WIN=1 - WINCMD=1 -endif -ifeq (msys,$(OSTYPE)) - WIN=1 - WINCMD=0 -endif +ifeq (Windows_NT,$(OS)) + WIN=1 + WINCMD=1 +endif +ifeq (msys,$(OSTYPE)) + WIN=1 + WINCMD=0 +endif ifeq (1,$(WIN)) EXE = xlatcc.exe @@ -19,10 +19,10 @@ CCDV = @../../ccdv CC = gcc LDFLAGS= -s -BISON = bison -BISONFLAGS = +LEMON = ../lemon/lemon +LEMONFLAGS = -OBJS = gen.o xlat-parse.tab.o +OBJS = gen.o xlat-parse.o all: $(EXE) @@ -40,11 +40,11 @@ else rm -f *.o endif -xlat-parse.tab.o: xlat-parse.tab.c xlat.h +xlat-parse.o: xlat-parse.c xlat.h xlat-parse.h $(CCDV) $(CC) $(CFLAGS) -c -o $@ $< -xlat-parse.tab.c: xlat-parse.y - $(CCDV) $(BISON) $(BISONFLAGS) -o $@ $< +xlat-parse.c xlat-parse.h: xlat-parse.y + $(CCDV) $(LEMON) $(LEMONFLAGS) $< gen.o: gen.c xlat.h $(CCDV) $(CC) $(CFLAGS) -c -o $@ $< diff --git a/tools/xlatcc/gen.c b/tools/xlatcc/gen.c index 36e34d592..9aae1ce2d 100644 --- a/tools/xlatcc/gen.c +++ b/tools/xlatcc/gen.c @@ -19,7 +19,7 @@ static char *NameStack[FILE_STACK]; static int LineStack[FILE_STACK]; static int SourceStackSize; -int yyparse (); +void yyparse (void); int CountSimpleTranslators (void) { diff --git a/tools/xlatcc/xlat-parse.c b/tools/xlatcc/xlat-parse.c new file mode 100644 index 000000000..9d83daced --- /dev/null +++ b/tools/xlatcc/xlat-parse.c @@ -0,0 +1,2090 @@ +/* Driver template for the LEMON parser generator. +** The author disclaims copyright to this source code. +*/ +/* First off, code is included which follows the "include" declaration +** in the input file. */ +#include +#include +#line 1 "xlat-parse.y" + +#include "xlat.h" +#include "xlat-parse.h" +#include +#include + +int yyerror (char *s); + +typedef struct _Symbol +{ + struct _Symbol *Next; + int Value; + char Sym[1]; +} Symbol; + +static bool FindToken (char *tok, int *type); +static void AddSym (char *sym, int val); +static bool FindSym (char *sym, Symbol **val); + +static int EnumVal; + +struct ListFilter +{ + WORD filter; + BYTE value; +}; + +typedef struct _morefilters +{ + struct _morefilters *next; + struct ListFilter filter; +} MoreFilters; + +typedef struct _morelines +{ + struct _morelines *next; + BoomArg arg; +} MoreLines; + +typedef struct _specialargs +{ + BYTE addflags; + BYTE args[5]; +} SpecialArgs; + +typedef struct _boomarg +{ + BYTE constant; + WORD mask; + MoreFilters *filters; +} ParseBoomArg; + +typedef union YYSTYPE +{ + int val; + char sym[80]; + char string[80]; + Symbol *symval; +} YYSTYPE; + +#include +#include + +int yylex (YYSTYPE *yylval) +{ + char token[80]; + int toksize; + int c; + +loop: + while (Source == NULL) + { + if (!EndFile ()) + return 0; + } + while (isspace (c = fgetc (Source)) && c != EOF) + { + if (c == '\n') + SourceLine++; + } + + if (c == EOF) + { + if (EndFile ()) + goto loop; + return 0; + } + if (isdigit (c)) + { + int buildup = c - '0'; + if (c == '0') + { + c = fgetc (Source); + if (c == 'x' || c == 'X') + { + for (;;) + { + c = fgetc (Source); + if (isdigit (c)) + { + buildup = (buildup<<4) + c - '0'; + } + else if (c >= 'a' && c <= 'f') + { + buildup = (buildup<<4) + c - 'a' + 10; + } + else if (c >= 'A' && c <= 'F') + { + buildup = (buildup<<4) + c - 'A' + 10; + } + else + { + ungetc (c, Source); + yylval->val = buildup; + return NUM; + } + } + } + else + { + ungetc (c, Source); + } + } + while (isdigit (c = fgetc (Source))) + { + buildup = buildup*10 + c - '0'; + } + ungetc (c, Source); + yylval->val = buildup; + return NUM; + } + if (isalpha (c)) + { + int buildup = 0; + + token[0] = c; + toksize = 1; + while (toksize < 79 && (isalnum (c = fgetc (Source)) || c == '_')) + { + token[toksize++] = c; + } + token[toksize] = 0; + if (toksize == 79 && isalnum (c)) + { + while (isalnum (c = fgetc (Source))) + ; + } + ungetc (c, Source); + if (FindToken (token, &buildup)) + { + return buildup; + } + if (FindSym (token, &yylval->symval)) + { + return SYMNUM; + } + strcpy (yylval->sym, token); + return SYM; + } + if (c == '/') + { + c = fgetc (Source); + if (c == '*') + { + for (;;) + { + while ((c = fgetc (Source)) != '*' && c != EOF) + { + if (c == '\n') + SourceLine++; + } + if (c == EOF) + return 0; + if ((c = fgetc (Source)) == '/') + goto loop; + if (c == EOF) + return 0; + ungetc (c, Source); + } + } + else if (c == '/') + { + while ((c = fgetc (Source)) != '\n' && c != EOF) + ; + if (c == '\n') + SourceLine++; + else if (c == EOF) + return 0; + goto loop; + } + else + { + ungetc (c, Source); + return DIVIDE; + } + } + if (c == '"') + { + int tokensize = 0; + while ((c = fgetc (Source)) != '"' && c != EOF) + { + yylval->string[tokensize++] = c; + } + yylval->string[tokensize] = 0; + return STRING; + } + if (c == '|') + { + c = fgetc (Source); + if (c == '=') + return OR_EQUAL; + ungetc (c, Source); + return OR; + } + switch (c) + { + case '^': return XOR; + case '&': return AND; + case '-': return MINUS; + case '+': return PLUS; + case '*': return MULTIPLY; + case '(': return LPAREN; + case ')': return RPAREN; + case ',': return COMMA; + case '{': return LBRACE; + case '}': return RBRACE; + case '=': return EQUALS; + case ';': return SEMICOLON; + case ':': return COLON; + case '[': return LBRACKET; + case ']': return RBRACKET; + default: return 0; + } +} + +void *ParseAlloc(void *(*mallocProc)(size_t)); +void Parse(void *yyp, int yymajor, YYSTYPE yyminor); +void ParseFree(void *p, void (*freeProc)(void*)); +void ParseTrace(FILE *TraceFILE, char *zTracePrompt); + +void yyparse (void) +{ + void *pParser = ParseAlloc (malloc); + YYSTYPE token; + int tokentype; + + while ((tokentype = yylex(&token)) != 0) + { + Parse (pParser, tokentype, token); + } + memset (&token, 0, sizeof(token)); + Parse (pParser, 0, token); + ParseFree (pParser, free); +} + +static Symbol *FirstSym; + +static void AddSym (char *sym, int val) +{ + Symbol *syme = malloc (strlen (sym) + sizeof(Symbol)); + syme->Next = FirstSym; + syme->Value = val; + strcpy (syme->Sym, sym); + FirstSym = syme; +} + +static bool FindSym (char *sym, Symbol **val) +{ + Symbol *syme = FirstSym; + + while (syme != NULL) + { + if (strcmp (syme->Sym, sym) == 0) + { + *val = syme; + return 1; + } + syme = syme->Next; + } + return 0; +} + +static bool FindToken (char *tok, int *type) +{ + static const char tokens[][8] = + { + "endl", "print", "include", "special", "define", "enum", + "arg5", "arg4", "arg3", "arg2", "flags", "lineid", "tag" + + }; + static const short types[] = + { + ENDL, PRINT, INCLUDE, SPECIAL, DEFINE, ENUM, + ARG5, ARG4, ARG3, ARG2, FLAGS, LINEID, TAG + }; + int i; + + for (i = sizeof(tokens)/sizeof(tokens[0])-1; i >= 0; i--) + { + if (strcmp (tok, tokens[i]) == 0) + { + *type = types[i]; + return 1; + } + } + return 0; +} + +int yyerror (char *s) +{ + if (SourceName != NULL) + printf ("%s, line %d: %s\n", SourceName, SourceLine, s); + else + printf ("%s\n", s); + return 0; +} + +#line 327 "xlat-parse.c" +/* Next is all token values, in a form suitable for use by makeheaders. +** This section will be null unless lemon is run with the -m switch. +*/ +/* +** These constants (all generated automatically by the parser generator) +** specify the various kinds of tokens (terminals) that the parser +** understands. +** +** Each symbol here is a terminal symbol in the grammar. +*/ +/* Make sure the INTERFACE macro is defined. +*/ +#ifndef INTERFACE +# define INTERFACE 1 +#endif +/* The next thing included is series of defines which control +** various aspects of the generated parser. +** YYCODETYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 terminals +** and nonterminals. "int" is used otherwise. +** YYNOCODE is a number of type YYCODETYPE which corresponds +** to no legal terminal or nonterminal number. This +** number is used to fill in empty slots of the hash +** table. +** YYFALLBACK If defined, this indicates that one or more tokens +** have fall-back values which should be used if the +** original value of the token will not parse. +** YYACTIONTYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 rules and +** states combined. "int" is used otherwise. +** ParseTOKENTYPE is the data type used for minor tokens given +** directly to the parser from the tokenizer. +** YYMINORTYPE is the data type used for all minor tokens. +** This is typically a union of many types, one of +** which is ParseTOKENTYPE. The entry in the union +** for base tokens is called "yy0". +** YYSTACKDEPTH is the maximum depth of the parser's stack. +** ParseARG_SDECL A static variable declaration for the %extra_argument +** ParseARG_PDECL A parameter declaration for the %extra_argument +** ParseARG_STORE Code to store %extra_argument into yypParser +** ParseARG_FETCH Code to extract %extra_argument from yypParser +** YYNSTATE the combined number of states. +** YYNRULE the number of rules in the grammar +** YYERRORSYMBOL is the code number of the error symbol. If not +** defined, then do no error processing. +*/ +#define YYCODETYPE unsigned char +#define YYNOCODE 66 +#define YYACTIONTYPE unsigned short int +#define ParseTOKENTYPE YYSTYPE +typedef union { + ParseTOKENTYPE yy0; + MoreLines * yy49; + SpecialArgs yy57; + BoomArg yy58; + int yy72; + ParseBoomArg yy83; + MoreFilters * yy87; + struct ListFilter yy124; + int yy131; +} YYMINORTYPE; +#define YYSTACKDEPTH 100 +#define ParseARG_SDECL +#define ParseARG_PDECL +#define ParseARG_FETCH +#define ParseARG_STORE +#define YYNSTATE 173 +#define YYNRULE 93 +#define YYERRORSYMBOL 37 +#define YYERRSYMDT yy131 +#define YY_NO_ACTION (YYNSTATE+YYNRULE+2) +#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1) +#define YY_ERROR_ACTION (YYNSTATE+YYNRULE) + +/* Next are that tables used to determine what action to take based on the +** current state and lookahead token. These tables are used to implement +** functions that take a state number and lookahead value and return an +** action integer. +** +** Suppose the action integer is N. Then the action is determined as +** follows +** +** 0 <= N < YYNSTATE Shift N. That is, push the lookahead +** token onto the stack and goto state N. +** +** YYNSTATE <= N < YYNSTATE+YYNRULE Reduce by rule N-YYNSTATE. +** +** N == YYNSTATE+YYNRULE A syntax error has occurred. +** +** N == YYNSTATE+YYNRULE+1 The parser accepts its input. +** +** N == YYNSTATE+YYNRULE+2 No such action. Denotes unused +** slots in the yy_action[] table. +** +** The action table is constructed as a single large table named yy_action[]. +** Given state S and lookahead X, the action is computed as +** +** yy_action[ yy_shift_ofst[S] + X ] +** +** If the index value yy_shift_ofst[S]+X is out of range or if the value +** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S] +** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table +** and that yy_default[S] should be used instead. +** +** The formula above is for computing the action when the lookahead is +** a terminal symbol. If the lookahead is a non-terminal (as occurs after +** a reduce action) then the yy_reduce_ofst[] array is used in place of +** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of +** YY_SHIFT_USE_DFLT. +** +** The following are the tables generated in this section: +** +** yy_action[] A single table containing all actions. +** yy_lookahead[] A table containing the lookahead for each entry in +** yy_action. Used to detect hash collisions. +** yy_shift_ofst[] For each state, the offset into yy_action for +** shifting terminals. +** yy_reduce_ofst[] For each state, the offset into yy_action for +** shifting non-terminals after a reduce. +** yy_default[] Default action for each state. +*/ +static const YYACTIONTYPE yy_action[] = { + /* 0 */ 65, 41, 32, 35, 52, 42, 28, 51, 77, 117, + /* 10 */ 267, 163, 160, 149, 148, 147, 146, 145, 144, 143, + /* 20 */ 30, 80, 14, 128, 164, 156, 151, 23, 123, 127, + /* 30 */ 55, 4, 152, 102, 33, 108, 80, 119, 128, 107, + /* 40 */ 5, 111, 113, 22, 2, 41, 32, 35, 52, 42, + /* 50 */ 28, 51, 32, 35, 52, 42, 28, 51, 19, 3, + /* 60 */ 41, 32, 35, 52, 42, 28, 51, 52, 42, 28, + /* 70 */ 51, 135, 116, 41, 32, 35, 52, 42, 28, 51, + /* 80 */ 41, 32, 35, 52, 42, 28, 51, 28, 51, 11, + /* 90 */ 9, 168, 169, 170, 171, 172, 77, 106, 26, 66, + /* 100 */ 41, 32, 35, 52, 42, 28, 51, 35, 52, 42, + /* 110 */ 28, 51, 10, 27, 61, 41, 32, 35, 52, 42, + /* 120 */ 28, 51, 68, 120, 100, 139, 165, 49, 18, 166, + /* 130 */ 41, 32, 35, 52, 42, 28, 51, 55, 4, 101, + /* 140 */ 167, 12, 40, 29, 43, 41, 32, 35, 52, 42, + /* 150 */ 28, 51, 136, 131, 113, 91, 66, 98, 16, 115, + /* 160 */ 41, 32, 35, 52, 42, 28, 51, 124, 130, 159, + /* 170 */ 56, 59, 129, 37, 61, 41, 32, 35, 52, 42, + /* 180 */ 28, 51, 138, 109, 48, 57, 60, 154, 20, 54, + /* 190 */ 41, 32, 35, 52, 42, 28, 51, 13, 62, 90, + /* 200 */ 89, 17, 15, 21, 7, 41, 32, 35, 52, 42, + /* 210 */ 28, 51, 39, 132, 63, 99, 94, 87, 31, 142, + /* 220 */ 41, 32, 35, 52, 42, 28, 51, 134, 133, 67, + /* 230 */ 88, 157, 74, 41, 32, 35, 52, 42, 28, 51, + /* 240 */ 41, 32, 35, 52, 42, 28, 51, 84, 161, 30, + /* 250 */ 141, 104, 86, 38, 156, 151, 23, 1, 153, 6, + /* 260 */ 96, 41, 32, 35, 52, 42, 28, 51, 41, 32, + /* 270 */ 35, 52, 42, 28, 51, 8, 41, 32, 35, 52, + /* 280 */ 42, 28, 51, 25, 103, 64, 97, 125, 71, 95, + /* 290 */ 24, 76, 41, 32, 35, 52, 42, 28, 51, 150, + /* 300 */ 158, 78, 268, 162, 268, 45, 83, 41, 32, 35, + /* 310 */ 52, 42, 28, 51, 92, 81, 82, 268, 70, 69, + /* 320 */ 44, 85, 41, 32, 35, 52, 42, 28, 51, 268, + /* 330 */ 72, 79, 75, 58, 73, 36, 93, 41, 32, 35, + /* 340 */ 52, 42, 28, 51, 268, 268, 268, 268, 268, 268, + /* 350 */ 46, 268, 41, 32, 35, 52, 42, 28, 51, 268, + /* 360 */ 268, 268, 268, 268, 268, 34, 268, 41, 32, 35, + /* 370 */ 52, 42, 28, 51, 268, 268, 268, 268, 268, 268, + /* 380 */ 47, 268, 41, 32, 35, 52, 42, 28, 51, 268, + /* 390 */ 268, 268, 268, 268, 268, 50, 268, 41, 32, 35, + /* 400 */ 52, 42, 28, 51, 268, 268, 268, 268, 268, 268, + /* 410 */ 53, 88, 41, 32, 35, 52, 42, 28, 51, 30, + /* 420 */ 268, 268, 30, 268, 156, 151, 23, 156, 151, 23, + /* 430 */ 30, 110, 104, 140, 137, 156, 151, 23, 268, 268, + /* 440 */ 30, 268, 268, 268, 105, 156, 151, 23, 268, 30, + /* 450 */ 114, 126, 30, 268, 156, 151, 23, 156, 151, 23, + /* 460 */ 30, 268, 268, 30, 268, 156, 151, 23, 156, 151, + /* 470 */ 23, 155, 268, 268, 268, 268, 268, 268, 268, 268, + /* 480 */ 122, 268, 268, 118, 268, 268, 268, 268, 268, 268, + /* 490 */ 268, 121, 268, 268, 112, +}; +static const YYCODETYPE yy_lookahead[] = { + /* 0 */ 38, 1, 2, 3, 4, 5, 6, 7, 38, 39, + /* 10 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + /* 20 */ 4, 38, 60, 40, 41, 9, 10, 11, 28, 13, + /* 30 */ 44, 45, 46, 17, 14, 19, 38, 21, 40, 41, + /* 40 */ 24, 61, 62, 27, 11, 1, 2, 3, 4, 5, + /* 50 */ 6, 7, 2, 3, 4, 5, 6, 7, 14, 22, + /* 60 */ 1, 2, 3, 4, 5, 6, 7, 4, 5, 6, + /* 70 */ 7, 12, 18, 1, 2, 3, 4, 5, 6, 7, + /* 80 */ 1, 2, 3, 4, 5, 6, 7, 6, 7, 11, + /* 90 */ 11, 29, 30, 31, 32, 33, 38, 39, 26, 38, + /* 100 */ 1, 2, 3, 4, 5, 6, 7, 3, 4, 5, + /* 110 */ 6, 7, 43, 14, 38, 1, 2, 3, 4, 5, + /* 120 */ 6, 7, 38, 47, 63, 64, 42, 11, 14, 23, + /* 130 */ 1, 2, 3, 4, 5, 6, 7, 44, 45, 46, + /* 140 */ 34, 14, 14, 14, 14, 1, 2, 3, 4, 5, + /* 150 */ 6, 7, 25, 61, 62, 38, 38, 38, 14, 10, + /* 160 */ 1, 2, 3, 4, 5, 6, 7, 18, 12, 38, + /* 170 */ 38, 38, 22, 14, 38, 1, 2, 3, 4, 5, + /* 180 */ 6, 7, 64, 47, 14, 38, 38, 12, 14, 23, + /* 190 */ 1, 2, 3, 4, 5, 6, 7, 11, 38, 38, + /* 200 */ 38, 14, 14, 14, 14, 1, 2, 3, 4, 5, + /* 210 */ 6, 7, 14, 20, 38, 38, 38, 38, 14, 12, + /* 220 */ 1, 2, 3, 4, 5, 6, 7, 12, 15, 38, + /* 230 */ 38, 12, 38, 1, 2, 3, 4, 5, 6, 7, + /* 240 */ 1, 2, 3, 4, 5, 6, 7, 38, 28, 4, + /* 250 */ 58, 59, 38, 14, 9, 10, 11, 14, 12, 27, + /* 260 */ 38, 1, 2, 3, 4, 5, 6, 7, 1, 2, + /* 270 */ 3, 4, 5, 6, 7, 11, 1, 2, 3, 4, + /* 280 */ 5, 6, 7, 11, 18, 38, 26, 12, 38, 38, + /* 290 */ 23, 38, 1, 2, 3, 4, 5, 6, 7, 20, + /* 300 */ 38, 38, 65, 38, 65, 14, 38, 1, 2, 3, + /* 310 */ 4, 5, 6, 7, 38, 38, 38, 65, 38, 38, + /* 320 */ 14, 38, 1, 2, 3, 4, 5, 6, 7, 65, + /* 330 */ 38, 38, 38, 38, 38, 14, 38, 1, 2, 3, + /* 340 */ 4, 5, 6, 7, 65, 65, 65, 65, 65, 65, + /* 350 */ 14, 65, 1, 2, 3, 4, 5, 6, 7, 65, + /* 360 */ 65, 65, 65, 65, 65, 14, 65, 1, 2, 3, + /* 370 */ 4, 5, 6, 7, 65, 65, 65, 65, 65, 65, + /* 380 */ 14, 65, 1, 2, 3, 4, 5, 6, 7, 65, + /* 390 */ 65, 65, 65, 65, 65, 14, 65, 1, 2, 3, + /* 400 */ 4, 5, 6, 7, 65, 65, 65, 65, 65, 65, + /* 410 */ 14, 38, 1, 2, 3, 4, 5, 6, 7, 4, + /* 420 */ 65, 65, 4, 65, 9, 10, 11, 9, 10, 11, + /* 430 */ 4, 58, 59, 15, 16, 9, 10, 11, 65, 65, + /* 440 */ 4, 65, 65, 65, 18, 9, 10, 11, 65, 4, + /* 450 */ 35, 36, 4, 65, 9, 10, 11, 9, 10, 11, + /* 460 */ 4, 65, 65, 4, 65, 9, 10, 11, 9, 10, + /* 470 */ 11, 35, 65, 65, 65, 65, 65, 65, 65, 65, + /* 480 */ 35, 65, 65, 35, 65, 65, 65, 65, 65, 65, + /* 490 */ 65, 35, 65, 65, 35, +}; +#define YY_SHIFT_USE_DFLT (-1) +#define YY_SHIFT_MAX 128 +static const short yy_shift_ofst[] = { + /* 0 */ 16, 418, 418, 62, 62, 245, 245, 245, 415, 415, + /* 10 */ 245, 245, 245, 245, 54, 54, 456, 459, 448, 426, + /* 20 */ 445, 436, 245, 245, 245, 245, 245, 245, 245, 245, + /* 30 */ 245, 245, 245, 245, 245, 245, 245, 245, 245, 245, + /* 40 */ 245, 245, 245, 245, 245, 245, 245, 245, 245, 245, + /* 50 */ 245, 245, 245, 245, 245, 106, 396, 381, 366, 351, + /* 60 */ 336, 321, 306, 291, 275, 267, 260, 239, 232, 0, + /* 70 */ 219, 204, 189, 174, 159, 144, 129, 114, 99, 79, + /* 80 */ 72, 59, 44, 411, 411, 411, 411, 411, 411, 411, + /* 90 */ 411, 411, 411, 411, 50, 104, 63, 149, 81, 81, + /* 100 */ 127, 279, 266, 272, 243, 264, 246, 220, 213, 215, + /* 110 */ 207, 193, 198, 188, 187, 186, 166, 175, 170, 150, + /* 120 */ 156, 130, 128, 116, 78, 37, 20, 33, 190, +}; +#define YY_REDUCE_USE_DFLT (-39) +#define YY_REDUCE_MAX 55 +static const short yy_reduce_ofst[] = { + /* 0 */ -38, 192, 373, 93, -14, 61, -2, -17, 58, -30, + /* 10 */ 84, 76, 118, 136, -20, 92, 296, 295, 294, 293, + /* 20 */ 292, 283, 281, 280, 278, 277, 276, 268, 265, 263, + /* 30 */ 262, 253, 251, 250, 247, 222, 214, 209, 194, 191, + /* 40 */ 179, 178, 177, 176, 162, 161, 160, 148, 147, 133, + /* 50 */ 132, 131, 119, 298, 117, 69, +}; +static const YYACTIONTYPE yy_default[] = { + /* 0 */ 185, 195, 195, 221, 221, 266, 266, 266, 236, 236, + /* 10 */ 266, 215, 266, 215, 205, 205, 266, 266, 266, 266, + /* 20 */ 266, 266, 266, 266, 266, 266, 266, 266, 266, 266, + /* 30 */ 266, 266, 266, 266, 266, 266, 266, 266, 266, 266, + /* 40 */ 266, 266, 266, 266, 266, 266, 266, 266, 266, 266, + /* 50 */ 266, 266, 266, 266, 266, 266, 258, 257, 238, 266, + /* 60 */ 239, 216, 240, 261, 266, 266, 266, 243, 231, 266, + /* 70 */ 266, 247, 254, 253, 244, 252, 248, 251, 249, 266, + /* 80 */ 266, 266, 266, 250, 245, 255, 217, 264, 199, 241, + /* 90 */ 262, 209, 235, 259, 180, 182, 181, 266, 177, 176, + /* 100 */ 266, 266, 266, 266, 196, 266, 266, 266, 266, 266, + /* 110 */ 266, 266, 242, 206, 237, 266, 208, 266, 256, 266, + /* 120 */ 266, 260, 263, 266, 266, 266, 246, 266, 233, 204, + /* 130 */ 213, 207, 203, 202, 214, 201, 210, 200, 212, 211, + /* 140 */ 198, 197, 194, 193, 192, 191, 190, 189, 188, 187, + /* 150 */ 220, 175, 222, 219, 218, 265, 174, 184, 183, 179, + /* 160 */ 186, 232, 178, 173, 234, 223, 229, 230, 224, 225, + /* 170 */ 226, 227, 228, +}; +#define YY_SZ_ACTTAB (int)(sizeof(yy_action)/sizeof(yy_action[0])) + +/* The next table maps tokens into fallback tokens. If a construct +** like the following: +** +** %fallback ID X Y Z. +** +** appears in the grammer, then ID becomes a fallback token for X, Y, +** and Z. Whenever one of the tokens X, Y, or Z is input to the parser +** but it does not parse, the type of the token is changed to ID and +** the parse is retried before an error is thrown. +*/ +#ifdef YYFALLBACK +static const YYCODETYPE yyFallback[] = { +}; +#endif /* YYFALLBACK */ + +/* The following structure represents a single element of the +** parser's stack. Information stored includes: +** +** + The state number for the parser at this level of the stack. +** +** + The value of the token stored at this level of the stack. +** (In other words, the "major" token.) +** +** + The semantic value stored at this level of the stack. This is +** the information used by the action routines in the grammar. +** It is sometimes called the "minor" token. +*/ +struct yyStackEntry { + int stateno; /* The state-number */ + int major; /* The major token value. This is the code + ** number for the token at this stack level */ + YYMINORTYPE minor; /* The user-supplied minor token value. This + ** is the value of the token */ +}; +typedef struct yyStackEntry yyStackEntry; + +/* The state of the parser is completely contained in an instance of +** the following structure */ +struct yyParser { + int yyidx; /* Index of top element in stack */ + int yyerrcnt; /* Shifts left before out of the error */ + ParseARG_SDECL /* A place to hold %extra_argument */ + yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */ +}; +typedef struct yyParser yyParser; + +#ifndef NDEBUG +#include +static FILE *yyTraceFILE = 0; +static char *yyTracePrompt = 0; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* +** Turn parser tracing on by giving a stream to which to write the trace +** and a prompt to preface each trace message. Tracing is turned off +** by making either argument NULL +** +** Inputs: +**
    +**
  • A FILE* to which trace output should be written. +** If NULL, then tracing is turned off. +**
  • A prefix string written at the beginning of every +** line of trace output. If NULL, then tracing is +** turned off. +**
+** +** Outputs: +** None. +*/ +void ParseTrace(FILE *TraceFILE, char *zTracePrompt){ + yyTraceFILE = TraceFILE; + yyTracePrompt = zTracePrompt; + if( yyTraceFILE==0 ) yyTracePrompt = 0; + else if( yyTracePrompt==0 ) yyTraceFILE = 0; +} +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing shifts, the names of all terminals and nonterminals +** are required. The following table supplies these names */ +static const char *const yyTokenName[] = { + "$", "OR", "XOR", "AND", + "MINUS", "PLUS", "MULTIPLY", "DIVIDE", + "NEG", "NUM", "SYMNUM", "LPAREN", + "RPAREN", "PRINT", "COMMA", "STRING", + "ENDL", "DEFINE", "SYM", "INCLUDE", + "RBRACE", "ENUM", "LBRACE", "EQUALS", + "SPECIAL", "SEMICOLON", "COLON", "LBRACKET", + "RBRACKET", "FLAGS", "ARG2", "ARG3", + "ARG4", "ARG5", "OR_EQUAL", "TAG", + "LINEID", "error", "exp", "special_args", + "list_val", "arg_list", "boom_args", "boom_op", + "boom_selector", "boom_line", "boom_body", "maybe_argcount", + "main", "translation_unit", "external_declaration", "define_statement", + "include_statement", "print_statement", "enum_statement", "linetype_declaration", + "boom_declaration", "special_declaration", "print_list", "print_item", + "enum_open", "enum_list", "single_enum", "special_list", + "special_def", +}; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing reduce actions, the names of all rules are required. +*/ +static const char *const yyRuleName[] = { + /* 0 */ "main ::= translation_unit", + /* 1 */ "exp ::= NUM", + /* 2 */ "exp ::= SYMNUM", + /* 3 */ "exp ::= exp PLUS exp", + /* 4 */ "exp ::= exp MINUS exp", + /* 5 */ "exp ::= exp MULTIPLY exp", + /* 6 */ "exp ::= exp DIVIDE exp", + /* 7 */ "exp ::= exp OR exp", + /* 8 */ "exp ::= exp AND exp", + /* 9 */ "exp ::= exp XOR exp", + /* 10 */ "exp ::= MINUS exp", + /* 11 */ "exp ::= LPAREN exp RPAREN", + /* 12 */ "translation_unit ::=", + /* 13 */ "translation_unit ::= external_declaration", + /* 14 */ "external_declaration ::= define_statement", + /* 15 */ "external_declaration ::= include_statement", + /* 16 */ "external_declaration ::= print_statement", + /* 17 */ "external_declaration ::= enum_statement", + /* 18 */ "external_declaration ::= linetype_declaration", + /* 19 */ "external_declaration ::= boom_declaration", + /* 20 */ "external_declaration ::= special_declaration", + /* 21 */ "print_statement ::= PRINT LPAREN print_list RPAREN", + /* 22 */ "print_list ::=", + /* 23 */ "print_list ::= print_item", + /* 24 */ "print_list ::= print_item COMMA print_list", + /* 25 */ "print_item ::= STRING", + /* 26 */ "print_item ::= exp", + /* 27 */ "print_item ::= ENDL", + /* 28 */ "define_statement ::= DEFINE SYM LPAREN exp RPAREN", + /* 29 */ "include_statement ::= INCLUDE STRING", + /* 30 */ "enum_statement ::= enum_open enum_list RBRACE", + /* 31 */ "enum_open ::= ENUM LBRACE", + /* 32 */ "enum_list ::=", + /* 33 */ "enum_list ::= single_enum", + /* 34 */ "enum_list ::= single_enum COMMA enum_list", + /* 35 */ "single_enum ::= SYM", + /* 36 */ "single_enum ::= SYM EQUALS exp", + /* 37 */ "special_declaration ::= SPECIAL special_list SEMICOLON", + /* 38 */ "special_list ::= special_def", + /* 39 */ "special_list ::= special_list COMMA special_def", + /* 40 */ "special_def ::= exp COLON SYM LPAREN maybe_argcount RPAREN", + /* 41 */ "special_def ::= exp COLON SYMNUM LPAREN maybe_argcount RPAREN", + /* 42 */ "maybe_argcount ::=", + /* 43 */ "maybe_argcount ::= exp", + /* 44 */ "maybe_argcount ::= exp COMMA exp", + /* 45 */ "linetype_declaration ::= exp EQUALS exp COMMA exp LPAREN special_args RPAREN", + /* 46 */ "linetype_declaration ::= exp EQUALS exp COMMA SYM LPAREN special_args RPAREN", + /* 47 */ "boom_declaration ::= LBRACKET exp RBRACKET LPAREN exp COMMA exp RPAREN LBRACE boom_body RBRACE", + /* 48 */ "boom_body ::=", + /* 49 */ "boom_body ::= boom_line boom_body", + /* 50 */ "boom_line ::= boom_selector boom_op boom_args", + /* 51 */ "boom_selector ::= FLAGS", + /* 52 */ "boom_selector ::= ARG2", + /* 53 */ "boom_selector ::= ARG3", + /* 54 */ "boom_selector ::= ARG4", + /* 55 */ "boom_selector ::= ARG5", + /* 56 */ "boom_op ::= EQUALS", + /* 57 */ "boom_op ::= OR_EQUAL", + /* 58 */ "boom_args ::= exp", + /* 59 */ "boom_args ::= exp LBRACKET arg_list RBRACKET", + /* 60 */ "arg_list ::= list_val", + /* 61 */ "arg_list ::= list_val COMMA arg_list", + /* 62 */ "list_val ::= exp COLON exp", + /* 63 */ "special_args ::=", + /* 64 */ "special_args ::= TAG", + /* 65 */ "special_args ::= TAG COMMA exp", + /* 66 */ "special_args ::= TAG COMMA exp COMMA exp", + /* 67 */ "special_args ::= TAG COMMA exp COMMA exp COMMA exp", + /* 68 */ "special_args ::= TAG COMMA exp COMMA exp COMMA exp COMMA exp", + /* 69 */ "special_args ::= TAG COMMA TAG", + /* 70 */ "special_args ::= TAG COMMA TAG COMMA exp", + /* 71 */ "special_args ::= TAG COMMA TAG COMMA exp COMMA exp", + /* 72 */ "special_args ::= TAG COMMA TAG COMMA exp COMMA exp COMMA exp", + /* 73 */ "special_args ::= LINEID", + /* 74 */ "special_args ::= LINEID COMMA exp", + /* 75 */ "special_args ::= LINEID COMMA exp COMMA exp", + /* 76 */ "special_args ::= LINEID COMMA exp COMMA exp COMMA exp", + /* 77 */ "special_args ::= LINEID COMMA exp COMMA exp COMMA exp COMMA exp", + /* 78 */ "special_args ::= exp", + /* 79 */ "special_args ::= exp COMMA exp", + /* 80 */ "special_args ::= exp COMMA exp COMMA exp", + /* 81 */ "special_args ::= exp COMMA exp COMMA exp COMMA exp", + /* 82 */ "special_args ::= exp COMMA exp COMMA exp COMMA exp COMMA exp", + /* 83 */ "special_args ::= exp COMMA TAG", + /* 84 */ "special_args ::= exp COMMA TAG COMMA exp", + /* 85 */ "special_args ::= exp COMMA TAG COMMA exp COMMA exp", + /* 86 */ "special_args ::= exp COMMA TAG COMMA exp COMMA exp COMMA exp", + /* 87 */ "special_args ::= exp COMMA exp COMMA TAG", + /* 88 */ "special_args ::= exp COMMA exp COMMA TAG COMMA exp", + /* 89 */ "special_args ::= exp COMMA exp COMMA TAG COMMA exp COMMA exp", + /* 90 */ "special_args ::= exp COMMA exp COMMA exp COMMA TAG", + /* 91 */ "special_args ::= exp COMMA exp COMMA exp COMMA TAG COMMA exp", + /* 92 */ "special_args ::= exp COMMA exp COMMA exp COMMA exp COMMA TAG", +}; +#endif /* NDEBUG */ + +/* +** This function returns the symbolic name associated with a token +** value. +*/ +const char *ParseTokenName(int tokenType){ +#ifndef NDEBUG + if( tokenType>0 && tokenType<(sizeof(yyTokenName)/sizeof(yyTokenName[0])) ){ + return yyTokenName[tokenType]; + }else{ + return "Unknown"; + } +#else + return ""; +#endif +} + +/* +** This function allocates a new parser. +** The only argument is a pointer to a function which works like +** malloc. +** +** Inputs: +** A pointer to the function used to allocate memory. +** +** Outputs: +** A pointer to a parser. This pointer is used in subsequent calls +** to Parse and ParseFree. +*/ +void *ParseAlloc(void *(*mallocProc)(size_t)){ + yyParser *pParser; + pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) ); + if( pParser ){ + pParser->yyidx = -1; + } + return pParser; +} + +/* The following function deletes the value associated with a +** symbol. The symbol can be either a terminal or nonterminal. +** "yymajor" is the symbol code, and "yypminor" is a pointer to +** the value. +*/ +static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){ + switch( yymajor ){ + /* Here is inserted the actions which take place when a + ** terminal or non-terminal is destroyed. This can happen + ** when the symbol is popped from the stack during a + ** reduce or during error processing or when a parser is + ** being destroyed before it is finished parsing. + ** + ** Note: during a reduce, the only symbols destroyed are those + ** which appear on the RHS of the rule, but which are not used + ** inside the C code. + */ + default: break; /* If no destructor action specified: do nothing */ + } +} + +/* +** Pop the parser's stack once. +** +** If there is a destructor routine associated with the token which +** is popped from the stack, then call it. +** +** Return the major token number for the symbol popped. +*/ +static int yy_pop_parser_stack(yyParser *pParser){ + YYCODETYPE yymajor; + yyStackEntry *yytos = &pParser->yystack[pParser->yyidx]; + + if( pParser->yyidx<0 ) return 0; +#ifndef NDEBUG + if( yyTraceFILE && pParser->yyidx>=0 ){ + fprintf(yyTraceFILE,"%sPopping %s\n", + yyTracePrompt, + yyTokenName[yytos->major]); + } +#endif + yymajor = yytos->major; + yy_destructor( yymajor, &yytos->minor); + pParser->yyidx--; + return yymajor; +} + +/* +** Deallocate and destroy a parser. Destructors are all called for +** all stack elements before shutting the parser down. +** +** Inputs: +**
    +**
  • A pointer to the parser. This should be a pointer +** obtained from ParseAlloc. +**
  • A pointer to a function used to reclaim memory obtained +** from malloc. +**
+*/ +void ParseFree( + void *p, /* The parser to be deleted */ + void (*freeProc)(void*) /* Function used to reclaim memory */ +){ + yyParser *pParser = (yyParser*)p; + if( pParser==0 ) return; + while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser); + (*freeProc)((void*)pParser); +} + +/* +** Find the appropriate action for a parser given the terminal +** look-ahead token iLookAhead. +** +** If the look-ahead token is YYNOCODE, then check to see if the action is +** independent of the look-ahead. If it is, return the action, otherwise +** return YY_NO_ACTION. +*/ +static int yy_find_shift_action( + yyParser *pParser, /* The parser */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; + int stateno = pParser->yystack[pParser->yyidx].stateno; + + if( stateno>YY_SHIFT_MAX || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){ + return yy_default[stateno]; + } + if( iLookAhead==YYNOCODE ){ + return YY_NO_ACTION; + } + i += iLookAhead; + if( i<0 || i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){ + if( iLookAhead>0 ){ +#ifdef YYFALLBACK + int iFallback; /* Fallback token */ + if( iLookAhead %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); + } +#endif + return yy_find_shift_action(pParser, iFallback); + } +#endif +#ifdef YYWILDCARD + { + int j = i - iLookAhead + YYWILDCARD; + if( j>=0 && j %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]); + } +#endif /* NDEBUG */ + return yy_action[j]; + } + } +#endif /* YYWILDCARD */ + } + return yy_default[stateno]; + }else{ + return yy_action[i]; + } +} + +/* +** Find the appropriate action for a parser given the non-terminal +** look-ahead token iLookAhead. +** +** If the look-ahead token is YYNOCODE, then check to see if the action is +** independent of the look-ahead. If it is, return the action, otherwise +** return YY_NO_ACTION. +*/ +static int yy_find_reduce_action( + int stateno, /* Current state number */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; + /* int stateno = pParser->yystack[pParser->yyidx].stateno; */ + + if( stateno>YY_REDUCE_MAX || + (i = yy_reduce_ofst[stateno])==YY_REDUCE_USE_DFLT ){ + return yy_default[stateno]; + } + if( iLookAhead==YYNOCODE ){ + return YY_NO_ACTION; + } + i += iLookAhead; + if( i<0 || i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){ + return yy_default[stateno]; + }else{ + return yy_action[i]; + } +} + +/* +** Perform a shift action. +*/ +static void yy_shift( + yyParser *yypParser, /* The parser to be shifted */ + int yyNewState, /* The new state to shift in */ + int yyMajor, /* The major token to shift in */ + YYMINORTYPE *yypMinor /* Pointer ot the minor token to shift in */ +){ + yyStackEntry *yytos; + yypParser->yyidx++; + if( yypParser->yyidx>=YYSTACKDEPTH ){ + ParseARG_FETCH; + yypParser->yyidx--; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will execute if the parser + ** stack ever overflows */ + ParseARG_STORE; /* Suppress warning about unused %extra_argument var */ + return; + } + yytos = &yypParser->yystack[yypParser->yyidx]; + yytos->stateno = yyNewState; + yytos->major = yyMajor; + yytos->minor = *yypMinor; +#ifndef NDEBUG + if( yyTraceFILE && yypParser->yyidx>0 ){ + int i; + fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState); + fprintf(yyTraceFILE,"%sStack:",yyTracePrompt); + for(i=1; i<=yypParser->yyidx; i++) + fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]); + fprintf(yyTraceFILE,"\n"); + } +#endif +} + +/* The following table contains information about every rule that +** is used during the reduce. +*/ +static const struct { + YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ + unsigned char nrhs; /* Number of right-hand side symbols in the rule */ +} yyRuleInfo[] = { + { 48, 1 }, + { 38, 1 }, + { 38, 1 }, + { 38, 3 }, + { 38, 3 }, + { 38, 3 }, + { 38, 3 }, + { 38, 3 }, + { 38, 3 }, + { 38, 3 }, + { 38, 2 }, + { 38, 3 }, + { 49, 0 }, + { 49, 1 }, + { 50, 1 }, + { 50, 1 }, + { 50, 1 }, + { 50, 1 }, + { 50, 1 }, + { 50, 1 }, + { 50, 1 }, + { 53, 4 }, + { 58, 0 }, + { 58, 1 }, + { 58, 3 }, + { 59, 1 }, + { 59, 1 }, + { 59, 1 }, + { 51, 5 }, + { 52, 2 }, + { 54, 3 }, + { 60, 2 }, + { 61, 0 }, + { 61, 1 }, + { 61, 3 }, + { 62, 1 }, + { 62, 3 }, + { 57, 3 }, + { 63, 1 }, + { 63, 3 }, + { 64, 6 }, + { 64, 6 }, + { 47, 0 }, + { 47, 1 }, + { 47, 3 }, + { 55, 8 }, + { 55, 8 }, + { 56, 11 }, + { 46, 0 }, + { 46, 2 }, + { 45, 3 }, + { 44, 1 }, + { 44, 1 }, + { 44, 1 }, + { 44, 1 }, + { 44, 1 }, + { 43, 1 }, + { 43, 1 }, + { 42, 1 }, + { 42, 4 }, + { 41, 1 }, + { 41, 3 }, + { 40, 3 }, + { 39, 0 }, + { 39, 1 }, + { 39, 3 }, + { 39, 5 }, + { 39, 7 }, + { 39, 9 }, + { 39, 3 }, + { 39, 5 }, + { 39, 7 }, + { 39, 9 }, + { 39, 1 }, + { 39, 3 }, + { 39, 5 }, + { 39, 7 }, + { 39, 9 }, + { 39, 1 }, + { 39, 3 }, + { 39, 5 }, + { 39, 7 }, + { 39, 9 }, + { 39, 3 }, + { 39, 5 }, + { 39, 7 }, + { 39, 9 }, + { 39, 5 }, + { 39, 7 }, + { 39, 9 }, + { 39, 7 }, + { 39, 9 }, + { 39, 9 }, +}; + +static void yy_accept(yyParser*); /* Forward Declaration */ + +/* +** Perform a reduce action and the shift that must immediately +** follow the reduce. +*/ +static void yy_reduce( + yyParser *yypParser, /* The parser */ + int yyruleno /* Number of the rule by which to reduce */ +){ + int yygoto; /* The next state */ + int yyact; /* The next action */ + YYMINORTYPE yygotominor; /* The LHS of the rule reduced */ + yyStackEntry *yymsp; /* The top of the parser's stack */ + int yysize; /* Amount to pop the stack */ + ParseARG_FETCH; + yymsp = &yypParser->yystack[yypParser->yyidx]; +#ifndef NDEBUG + if( yyTraceFILE && yyruleno>=0 + && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ + fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt, + yyRuleName[yyruleno]); + } +#endif /* NDEBUG */ + + /* Silence complaints from purify about yygotominor being uninitialized + ** in some cases when it is copied into the stack after the following + ** switch. yygotominor is uninitialized when a rule reduces that does + ** not set the value of its left-hand side nonterminal. Leaving the + ** value of the nonterminal uninitialized is utterly harmless as long + ** as the value is never used. So really the only thing this code + ** accomplishes is to quieten purify. + ** + ** 2007-01-16: The wireshark project (www.wireshark.org) reports that + ** without this code, their parser segfaults. I'm not sure what there + ** parser is doing to make this happen. This is the second bug report + ** from wireshark this week. Clearly they are stressing Lemon in ways + ** that it has not been previously stressed... (SQLite ticket #2172) + */ + memset(&yygotominor, 0, sizeof(yygotominor)); + + + switch( yyruleno ){ + /* Beginning here are the reduction cases. A typical example + ** follows: + ** case 0: + ** #line + ** { ... } // User supplied code + ** #line + ** break; + */ + case 1: +#line 344 "xlat-parse.y" +{ yygotominor.yy72 = yymsp[0].minor.yy0.val; } +#line 1197 "xlat-parse.c" + break; + case 2: +#line 345 "xlat-parse.y" +{ yygotominor.yy72 = yymsp[0].minor.yy0.symval->Value; } +#line 1202 "xlat-parse.c" + break; + case 3: +#line 346 "xlat-parse.y" +{ yygotominor.yy72 = yymsp[-2].minor.yy72 + yymsp[0].minor.yy72; } +#line 1207 "xlat-parse.c" + break; + case 4: +#line 347 "xlat-parse.y" +{ yygotominor.yy72 = yymsp[-2].minor.yy72 - yymsp[0].minor.yy72; } +#line 1212 "xlat-parse.c" + break; + case 5: +#line 348 "xlat-parse.y" +{ yygotominor.yy72 = yymsp[-2].minor.yy72 * yymsp[0].minor.yy72; } +#line 1217 "xlat-parse.c" + break; + case 6: +#line 349 "xlat-parse.y" +{ yygotominor.yy72 = yymsp[-2].minor.yy72 / yymsp[0].minor.yy72; } +#line 1222 "xlat-parse.c" + break; + case 7: +#line 350 "xlat-parse.y" +{ yygotominor.yy72 = yymsp[-2].minor.yy72 | yymsp[0].minor.yy72; } +#line 1227 "xlat-parse.c" + break; + case 8: +#line 351 "xlat-parse.y" +{ yygotominor.yy72 = yymsp[-2].minor.yy72 & yymsp[0].minor.yy72; } +#line 1232 "xlat-parse.c" + break; + case 9: +#line 352 "xlat-parse.y" +{ yygotominor.yy72 = yymsp[-2].minor.yy72 ^ yymsp[0].minor.yy72; } +#line 1237 "xlat-parse.c" + break; + case 10: +#line 353 "xlat-parse.y" +{ yygotominor.yy72 = -yymsp[0].minor.yy72; } +#line 1242 "xlat-parse.c" + break; + case 11: +#line 354 "xlat-parse.y" +{ yygotominor.yy72 = yymsp[-1].minor.yy72; } +#line 1247 "xlat-parse.c" + break; + case 21: +#line 368 "xlat-parse.y" +{ + printf ("\n"); +} +#line 1254 "xlat-parse.c" + break; + case 25: +#line 376 "xlat-parse.y" +{ printf ("%s", yymsp[0].minor.yy0.string); } +#line 1259 "xlat-parse.c" + break; + case 26: +#line 377 "xlat-parse.y" +{ printf ("%d", yymsp[0].minor.yy72); } +#line 1264 "xlat-parse.c" + break; + case 27: +#line 378 "xlat-parse.y" +{ printf ("\n"); } +#line 1269 "xlat-parse.c" + break; + case 28: +#line 381 "xlat-parse.y" +{ + AddSym (yymsp[-3].minor.yy0.sym, yymsp[-1].minor.yy72); +} +#line 1276 "xlat-parse.c" + break; + case 29: +#line 386 "xlat-parse.y" +{ + IncludeFile (yymsp[0].minor.yy0.string); +} +#line 1283 "xlat-parse.c" + break; + case 31: +#line 393 "xlat-parse.y" +{ + EnumVal = 0; +} +#line 1290 "xlat-parse.c" + break; + case 35: +#line 402 "xlat-parse.y" +{ + AddSym (yymsp[0].minor.yy0.sym, EnumVal++); +} +#line 1297 "xlat-parse.c" + break; + case 36: +#line 407 "xlat-parse.y" +{ + AddSym (yymsp[-2].minor.yy0.sym, EnumVal = yymsp[0].minor.yy72); +} +#line 1304 "xlat-parse.c" + break; + case 40: +#line 420 "xlat-parse.y" +{ + AddSym (yymsp[-3].minor.yy0.sym, yymsp[-5].minor.yy72); +} +#line 1311 "xlat-parse.c" + break; + case 41: +#line 424 "xlat-parse.y" +{ + printf ("%s, line %d: %s is already defined\n", SourceName, SourceLine, yymsp[-3].minor.yy0.symval->Sym); +} +#line 1318 "xlat-parse.c" + break; + case 45: +#line 433 "xlat-parse.y" +{ + Simple[yymsp[-7].minor.yy72].NewSpecial = yymsp[-3].minor.yy72; + Simple[yymsp[-7].minor.yy72].Flags = yymsp[-5].minor.yy72 | yymsp[-1].minor.yy57.addflags; + Simple[yymsp[-7].minor.yy72].Args[0] = yymsp[-1].minor.yy57.args[0]; + Simple[yymsp[-7].minor.yy72].Args[1] = yymsp[-1].minor.yy57.args[1]; + Simple[yymsp[-7].minor.yy72].Args[2] = yymsp[-1].minor.yy57.args[2]; + Simple[yymsp[-7].minor.yy72].Args[3] = yymsp[-1].minor.yy57.args[3]; + Simple[yymsp[-7].minor.yy72].Args[4] = yymsp[-1].minor.yy57.args[4]; +} +#line 1331 "xlat-parse.c" + break; + case 46: +#line 443 "xlat-parse.y" +{ + printf ("%s, line %d: %s is undefined\n", SourceName, SourceLine, yymsp[-3].minor.yy0.sym); +} +#line 1338 "xlat-parse.c" + break; + case 47: +#line 448 "xlat-parse.y" +{ + if (NumBoomish == MAX_BOOMISH) + { + MoreLines *probe = yymsp[-1].minor.yy49; + + while (probe != NULL) + { + MoreLines *next = probe->next; + free (probe); + probe = next; + } + printf ("%s, line %d: Too many BOOM translators\n", SourceName, SourceLine); + } + else + { + int i; + MoreLines *probe; + + Boomish[NumBoomish].FirstLinetype = yymsp[-6].minor.yy72; + Boomish[NumBoomish].LastLinetype = yymsp[-4].minor.yy72; + Boomish[NumBoomish].NewSpecial = yymsp[-9].minor.yy72; + + for (i = 0, probe = yymsp[-1].minor.yy49; probe != NULL; i++) + { + MoreLines *next = probe->next;; + if (i < MAX_BOOMISH_EXEC) + { + Boomish[NumBoomish].Args[i] = probe->arg; + } + else if (i == MAX_BOOMISH_EXEC) + { + printf ("%s, line %d: Too many commands for this BOOM translator\n", SourceName, SourceLine); + } + free (probe); + probe = next; + } + if (i < MAX_BOOMISH_EXEC) + { + Boomish[NumBoomish].Args[i].bDefined = 0; + } + NumBoomish++; + } +} +#line 1385 "xlat-parse.c" + break; + case 48: +#line 493 "xlat-parse.y" +{ + yygotominor.yy49 = NULL; +} +#line 1392 "xlat-parse.c" + break; + case 49: +#line 497 "xlat-parse.y" +{ + yygotominor.yy49 = malloc (sizeof(MoreLines)); + yygotominor.yy49->next = yymsp[0].minor.yy49; + yygotominor.yy49->arg = yymsp[-1].minor.yy58; +} +#line 1401 "xlat-parse.c" + break; + case 50: +#line 504 "xlat-parse.y" +{ + yygotominor.yy58.bDefined = 1; + yygotominor.yy58.bOrExisting = (yymsp[-1].minor.yy72 == OR_EQUAL); + yygotominor.yy58.bUseConstant = (yymsp[0].minor.yy83.filters == NULL); + yygotominor.yy58.ArgNum = yymsp[-2].minor.yy72; + yygotominor.yy58.ConstantValue = yymsp[0].minor.yy83.constant; + yygotominor.yy58.AndValue = yymsp[0].minor.yy83.mask; + + if (yymsp[0].minor.yy83.filters != NULL) + { + int i; + MoreFilters *probe; + + for (i = 0, probe = yymsp[0].minor.yy83.filters; probe != NULL; i++) + { + MoreFilters *next = probe->next; + if (i < 15) + { + yygotominor.yy58.ResultFilter[i] = probe->filter.filter; + yygotominor.yy58.ResultValue[i] = probe->filter.value; + } + else if (i == 15) + { + yyerror ("Lists can only have 15 elements"); + } + free (probe); + probe = next; + } + yygotominor.yy58.ListSize = i > 15 ? 15 : i; + } +} +#line 1436 "xlat-parse.c" + break; + case 51: +#line 536 "xlat-parse.y" +{ yygotominor.yy72 = 4; } +#line 1441 "xlat-parse.c" + break; + case 52: +#line 537 "xlat-parse.y" +{ yygotominor.yy72 = 0; } +#line 1446 "xlat-parse.c" + break; + case 53: +#line 538 "xlat-parse.y" +{ yygotominor.yy72 = 1; } +#line 1451 "xlat-parse.c" + break; + case 54: +#line 539 "xlat-parse.y" +{ yygotominor.yy72 = 2; } +#line 1456 "xlat-parse.c" + break; + case 55: +#line 540 "xlat-parse.y" +{ yygotominor.yy72 = 3; } +#line 1461 "xlat-parse.c" + break; + case 56: +#line 542 "xlat-parse.y" +{ yygotominor.yy72 = '='; } +#line 1466 "xlat-parse.c" + break; + case 57: +#line 543 "xlat-parse.y" +{ yygotominor.yy72 = OR_EQUAL; } +#line 1471 "xlat-parse.c" + break; + case 58: +#line 546 "xlat-parse.y" +{ + yygotominor.yy83.constant = yymsp[0].minor.yy72; + yygotominor.yy83.filters = NULL; +} +#line 1479 "xlat-parse.c" + break; + case 59: +#line 551 "xlat-parse.y" +{ + yygotominor.yy83.mask = yymsp[-3].minor.yy72; + yygotominor.yy83.filters = yymsp[-1].minor.yy87; +} +#line 1487 "xlat-parse.c" + break; + case 60: +#line 557 "xlat-parse.y" +{ + yygotominor.yy87 = malloc (sizeof(MoreFilters)); + yygotominor.yy87->next = NULL; + yygotominor.yy87->filter = yymsp[0].minor.yy124; +} +#line 1496 "xlat-parse.c" + break; + case 61: +#line 563 "xlat-parse.y" +{ + yygotominor.yy87 = malloc (sizeof(MoreFilters)); + yygotominor.yy87->next = yymsp[0].minor.yy87; + yygotominor.yy87->filter = yymsp[-2].minor.yy124; +} +#line 1505 "xlat-parse.c" + break; + case 62: +#line 570 "xlat-parse.y" +{ + yygotominor.yy124.filter = yymsp[-2].minor.yy72; + yygotominor.yy124.value = yymsp[0].minor.yy72; +} +#line 1513 "xlat-parse.c" + break; + case 63: +#line 576 "xlat-parse.y" +{ + yygotominor.yy57.addflags = 0; + memset (yygotominor.yy57.args, 0, 5); +} +#line 1521 "xlat-parse.c" + break; + case 64: +#line 581 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT1; + memset (yygotominor.yy57.args, 0, 5); +} +#line 1529 "xlat-parse.c" + break; + case 65: +#line 586 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT1; + yygotominor.yy57.args[0] = 0; + yygotominor.yy57.args[1] = yymsp[0].minor.yy72; + yygotominor.yy57.args[2] = 0; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = 0; +} +#line 1541 "xlat-parse.c" + break; + case 66: +#line 595 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT1; + yygotominor.yy57.args[0] = 0; + yygotominor.yy57.args[1] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[2] = yymsp[0].minor.yy72; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = 0; +} +#line 1553 "xlat-parse.c" + break; + case 67: +#line 604 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT1; + yygotominor.yy57.args[0] = 0; + yygotominor.yy57.args[1] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[2] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[3] = yymsp[0].minor.yy72; + yygotominor.yy57.args[4] = 0; +} +#line 1565 "xlat-parse.c" + break; + case 68: +#line 613 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT1; + yygotominor.yy57.args[0] = 0; + yygotominor.yy57.args[1] = yymsp[-6].minor.yy72; + yygotominor.yy57.args[2] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[3] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[4] = yymsp[0].minor.yy72; +} +#line 1577 "xlat-parse.c" + break; + case 69: +#line 622 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HAS2TAGS; + yygotominor.yy57.args[0] = yygotominor.yy57.args[1] = 0; + yygotominor.yy57.args[2] = 0; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = 0; +} +#line 1588 "xlat-parse.c" + break; + case 70: +#line 630 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HAS2TAGS; + yygotominor.yy57.args[0] = yygotominor.yy57.args[1] = 0; + yygotominor.yy57.args[2] = yymsp[0].minor.yy72; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = 0; +} +#line 1599 "xlat-parse.c" + break; + case 71: +#line 638 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HAS2TAGS; + yygotominor.yy57.args[0] = yygotominor.yy57.args[1] = 0; + yygotominor.yy57.args[2] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[3] = yymsp[0].minor.yy72; + yygotominor.yy57.args[4] = 0; +} +#line 1610 "xlat-parse.c" + break; + case 72: +#line 646 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HAS2TAGS; + yygotominor.yy57.args[0] = yygotominor.yy57.args[1] = 0; + yygotominor.yy57.args[2] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[3] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[4] = yymsp[0].minor.yy72; +} +#line 1621 "xlat-parse.c" + break; + case 73: +#line 654 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASLINEID; + memset (yygotominor.yy57.args, 0, 5); +} +#line 1629 "xlat-parse.c" + break; + case 74: +#line 659 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASLINEID; + yygotominor.yy57.args[0] = 0; + yygotominor.yy57.args[1] = yymsp[0].minor.yy72; + yygotominor.yy57.args[2] = 0; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = 0; +} +#line 1641 "xlat-parse.c" + break; + case 75: +#line 668 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASLINEID; + yygotominor.yy57.args[0] = 0; + yygotominor.yy57.args[1] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[2] = yymsp[0].minor.yy72; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = 0; +} +#line 1653 "xlat-parse.c" + break; + case 76: +#line 677 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASLINEID; + yygotominor.yy57.args[0] = 0; + yygotominor.yy57.args[1] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[2] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[3] = yymsp[0].minor.yy72; + yygotominor.yy57.args[4] = 0; +} +#line 1665 "xlat-parse.c" + break; + case 77: +#line 686 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASLINEID; + yygotominor.yy57.args[0] = 0; + yygotominor.yy57.args[1] = yymsp[-6].minor.yy72; + yygotominor.yy57.args[2] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[3] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[4] = yymsp[0].minor.yy72; +} +#line 1677 "xlat-parse.c" + break; + case 78: +#line 695 "xlat-parse.y" +{ + yygotominor.yy57.addflags = 0; + yygotominor.yy57.args[0] = yymsp[0].minor.yy72; + yygotominor.yy57.args[1] = 0; + yygotominor.yy57.args[2] = 0; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = 0; +} +#line 1689 "xlat-parse.c" + break; + case 79: +#line 704 "xlat-parse.y" +{ + yygotominor.yy57.addflags = 0; + yygotominor.yy57.args[0] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[1] = yymsp[0].minor.yy72; + yygotominor.yy57.args[2] = 0; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = 0; +} +#line 1701 "xlat-parse.c" + break; + case 80: +#line 713 "xlat-parse.y" +{ + yygotominor.yy57.addflags = 0; + yygotominor.yy57.args[0] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[1] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[2] = yymsp[0].minor.yy72; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = 0; +} +#line 1713 "xlat-parse.c" + break; + case 81: +#line 722 "xlat-parse.y" +{ + yygotominor.yy57.addflags = 0; + yygotominor.yy57.args[0] = yymsp[-6].minor.yy72; + yygotominor.yy57.args[1] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[2] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[3] = yymsp[0].minor.yy72; + yygotominor.yy57.args[4] = 0; +} +#line 1725 "xlat-parse.c" + break; + case 82: +#line 731 "xlat-parse.y" +{ + yygotominor.yy57.addflags = 0; + yygotominor.yy57.args[0] = yymsp[-8].minor.yy72; + yygotominor.yy57.args[1] = yymsp[-6].minor.yy72; + yygotominor.yy57.args[2] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[3] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[4] = yymsp[0].minor.yy72; +} +#line 1737 "xlat-parse.c" + break; + case 83: +#line 740 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT2; + yygotominor.yy57.args[0] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[1] = 0; + yygotominor.yy57.args[2] = 0; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = 0; +} +#line 1749 "xlat-parse.c" + break; + case 84: +#line 749 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT2; + yygotominor.yy57.args[0] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[1] = 0; + yygotominor.yy57.args[2] = yymsp[0].minor.yy72; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = 0; +} +#line 1761 "xlat-parse.c" + break; + case 85: +#line 758 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT2; + yygotominor.yy57.args[0] = yymsp[-6].minor.yy72; + yygotominor.yy57.args[1] = 0; + yygotominor.yy57.args[2] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[3] = yymsp[0].minor.yy72; + yygotominor.yy57.args[4] = 0; +} +#line 1773 "xlat-parse.c" + break; + case 86: +#line 767 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT2; + yygotominor.yy57.args[0] = yymsp[-8].minor.yy72; + yygotominor.yy57.args[1] = 0; + yygotominor.yy57.args[2] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[3] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[4] = yymsp[0].minor.yy72; +} +#line 1785 "xlat-parse.c" + break; + case 87: +#line 776 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT3; + yygotominor.yy57.args[0] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[1] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[2] = 0; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = 0; +} +#line 1797 "xlat-parse.c" + break; + case 88: +#line 785 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT3; + yygotominor.yy57.args[0] = yymsp[-6].minor.yy72; + yygotominor.yy57.args[1] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[2] = 0; + yygotominor.yy57.args[3] = yymsp[0].minor.yy72; + yygotominor.yy57.args[4] = 0; +} +#line 1809 "xlat-parse.c" + break; + case 89: +#line 794 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT3; + yygotominor.yy57.args[0] = yymsp[-8].minor.yy72; + yygotominor.yy57.args[1] = yymsp[-6].minor.yy72; + yygotominor.yy57.args[2] = 0; + yygotominor.yy57.args[3] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[4] = yymsp[0].minor.yy72; +} +#line 1821 "xlat-parse.c" + break; + case 90: +#line 803 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT4; + yygotominor.yy57.args[0] = yymsp[-6].minor.yy72; + yygotominor.yy57.args[1] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[2] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = 0; +} +#line 1833 "xlat-parse.c" + break; + case 91: +#line 812 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT4; + yygotominor.yy57.args[0] = yymsp[-8].minor.yy72; + yygotominor.yy57.args[1] = yymsp[-6].minor.yy72; + yygotominor.yy57.args[2] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[3] = 0; + yygotominor.yy57.args[4] = yymsp[0].minor.yy72; +} +#line 1845 "xlat-parse.c" + break; + case 92: +#line 821 "xlat-parse.y" +{ + yygotominor.yy57.addflags = SIMPLE_HASTAGAT5; + yygotominor.yy57.args[0] = yymsp[-8].minor.yy72; + yygotominor.yy57.args[1] = yymsp[-6].minor.yy72; + yygotominor.yy57.args[2] = yymsp[-4].minor.yy72; + yygotominor.yy57.args[3] = yymsp[-2].minor.yy72; + yygotominor.yy57.args[4] = 0; +} +#line 1857 "xlat-parse.c" + break; + }; + yygoto = yyRuleInfo[yyruleno].lhs; + yysize = yyRuleInfo[yyruleno].nrhs; + yypParser->yyidx -= yysize; + yyact = yy_find_reduce_action(yymsp[-yysize].stateno,yygoto); + if( yyact < YYNSTATE ){ +#ifdef NDEBUG + /* If we are not debugging and the reduce action popped at least + ** one element off the stack, then we can push the new element back + ** onto the stack here, and skip the stack overflow test in yy_shift(). + ** That gives a significant speed improvement. */ + if( yysize ){ + yypParser->yyidx++; + yymsp -= yysize-1; + yymsp->stateno = yyact; + yymsp->major = yygoto; + yymsp->minor = yygotominor; + }else +#endif + { + yy_shift(yypParser,yyact,yygoto,&yygotominor); + } + }else if( yyact == YYNSTATE + YYNRULE + 1 ){ + yy_accept(yypParser); + } +} + +/* +** The following code executes when the parse fails +*/ +static void yy_parse_failed( + yyParser *yypParser /* The parser */ +){ + ParseARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser fails */ + ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following code executes when a syntax error first occurs. +*/ +static void yy_syntax_error( + yyParser *yypParser, /* The parser */ + int yymajor, /* The major type of the error token */ + YYMINORTYPE yyminor /* The minor type of the error token */ +){ + ParseARG_FETCH; +#define TOKEN (yyminor.yy0) +#line 322 "xlat-parse.y" +yyerror("syntax error"); +#line 1916 "xlat-parse.c" + ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following is executed when the parser accepts +*/ +static void yy_accept( + yyParser *yypParser /* The parser */ +){ + ParseARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser accepts */ + ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* The main parser program. +** The first argument is a pointer to a structure obtained from +** "ParseAlloc" which describes the current state of the parser. +** The second argument is the major token number. The third is +** the minor token. The fourth optional argument is whatever the +** user wants (and specified in the grammar) and is available for +** use by the action routines. +** +** Inputs: +**
    +**
  • A pointer to the parser (an opaque structure.) +**
  • The major token number. +**
  • The minor token number. +**
  • An option argument of a grammar-specified type. +**
+** +** Outputs: +** None. +*/ +void Parse( + void *yyp, /* The parser */ + int yymajor, /* The major token code number */ + ParseTOKENTYPE yyminor /* The value for the token */ + ParseARG_PDECL /* Optional %extra_argument parameter */ +){ + YYMINORTYPE yyminorunion; + int yyact; /* The parser action. */ + int yyendofinput; /* True if we are at the end of input */ + int yyerrorhit = 0; /* True if yymajor has invoked an error */ + yyParser *yypParser; /* The parser */ + + /* (re)initialize the parser, if necessary */ + yypParser = (yyParser*)yyp; + if( yypParser->yyidx<0 ){ + /* if( yymajor==0 ) return; // not sure why this was here... */ + yypParser->yyidx = 0; + yypParser->yyerrcnt = -1; + yypParser->yystack[0].stateno = 0; + yypParser->yystack[0].major = 0; + } + yyminorunion.yy0 = yyminor; + yyendofinput = (yymajor==0); + ParseARG_STORE; + +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]); + } +#endif + + do{ + yyact = yy_find_shift_action(yypParser,yymajor); + if( yyactyyerrcnt--; + if( yyendofinput && yypParser->yyidx>=0 ){ + yymajor = 0; + }else{ + yymajor = YYNOCODE; + while( yypParser->yyidx>= 0 && (yyact = yy_find_shift_action(yypParser,YYNOCODE)) < YYNSTATE + YYNRULE ){ + yy_reduce(yypParser,yyact-YYNSTATE); + } + } + }else if( yyact < YYNSTATE + YYNRULE ){ + yy_reduce(yypParser,yyact-YYNSTATE); + }else if( yyact == YY_ERROR_ACTION ){ + int yymx; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt); + } +#endif +#ifdef YYERRORSYMBOL + /* A syntax error has occurred. + ** The response to an error depends upon whether or not the + ** grammar defines an error token "ERROR". + ** + ** This is what we do if the grammar does define ERROR: + ** + ** * Call the %syntax_error function. + ** + ** * Begin popping the stack until we enter a state where + ** it is legal to shift the error symbol, then shift + ** the error symbol. + ** + ** * Set the error count to three. + ** + ** * Begin accepting and shifting new tokens. No new error + ** processing will occur until three tokens have been + ** shifted successfully. + ** + */ + if( yypParser->yyerrcnt<0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + yymx = yypParser->yystack[yypParser->yyidx].major; + if( yymx==YYERRORSYMBOL || yyerrorhit ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sDiscard input token %s\n", + yyTracePrompt,yyTokenName[yymajor]); + } +#endif + yy_destructor(yymajor,&yyminorunion); + yymajor = YYNOCODE; + }else{ + while( + yypParser->yyidx >= 0 && + yymx != YYERRORSYMBOL && + (yyact = yy_find_reduce_action( + yypParser->yystack[yypParser->yyidx].stateno, + YYERRORSYMBOL)) >= YYNSTATE + ){ + yy_pop_parser_stack(yypParser); + } + if( yypParser->yyidx < 0 || yymajor==0 ){ + yy_destructor(yymajor,&yyminorunion); + yy_parse_failed(yypParser); + yymajor = YYNOCODE; + }else if( yymx!=YYERRORSYMBOL ){ + YYMINORTYPE u2; + u2.YYERRSYMDT = 0; + yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2); + } + } + yypParser->yyerrcnt = 3; + yyerrorhit = 1; +#else /* YYERRORSYMBOL is not defined */ + /* This is what we do if the grammar does not define ERROR: + ** + ** * Report an error message, and throw away the input token. + ** + ** * If the input token is $, then fail the parse. + ** + ** As before, subsequent error messages are suppressed until + ** three input tokens have been successfully shifted. + */ + if( yypParser->yyerrcnt<=0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + yypParser->yyerrcnt = 3; + yy_destructor(yymajor,&yyminorunion); + if( yyendofinput ){ + yy_parse_failed(yypParser); + } + yymajor = YYNOCODE; +#endif + }else{ + yy_accept(yypParser); + yymajor = YYNOCODE; + } + }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 ); + return; +} diff --git a/tools/xlatcc/xlat-parse.h b/tools/xlatcc/xlat-parse.h new file mode 100644 index 000000000..fae813aa3 --- /dev/null +++ b/tools/xlatcc/xlat-parse.h @@ -0,0 +1,36 @@ +#define OR 1 +#define XOR 2 +#define AND 3 +#define MINUS 4 +#define PLUS 5 +#define MULTIPLY 6 +#define DIVIDE 7 +#define NEG 8 +#define NUM 9 +#define SYMNUM 10 +#define LPAREN 11 +#define RPAREN 12 +#define PRINT 13 +#define COMMA 14 +#define STRING 15 +#define ENDL 16 +#define DEFINE 17 +#define SYM 18 +#define INCLUDE 19 +#define RBRACE 20 +#define ENUM 21 +#define LBRACE 22 +#define EQUALS 23 +#define SPECIAL 24 +#define SEMICOLON 25 +#define COLON 26 +#define LBRACKET 27 +#define RBRACKET 28 +#define FLAGS 29 +#define ARG2 30 +#define ARG3 31 +#define ARG4 32 +#define ARG5 33 +#define OR_EQUAL 34 +#define TAG 35 +#define LINEID 36 diff --git a/tools/xlatcc/xlat-parse.tab.c b/tools/xlatcc/xlat-parse.tab.c deleted file mode 100644 index 87eaccdcb..000000000 --- a/tools/xlatcc/xlat-parse.tab.c +++ /dev/null @@ -1,2548 +0,0 @@ -/* A Bison parser, made by GNU Bison 2.1. */ - -/* Skeleton parser for Yacc-like parsing with Bison, - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. - - 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, 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., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ - -/* As a special exception, when this file is copied by Bison into a - Bison output file, you may use that output file without restriction. - This special exception was added by the Free Software Foundation - in version 1.24 of Bison. */ - -/* Written by Richard Stallman by simplifying the original so called - ``semantic'' parser. */ - -/* All symbols defined below should begin with yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -/* Identify Bison output. */ -#define YYBISON 1 - -/* Bison version. */ -#define YYBISON_VERSION "2.1" - -/* Skeleton name. */ -#define YYSKELETON_NAME "yacc.c" - -/* Pure parsers. */ -#define YYPURE 0 - -/* Using locations. */ -#define YYLSP_NEEDED 0 - - - -/* Tokens. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum yytokentype { - NUM = 258, - SYMNUM = 259, - SYM = 260, - STRING = 261, - DEFINE = 262, - INCLUDE = 263, - TAG = 264, - LINEID = 265, - SPECIAL = 266, - FLAGS = 267, - ARG2 = 268, - ARG3 = 269, - ARG4 = 270, - ARG5 = 271, - OR_EQUAL = 272, - ENUM = 273, - PRINT = 274, - ENDL = 275, - NEG = 276 - }; -#endif -/* Tokens. */ -#define NUM 258 -#define SYMNUM 259 -#define SYM 260 -#define STRING 261 -#define DEFINE 262 -#define INCLUDE 263 -#define TAG 264 -#define LINEID 265 -#define SPECIAL 266 -#define FLAGS 267 -#define ARG2 268 -#define ARG3 269 -#define ARG4 270 -#define ARG5 271 -#define OR_EQUAL 272 -#define ENUM 273 -#define PRINT 274 -#define ENDL 275 -#define NEG 276 - - - - -/* Copy the first part of user declarations. */ -#line 7 "xlat-parse.y" - -#include "xlat.h" -#include -#include - -// verbose doesn't seem to help all that much -//#define YYERROR_VERBOSE 1 - -int yyerror (char *s); -int yylex (void); - -typedef struct _Symbol -{ - struct _Symbol *Next; - int Value; - char Sym[1]; -} Symbol; - -static bool FindToken (char *tok, int *type); -static void AddSym (char *sym, int val); -static bool FindSym (char *sym, Symbol **val); - -static int EnumVal; - -struct ListFilter -{ - WORD filter; - BYTE value; -}; - -typedef struct _morefilters -{ - struct _morefilters *next; - struct ListFilter filter; -} MoreFilters; - -typedef struct _morelines -{ - struct _morelines *next; - BoomArg arg; -} MoreLines; - - - -/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG 0 -#endif - -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -# undef YYERROR_VERBOSE -# define YYERROR_VERBOSE 1 -#else -# define YYERROR_VERBOSE 0 -#endif - -/* Enabling the token table. */ -#ifndef YYTOKEN_TABLE -# define YYTOKEN_TABLE 0 -#endif - -#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) -#line 51 "xlat-parse.y" -typedef union YYSTYPE { - int val; - char sym[80]; - char string[80]; - struct - { - BYTE addflags; - BYTE args[5]; - } args; - struct ListFilter filter; - MoreFilters *filter_p; - struct - { - BYTE constant; - WORD mask; - MoreFilters *filters; - } boomarg; - Symbol *symval; - BoomArg boomline; - MoreLines *boomlines; -} YYSTYPE; -/* Line 196 of yacc.c. */ -#line 193 "xlat-parse.tab.c" -# define yystype YYSTYPE /* obsolescent; will be withdrawn */ -# define YYSTYPE_IS_DECLARED 1 -# define YYSTYPE_IS_TRIVIAL 1 -#endif - - - -/* Copy the second part of user declarations. */ - - -/* Line 219 of yacc.c. */ -#line 205 "xlat-parse.tab.c" - -#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) -# define YYSIZE_T __SIZE_TYPE__ -#endif -#if ! defined (YYSIZE_T) && defined (size_t) -# define YYSIZE_T size_t -#endif -#if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus)) -# include /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -#endif -#if ! defined (YYSIZE_T) -# define YYSIZE_T unsigned int -#endif - -#ifndef YY_ -# if YYENABLE_NLS -# if ENABLE_NLS -# include /* INFRINGES ON USER NAME SPACE */ -# define YY_(msgid) dgettext ("bison-runtime", msgid) -# endif -# endif -# ifndef YY_ -# define YY_(msgid) msgid -# endif -#endif - -#if ! defined (yyoverflow) || YYERROR_VERBOSE - -/* The parser invokes alloca or malloc; define the necessary symbols. */ - -# ifdef YYSTACK_USE_ALLOCA -# if YYSTACK_USE_ALLOCA -# ifdef __GNUC__ -# define YYSTACK_ALLOC __builtin_alloca -# else -# define YYSTACK_ALLOC alloca -# if defined (__STDC__) || defined (__cplusplus) -# include /* INFRINGES ON USER NAME SPACE */ -# define YYINCLUDED_STDLIB_H -# endif -# endif -# endif -# endif - -# ifdef YYSTACK_ALLOC - /* Pacify GCC's `empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) -# ifndef YYSTACK_ALLOC_MAXIMUM - /* The OS might guarantee only one guard page at the bottom of the stack, - and a page size can be as small as 4096 bytes. So we cannot safely - invoke alloca (N) if N exceeds 4096. Use a slightly smaller number - to allow for a few compiler-allocated temporary stack slots. */ -# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */ -# endif -# else -# define YYSTACK_ALLOC YYMALLOC -# define YYSTACK_FREE YYFREE -# ifndef YYSTACK_ALLOC_MAXIMUM -# define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1) -# endif -# ifdef __cplusplus -extern "C" { -# endif -# ifndef YYMALLOC -# define YYMALLOC malloc -# if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \ - && (defined (__STDC__) || defined (__cplusplus))) -void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ -# endif -# endif -# ifndef YYFREE -# define YYFREE free -# if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \ - && (defined (__STDC__) || defined (__cplusplus))) -void free (void *); /* INFRINGES ON USER NAME SPACE */ -# endif -# endif -# ifdef __cplusplus -} -# endif -# endif -#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ - - -#if (! defined (yyoverflow) \ - && (! defined (__cplusplus) \ - || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) - -/* A type that is properly aligned for any stack member. */ -union yyalloc -{ - short int yyss; - YYSTYPE yyvs; - }; - -/* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) - -/* The size of an array large to enough to hold all stacks, each with - N elements. */ -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAXIMUM) - -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if defined (__GNUC__) && 1 < __GNUC__ -# define YYCOPY(To, From, Count) \ - __builtin_memcpy (To, From, (Count) * sizeof (*(From))) -# else -# define YYCOPY(To, From, Count) \ - do \ - { \ - YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } \ - while (0) -# endif -# endif - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - elements in the stack, and YYPTR gives the new location of the - stack. Advance YYPTR to a properly aligned location for the next - stack. */ -# define YYSTACK_RELOCATE(Stack) \ - do \ - { \ - YYSIZE_T yynewbytes; \ - YYCOPY (&yyptr->Stack, Stack, yysize); \ - Stack = &yyptr->Stack; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / sizeof (*yyptr); \ - } \ - while (0) - -#endif - -#if defined (__STDC__) || defined (__cplusplus) - typedef signed char yysigned_char; -#else - typedef short int yysigned_char; -#endif - -/* YYFINAL -- State number of the termination state. */ -#define YYFINAL 2 -/* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 449 - -/* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 39 -/* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 28 -/* YYNRULES -- Number of rules. */ -#define YYNRULES 95 -/* YYNRULES -- Number of states. */ -#define YYNSTATES 175 - -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ -#define YYUNDEFTOK 2 -#define YYMAXUTOK 276 - -#define YYTRANSLATE(YYX) \ - ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) - -/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ -static const unsigned char yytranslate[] = -{ - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 23, 2, - 29, 30, 26, 25, 31, 24, 2, 27, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 36, 35, - 2, 34, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 37, 2, 38, 22, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 32, 21, 33, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 28 -}; - -#if YYDEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const unsigned short int yyprhs[] = -{ - 0, 0, 3, 5, 7, 11, 15, 19, 23, 27, - 31, 35, 38, 42, 43, 46, 48, 50, 52, 54, - 56, 58, 60, 65, 66, 68, 72, 74, 76, 78, - 84, 87, 88, 94, 95, 97, 101, 103, 107, 111, - 112, 114, 118, 125, 126, 134, 135, 137, 141, 150, - 159, 171, 172, 175, 179, 181, 183, 185, 187, 189, - 191, 193, 195, 200, 202, 206, 210, 211, 213, 217, - 223, 231, 241, 245, 251, 259, 269, 271, 275, 281, - 289, 299, 301, 305, 311, 319, 329, 333, 339, 347, - 357, 363, 371, 381, 389, 399 -}; - -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const yysigned_char yyrhs[] = -{ - 41, 0, -1, 3, -1, 4, -1, 40, 25, 40, - -1, 40, 24, 40, -1, 40, 26, 40, -1, 40, - 27, 40, -1, 40, 21, 40, -1, 40, 23, 40, - -1, 40, 22, 40, -1, 24, 40, -1, 29, 40, - 30, -1, -1, 41, 42, -1, 46, -1, 47, -1, - 43, -1, 48, -1, 57, -1, 58, -1, 52, -1, - 19, 29, 44, 30, -1, -1, 45, -1, 45, 31, - 44, -1, 6, -1, 40, -1, 20, -1, 7, 5, - 29, 40, 30, -1, 8, 6, -1, -1, 18, 32, - 49, 50, 33, -1, -1, 51, -1, 51, 31, 50, - -1, 5, -1, 5, 34, 40, -1, 11, 53, 35, - -1, -1, 54, -1, 54, 31, 53, -1, 40, 36, - 5, 29, 56, 30, -1, -1, 40, 36, 4, 55, - 29, 56, 30, -1, -1, 40, -1, 40, 31, 40, - -1, 40, 34, 40, 31, 40, 29, 66, 30, -1, - 40, 34, 40, 31, 5, 29, 66, 30, -1, 37, - 40, 38, 29, 40, 31, 40, 30, 32, 59, 33, - -1, -1, 60, 59, -1, 61, 62, 63, -1, 12, - -1, 13, -1, 14, -1, 15, -1, 16, -1, 34, - -1, 17, -1, 40, -1, 40, 37, 64, 38, -1, - 65, -1, 65, 31, 64, -1, 40, 36, 40, -1, - -1, 9, -1, 9, 31, 40, -1, 9, 31, 40, - 31, 40, -1, 9, 31, 40, 31, 40, 31, 40, - -1, 9, 31, 40, 31, 40, 31, 40, 31, 40, - -1, 9, 31, 9, -1, 9, 31, 9, 31, 40, - -1, 9, 31, 9, 31, 40, 31, 40, -1, 9, - 31, 9, 31, 40, 31, 40, 31, 40, -1, 10, - -1, 10, 31, 40, -1, 10, 31, 40, 31, 40, - -1, 10, 31, 40, 31, 40, 31, 40, -1, 10, - 31, 40, 31, 40, 31, 40, 31, 40, -1, 40, - -1, 40, 31, 40, -1, 40, 31, 40, 31, 40, - -1, 40, 31, 40, 31, 40, 31, 40, -1, 40, - 31, 40, 31, 40, 31, 40, 31, 40, -1, 40, - 31, 9, -1, 40, 31, 9, 31, 40, -1, 40, - 31, 9, 31, 40, 31, 40, -1, 40, 31, 9, - 31, 40, 31, 40, 31, 40, -1, 40, 31, 40, - 31, 9, -1, 40, 31, 40, 31, 9, 31, 40, - -1, 40, 31, 40, 31, 9, 31, 40, 31, 40, - -1, 40, 31, 40, 31, 40, 31, 9, -1, 40, - 31, 40, 31, 40, 31, 9, 31, 40, -1, 40, - 31, 40, 31, 40, 31, 40, 31, 9, -1 -}; - -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const unsigned short int yyrline[] = -{ - 0, 116, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 129, 130, 134, 135, 136, 137, 138, - 139, 140, 144, 150, 152, 153, 157, 158, 159, 163, - 167, 171, 171, 174, 176, 177, 181, 182, 189, 192, - 194, 195, 199, 201, 200, 206, 207, 208, 212, 222, - 229, 277, 280, 289, 324, 325, 326, 327, 328, 332, - 333, 337, 342, 350, 356, 365, 370, 374, 379, 388, - 397, 406, 416, 424, 432, 440, 449, 454, 463, 472, - 481, 491, 500, 509, 518, 527, 537, 546, 555, 564, - 574, 583, 592, 602, 611, 621 -}; -#endif - -#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE -/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. - First, the terminals, then, starting at YYNTOKENS, nonterminals. */ -static const char *const yytname[] = -{ - "$end", "error", "$undefined", "NUM", "SYMNUM", "SYM", "STRING", - "DEFINE", "INCLUDE", "TAG", "LINEID", "SPECIAL", "FLAGS", "ARG2", "ARG3", - "ARG4", "ARG5", "OR_EQUAL", "ENUM", "PRINT", "ENDL", "'|'", "'^'", "'&'", - "'-'", "'+'", "'*'", "'/'", "NEG", "'('", "')'", "','", "'{'", "'}'", - "'='", "';'", "':'", "'['", "']'", "$accept", "exp", "translation_unit", - "external_declaration", "print_statement", "print_list", "print_item", - "define_statement", "include_statement", "enum_statement", "@1", - "enum_list", "single_enum", "special_declaration", "special_list", - "special_def", "@2", "maybe_argcount", "linetype_declaration", - "boom_declaration", "boom_body", "boom_line", "boom_selector", "boom_op", - "boom_args", "arg_list", "list_val", "special_args", 0 -}; -#endif - -# ifdef YYPRINT -/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to - token YYLEX-NUM. */ -static const unsigned short int yytoknum[] = -{ - 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 124, 94, 38, 45, 43, 42, 47, 276, 40, - 41, 44, 123, 125, 61, 59, 58, 91, 93 -}; -# endif - -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const unsigned char yyr1[] = -{ - 0, 39, 40, 40, 40, 40, 40, 40, 40, 40, - 40, 40, 40, 41, 41, 42, 42, 42, 42, 42, - 42, 42, 43, 44, 44, 44, 45, 45, 45, 46, - 47, 49, 48, 50, 50, 50, 51, 51, 52, 53, - 53, 53, 54, 55, 54, 56, 56, 56, 57, 57, - 58, 59, 59, 60, 61, 61, 61, 61, 61, 62, - 62, 63, 63, 64, 64, 65, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 66, 66 -}; - -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const unsigned char yyr2[] = -{ - 0, 2, 1, 1, 3, 3, 3, 3, 3, 3, - 3, 2, 3, 0, 2, 1, 1, 1, 1, 1, - 1, 1, 4, 0, 1, 3, 1, 1, 1, 5, - 2, 0, 5, 0, 1, 3, 1, 3, 3, 0, - 1, 3, 6, 0, 7, 0, 1, 3, 8, 8, - 11, 0, 2, 3, 1, 1, 1, 1, 1, 1, - 1, 1, 4, 1, 3, 3, 0, 1, 3, 5, - 7, 9, 3, 5, 7, 9, 1, 3, 5, 7, - 9, 1, 3, 5, 7, 9, 3, 5, 7, 9, - 5, 7, 9, 7, 9, 9 -}; - -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state - STATE-NUM when YYTABLE doesn't specify something else to do. Zero - means the default is an error. */ -static const unsigned char yydefact[] = -{ - 13, 0, 1, 2, 3, 0, 0, 39, 0, 0, - 0, 0, 0, 0, 14, 17, 15, 16, 18, 21, - 19, 20, 0, 30, 0, 0, 40, 31, 23, 11, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 38, 39, 33, 26, 28, 27, 0, 24, - 12, 0, 8, 10, 9, 5, 4, 6, 7, 0, - 0, 43, 0, 41, 36, 0, 34, 22, 23, 0, - 0, 29, 0, 45, 0, 32, 33, 25, 0, 0, - 0, 45, 46, 0, 37, 35, 0, 66, 66, 0, - 0, 42, 0, 67, 76, 81, 0, 0, 44, 47, - 0, 0, 0, 0, 49, 48, 51, 72, 68, 77, - 86, 82, 54, 55, 56, 57, 58, 0, 51, 0, - 0, 0, 0, 0, 0, 50, 52, 60, 59, 0, - 73, 69, 78, 87, 90, 83, 61, 53, 0, 0, - 0, 0, 0, 0, 0, 74, 70, 79, 88, 91, - 93, 84, 0, 0, 63, 0, 0, 0, 0, 0, - 0, 0, 0, 62, 0, 75, 71, 80, 89, 92, - 94, 95, 85, 65, 64 -}; - -/* YYDEFGOTO[NTERM-NUM]. */ -static const short int yydefgoto[] = -{ - -1, 24, 1, 14, 15, 48, 49, 16, 17, 18, - 44, 65, 66, 19, 25, 26, 72, 83, 20, 21, - 117, 118, 119, 129, 137, 153, 154, 96 -}; - -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -#define YYPACT_NINF -28 -static const short int yypact[] = -{ - -28, 41, -28, -28, -28, 2, 6, 50, -27, 11, - 50, 50, 50, 166, -28, -28, -28, -28, -28, -28, - -28, -28, 14, -28, 143, -7, -5, -28, 0, -28, - 378, -8, 50, 50, 50, 50, 50, 50, 50, 50, - 50, -3, -28, 50, 53, -28, -28, 417, 16, 24, - -28, 46, 158, 171, 37, 68, 68, -28, -28, 180, - 388, -28, 48, -28, 32, 51, 66, -28, 0, 50, - 18, -28, 52, 50, 50, -28, 53, -28, 191, 70, - 408, 50, 202, 84, 417, -28, 50, 47, 47, 85, - 50, -28, 398, 78, 86, 213, 94, 96, -28, 417, - 97, 79, 50, 87, -28, -28, 433, 100, 224, 235, - 102, 246, -28, -28, -28, -28, -28, 111, 433, -9, - 50, 50, 50, 50, 89, -28, -28, -28, -28, 50, - 257, 268, 279, 290, 104, 301, 125, -28, 50, 50, - 50, 50, 50, 101, 50, 312, 323, 334, 345, 356, - 105, 367, 150, 107, 122, 50, 50, 50, 50, 50, - 50, 103, 50, -28, 50, 417, 417, 417, 417, 417, - 417, -28, 417, 417, -28 -}; - -/* YYPGOTO[NTERM-NUM]. */ -static const short int yypgoto[] = -{ - -28, -1, -28, -28, -28, 110, -28, -28, -28, -28, - -28, 58, -28, -28, 156, -28, -28, 127, -28, -28, - 91, -28, -28, -28, -28, 55, -28, 132 -}; - -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. - If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -1 -static const unsigned char yytable[] = -{ - 13, 61, 62, 3, 4, 27, 45, 22, 127, 29, - 30, 31, 23, 32, 33, 34, 35, 36, 37, 38, - 46, 3, 4, 79, 10, 128, 43, 47, 42, 11, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 28, 2, 10, 40, 3, 4, 67, 11, 5, 6, - 3, 4, 7, 3, 4, 68, 93, 94, 64, 8, - 9, 35, 36, 37, 38, 10, 74, 47, 78, 80, - 11, 10, 82, 84, 10, 69, 11, 73, 12, 11, - 82, 81, 3, 4, 75, 92, 95, 95, 107, 99, - 3, 4, 3, 4, 37, 38, 110, 76, 134, 87, - 108, 109, 111, 10, 3, 4, 3, 4, 11, 101, - 150, 10, 171, 10, 91, 98, 11, 102, 11, 130, - 131, 132, 133, 135, 104, 10, 105, 10, 136, 106, - 11, 120, 11, 123, 85, 142, 160, 145, 146, 147, - 148, 149, 151, 152, 125, 163, 32, 33, 34, 35, - 36, 37, 38, 164, 165, 166, 167, 168, 169, 170, - 172, 173, 144, 152, 32, 33, 34, 35, 36, 37, - 38, 32, 33, 34, 35, 36, 37, 38, 77, 41, - 33, 34, 35, 36, 37, 38, 162, 32, 33, 34, - 35, 36, 37, 38, 34, 35, 36, 37, 38, 63, - 39, 32, 33, 34, 35, 36, 37, 38, 89, 126, - 0, 70, 32, 33, 34, 35, 36, 37, 38, 174, - 97, 0, 86, 32, 33, 34, 35, 36, 37, 38, - 0, 0, 0, 90, 32, 33, 34, 35, 36, 37, - 38, 0, 0, 0, 103, 32, 33, 34, 35, 36, - 37, 38, 0, 0, 0, 121, 32, 33, 34, 35, - 36, 37, 38, 0, 0, 0, 122, 32, 33, 34, - 35, 36, 37, 38, 0, 0, 0, 124, 32, 33, - 34, 35, 36, 37, 38, 0, 0, 0, 138, 32, - 33, 34, 35, 36, 37, 38, 0, 0, 0, 139, - 32, 33, 34, 35, 36, 37, 38, 0, 0, 0, - 140, 32, 33, 34, 35, 36, 37, 38, 0, 0, - 0, 141, 32, 33, 34, 35, 36, 37, 38, 0, - 0, 0, 143, 32, 33, 34, 35, 36, 37, 38, - 0, 0, 0, 155, 32, 33, 34, 35, 36, 37, - 38, 0, 0, 0, 156, 32, 33, 34, 35, 36, - 37, 38, 0, 0, 0, 157, 32, 33, 34, 35, - 36, 37, 38, 0, 0, 0, 158, 32, 33, 34, - 35, 36, 37, 38, 0, 0, 0, 159, 32, 33, - 34, 35, 36, 37, 38, 0, 0, 0, 161, 32, - 33, 34, 35, 36, 37, 38, 0, 0, 50, 32, - 33, 34, 35, 36, 37, 38, 0, 0, 71, 32, - 33, 34, 35, 36, 37, 38, 0, 0, 100, 32, - 33, 34, 35, 36, 37, 38, 0, 88, 32, 33, - 34, 35, 36, 37, 38, 112, 113, 114, 115, 116 -}; - -static const short int yycheck[] = -{ - 1, 4, 5, 3, 4, 32, 6, 5, 17, 10, - 11, 12, 6, 21, 22, 23, 24, 25, 26, 27, - 20, 3, 4, 5, 24, 34, 31, 28, 35, 29, - 38, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 29, 0, 24, 29, 3, 4, 30, 29, 7, 8, - 3, 4, 11, 3, 4, 31, 9, 10, 5, 18, - 19, 24, 25, 26, 27, 24, 34, 68, 69, 70, - 29, 24, 73, 74, 24, 29, 29, 29, 37, 29, - 81, 29, 3, 4, 33, 86, 87, 88, 9, 90, - 3, 4, 3, 4, 26, 27, 9, 31, 9, 29, - 101, 102, 103, 24, 3, 4, 3, 4, 29, 31, - 9, 24, 9, 24, 30, 30, 29, 31, 29, 120, - 121, 122, 123, 124, 30, 24, 30, 24, 129, 32, - 29, 31, 29, 31, 76, 31, 31, 138, 139, 140, - 141, 142, 143, 144, 33, 38, 21, 22, 23, 24, - 25, 26, 27, 31, 155, 156, 157, 158, 159, 160, - 161, 162, 37, 164, 21, 22, 23, 24, 25, 26, - 27, 21, 22, 23, 24, 25, 26, 27, 68, 36, - 22, 23, 24, 25, 26, 27, 36, 21, 22, 23, - 24, 25, 26, 27, 23, 24, 25, 26, 27, 43, - 34, 21, 22, 23, 24, 25, 26, 27, 81, 118, - -1, 31, 21, 22, 23, 24, 25, 26, 27, 164, - 88, -1, 31, 21, 22, 23, 24, 25, 26, 27, - -1, -1, -1, 31, 21, 22, 23, 24, 25, 26, - 27, -1, -1, -1, 31, 21, 22, 23, 24, 25, - 26, 27, -1, -1, -1, 31, 21, 22, 23, 24, - 25, 26, 27, -1, -1, -1, 31, 21, 22, 23, - 24, 25, 26, 27, -1, -1, -1, 31, 21, 22, - 23, 24, 25, 26, 27, -1, -1, -1, 31, 21, - 22, 23, 24, 25, 26, 27, -1, -1, -1, 31, - 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, - 31, 21, 22, 23, 24, 25, 26, 27, -1, -1, - -1, 31, 21, 22, 23, 24, 25, 26, 27, -1, - -1, -1, 31, 21, 22, 23, 24, 25, 26, 27, - -1, -1, -1, 31, 21, 22, 23, 24, 25, 26, - 27, -1, -1, -1, 31, 21, 22, 23, 24, 25, - 26, 27, -1, -1, -1, 31, 21, 22, 23, 24, - 25, 26, 27, -1, -1, -1, 31, 21, 22, 23, - 24, 25, 26, 27, -1, -1, -1, 31, 21, 22, - 23, 24, 25, 26, 27, -1, -1, -1, 31, 21, - 22, 23, 24, 25, 26, 27, -1, -1, 30, 21, - 22, 23, 24, 25, 26, 27, -1, -1, 30, 21, - 22, 23, 24, 25, 26, 27, -1, -1, 30, 21, - 22, 23, 24, 25, 26, 27, -1, 29, 21, 22, - 23, 24, 25, 26, 27, 12, 13, 14, 15, 16 -}; - -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ -static const unsigned char yystos[] = -{ - 0, 41, 0, 3, 4, 7, 8, 11, 18, 19, - 24, 29, 37, 40, 42, 43, 46, 47, 48, 52, - 57, 58, 5, 6, 40, 53, 54, 32, 29, 40, - 40, 40, 21, 22, 23, 24, 25, 26, 27, 34, - 29, 36, 35, 31, 49, 6, 20, 40, 44, 45, - 30, 38, 40, 40, 40, 40, 40, 40, 40, 40, - 40, 4, 5, 53, 5, 50, 51, 30, 31, 29, - 31, 30, 55, 29, 34, 33, 31, 44, 40, 5, - 40, 29, 40, 56, 40, 50, 31, 29, 29, 56, - 31, 30, 40, 9, 10, 40, 66, 66, 30, 40, - 30, 31, 31, 31, 30, 30, 32, 9, 40, 40, - 9, 40, 12, 13, 14, 15, 16, 59, 60, 61, - 31, 31, 31, 31, 31, 33, 59, 17, 34, 62, - 40, 40, 40, 40, 9, 40, 40, 63, 31, 31, - 31, 31, 31, 31, 37, 40, 40, 40, 40, 40, - 9, 40, 40, 64, 65, 31, 31, 31, 31, 31, - 31, 31, 36, 38, 31, 40, 40, 40, 40, 40, - 40, 9, 40, 40, 64 -}; - -#define yyerrok (yyerrstatus = 0) -#define yyclearin (yychar = YYEMPTY) -#define YYEMPTY (-2) -#define YYEOF 0 - -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab - - -/* Like YYERROR except do call yyerror. This remains here temporarily - to ease the transition to the new meaning of YYERROR, for GCC. - Once GCC version 2 has supplanted version 1, this can go. */ - -#define YYFAIL goto yyerrlab - -#define YYRECOVERING() (!!yyerrstatus) - -#define YYBACKUP(Token, Value) \ -do \ - if (yychar == YYEMPTY && yylen == 1) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - yytoken = YYTRANSLATE (yychar); \ - YYPOPSTACK; \ - goto yybackup; \ - } \ - else \ - { \ - yyerror (YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ -while (0) - - -#define YYTERROR 1 -#define YYERRCODE 256 - - -/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. - If N is 0, then set CURRENT to the empty location which ends - the previous symbol: RHS[0] (always defined). */ - -#define YYRHSLOC(Rhs, K) ((Rhs)[K]) -#ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (N) \ - { \ - (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ - (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ - (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ - (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ - } \ - else \ - { \ - (Current).first_line = (Current).last_line = \ - YYRHSLOC (Rhs, 0).last_line; \ - (Current).first_column = (Current).last_column = \ - YYRHSLOC (Rhs, 0).last_column; \ - } \ - while (0) -#endif - - -/* YY_LOCATION_PRINT -- Print the location on the stream. - This macro was not mandated originally: define only if we know - we won't break user code: when these are the locations we know. */ - -#ifndef YY_LOCATION_PRINT -# if YYLTYPE_IS_TRIVIAL -# define YY_LOCATION_PRINT(File, Loc) \ - fprintf (File, "%d.%d-%d.%d", \ - (Loc).first_line, (Loc).first_column, \ - (Loc).last_line, (Loc).last_column) -# else -# define YY_LOCATION_PRINT(File, Loc) ((void) 0) -# endif -#endif - - -/* YYLEX -- calling `yylex' with the right arguments. */ - -#ifdef YYLEX_PARAM -# define YYLEX yylex (YYLEX_PARAM) -#else -# define YYLEX yylex () -#endif - -/* Enable debugging if requested. */ -#if YYDEBUG - -# ifndef YYFPRINTF -# include /* INFRINGES ON USER NAME SPACE */ -# define YYFPRINTF fprintf -# endif - -# define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ -} while (0) - -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ -do { \ - if (yydebug) \ - { \ - YYFPRINTF (stderr, "%s ", Title); \ - yysymprint (stderr, \ - Type, Value); \ - YYFPRINTF (stderr, "\n"); \ - } \ -} while (0) - -/*------------------------------------------------------------------. -| yy_stack_print -- Print the state stack from its BOTTOM up to its | -| TOP (included). | -`------------------------------------------------------------------*/ - -#if defined (__STDC__) || defined (__cplusplus) -static void -yy_stack_print (short int *bottom, short int *top) -#else -static void -yy_stack_print (bottom, top) - short int *bottom; - short int *top; -#endif -{ - YYFPRINTF (stderr, "Stack now"); - for (/* Nothing. */; bottom <= top; ++bottom) - YYFPRINTF (stderr, " %d", *bottom); - YYFPRINTF (stderr, "\n"); -} - -# define YY_STACK_PRINT(Bottom, Top) \ -do { \ - if (yydebug) \ - yy_stack_print ((Bottom), (Top)); \ -} while (0) - - -/*------------------------------------------------. -| Report that the YYRULE is going to be reduced. | -`------------------------------------------------*/ - -#if defined (__STDC__) || defined (__cplusplus) -static void -yy_reduce_print (int yyrule) -#else -static void -yy_reduce_print (yyrule) - int yyrule; -#endif -{ - int yyi; - unsigned long int yylno = yyrline[yyrule]; - YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ", - yyrule - 1, yylno); - /* Print the symbols being reduced, and their result. */ - for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) - YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); - YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]); -} - -# define YY_REDUCE_PRINT(Rule) \ -do { \ - if (yydebug) \ - yy_reduce_print (Rule); \ -} while (0) - -/* Nonzero means print parse trace. It is left uninitialized so that - multiple parsers can coexist. */ -int yydebug; -#else /* !YYDEBUG */ -# define YYDPRINTF(Args) -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) -# define YY_STACK_PRINT(Bottom, Top) -# define YY_REDUCE_PRINT(Rule) -#endif /* !YYDEBUG */ - - -/* YYINITDEPTH -- initial size of the parser's stacks. */ -#ifndef YYINITDEPTH -# define YYINITDEPTH 200 -#endif - -/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only - if the built-in stack extension method is used). - - Do not make this value too large; the results are undefined if - YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) - evaluated with infinite-precision integer arithmetic. */ - -#ifndef YYMAXDEPTH -# define YYMAXDEPTH 10000 -#endif - - - -#if YYERROR_VERBOSE - -# ifndef yystrlen -# if defined (__GLIBC__) && defined (_STRING_H) -# define yystrlen strlen -# else -/* Return the length of YYSTR. */ -static YYSIZE_T -# if defined (__STDC__) || defined (__cplusplus) -yystrlen (const char *yystr) -# else -yystrlen (yystr) - const char *yystr; -# endif -{ - const char *yys = yystr; - - while (*yys++ != '\0') - continue; - - return yys - yystr - 1; -} -# endif -# endif - -# ifndef yystpcpy -# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) -# define yystpcpy stpcpy -# else -/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in - YYDEST. */ -static char * -# if defined (__STDC__) || defined (__cplusplus) -yystpcpy (char *yydest, const char *yysrc) -# else -yystpcpy (yydest, yysrc) - char *yydest; - const char *yysrc; -# endif -{ - char *yyd = yydest; - const char *yys = yysrc; - - while ((*yyd++ = *yys++) != '\0') - continue; - - return yyd - 1; -} -# endif -# endif - -# ifndef yytnamerr -/* Copy to YYRES the contents of YYSTR after stripping away unnecessary - quotes and backslashes, so that it's suitable for yyerror. The - heuristic is that double-quoting is unnecessary unless the string - contains an apostrophe, a comma, or backslash (other than - backslash-backslash). YYSTR is taken from yytname. If YYRES is - null, do not copy; instead, return the length of what the result - would have been. */ -static YYSIZE_T -yytnamerr (char *yyres, const char *yystr) -{ - if (*yystr == '"') - { - size_t yyn = 0; - char const *yyp = yystr; - - for (;;) - switch (*++yyp) - { - case '\'': - case ',': - goto do_not_strip_quotes; - - case '\\': - if (*++yyp != '\\') - goto do_not_strip_quotes; - /* Fall through. */ - default: - if (yyres) - yyres[yyn] = *yyp; - yyn++; - break; - - case '"': - if (yyres) - yyres[yyn] = '\0'; - return yyn; - } - do_not_strip_quotes: ; - } - - if (! yyres) - return yystrlen (yystr); - - return yystpcpy (yyres, yystr) - yyres; -} -# endif - -#endif /* YYERROR_VERBOSE */ - - - -#if YYDEBUG -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -#if defined (__STDC__) || defined (__cplusplus) -static void -yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) -#else -static void -yysymprint (yyoutput, yytype, yyvaluep) - FILE *yyoutput; - int yytype; - YYSTYPE *yyvaluep; -#endif -{ - /* Pacify ``unused variable'' warnings. */ - (void) yyvaluep; - - if (yytype < YYNTOKENS) - YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); - else - YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); - - -# ifdef YYPRINT - if (yytype < YYNTOKENS) - YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); -# endif - switch (yytype) - { - default: - break; - } - YYFPRINTF (yyoutput, ")"); -} - -#endif /* ! YYDEBUG */ -/*-----------------------------------------------. -| Release the memory associated to this symbol. | -`-----------------------------------------------*/ - -#if defined (__STDC__) || defined (__cplusplus) -static void -yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) -#else -static void -yydestruct (yymsg, yytype, yyvaluep) - const char *yymsg; - int yytype; - YYSTYPE *yyvaluep; -#endif -{ - /* Pacify ``unused variable'' warnings. */ - (void) yyvaluep; - - if (!yymsg) - yymsg = "Deleting"; - YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); - - switch (yytype) - { - - default: - break; - } -} - - -/* Prevent warnings from -Wmissing-prototypes. */ - -#ifdef YYPARSE_PARAM -# if defined (__STDC__) || defined (__cplusplus) -int yyparse (void *YYPARSE_PARAM); -# else -int yyparse (); -# endif -#else /* ! YYPARSE_PARAM */ -#if defined (__STDC__) || defined (__cplusplus) -int yyparse (void); -#else -int yyparse (); -#endif -#endif /* ! YYPARSE_PARAM */ - - - -/* The look-ahead symbol. */ -int yychar; - -/* The semantic value of the look-ahead symbol. */ -YYSTYPE yylval; - -/* Number of syntax errors so far. */ -int yynerrs; - - - -/*----------. -| yyparse. | -`----------*/ - -#ifdef YYPARSE_PARAM -# if defined (__STDC__) || defined (__cplusplus) -int yyparse (void *YYPARSE_PARAM) -# else -int yyparse (YYPARSE_PARAM) - void *YYPARSE_PARAM; -# endif -#else /* ! YYPARSE_PARAM */ -#if defined (__STDC__) || defined (__cplusplus) -int -yyparse (void) -#else -int -yyparse () - ; -#endif -#endif -{ - - int yystate; - int yyn; - int yyresult; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus; - /* Look-ahead token as an internal (translated) token number. */ - int yytoken = 0; - - /* Three stacks and their tools: - `yyss': related to states, - `yyvs': related to semantic values, - `yyls': related to locations. - - Refer to the stacks thru separate pointers, to allow yyoverflow - to reallocate them elsewhere. */ - - /* The state stack. */ - short int yyssa[YYINITDEPTH]; - short int *yyss = yyssa; - short int *yyssp; - - /* The semantic value stack. */ - YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE *yyvs = yyvsa; - YYSTYPE *yyvsp; - - - -#define YYPOPSTACK (yyvsp--, yyssp--) - - YYSIZE_T yystacksize = YYINITDEPTH; - - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval; - - - /* When reducing, the number of symbols on the RHS of the reduced - rule. */ - int yylen; - - YYDPRINTF ((stderr, "Starting parse\n")); - - yystate = 0; - yyerrstatus = 0; - yynerrs = 0; - yychar = YYEMPTY; /* Cause a token to be read. */ - - /* Initialize stack pointers. - Waste one element of value and location stack - so that they stay on the same level as the state stack. - The wasted elements are never initialized. */ - - yyssp = yyss; - yyvsp = yyvs; - - goto yysetstate; - -/*------------------------------------------------------------. -| yynewstate -- Push a new state, which is found in yystate. | -`------------------------------------------------------------*/ - yynewstate: - /* In all cases, when you get here, the value and location stacks - have just been pushed. so pushing a state here evens the stacks. - */ - yyssp++; - - yysetstate: - *yyssp = yystate; - - if (yyss + yystacksize - 1 <= yyssp) - { - /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; - -#ifdef yyoverflow - { - /* Give user a chance to reallocate the stack. Use copies of - these so that the &'s don't force the real ones into - memory. */ - YYSTYPE *yyvs1 = yyvs; - short int *yyss1 = yyss; - - - /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. This used to be a - conditional around just the two extra args, but that might - be undefined if yyoverflow is a macro. */ - yyoverflow (YY_("memory exhausted"), - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), - - &yystacksize); - - yyss = yyss1; - yyvs = yyvs1; - } -#else /* no yyoverflow */ -# ifndef YYSTACK_RELOCATE - goto yyexhaustedlab; -# else - /* Extend the stack our own way. */ - if (YYMAXDEPTH <= yystacksize) - goto yyexhaustedlab; - yystacksize *= 2; - if (YYMAXDEPTH < yystacksize) - yystacksize = YYMAXDEPTH; - - { - short int *yyss1 = yyss; - union yyalloc *yyptr = - (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); - if (! yyptr) - goto yyexhaustedlab; - YYSTACK_RELOCATE (yyss); - YYSTACK_RELOCATE (yyvs); - -# undef YYSTACK_RELOCATE - if (yyss1 != yyssa) - YYSTACK_FREE (yyss1); - } -# endif -#endif /* no yyoverflow */ - - yyssp = yyss + yysize - 1; - yyvsp = yyvs + yysize - 1; - - - YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); - - if (yyss + yystacksize - 1 <= yyssp) - YYABORT; - } - - YYDPRINTF ((stderr, "Entering state %d\n", yystate)); - - goto yybackup; - -/*-----------. -| yybackup. | -`-----------*/ -yybackup: - -/* Do appropriate processing given the current state. */ -/* Read a look-ahead token if we need one and don't already have one. */ -/* yyresume: */ - - /* First try to decide what to do without reference to look-ahead token. */ - - yyn = yypact[yystate]; - if (yyn == YYPACT_NINF) - goto yydefault; - - /* Not known => get a look-ahead token if don't already have one. */ - - /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ - if (yychar == YYEMPTY) - { - YYDPRINTF ((stderr, "Reading a token: ")); - yychar = YYLEX; - } - - if (yychar <= YYEOF) - { - yychar = yytoken = YYEOF; - YYDPRINTF ((stderr, "Now at end of input.\n")); - } - else - { - yytoken = YYTRANSLATE (yychar); - YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); - } - - /* If the proper action on seeing token YYTOKEN is to reduce or to - detect an error, take that action. */ - yyn += yytoken; - if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) - goto yydefault; - yyn = yytable[yyn]; - if (yyn <= 0) - { - if (yyn == 0 || yyn == YYTABLE_NINF) - goto yyerrlab; - yyn = -yyn; - goto yyreduce; - } - - if (yyn == YYFINAL) - YYACCEPT; - - /* Shift the look-ahead token. */ - YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); - - /* Discard the token being shifted unless it is eof. */ - if (yychar != YYEOF) - yychar = YYEMPTY; - - *++yyvsp = yylval; - - - /* Count tokens shifted since error; after three, turn off error - status. */ - if (yyerrstatus) - yyerrstatus--; - - yystate = yyn; - goto yynewstate; - - -/*-----------------------------------------------------------. -| yydefault -- do the default action for the current state. | -`-----------------------------------------------------------*/ -yydefault: - yyn = yydefact[yystate]; - if (yyn == 0) - goto yyerrlab; - goto yyreduce; - - -/*-----------------------------. -| yyreduce -- Do a reduction. | -`-----------------------------*/ -yyreduce: - /* yyn is the number of a rule to reduce with. */ - yylen = yyr2[yyn]; - - /* If YYLEN is nonzero, implement the default value of the action: - `$$ = $1'. - - Otherwise, the following line sets YYVAL to garbage. - This behavior is undocumented and Bison - users should not rely upon it. Assigning to YYVAL - unconditionally makes the parser a bit smaller, and it avoids a - GCC warning that YYVAL may be used uninitialized. */ - yyval = yyvsp[1-yylen]; - - - YY_REDUCE_PRINT (yyn); - switch (yyn) - { - case 3: -#line 117 "xlat-parse.y" - { (yyval.val) = (yyvsp[0].symval)->Value; ;} - break; - - case 4: -#line 118 "xlat-parse.y" - { (yyval.val) = (yyvsp[-2].val) + (yyvsp[0].val); ;} - break; - - case 5: -#line 119 "xlat-parse.y" - { (yyval.val) = (yyvsp[-2].val) - (yyvsp[0].val); ;} - break; - - case 6: -#line 120 "xlat-parse.y" - { (yyval.val) = (yyvsp[-2].val) * (yyvsp[0].val); ;} - break; - - case 7: -#line 121 "xlat-parse.y" - { (yyval.val) = (yyvsp[-2].val) / (yyvsp[0].val); ;} - break; - - case 8: -#line 122 "xlat-parse.y" - { (yyval.val) = (yyvsp[-2].val) | (yyvsp[0].val); ;} - break; - - case 9: -#line 123 "xlat-parse.y" - { (yyval.val) = (yyvsp[-2].val) & (yyvsp[0].val); ;} - break; - - case 10: -#line 124 "xlat-parse.y" - { (yyval.val) = (yyvsp[-2].val) ^ (yyvsp[0].val); ;} - break; - - case 11: -#line 125 "xlat-parse.y" - { (yyval.val) = -(yyvsp[0].val) ;} - break; - - case 12: -#line 126 "xlat-parse.y" - { (yyval.val) = (yyvsp[-1].val); ;} - break; - - case 22: -#line 145 "xlat-parse.y" - { - printf ("\n"); - ;} - break; - - case 26: -#line 157 "xlat-parse.y" - { printf ("%s", (yyvsp[0].string)); ;} - break; - - case 27: -#line 158 "xlat-parse.y" - { printf ("%d", (yyvsp[0].val)); ;} - break; - - case 28: -#line 159 "xlat-parse.y" - { printf ("\n"); ;} - break; - - case 29: -#line 163 "xlat-parse.y" - { AddSym ((yyvsp[-3].sym), (yyvsp[-1].val)); ;} - break; - - case 30: -#line 167 "xlat-parse.y" - { IncludeFile ((yyvsp[0].string)); ;} - break; - - case 31: -#line 171 "xlat-parse.y" - { EnumVal = 0; ;} - break; - - case 36: -#line 181 "xlat-parse.y" - { AddSym ((yyvsp[0].sym), EnumVal++); ;} - break; - - case 37: -#line 182 "xlat-parse.y" - { AddSym ((yyvsp[-2].sym), EnumVal = (yyvsp[0].val)); ;} - break; - - case 42: -#line 199 "xlat-parse.y" - { AddSym ((yyvsp[-3].sym), (yyvsp[-5].val)); ;} - break; - - case 43: -#line 201 "xlat-parse.y" - { printf ("%s, line %d: %s is already defined\n", SourceName, SourceLine, (yyvsp[0].symval)->Sym); ;} - break; - - case 45: -#line 206 "xlat-parse.y" - { (yyval.val) = 0; ;} - break; - - case 48: -#line 213 "xlat-parse.y" - { - Simple[(yyvsp[-7].val)].NewSpecial = (yyvsp[-3].val); - Simple[(yyvsp[-7].val)].Flags = (yyvsp[-5].val) | (yyvsp[-1].args).addflags; - Simple[(yyvsp[-7].val)].Args[0] = (yyvsp[-1].args).args[0]; - Simple[(yyvsp[-7].val)].Args[1] = (yyvsp[-1].args).args[1]; - Simple[(yyvsp[-7].val)].Args[2] = (yyvsp[-1].args).args[2]; - Simple[(yyvsp[-7].val)].Args[3] = (yyvsp[-1].args).args[3]; - Simple[(yyvsp[-7].val)].Args[4] = (yyvsp[-1].args).args[4]; - ;} - break; - - case 49: -#line 223 "xlat-parse.y" - { - printf ("%s, line %d: %s is undefined\n", SourceName, SourceLine, (yyvsp[-3].sym)); - ;} - break; - - case 50: -#line 230 "xlat-parse.y" - { - if (NumBoomish == MAX_BOOMISH) - { - MoreLines *probe = (yyvsp[-1].boomlines); - - while (probe != NULL) - { - MoreLines *next = probe->next; - free (probe); - probe = next; - } - printf ("%s, line %d: Too many BOOM translators\n", SourceName, SourceLine); - } - else - { - int i; - MoreLines *probe; - - Boomish[NumBoomish].FirstLinetype = (yyvsp[-6].val); - Boomish[NumBoomish].LastLinetype = (yyvsp[-4].val); - Boomish[NumBoomish].NewSpecial = (yyvsp[-9].val); - - for (i = 0, probe = (yyvsp[-1].boomlines); probe != NULL; i++) - { - MoreLines *next = probe->next;; - if (i < MAX_BOOMISH_EXEC) - { - Boomish[NumBoomish].Args[i] = probe->arg; - } - else if (i == MAX_BOOMISH_EXEC) - { - printf ("%s, line %d: Too many commands for this BOOM translator\n", SourceName, SourceLine); - } - free (probe); - probe = next; - } - if (i < MAX_BOOMISH_EXEC) - { - Boomish[NumBoomish].Args[i].bDefined = 0; - } - NumBoomish++; - } - ;} - break; - - case 51: -#line 277 "xlat-parse.y" - { - (yyval.boomlines) = NULL; - ;} - break; - - case 52: -#line 281 "xlat-parse.y" - { - (yyval.boomlines) = malloc (sizeof(MoreLines)); - (yyval.boomlines)->next = (yyvsp[0].boomlines); - (yyval.boomlines)->arg = (yyvsp[-1].boomline); - ;} - break; - - case 53: -#line 290 "xlat-parse.y" - { - (yyval.boomline).bDefined = 1; - (yyval.boomline).bOrExisting = ((yyvsp[-1].val) == OR_EQUAL); - (yyval.boomline).bUseConstant = ((yyvsp[0].boomarg).filters == NULL); - (yyval.boomline).ArgNum = (yyvsp[-2].val); - (yyval.boomline).ConstantValue = (yyvsp[0].boomarg).constant; - (yyval.boomline).AndValue = (yyvsp[0].boomarg).mask; - - if ((yyvsp[0].boomarg).filters != NULL) - { - int i; - MoreFilters *probe; - - for (i = 0, probe = (yyvsp[0].boomarg).filters; probe != NULL; i++) - { - MoreFilters *next = probe->next; - if (i < 15) - { - (yyval.boomline).ResultFilter[i] = probe->filter.filter; - (yyval.boomline).ResultValue[i] = probe->filter.value; - } - else if (i == 15) - { - yyerror ("Lists can only have 15 elements"); - } - free (probe); - probe = next; - } - (yyval.boomline).ListSize = i > 15 ? 15 : i; - } - ;} - break; - - case 54: -#line 324 "xlat-parse.y" - { (yyval.val) = 4; ;} - break; - - case 55: -#line 325 "xlat-parse.y" - { (yyval.val) = 0; ;} - break; - - case 56: -#line 326 "xlat-parse.y" - { (yyval.val) = 1; ;} - break; - - case 57: -#line 327 "xlat-parse.y" - { (yyval.val) = 2; ;} - break; - - case 58: -#line 328 "xlat-parse.y" - { (yyval.val) = 3; ;} - break; - - case 59: -#line 332 "xlat-parse.y" - { (yyval.val) = '='; ;} - break; - - case 60: -#line 333 "xlat-parse.y" - { (yyval.val) = OR_EQUAL; ;} - break; - - case 61: -#line 338 "xlat-parse.y" - { - (yyval.boomarg).constant = (yyvsp[0].val); - (yyval.boomarg).filters = NULL; - ;} - break; - - case 62: -#line 343 "xlat-parse.y" - { - (yyval.boomarg).mask = (yyvsp[-3].val); - (yyval.boomarg).filters = (yyvsp[-1].filter_p); - ;} - break; - - case 63: -#line 351 "xlat-parse.y" - { - (yyval.filter_p) = malloc (sizeof (MoreFilters)); - (yyval.filter_p)->next = NULL; - (yyval.filter_p)->filter = (yyvsp[0].filter); - ;} - break; - - case 64: -#line 357 "xlat-parse.y" - { - (yyval.filter_p) = malloc (sizeof (MoreFilters)); - (yyval.filter_p)->next = (yyvsp[0].filter_p); - (yyval.filter_p)->filter = (yyvsp[-2].filter); - ;} - break; - - case 65: -#line 365 "xlat-parse.y" - { (yyval.filter).filter = (yyvsp[-2].val); (yyval.filter).value = (yyvsp[0].val); ;} - break; - - case 66: -#line 370 "xlat-parse.y" - { - (yyval.args).addflags = 0; - memset ((yyval.args).args, 0, 5); - ;} - break; - - case 67: -#line 375 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT1; - memset ((yyval.args).args, 0, 5); - ;} - break; - - case 68: -#line 380 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT1; - (yyval.args).args[0] = 0; - (yyval.args).args[1] = (yyvsp[0].val); - (yyval.args).args[2] = 0; - (yyval.args).args[3] = 0; - (yyval.args).args[4] = 0; - ;} - break; - - case 69: -#line 389 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT1; - (yyval.args).args[0] = 0; - (yyval.args).args[1] = (yyvsp[-2].val); - (yyval.args).args[2] = (yyvsp[0].val); - (yyval.args).args[3] = 0; - (yyval.args).args[4] = 0; - ;} - break; - - case 70: -#line 398 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT1; - (yyval.args).args[0] = 0; - (yyval.args).args[1] = (yyvsp[-4].val); - (yyval.args).args[2] = (yyvsp[-2].val); - (yyval.args).args[3] = (yyvsp[0].val); - (yyval.args).args[4] = 0; - ;} - break; - - case 71: -#line 407 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT1; - (yyval.args).args[0] = 0; - (yyval.args).args[1] = (yyvsp[-6].val); - (yyval.args).args[2] = (yyvsp[-4].val); - (yyval.args).args[3] = (yyvsp[-2].val); - (yyval.args).args[4] = (yyvsp[0].val); - ;} - break; - - case 72: -#line 417 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HAS2TAGS; - (yyval.args).args[0] = (yyval.args).args[1] = 0; - (yyval.args).args[2] = 0; - (yyval.args).args[3] = 0; - (yyval.args).args[4] = 0; - ;} - break; - - case 73: -#line 425 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HAS2TAGS; - (yyval.args).args[0] = (yyval.args).args[1] = 0; - (yyval.args).args[2] = (yyvsp[0].val); - (yyval.args).args[3] = 0; - (yyval.args).args[4] = 0; - ;} - break; - - case 74: -#line 433 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HAS2TAGS; - (yyval.args).args[0] = (yyval.args).args[1] = 0; - (yyval.args).args[2] = (yyvsp[-2].val); - (yyval.args).args[3] = (yyvsp[0].val); - (yyval.args).args[4] = 0; - ;} - break; - - case 75: -#line 441 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HAS2TAGS; - (yyval.args).args[0] = (yyval.args).args[1] = 0; - (yyval.args).args[2] = (yyvsp[-4].val); - (yyval.args).args[3] = (yyvsp[-2].val); - (yyval.args).args[4] = (yyvsp[0].val); - ;} - break; - - case 76: -#line 450 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASLINEID; - memset ((yyval.args).args, 0, 5); - ;} - break; - - case 77: -#line 455 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASLINEID; - (yyval.args).args[0] = 0; - (yyval.args).args[1] = (yyvsp[0].val); - (yyval.args).args[2] = 0; - (yyval.args).args[3] = 0; - (yyval.args).args[4] = 0; - ;} - break; - - case 78: -#line 464 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASLINEID; - (yyval.args).args[0] = 0; - (yyval.args).args[1] = (yyvsp[-2].val); - (yyval.args).args[2] = (yyvsp[0].val); - (yyval.args).args[3] = 0; - (yyval.args).args[4] = 0; - ;} - break; - - case 79: -#line 473 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASLINEID; - (yyval.args).args[0] = 0; - (yyval.args).args[1] = (yyvsp[-4].val); - (yyval.args).args[2] = (yyvsp[-2].val); - (yyval.args).args[3] = (yyvsp[0].val); - (yyval.args).args[4] = 0; - ;} - break; - - case 80: -#line 482 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASLINEID; - (yyval.args).args[0] = 0; - (yyval.args).args[1] = (yyvsp[-6].val); - (yyval.args).args[2] = (yyvsp[-4].val); - (yyval.args).args[3] = (yyvsp[-2].val); - (yyval.args).args[4] = (yyvsp[0].val); - ;} - break; - - case 81: -#line 492 "xlat-parse.y" - { - (yyval.args).addflags = 0; - (yyval.args).args[0] = (yyvsp[0].val); - (yyval.args).args[1] = 0; - (yyval.args).args[2] = 0; - (yyval.args).args[3] = 0; - (yyval.args).args[4] = 0; - ;} - break; - - case 82: -#line 501 "xlat-parse.y" - { - (yyval.args).addflags = 0; - (yyval.args).args[0] = (yyvsp[-2].val); - (yyval.args).args[1] = (yyvsp[0].val); - (yyval.args).args[2] = 0; - (yyval.args).args[3] = 0; - (yyval.args).args[4] = 0; - ;} - break; - - case 83: -#line 510 "xlat-parse.y" - { - (yyval.args).addflags = 0; - (yyval.args).args[0] = (yyvsp[-4].val); - (yyval.args).args[1] = (yyvsp[-2].val); - (yyval.args).args[2] = (yyvsp[0].val); - (yyval.args).args[3] = 0; - (yyval.args).args[4] = 0; - ;} - break; - - case 84: -#line 519 "xlat-parse.y" - { - (yyval.args).addflags = 0; - (yyval.args).args[0] = (yyvsp[-6].val); - (yyval.args).args[1] = (yyvsp[-4].val); - (yyval.args).args[2] = (yyvsp[-2].val); - (yyval.args).args[3] = (yyvsp[0].val); - (yyval.args).args[4] = 0; - ;} - break; - - case 85: -#line 528 "xlat-parse.y" - { - (yyval.args).addflags = 0; - (yyval.args).args[0] = (yyvsp[-8].val); - (yyval.args).args[1] = (yyvsp[-6].val); - (yyval.args).args[2] = (yyvsp[-4].val); - (yyval.args).args[3] = (yyvsp[-2].val); - (yyval.args).args[4] = (yyvsp[0].val); - ;} - break; - - case 86: -#line 538 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT2; - (yyval.args).args[0] = (yyvsp[-2].val); - (yyval.args).args[1] = 0; - (yyval.args).args[2] = 0; - (yyval.args).args[3] = 0; - (yyval.args).args[4] = 0; - ;} - break; - - case 87: -#line 547 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT2; - (yyval.args).args[0] = (yyvsp[-4].val); - (yyval.args).args[1] = 0; - (yyval.args).args[2] = (yyvsp[0].val); - (yyval.args).args[3] = 0; - (yyval.args).args[4] = 0; - ;} - break; - - case 88: -#line 556 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT2; - (yyval.args).args[0] = (yyvsp[-6].val); - (yyval.args).args[1] = 0; - (yyval.args).args[2] = (yyvsp[-2].val); - (yyval.args).args[3] = (yyvsp[0].val); - (yyval.args).args[4] = 0; - ;} - break; - - case 89: -#line 565 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT2; - (yyval.args).args[0] = (yyvsp[-8].val); - (yyval.args).args[1] = 0; - (yyval.args).args[2] = (yyvsp[-4].val); - (yyval.args).args[3] = (yyvsp[-2].val); - (yyval.args).args[4] = (yyvsp[0].val); - ;} - break; - - case 90: -#line 575 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT3; - (yyval.args).args[0] = (yyvsp[-4].val); - (yyval.args).args[1] = (yyvsp[-2].val); - (yyval.args).args[2] = 0; - (yyval.args).args[3] = 0; - (yyval.args).args[4] = 0; - ;} - break; - - case 91: -#line 584 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT3; - (yyval.args).args[0] = (yyvsp[-6].val); - (yyval.args).args[1] = (yyvsp[-4].val); - (yyval.args).args[2] = 0; - (yyval.args).args[3] = (yyvsp[0].val); - (yyval.args).args[4] = 0; - ;} - break; - - case 92: -#line 593 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT3; - (yyval.args).args[0] = (yyvsp[-8].val); - (yyval.args).args[1] = (yyvsp[-6].val); - (yyval.args).args[2] = 0; - (yyval.args).args[3] = (yyvsp[-2].val); - (yyval.args).args[4] = (yyvsp[0].val); - ;} - break; - - case 93: -#line 603 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT4; - (yyval.args).args[0] = (yyvsp[-6].val); - (yyval.args).args[1] = (yyvsp[-4].val); - (yyval.args).args[2] = (yyvsp[-2].val); - (yyval.args).args[3] = 0; - (yyval.args).args[4] = 0; - ;} - break; - - case 94: -#line 612 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT4; - (yyval.args).args[0] = (yyvsp[-8].val); - (yyval.args).args[1] = (yyvsp[-6].val); - (yyval.args).args[2] = (yyvsp[-4].val); - (yyval.args).args[3] = 0; - (yyval.args).args[4] = (yyvsp[0].val); - ;} - break; - - case 95: -#line 622 "xlat-parse.y" - { - (yyval.args).addflags = SIMPLE_HASTAGAT5; - (yyval.args).args[0] = (yyvsp[-8].val); - (yyval.args).args[1] = (yyvsp[-6].val); - (yyval.args).args[2] = (yyvsp[-4].val); - (yyval.args).args[3] = (yyvsp[-2].val); - (yyval.args).args[4] = 0; - ;} - break; - - - default: break; - } - -/* Line 1126 of yacc.c. */ -#line 2059 "xlat-parse.tab.c" - - yyvsp -= yylen; - yyssp -= yylen; - - - YY_STACK_PRINT (yyss, yyssp); - - *++yyvsp = yyval; - - - /* Now `shift' the result of the reduction. Determine what state - that goes to, based on the state we popped back to and the rule - number reduced by. */ - - yyn = yyr1[yyn]; - - yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) - yystate = yytable[yystate]; - else - yystate = yydefgoto[yyn - YYNTOKENS]; - - goto yynewstate; - - -/*------------------------------------. -| yyerrlab -- here on detecting error | -`------------------------------------*/ -yyerrlab: - /* If not already recovering from an error, report this error. */ - if (!yyerrstatus) - { - ++yynerrs; -#if YYERROR_VERBOSE - yyn = yypact[yystate]; - - if (YYPACT_NINF < yyn && yyn < YYLAST) - { - int yytype = YYTRANSLATE (yychar); - YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); - YYSIZE_T yysize = yysize0; - YYSIZE_T yysize1; - int yysize_overflow = 0; - char *yymsg = 0; -# define YYERROR_VERBOSE_ARGS_MAXIMUM 5 - char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - int yyx; - -#if 0 - /* This is so xgettext sees the translatable formats that are - constructed on the fly. */ - YY_("syntax error, unexpected %s"); - YY_("syntax error, unexpected %s, expecting %s"); - YY_("syntax error, unexpected %s, expecting %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); -#endif - char *yyfmt; - char const *yyf; - static char const yyunexpected[] = "syntax error, unexpected %s"; - static char const yyexpecting[] = ", expecting %s"; - static char const yyor[] = " or %s"; - char yyformat[sizeof yyunexpected - + sizeof yyexpecting - 1 - + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) - * (sizeof yyor - 1))]; - char const *yyprefix = yyexpecting; - - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - int yyxbegin = yyn < 0 ? -yyn : 0; - - /* Stay within bounds of both yycheck and yytname. */ - int yychecklim = YYLAST - yyn; - int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; - int yycount = 1; - - yyarg[0] = yytname[yytype]; - yyfmt = yystpcpy (yyformat, yyunexpected); - - for (yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) - { - if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) - { - yycount = 1; - yysize = yysize0; - yyformat[sizeof yyunexpected - 1] = '\0'; - break; - } - yyarg[yycount++] = yytname[yyx]; - yysize1 = yysize + yytnamerr (0, yytname[yyx]); - yysize_overflow |= yysize1 < yysize; - yysize = yysize1; - yyfmt = yystpcpy (yyfmt, yyprefix); - yyprefix = yyor; - } - - yyf = YY_(yyformat); - yysize1 = yysize + yystrlen (yyf); - yysize_overflow |= yysize1 < yysize; - yysize = yysize1; - - if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM) - yymsg = (char *) YYSTACK_ALLOC (yysize); - if (yymsg) - { - /* Avoid sprintf, as that infringes on the user's name space. - Don't have undefined behavior even if the translation - produced a string with the wrong number of "%s"s. */ - char *yyp = yymsg; - int yyi = 0; - while ((*yyp = *yyf)) - { - if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) - { - yyp += yytnamerr (yyp, yyarg[yyi++]); - yyf += 2; - } - else - { - yyp++; - yyf++; - } - } - yyerror (yymsg); - YYSTACK_FREE (yymsg); - } - else - { - yyerror (YY_("syntax error")); - goto yyexhaustedlab; - } - } - else -#endif /* YYERROR_VERBOSE */ - yyerror (YY_("syntax error")); - } - - - - if (yyerrstatus == 3) - { - /* If just tried and failed to reuse look-ahead token after an - error, discard it. */ - - if (yychar <= YYEOF) - { - /* Return failure if at end of input. */ - if (yychar == YYEOF) - YYABORT; - } - else - { - yydestruct ("Error: discarding", yytoken, &yylval); - yychar = YYEMPTY; - } - } - - /* Else will try to reuse look-ahead token after shifting the error - token. */ - goto yyerrlab1; - - -/*---------------------------------------------------. -| yyerrorlab -- error raised explicitly by YYERROR. | -`---------------------------------------------------*/ -yyerrorlab: - - /* Pacify compilers like GCC when the user code never invokes - YYERROR and the label yyerrorlab therefore never appears in user - code. */ - if (0) - goto yyerrorlab; - -yyvsp -= yylen; - yyssp -= yylen; - yystate = *yyssp; - goto yyerrlab1; - - -/*-------------------------------------------------------------. -| yyerrlab1 -- common code for both syntax error and YYERROR. | -`-------------------------------------------------------------*/ -yyerrlab1: - yyerrstatus = 3; /* Each real token shifted decrements this. */ - - for (;;) - { - yyn = yypact[yystate]; - if (yyn != YYPACT_NINF) - { - yyn += YYTERROR; - if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) - { - yyn = yytable[yyn]; - if (0 < yyn) - break; - } - } - - /* Pop the current state because it cannot handle the error token. */ - if (yyssp == yyss) - YYABORT; - - - yydestruct ("Error: popping", yystos[yystate], yyvsp); - YYPOPSTACK; - yystate = *yyssp; - YY_STACK_PRINT (yyss, yyssp); - } - - if (yyn == YYFINAL) - YYACCEPT; - - *++yyvsp = yylval; - - - /* Shift the error token. */ - YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); - - yystate = yyn; - goto yynewstate; - - -/*-------------------------------------. -| yyacceptlab -- YYACCEPT comes here. | -`-------------------------------------*/ -yyacceptlab: - yyresult = 0; - goto yyreturn; - -/*-----------------------------------. -| yyabortlab -- YYABORT comes here. | -`-----------------------------------*/ -yyabortlab: - yyresult = 1; - goto yyreturn; - -#ifndef yyoverflow -/*-------------------------------------------------. -| yyexhaustedlab -- memory exhaustion comes here. | -`-------------------------------------------------*/ -yyexhaustedlab: - yyerror (YY_("memory exhausted")); - yyresult = 2; - /* Fall through. */ -#endif - -yyreturn: - if (yychar != YYEOF && yychar != YYEMPTY) - yydestruct ("Cleanup: discarding lookahead", - yytoken, &yylval); - while (yyssp != yyss) - { - yydestruct ("Cleanup: popping", - yystos[*yyssp], yyvsp); - YYPOPSTACK; - } -#ifndef yyoverflow - if (yyss != yyssa) - YYSTACK_FREE (yyss); -#endif - return yyresult; -} - - -#line 632 "xlat-parse.y" - - -#include -#include - -int yylex (void) -{ - char token[80]; - int toksize; - int c; - -loop: - while (Source == NULL) - { - if (!EndFile ()) - return 0; - } - while (isspace (c = fgetc (Source)) && c != EOF) - { - if (c == '\n') - SourceLine++; - } - - if (c == EOF) - { - if (EndFile ()) - goto loop; - return 0; - } - if (isdigit (c)) - { - int buildup = c - '0'; - if (c == '0') - { - c = fgetc (Source); - if (c == 'x' || c == 'X') - { - for (;;) - { - c = fgetc (Source); - if (isdigit (c)) - { - buildup = (buildup<<4) + c - '0'; - } - else if (c >= 'a' && c <= 'f') - { - buildup = (buildup<<4) + c - 'a' + 10; - } - else if (c >= 'A' && c <= 'F') - { - buildup = (buildup<<4) + c - 'A' + 10; - } - else - { - ungetc (c, Source); - yylval.val = buildup; - return NUM; - } - } - } - else - { - ungetc (c, Source); - } - } - while (isdigit (c = fgetc (Source))) - { - buildup = buildup*10 + c - '0'; - } - ungetc (c, Source); - yylval.val = buildup; - return NUM; - } - if (isalpha (c)) - { - int buildup = 0; - - token[0] = c; - toksize = 1; - while (toksize < 79 && (isalnum (c = fgetc (Source)) || c == '_')) - { - token[toksize++] = c; - } - token[toksize] = 0; - if (toksize == 79 && isalnum (c)) - { - while (isalnum (c = fgetc (Source))) - ; - } - ungetc (c, Source); - if (FindToken (token, &buildup)) - { - return buildup; - } - if (FindSym (token, &yylval.symval)) - { - return SYMNUM; - } - strcpy (yylval.sym, token); - return SYM; - } - if (c == '/') - { - c = fgetc (Source); - if (c == '*') - { - for (;;) - { - while ((c = fgetc (Source)) != '*' && c != EOF) - { - if (c == '\n') - SourceLine++; - } - if (c == EOF) - return 0; - if ((c = fgetc (Source)) == '/') - goto loop; - if (c == EOF) - return 0; - ungetc (c, Source); - } - } - else if (c == '/') - { - while ((c = fgetc (Source)) != '\n' && c != EOF) - ; - if (c == '\n') - SourceLine++; - else if (c == EOF) - return 0; - goto loop; - } - else - { - ungetc (c, Source); - return '/'; - } - } - if (c == '"') - { - int tokensize = 0; - while ((c = fgetc (Source)) != '"' && c != EOF) - { - yylval.string[tokensize++] = c; - } - yylval.string[tokensize] = 0; - return STRING; - } - if (c == '|') - { - c = fgetc (Source); - if (c == '=') - return OR_EQUAL; - ungetc (c, Source); - return '|'; - } - return c; -} - -static Symbol *FirstSym; - -static void AddSym (char *sym, int val) -{ - Symbol *syme = malloc (strlen (sym) + sizeof(Symbol)); - syme->Next = FirstSym; - syme->Value = val; - strcpy (syme->Sym, sym); - FirstSym = syme; -} - -static bool FindSym (char *sym, Symbol **val) -{ - Symbol *syme = FirstSym; - - while (syme != NULL) - { - if (strcmp (syme->Sym, sym) == 0) - { - *val = syme; - return 1; - } - syme = syme->Next; - } - return 0; -} - -static bool FindToken (char *tok, int *type) -{ - static const char tokens[][8] = - { - "endl", "print", "include", "special", "define", "enum", - "arg5", "arg4", "arg3", "arg2", "flags", "lineid", "tag" - - }; - static const short types[] = - { - ENDL, PRINT, INCLUDE, SPECIAL, DEFINE, ENUM, - ARG5, ARG4, ARG3, ARG2, FLAGS, LINEID, TAG - }; - int i; - - for (i = sizeof(tokens)/sizeof(tokens[0])-1; i >= 0; i--) - { - if (strcmp (tok, tokens[i]) == 0) - { - *type = types[i]; - return 1; - } - } - return 0; -} - -int yyerror (char *s) -{ - if (SourceName != NULL) - printf ("%s, line %d: %s\n", SourceName, SourceLine, s); - else - printf ("%s\n", s); - return 0; -} - - diff --git a/tools/xlatcc/xlat-parse.y b/tools/xlatcc/xlat-parse.y index 4cdecf29a..1f94dae10 100644 --- a/tools/xlatcc/xlat-parse.y +++ b/tools/xlatcc/xlat-parse.y @@ -1,19 +1,10 @@ -/* You need Bison (or maybe Yacc) to rebuild the .c file from this grammar. - * Or you could rewrite it to use Lemon, since the ZDoom source comes with Lemon. - * Since I have Bison, and the existing code works fine, there's no motivation - * for me to rewrite it. - */ - -%{ +%include{ #include "xlat.h" +#include "xlat-parse.h" #include #include -// verbose doesn't seem to help all that much -//#define YYERROR_VERBOSE 1 - int yyerror (char *s); -int yylex (void); typedef struct _Symbol { @@ -46,595 +37,31 @@ typedef struct _morelines BoomArg arg; } MoreLines; -%} +typedef struct _specialargs +{ + BYTE addflags; + BYTE args[5]; +} SpecialArgs; -%union { +typedef struct _boomarg +{ + BYTE constant; + WORD mask; + MoreFilters *filters; +} ParseBoomArg; + +typedef union YYSTYPE +{ int val; char sym[80]; char string[80]; - struct - { - BYTE addflags; - BYTE args[5]; - } args; - struct ListFilter filter; - MoreFilters *filter_p; - struct - { - BYTE constant; - WORD mask; - MoreFilters *filters; - } boomarg; Symbol *symval; - BoomArg boomline; - MoreLines *boomlines; -} - -%token NUM -%token SYMNUM -%token SYM -%token STRING - -%type exp -%type special_args -%type list_val -%type arg_list -%type boom_args -%type boom_op -%type boom_selector -%type boom_line -%type boom_body -%type maybe_argcount - -%token DEFINE -%token INCLUDE -%token TAG -%token LINEID -%token SPECIAL -%token FLAGS -%token ARG2 -%token ARG3 -%token ARG4 -%token ARG5 -%token OR_EQUAL -%token ENUM -%token PRINT -%token ENDL - -%left '|' -%left '^' -%left '&' -%left '-' '+' -%left '*' '/' -%left NEG - -%start translation_unit - -%% - -exp: - NUM - | SYMNUM { $$ = $1->Value; } - | exp '+' exp { $$ = $1 + $3; } - | exp '-' exp { $$ = $1 - $3; } - | exp '*' exp { $$ = $1 * $3; } - | exp '/' exp { $$ = $1 / $3; } - | exp '|' exp { $$ = $1 | $3; } - | exp '&' exp { $$ = $1 & $3; } - | exp '^' exp { $$ = $1 ^ $3; } - | '-' exp %prec NEG { $$ = -$2 } - | '(' exp ')' { $$ = $2; } -; - -translation_unit: /* empty line */ - | translation_unit external_declaration -; - -external_declaration: - define_statement - | include_statement - | print_statement - | enum_statement - | linetype_declaration - | boom_declaration - | special_declaration -; - -print_statement: - PRINT '(' print_list ')' - { - printf ("\n"); - } -; - -print_list: - /* EMPTY */ - | print_item - | print_item ',' print_list -; - -print_item: - STRING { printf ("%s", $1); } - | exp { printf ("%d", $1); } - | ENDL { printf ("\n"); } -; - -define_statement: - DEFINE SYM '(' exp ')' { AddSym ($2, $4); } -; - -include_statement: - INCLUDE STRING { IncludeFile ($2); } -; - -enum_statement: - ENUM '{' { EnumVal = 0; } enum_list '}' -; - -enum_list: - /* empty */ - | single_enum - | single_enum ',' enum_list -; - -single_enum: - SYM { AddSym ($1, EnumVal++); } - | SYM '=' exp { AddSym ($1, EnumVal = $3); } -; - -/* special declarations work just like they do for ACS, so - * specials can be defined just by including zspecial.acs - */ -special_declaration: - SPECIAL special_list ';' -; - -special_list: - /* empty */ - | special_def - | special_def ',' special_list -; - -special_def: - exp ':' SYM '(' maybe_argcount ')' { AddSym ($3, $1); } - | exp ':' SYMNUM - { printf ("%s, line %d: %s is already defined\n", SourceName, SourceLine, $3->Sym); } - '(' maybe_argcount ')' -; - -maybe_argcount: - /* empty */ { $$ = 0; } - | exp - | exp ',' exp -; - -linetype_declaration: - exp '=' exp ',' exp '(' special_args ')' - { - Simple[$1].NewSpecial = $5; - Simple[$1].Flags = $3 | $7.addflags; - Simple[$1].Args[0] = $7.args[0]; - Simple[$1].Args[1] = $7.args[1]; - Simple[$1].Args[2] = $7.args[2]; - Simple[$1].Args[3] = $7.args[3]; - Simple[$1].Args[4] = $7.args[4]; - } - | exp '=' exp ',' SYM '(' special_args ')' - { - printf ("%s, line %d: %s is undefined\n", SourceName, SourceLine, $5); - } -; - -boom_declaration: - '[' exp ']' '(' exp ',' exp ')' '{' boom_body '}' - { - if (NumBoomish == MAX_BOOMISH) - { - MoreLines *probe = $10; - - while (probe != NULL) - { - MoreLines *next = probe->next; - free (probe); - probe = next; - } - printf ("%s, line %d: Too many BOOM translators\n", SourceName, SourceLine); - } - else - { - int i; - MoreLines *probe; - - Boomish[NumBoomish].FirstLinetype = $5; - Boomish[NumBoomish].LastLinetype = $7; - Boomish[NumBoomish].NewSpecial = $2; - - for (i = 0, probe = $10; probe != NULL; i++) - { - MoreLines *next = probe->next;; - if (i < MAX_BOOMISH_EXEC) - { - Boomish[NumBoomish].Args[i] = probe->arg; - } - else if (i == MAX_BOOMISH_EXEC) - { - printf ("%s, line %d: Too many commands for this BOOM translator\n", SourceName, SourceLine); - } - free (probe); - probe = next; - } - if (i < MAX_BOOMISH_EXEC) - { - Boomish[NumBoomish].Args[i].bDefined = 0; - } - NumBoomish++; - } - } -; - -boom_body: - /* empty */ - { - $$ = NULL; - } - | boom_line boom_body - { - $$ = malloc (sizeof(MoreLines)); - $$->next = $2; - $$->arg = $1; - } -; - -boom_line: - boom_selector boom_op boom_args - { - $$.bDefined = 1; - $$.bOrExisting = ($2 == OR_EQUAL); - $$.bUseConstant = ($3.filters == NULL); - $$.ArgNum = $1; - $$.ConstantValue = $3.constant; - $$.AndValue = $3.mask; - - if ($3.filters != NULL) - { - int i; - MoreFilters *probe; - - for (i = 0, probe = $3.filters; probe != NULL; i++) - { - MoreFilters *next = probe->next; - if (i < 15) - { - $$.ResultFilter[i] = probe->filter.filter; - $$.ResultValue[i] = probe->filter.value; - } - else if (i == 15) - { - yyerror ("Lists can only have 15 elements"); - } - free (probe); - probe = next; - } - $$.ListSize = i > 15 ? 15 : i; - } - } -; - -boom_selector: - FLAGS { $$ = 4; } - | ARG2 { $$ = 0; } - | ARG3 { $$ = 1; } - | ARG4 { $$ = 2; } - | ARG5 { $$ = 3; } -; - -boom_op: - '=' { $$ = '='; } - | OR_EQUAL { $$ = OR_EQUAL; } -; - -boom_args: - exp - { - $$.constant = $1; - $$.filters = NULL; - } - | exp '[' arg_list ']' - { - $$.mask = $1; - $$.filters = $3; - } -; - -arg_list: - list_val - { - $$ = malloc (sizeof (MoreFilters)); - $$->next = NULL; - $$->filter = $1; - } - | list_val ',' arg_list - { - $$ = malloc (sizeof (MoreFilters)); - $$->next = $3; - $$->filter = $1; - } -; - -list_val: - exp ':' exp { $$.filter = $1; $$.value = $3; } -; - -special_args: - /* EMPTY LINE */ - { - $$.addflags = 0; - memset ($$.args, 0, 5); - } - | TAG - { - $$.addflags = SIMPLE_HASTAGAT1; - memset ($$.args, 0, 5); - } - | TAG ',' exp - { - $$.addflags = SIMPLE_HASTAGAT1; - $$.args[0] = 0; - $$.args[1] = $3; - $$.args[2] = 0; - $$.args[3] = 0; - $$.args[4] = 0; - } - | TAG ',' exp ',' exp - { - $$.addflags = SIMPLE_HASTAGAT1; - $$.args[0] = 0; - $$.args[1] = $3; - $$.args[2] = $5; - $$.args[3] = 0; - $$.args[4] = 0; - } - | TAG ',' exp ',' exp ',' exp - { - $$.addflags = SIMPLE_HASTAGAT1; - $$.args[0] = 0; - $$.args[1] = $3; - $$.args[2] = $5; - $$.args[3] = $7; - $$.args[4] = 0; - } - | TAG ',' exp ',' exp ',' exp ',' exp - { - $$.addflags = SIMPLE_HASTAGAT1; - $$.args[0] = 0; - $$.args[1] = $3; - $$.args[2] = $5; - $$.args[3] = $7; - $$.args[4] = $9; - } - - | TAG ',' TAG - { - $$.addflags = SIMPLE_HAS2TAGS; - $$.args[0] = $$.args[1] = 0; - $$.args[2] = 0; - $$.args[3] = 0; - $$.args[4] = 0; - } - | TAG ',' TAG ',' exp - { - $$.addflags = SIMPLE_HAS2TAGS; - $$.args[0] = $$.args[1] = 0; - $$.args[2] = $5; - $$.args[3] = 0; - $$.args[4] = 0; - } - | TAG ',' TAG ',' exp ',' exp - { - $$.addflags = SIMPLE_HAS2TAGS; - $$.args[0] = $$.args[1] = 0; - $$.args[2] = $5; - $$.args[3] = $7; - $$.args[4] = 0; - } - | TAG ',' TAG ',' exp ',' exp ',' exp - { - $$.addflags = SIMPLE_HAS2TAGS; - $$.args[0] = $$.args[1] = 0; - $$.args[2] = $5; - $$.args[3] = $7; - $$.args[4] = $9; - } - - | LINEID - { - $$.addflags = SIMPLE_HASLINEID; - memset ($$.args, 0, 5); - } - | LINEID ',' exp - { - $$.addflags = SIMPLE_HASLINEID; - $$.args[0] = 0; - $$.args[1] = $3; - $$.args[2] = 0; - $$.args[3] = 0; - $$.args[4] = 0; - } - | LINEID ',' exp ',' exp - { - $$.addflags = SIMPLE_HASLINEID; - $$.args[0] = 0; - $$.args[1] = $3; - $$.args[2] = $5; - $$.args[3] = 0; - $$.args[4] = 0; - } - | LINEID ',' exp ',' exp ',' exp - { - $$.addflags = SIMPLE_HASLINEID; - $$.args[0] = 0; - $$.args[1] = $3; - $$.args[2] = $5; - $$.args[3] = $7; - $$.args[4] = 0; - } - | LINEID ',' exp ',' exp ',' exp ',' exp - { - $$.addflags = SIMPLE_HASLINEID; - $$.args[0] = 0; - $$.args[1] = $3; - $$.args[2] = $5; - $$.args[3] = $7; - $$.args[4] = $9; - } - - | exp - { - $$.addflags = 0; - $$.args[0] = $1; - $$.args[1] = 0; - $$.args[2] = 0; - $$.args[3] = 0; - $$.args[4] = 0; - } - | exp ',' exp - { - $$.addflags = 0; - $$.args[0] = $1; - $$.args[1] = $3; - $$.args[2] = 0; - $$.args[3] = 0; - $$.args[4] = 0; - } - | exp ',' exp ',' exp - { - $$.addflags = 0; - $$.args[0] = $1; - $$.args[1] = $3; - $$.args[2] = $5; - $$.args[3] = 0; - $$.args[4] = 0; - } - | exp ',' exp ',' exp ',' exp - { - $$.addflags = 0; - $$.args[0] = $1; - $$.args[1] = $3; - $$.args[2] = $5; - $$.args[3] = $7; - $$.args[4] = 0; - } - | exp ',' exp ',' exp ',' exp ',' exp - { - $$.addflags = 0; - $$.args[0] = $1; - $$.args[1] = $3; - $$.args[2] = $5; - $$.args[3] = $7; - $$.args[4] = $9; - } - - | exp ',' TAG - { - $$.addflags = SIMPLE_HASTAGAT2; - $$.args[0] = $1; - $$.args[1] = 0; - $$.args[2] = 0; - $$.args[3] = 0; - $$.args[4] = 0; - } - | exp ',' TAG ',' exp - { - $$.addflags = SIMPLE_HASTAGAT2; - $$.args[0] = $1; - $$.args[1] = 0; - $$.args[2] = $5; - $$.args[3] = 0; - $$.args[4] = 0; - } - | exp ',' TAG ',' exp ',' exp - { - $$.addflags = SIMPLE_HASTAGAT2; - $$.args[0] = $1; - $$.args[1] = 0; - $$.args[2] = $5; - $$.args[3] = $7; - $$.args[4] = 0; - } - | exp ',' TAG ',' exp ',' exp ',' exp - { - $$.addflags = SIMPLE_HASTAGAT2; - $$.args[0] = $1; - $$.args[1] = 0; - $$.args[2] = $5; - $$.args[3] = $7; - $$.args[4] = $9; - } - - | exp ',' exp ',' TAG - { - $$.addflags = SIMPLE_HASTAGAT3; - $$.args[0] = $1; - $$.args[1] = $3; - $$.args[2] = 0; - $$.args[3] = 0; - $$.args[4] = 0; - } - | exp ',' exp ',' TAG ',' exp - { - $$.addflags = SIMPLE_HASTAGAT3; - $$.args[0] = $1; - $$.args[1] = $3; - $$.args[2] = 0; - $$.args[3] = $7; - $$.args[4] = 0; - } - | exp ',' exp ',' TAG ',' exp ',' exp - { - $$.addflags = SIMPLE_HASTAGAT3; - $$.args[0] = $1; - $$.args[1] = $3; - $$.args[2] = 0; - $$.args[3] = $7; - $$.args[4] = $9; - } - - | exp ',' exp ',' exp ',' TAG - { - $$.addflags = SIMPLE_HASTAGAT4; - $$.args[0] = $1; - $$.args[1] = $3; - $$.args[2] = $5; - $$.args[3] = 0; - $$.args[4] = 0; - } - | exp ',' exp ',' exp ',' TAG ',' exp - { - $$.addflags = SIMPLE_HASTAGAT4; - $$.args[0] = $1; - $$.args[1] = $3; - $$.args[2] = $5; - $$.args[3] = 0; - $$.args[4] = $9; - } - - | exp ',' exp ',' exp ',' exp ',' TAG - { - $$.addflags = SIMPLE_HASTAGAT5; - $$.args[0] = $1; - $$.args[1] = $3; - $$.args[2] = $5; - $$.args[3] = $7; - $$.args[4] = 0; - } -; - -%% +} YYSTYPE; #include #include -int yylex (void) +int yylex (YYSTYPE *yylval) { char token[80]; int toksize; @@ -684,7 +111,7 @@ loop: else { ungetc (c, Source); - yylval.val = buildup; + yylval->val = buildup; return NUM; } } @@ -699,7 +126,7 @@ loop: buildup = buildup*10 + c - '0'; } ungetc (c, Source); - yylval.val = buildup; + yylval->val = buildup; return NUM; } if (isalpha (c)) @@ -723,11 +150,11 @@ loop: { return buildup; } - if (FindSym (token, &yylval.symval)) + if (FindSym (token, &yylval->symval)) { return SYMNUM; } - strcpy (yylval.sym, token); + strcpy (yylval->sym, token); return SYM; } if (c == '/') @@ -764,7 +191,7 @@ loop: else { ungetc (c, Source); - return '/'; + return DIVIDE; } } if (c == '"') @@ -772,9 +199,9 @@ loop: int tokensize = 0; while ((c = fgetc (Source)) != '"' && c != EOF) { - yylval.string[tokensize++] = c; + yylval->string[tokensize++] = c; } - yylval.string[tokensize] = 0; + yylval->string[tokensize] = 0; return STRING; } if (c == '|') @@ -783,9 +210,47 @@ loop: if (c == '=') return OR_EQUAL; ungetc (c, Source); - return '|'; + return OR; } - return c; + switch (c) + { + case '^': return XOR; + case '&': return AND; + case '-': return MINUS; + case '+': return PLUS; + case '*': return MULTIPLY; + case '(': return LPAREN; + case ')': return RPAREN; + case ',': return COMMA; + case '{': return LBRACE; + case '}': return RBRACE; + case '=': return EQUALS; + case ';': return SEMICOLON; + case ':': return COLON; + case '[': return LBRACKET; + case ']': return RBRACKET; + default: return 0; + } +} + +void *ParseAlloc(void *(*mallocProc)(size_t)); +void Parse(void *yyp, int yymajor, YYSTYPE yyminor); +void ParseFree(void *p, void (*freeProc)(void*)); +void ParseTrace(FILE *TraceFILE, char *zTracePrompt); + +void yyparse (void) +{ + void *pParser = ParseAlloc (malloc); + YYSTYPE token; + int tokentype; + + while ((tokentype = yylex(&token)) != 0) + { + Parse (pParser, tokentype, token); + } + memset (&token, 0, sizeof(token)); + Parse (pParser, 0, token); + ParseFree (pParser, free); } static Symbol *FirstSym; @@ -849,3 +314,515 @@ int yyerror (char *s) printf ("%s\n", s); return 0; } + +} + +%token_type {YYSTYPE} + +%syntax_error {yyerror("syntax error");} + +%type exp {int} +%type special_args {SpecialArgs} +%type list_val {struct ListFilter} +%type arg_list {MoreFilters *} +%type boom_args {ParseBoomArg} +%type boom_op {int} +%type boom_selector {int} +%type boom_line {BoomArg} +%type boom_body {MoreLines *} +%type maybe_argcount {int} + +%left OR. +%left XOR. +%left AND. +%left MINUS PLUS. +%left MULTIPLY DIVIDE. +%left NEG. + +main ::= translation_unit. + +exp(A) ::= NUM(B). { A = B.val; } +exp(A) ::= SYMNUM(B). { A = B.symval->Value; } +exp(A) ::= exp(B) PLUS exp(C). { A = B + C; } +exp(A) ::= exp(B) MINUS exp(C). { A = B - C; } +exp(A) ::= exp(B) MULTIPLY exp(C). { A = B * C; } +exp(A) ::= exp(B) DIVIDE exp(C). { A = B / C; } +exp(A) ::= exp(B) OR exp(C). { A = B | C; } +exp(A) ::= exp(B) AND exp(C). { A = B & C; } +exp(A) ::= exp(B) XOR exp(C). { A = B ^ C; } +exp(A) ::= MINUS exp(B). [NEG] { A = -B; } +exp(A) ::= LPAREN exp(B) RPAREN. { A = B; } + +translation_unit ::= . /* empty */ +translation_unit ::= external_declaration. + +external_declaration ::= define_statement. +external_declaration ::= include_statement. +external_declaration ::= print_statement. +external_declaration ::= enum_statement. +external_declaration ::= linetype_declaration. +external_declaration ::= boom_declaration. +external_declaration ::= special_declaration. + +print_statement ::= PRINT LPAREN print_list RPAREN. +{ + printf ("\n"); +} + +print_list ::= . /* EMPTY */ +print_list ::= print_item. +print_list ::= print_item COMMA print_list. + +print_item ::= STRING(A). { printf ("%s", A.string); } +print_item ::= exp(A). { printf ("%d", A); } +print_item ::= ENDL. { printf ("\n"); } + +define_statement ::= DEFINE SYM(A) LPAREN exp(B) RPAREN. +{ + AddSym (A.sym, B); +} + +include_statement ::= INCLUDE STRING(A). +{ + IncludeFile (A.string); +} + +enum_statement ::= enum_open enum_list RBRACE. + +enum_open ::= ENUM LBRACE. +{ + EnumVal = 0; +} + +enum_list ::= . /* empty */ +enum_list ::= single_enum. +enum_list ::= single_enum COMMA enum_list. + +single_enum ::= SYM(A). +{ + AddSym (A.sym, EnumVal++); +} + +single_enum ::= SYM(A) EQUALS exp(B). +{ + AddSym (A.sym, EnumVal = B); +} + +/* special declarations work just like they do for ACS, so + * specials can be defined just by including zspecial.acs + */ +special_declaration ::= SPECIAL special_list SEMICOLON. + +special_list ::= special_def. +special_list ::= special_list COMMA special_def. + +special_def ::= exp(A) COLON SYM(B) LPAREN maybe_argcount RPAREN. +{ + AddSym (B.sym, A); +} +special_def ::= exp COLON SYMNUM(B) LPAREN maybe_argcount RPAREN. +{ + printf ("%s, line %d: %s is already defined\n", SourceName, SourceLine, B.symval->Sym); +} + +maybe_argcount ::= . /* empty */ +maybe_argcount ::= exp. +maybe_argcount ::= exp COMMA exp. + +linetype_declaration ::= exp(linetype) EQUALS exp(flags) COMMA exp(special) LPAREN special_args(arg) RPAREN. +{ + Simple[linetype].NewSpecial = special; + Simple[linetype].Flags = flags | arg.addflags; + Simple[linetype].Args[0] = arg.args[0]; + Simple[linetype].Args[1] = arg.args[1]; + Simple[linetype].Args[2] = arg.args[2]; + Simple[linetype].Args[3] = arg.args[3]; + Simple[linetype].Args[4] = arg.args[4]; +} +linetype_declaration ::= exp EQUALS exp COMMA SYM(S) LPAREN special_args RPAREN. +{ + printf ("%s, line %d: %s is undefined\n", SourceName, SourceLine, S.sym); +} + +boom_declaration ::= LBRACKET exp(special) RBRACKET LPAREN exp(firsttype) COMMA exp(lasttype) RPAREN LBRACE boom_body(stores) RBRACE. +{ + if (NumBoomish == MAX_BOOMISH) + { + MoreLines *probe = stores; + + while (probe != NULL) + { + MoreLines *next = probe->next; + free (probe); + probe = next; + } + printf ("%s, line %d: Too many BOOM translators\n", SourceName, SourceLine); + } + else + { + int i; + MoreLines *probe; + + Boomish[NumBoomish].FirstLinetype = firsttype; + Boomish[NumBoomish].LastLinetype = lasttype; + Boomish[NumBoomish].NewSpecial = special; + + for (i = 0, probe = stores; probe != NULL; i++) + { + MoreLines *next = probe->next;; + if (i < MAX_BOOMISH_EXEC) + { + Boomish[NumBoomish].Args[i] = probe->arg; + } + else if (i == MAX_BOOMISH_EXEC) + { + printf ("%s, line %d: Too many commands for this BOOM translator\n", SourceName, SourceLine); + } + free (probe); + probe = next; + } + if (i < MAX_BOOMISH_EXEC) + { + Boomish[NumBoomish].Args[i].bDefined = 0; + } + NumBoomish++; + } +} + +boom_body(A) ::= . /* empty */ +{ + A = NULL; +} +boom_body(A) ::= boom_line(B) boom_body(C). +{ + A = malloc (sizeof(MoreLines)); + A->next = C; + A->arg = B; +} + +boom_line(A) ::= boom_selector(sel) boom_op(op) boom_args(args). +{ + A.bDefined = 1; + A.bOrExisting = (op == OR_EQUAL); + A.bUseConstant = (args.filters == NULL); + A.ArgNum = sel; + A.ConstantValue = args.constant; + A.AndValue = args.mask; + + if (args.filters != NULL) + { + int i; + MoreFilters *probe; + + for (i = 0, probe = args.filters; probe != NULL; i++) + { + MoreFilters *next = probe->next; + if (i < 15) + { + A.ResultFilter[i] = probe->filter.filter; + A.ResultValue[i] = probe->filter.value; + } + else if (i == 15) + { + yyerror ("Lists can only have 15 elements"); + } + free (probe); + probe = next; + } + A.ListSize = i > 15 ? 15 : i; + } +} + +boom_selector(A) ::= FLAGS. { A = 4; } +boom_selector(A) ::= ARG2. { A = 0; } +boom_selector(A) ::= ARG3. { A = 1; } +boom_selector(A) ::= ARG4. { A = 2; } +boom_selector(A) ::= ARG5. { A = 3; } + +boom_op(A) ::= EQUALS. { A = '='; } +boom_op(A) ::= OR_EQUAL. { A = OR_EQUAL; } + +boom_args(A) ::= exp(B). +{ + A.constant = B; + A.filters = NULL; +} +boom_args(A) ::= exp(B) LBRACKET arg_list(C) RBRACKET. +{ + A.mask = B; + A.filters = C; +} + +arg_list(A) ::= list_val(B). +{ + A = malloc (sizeof(MoreFilters)); + A->next = NULL; + A->filter = B; +} +arg_list(A) ::= list_val(B) COMMA arg_list(C). +{ + A = malloc (sizeof(MoreFilters)); + A->next = C; + A->filter = B; +} + +list_val(A) ::= exp(B) COLON exp(C). +{ + A.filter = B; + A.value = C; +} + +special_args(Z) ::= . /* empty */ +{ + Z.addflags = 0; + memset (Z.args, 0, 5); +} +special_args(Z) ::= TAG. +{ + Z.addflags = SIMPLE_HASTAGAT1; + memset (Z.args, 0, 5); +} +special_args(Z) ::= TAG COMMA exp(B). +{ + Z.addflags = SIMPLE_HASTAGAT1; + Z.args[0] = 0; + Z.args[1] = B; + Z.args[2] = 0; + Z.args[3] = 0; + Z.args[4] = 0; +} +special_args(Z) ::= TAG COMMA exp(B) COMMA exp(C). +{ + Z.addflags = SIMPLE_HASTAGAT1; + Z.args[0] = 0; + Z.args[1] = B; + Z.args[2] = C; + Z.args[3] = 0; + Z.args[4] = 0; +} +special_args(Z) ::= TAG COMMA exp(B) COMMA exp(C) COMMA exp(D). +{ + Z.addflags = SIMPLE_HASTAGAT1; + Z.args[0] = 0; + Z.args[1] = B; + Z.args[2] = C; + Z.args[3] = D; + Z.args[4] = 0; +} +special_args(Z) ::= TAG COMMA exp(B) COMMA exp(C) COMMA exp(D) COMMA exp(E). +{ + Z.addflags = SIMPLE_HASTAGAT1; + Z.args[0] = 0; + Z.args[1] = B; + Z.args[2] = C; + Z.args[3] = D; + Z.args[4] = E; +} +special_args(Z) ::= TAG COMMA TAG. +{ + Z.addflags = SIMPLE_HAS2TAGS; + Z.args[0] = Z.args[1] = 0; + Z.args[2] = 0; + Z.args[3] = 0; + Z.args[4] = 0; +} +special_args(Z) ::= TAG COMMA TAG COMMA exp(C). +{ + Z.addflags = SIMPLE_HAS2TAGS; + Z.args[0] = Z.args[1] = 0; + Z.args[2] = C; + Z.args[3] = 0; + Z.args[4] = 0; +} +special_args(Z) ::= TAG COMMA TAG COMMA exp(C) COMMA exp(D). +{ + Z.addflags = SIMPLE_HAS2TAGS; + Z.args[0] = Z.args[1] = 0; + Z.args[2] = C; + Z.args[3] = D; + Z.args[4] = 0; +} +special_args(Z) ::= TAG COMMA TAG COMMA exp(C) COMMA exp(D) COMMA exp(E). +{ + Z.addflags = SIMPLE_HAS2TAGS; + Z.args[0] = Z.args[1] = 0; + Z.args[2] = C; + Z.args[3] = D; + Z.args[4] = E; +} +special_args(Z) ::= LINEID. +{ + Z.addflags = SIMPLE_HASLINEID; + memset (Z.args, 0, 5); +} +special_args(Z) ::= LINEID COMMA exp(B). +{ + Z.addflags = SIMPLE_HASLINEID; + Z.args[0] = 0; + Z.args[1] = B; + Z.args[2] = 0; + Z.args[3] = 0; + Z.args[4] = 0; +} +special_args(Z) ::= LINEID COMMA exp(B) COMMA exp(C). +{ + Z.addflags = SIMPLE_HASLINEID; + Z.args[0] = 0; + Z.args[1] = B; + Z.args[2] = C; + Z.args[3] = 0; + Z.args[4] = 0; +} +special_args(Z) ::= LINEID COMMA exp(B) COMMA exp(C) COMMA exp(D). +{ + Z.addflags = SIMPLE_HASLINEID; + Z.args[0] = 0; + Z.args[1] = B; + Z.args[2] = C; + Z.args[3] = D; + Z.args[4] = 0; +} +special_args(Z) ::= LINEID COMMA exp(B) COMMA exp(C) COMMA exp(D) COMMA exp(E). +{ + Z.addflags = SIMPLE_HASLINEID; + Z.args[0] = 0; + Z.args[1] = B; + Z.args[2] = C; + Z.args[3] = D; + Z.args[4] = E; +} +special_args(Z) ::= exp(A). +{ + Z.addflags = 0; + Z.args[0] = A; + Z.args[1] = 0; + Z.args[2] = 0; + Z.args[3] = 0; + Z.args[4] = 0; +} +special_args(Z) ::= exp(A) COMMA exp(B). +{ + Z.addflags = 0; + Z.args[0] = A; + Z.args[1] = B; + Z.args[2] = 0; + Z.args[3] = 0; + Z.args[4] = 0; +} +special_args(Z) ::= exp(A) COMMA exp(B) COMMA exp(C). +{ + Z.addflags = 0; + Z.args[0] = A; + Z.args[1] = B; + Z.args[2] = C; + Z.args[3] = 0; + Z.args[4] = 0; +} +special_args(Z) ::= exp(A) COMMA exp(B) COMMA exp(C) COMMA exp(D). +{ + Z.addflags = 0; + Z.args[0] = A; + Z.args[1] = B; + Z.args[2] = C; + Z.args[3] = D; + Z.args[4] = 0; +} +special_args(Z) ::= exp(A) COMMA exp(B) COMMA exp(C) COMMA exp(D) COMMA exp(E). +{ + Z.addflags = 0; + Z.args[0] = A; + Z.args[1] = B; + Z.args[2] = C; + Z.args[3] = D; + Z.args[4] = E; +} +special_args(Z) ::= exp(A) COMMA TAG. +{ + Z.addflags = SIMPLE_HASTAGAT2; + Z.args[0] = A; + Z.args[1] = 0; + Z.args[2] = 0; + Z.args[3] = 0; + Z.args[4] = 0; +} +special_args(Z) ::= exp(A) COMMA TAG COMMA exp(C). +{ + Z.addflags = SIMPLE_HASTAGAT2; + Z.args[0] = A; + Z.args[1] = 0; + Z.args[2] = C; + Z.args[3] = 0; + Z.args[4] = 0; +} +special_args(Z) ::= exp(A) COMMA TAG COMMA exp(C) COMMA exp(D). +{ + Z.addflags = SIMPLE_HASTAGAT2; + Z.args[0] = A; + Z.args[1] = 0; + Z.args[2] = C; + Z.args[3] = D; + Z.args[4] = 0; +} +special_args(Z) ::= exp(A) COMMA TAG COMMA exp(C) COMMA exp(D) COMMA exp(E). +{ + Z.addflags = SIMPLE_HASTAGAT2; + Z.args[0] = A; + Z.args[1] = 0; + Z.args[2] = C; + Z.args[3] = D; + Z.args[4] = E; +} +special_args(Z) ::= exp(A) COMMA exp(B) COMMA TAG. +{ + Z.addflags = SIMPLE_HASTAGAT3; + Z.args[0] = A; + Z.args[1] = B; + Z.args[2] = 0; + Z.args[3] = 0; + Z.args[4] = 0; +} +special_args(Z) ::= exp(A) COMMA exp(B) COMMA TAG COMMA exp(D). +{ + Z.addflags = SIMPLE_HASTAGAT3; + Z.args[0] = A; + Z.args[1] = B; + Z.args[2] = 0; + Z.args[3] = D; + Z.args[4] = 0; +} +special_args(Z) ::= exp(A) COMMA exp(B) COMMA TAG COMMA exp(D) COMMA exp(E). +{ + Z.addflags = SIMPLE_HASTAGAT3; + Z.args[0] = A; + Z.args[1] = B; + Z.args[2] = 0; + Z.args[3] = D; + Z.args[4] = E; +} +special_args(Z) ::= exp(A) COMMA exp(B) COMMA exp(C) COMMA TAG. +{ + Z.addflags = SIMPLE_HASTAGAT4; + Z.args[0] = A; + Z.args[1] = B; + Z.args[2] = C; + Z.args[3] = 0; + Z.args[4] = 0; +} +special_args(Z) ::= exp(A) COMMA exp(B) COMMA exp(C) COMMA TAG COMMA exp(E). +{ + Z.addflags = SIMPLE_HASTAGAT4; + Z.args[0] = A; + Z.args[1] = B; + Z.args[2] = C; + Z.args[3] = 0; + Z.args[4] = E; +} +special_args(Z) ::= exp(A) COMMA exp(B) COMMA exp(C) COMMA exp(D) COMMA TAG. +{ + Z.addflags = SIMPLE_HASTAGAT5; + Z.args[0] = A; + Z.args[1] = B; + Z.args[2] = C; + Z.args[3] = D; + Z.args[4] = 0; +} diff --git a/tools/xlatcc/xlatcc.vcproj b/tools/xlatcc/xlatcc.vcproj index e5768ad2a..ac0f4e753 100644 --- a/tools/xlatcc/xlatcc.vcproj +++ b/tools/xlatcc/xlatcc.vcproj @@ -98,84 +98,6 @@ CommandLine="copy "$(TargetPath)" "$(ProjectDir)\$(TargetFileName)"" /> - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - + + @@ -407,8 +379,9 @@ > + + + diff --git a/wadsrc/xlat/defines.i b/wadsrc/xlat/defines.i index 5b3d20e56..b1ca45192 100644 --- a/wadsrc/xlat/defines.i +++ b/wadsrc/xlat/defines.i @@ -16,7 +16,7 @@ special 219:Sector_SetFriction(), 222:Scroll_Texture_Model(), 225:Scroll_Texture_Offsets(), - 227:PointPush_SetForce(), + 227:PointPush_SetForce() ; // Static_Init types