zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2024-11-17 09:51:26 +00:00
Code Issues Projects Releases Packages Wiki Activity
gzdoom/tools/xlatcc/xlat-parse.c

2132 lines
67 KiB
C
Raw Normal View History

- Updated lempar.c to v1.31. - Added .txt files to the list of types (wad, zip, and pk3) that can be loaded without listing them after -file. - Fonts that are created by the ACS setfont command to wrap a texture now support animated textures. - FON2 fonts can now use their full palette for CR_UNTRANSLATED when drawn with the hardware 2D path instead of being restricted to the game palette. - Fixed: Toggling vid_vsync would reset the displayed fullscreen gamma to 1 on a Radeon 9000. - Added back the off-by-one palette handling, but in a much more limited scope than before. The skipped entry is assumed to always be at 248, and it is assumed that all Shader Model 1.4 cards suffer from this. That's because all SM1.4 cards are based on variants of the ATI R200 core, and the RV250 in a Radeon 9000 craps up like this. I see no reason to assume that other flavors of the R200 are any different. (Interesting note: With the Radeon 9000, D3DTADDRESS_CLAMP is an invalid address mode when using the debug Direct3D 9 runtime, but it works perfectly fine with the retail Direct3D 9 runtime.) (Insight: The R200 probably uses bytes for all its math inside pixel shaders. That would explain perfectly why I can't use constants greater than 1 with PS1.4 and why it can't do an exact mapping to every entry in the color palette. - Fixed: The software shaded drawer did not work for 2D, because its selected "color"map was replaced with the identitymap before being used. - Fixed: I cannot use Printf to output messages before the framebuffer was completely setup, meaning that Shader Model 1.4 cards could not change resolution. - I have decided to let remap palettes specify variable alpha values for their colors. D3DFB no longer forces them to 255. - Updated re2c to version 0.12.3. - Fixed: A_Wander used threshold as a timer, when it should have used reactiontime. - Fixed: A_CustomRailgun would not fire at all for actors without a target when the aim parameter was disabled. - Made the warp command work in multiplayer, again courtesy of Karate Chris. - Fixed: Trying to spawn a bot while not in a game made for a crashing time. (Patch courtesy of Karate Chris.) - Removed some floating point math from hu_scores.cpp that somebody's GCC gave warnings for (not mine, though). - Fixed: The SBarInfo drawbar command crashed if the sprite image was unavailable. - Fixed: FString::operator=(const char *) did not release its old buffer when being assigned to the null string. - The scanner no longer has an upper limit on the length of strings it accepts, though short strings will be faster than long ones. - Moved all the text scanning functions into a class. Mainly, this means that multiple script scanner states can be stored without being forced to do so recursively. I think I might be taking advantage of that in the near future. Possibly. Maybe. - Removed some potential buffer overflows from the decal parser. - Applied Blzut3's SBARINFO update #9: * Fixed: When using even length values in drawnumber it would cap to a 98 value instead of a 99 as intended. * The SBarInfo parser can now accept negatives for coordinates. This doesn't allow much right now, but later I plan to add better fullscreen hud support in which the negatives will be more useful. This also cleans up the source a bit since all calls for (x, y) coordinates are with the function getCoordinates(). - Added support for stencilling actors. - Added support for non-black colors specified with DTA_ColorOverlay to the software renderer. - Fixed: The inverse, gold, red, and green fixed colormaps each allocated space for 32 different colormaps, even though each only used the first one. - Added two new blending flags to make reverse subtract blending more useful: STYLEF_InvertSource and STYLEF_InvertOverlay. These invert the color that gets blended with the background, since that seems like a good idea for reverse subtraction. They also work with the other two blending operations. - Added subtract and reverse subtract blending operations to the renderer. Since the ERenderStyle enumeration was getting rather unwieldy, I converted it into a new FRenderStyle structure that lets each parameter of the blending equation be set separately. This simplified the set up for the blend quite a bit, and it means a number of new combinations are available by setting the parameters properly. SVN r710 (trunk)
2008-01-25 23:57:44 +00:00
/* 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 <stdio.h>
#include <string.h>
#include <assert.h>
#line 1 "xlat-parse.y"
#include "xlat.h"
#include "xlat-parse.h"
#include <malloc.h>
#include <string.h>
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 <ctype.h>
#include <stdio.h>
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 328 "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. If
** zero the stack is dynamically sized using realloc()
** 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 */
#if YYSTACKDEPTH<=0
int yystksz; /* Current side of the stack */
yyStackEntry *yystack; /* The parser's stack */
#else
yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */
#endif
};
typedef struct yyParser yyParser;
#ifndef NDEBUG
#include <stdio.h>
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:
** <ul>
** <li> A FILE* to which trace output should be written.
** If NULL, then tracing is turned off.
** <li> A prefix string written at the beginning of every
** line of trace output. If NULL, then tracing is
** turned off.
** </ul>
**
** 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 */
#if YYSTACKDEPTH<=0
/*
** Try to increase the size of the parser stack.
*/
static void yyGrowStack(yyParser *p){
int newSize;
yyStackEntry *pNew;
newSize = p->yystksz*2 + 100;
pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
if( pNew ){
p->yystack = pNew;
p->yystksz = newSize;
#ifndef NDEBUG
if( yyTraceFILE ){
fprintf(yyTraceFILE,"%sStack grows to %d entries!\n",
yyTracePrompt, p->yystksz);
}
#endif
}
}
#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;
#if YYSTACKDEPTH<=0
yyGrowStack(pParser);
#endif
}
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:
** <ul>
** <li> A pointer to the parser. This should be a pointer
** obtained from ParseAlloc.
** <li> A pointer to a function used to reclaim memory obtained
** from malloc.
** </ul>
*/
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);
#if YYSTACKDEPTH<=0
free(pParser->yystack);
#endif
(*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<sizeof(yyFallback)/sizeof(yyFallback[0])
&& (iFallback = yyFallback[iLookAhead])!=0 ){
#ifndef NDEBUG
if( yyTraceFILE ){
fprintf(yyTraceFILE, "%sFALLBACK %s => %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<YY_SZ_ACTTAB && yy_lookahead[j]==YYWILDCARD ){
#ifndef NDEBUG
if( yyTraceFILE ){
fprintf(yyTraceFILE, "%sWILDCARD %s => %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;
assert( stateno<=YY_REDUCE_MAX );
i = yy_reduce_ofst[stateno];
assert( i!=YY_REDUCE_USE_DFLT );
assert( iLookAhead!=YYNOCODE );
i += iLookAhead;
assert( i>=0 && i<YY_SZ_ACTTAB );
assert( yy_lookahead[i]==iLookAhead );
return yy_action[i];
}
/*
** The following routine is called if the stack overflows.
*/
static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){
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 every overflows */
ParseARG_STORE; /* Suppress warning about unused %extra_argument var */
}
/*
** 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 YYSTACKDEPTH>0
if( yypParser->yyidx>=YYSTACKDEPTH ){
yyStackOverflow(yypParser, yypMinor);
return;
}
#else
if( yypParser->yyidx>=yypParser->yystksz ){
yyGrowStack(yypParser);
if( yypParser->yyidx>=yypParser->yystksz ){
yyStackOverflow(yypParser, yypMinor);
return;
}
}
#endif
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 <lineno> <grammarfile>
** { ... } // User supplied code
** #line <lineno> <thisfile>
** break;
*/
case 1:
#line 344 "xlat-parse.y"
{ yygotominor.yy72 = yymsp[0].minor.yy0.val; }
#line 1227 "xlat-parse.c"
break;
case 2:
#line 345 "xlat-parse.y"
{ yygotominor.yy72 = yymsp[0].minor.yy0.symval->Value; }
#line 1232 "xlat-parse.c"
break;
case 3:
#line 346 "xlat-parse.y"
{ yygotominor.yy72 = yymsp[-2].minor.yy72 + yymsp[0].minor.yy72; }
#line 1237 "xlat-parse.c"
break;
case 4:
#line 347 "xlat-parse.y"
{ yygotominor.yy72 = yymsp[-2].minor.yy72 - yymsp[0].minor.yy72; }
#line 1242 "xlat-parse.c"
break;
case 5:
#line 348 "xlat-parse.y"
{ yygotominor.yy72 = yymsp[-2].minor.yy72 * yymsp[0].minor.yy72; }
#line 1247 "xlat-parse.c"
break;
case 6:
#line 349 "xlat-parse.y"
{ yygotominor.yy72 = yymsp[-2].minor.yy72 / yymsp[0].minor.yy72; }
#line 1252 "xlat-parse.c"
break;
case 7:
#line 350 "xlat-parse.y"
{ yygotominor.yy72 = yymsp[-2].minor.yy72 | yymsp[0].minor.yy72; }
#line 1257 "xlat-parse.c"
break;
case 8:
#line 351 "xlat-parse.y"
{ yygotominor.yy72 = yymsp[-2].minor.yy72 & yymsp[0].minor.yy72; }
#line 1262 "xlat-parse.c"
break;
case 9:
#line 352 "xlat-parse.y"
{ yygotominor.yy72 = yymsp[-2].minor.yy72 ^ yymsp[0].minor.yy72; }
#line 1267 "xlat-parse.c"
break;
case 10:
#line 353 "xlat-parse.y"
{ yygotominor.yy72 = -yymsp[0].minor.yy72; }
#line 1272 "xlat-parse.c"
break;
case 11:
#line 354 "xlat-parse.y"
{ yygotominor.yy72 = yymsp[-1].minor.yy72; }
#line 1277 "xlat-parse.c"
break;
case 21:
#line 368 "xlat-parse.y"
{
printf ("\n");
}
#line 1284 "xlat-parse.c"
break;
case 25:
#line 376 "xlat-parse.y"
{ printf ("%s", yymsp[0].minor.yy0.string); }
#line 1289 "xlat-parse.c"
break;
case 26:
#line 377 "xlat-parse.y"
{ printf ("%d", yymsp[0].minor.yy72); }
#line 1294 "xlat-parse.c"
break;
case 27:
#line 378 "xlat-parse.y"
{ printf ("\n"); }
#line 1299 "xlat-parse.c"
break;
case 28:
#line 381 "xlat-parse.y"
{
AddSym (yymsp[-3].minor.yy0.sym, yymsp[-1].minor.yy72);
}
#line 1306 "xlat-parse.c"
break;
case 29:
#line 386 "xlat-parse.y"
{
IncludeFile (yymsp[0].minor.yy0.string);
}
#line 1313 "xlat-parse.c"
break;
case 31:
#line 393 "xlat-parse.y"
{
EnumVal = 0;
}
#line 1320 "xlat-parse.c"
break;
case 35:
#line 402 "xlat-parse.y"
{
AddSym (yymsp[0].minor.yy0.sym, EnumVal++);
}
#line 1327 "xlat-parse.c"
break;
case 36:
#line 407 "xlat-parse.y"
{
AddSym (yymsp[-2].minor.yy0.sym, EnumVal = yymsp[0].minor.yy72);
}
#line 1334 "xlat-parse.c"
break;
case 40:
#line 420 "xlat-parse.y"
{
AddSym (yymsp[-3].minor.yy0.sym, yymsp[-5].minor.yy72);
}
#line 1341 "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 1348 "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 1361 "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 1368 "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 1415 "xlat-parse.c"
break;
case 48:
#line 493 "xlat-parse.y"
{
yygotominor.yy49 = NULL;
}
#line 1422 "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 1431 "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 1466 "xlat-parse.c"
break;
case 51:
#line 536 "xlat-parse.y"
{ yygotominor.yy72 = 4; }
#line 1471 "xlat-parse.c"
break;
case 52:
#line 537 "xlat-parse.y"
{ yygotominor.yy72 = 0; }
#line 1476 "xlat-parse.c"
break;
case 53:
#line 538 "xlat-parse.y"
{ yygotominor.yy72 = 1; }
#line 1481 "xlat-parse.c"
break;
case 54:
#line 539 "xlat-parse.y"
{ yygotominor.yy72 = 2; }
#line 1486 "xlat-parse.c"
break;
case 55:
#line 540 "xlat-parse.y"
{ yygotominor.yy72 = 3; }
#line 1491 "xlat-parse.c"
break;
case 56:
#line 542 "xlat-parse.y"
{ yygotominor.yy72 = '='; }
#line 1496 "xlat-parse.c"
break;
case 57:
#line 543 "xlat-parse.y"
{ yygotominor.yy72 = OR_EQUAL; }
#line 1501 "xlat-parse.c"
break;
case 58:
#line 546 "xlat-parse.y"
{
yygotominor.yy83.constant = yymsp[0].minor.yy72;
yygotominor.yy83.filters = NULL;
}
#line 1509 "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 1517 "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 1526 "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 1535 "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 1543 "xlat-parse.c"
break;
case 63:
#line 576 "xlat-parse.y"
{
yygotominor.yy57.addflags = 0;
memset (yygotominor.yy57.args, 0, 5);
}
#line 1551 "xlat-parse.c"
break;
case 64:
#line 581 "xlat-parse.y"
{
yygotominor.yy57.addflags = SIMPLE_HASTAGAT1;
memset (yygotominor.yy57.args, 0, 5);
}
#line 1559 "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 1571 "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 1583 "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 1595 "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 1607 "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 1618 "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 1629 "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 1640 "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 1651 "xlat-parse.c"
break;
case 73:
#line 654 "xlat-parse.y"
{
yygotominor.yy57.addflags = SIMPLE_HASLINEID;
memset (yygotominor.yy57.args, 0, 5);
}
#line 1659 "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 1671 "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 1683 "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 1695 "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 1707 "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 1719 "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 1731 "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 1743 "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 1755 "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 1767 "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 1779 "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 1791 "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 1803 "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 1815 "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 1827 "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 1839 "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 1851 "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 1863 "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 1875 "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 1887 "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{
assert( 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 1947 "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:
** <ul>
** <li> A pointer to the parser (an opaque structure.)
** <li> The major token number.
** <li> The minor token number.
** <li> An option argument of a grammar-specified type.
** </ul>
**
** 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 */
#ifdef YYERRORSYMBOL
int yyerrorhit = 0; /* True if yymajor has invoked an error */
#endif
yyParser *yypParser; /* The parser */
/* (re)initialize the parser, if necessary */
yypParser = (yyParser*)yyp;
if( yypParser->yyidx<0 ){
#if YYSTACKDEPTH<=0
if( yypParser->yystksz <=0 ){
memset(&yyminorunion, 0, sizeof(yyminorunion));
yyStackOverflow(yypParser, &yyminorunion);
return;
}
#endif
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( yyact<YYNSTATE ){
assert( !yyendofinput ); /* Impossible to shift the $ token */
yy_shift(yypParser,yyact,yymajor,&yyminorunion);
yypParser->yyerrcnt--;
yymajor = YYNOCODE;
/* [RH] If we can reduce the stack now, do it. Otherwise, constructs */
/* like "include <somefile>" won't work because the next token after */
/* the include will be shifted before the include is reduced. Then the */
/* parser will act as if that token had been the first one in the */
/* included file. */
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{
#ifdef YYERRORSYMBOL
int yymx;
#endif
assert( yyact == YY_ERROR_ACTION );
#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
}
}while( yymajor!=YYNOCODE && yypParser->yyidx>=0 );
return;
}
Reference in a new issue Copy permalink