/* 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** in the input file. */#include <stdio.h>%%/* 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 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.*/%%#define YY_SZ_ACTTAB (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 YYFALLBACKstatic 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 <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[] = { %%};#endif /* NDEBUG */#ifndef NDEBUG/* For tracing reduce actions, the names of all rules are required.*/static const char *const yyRuleName[] = {%%};#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:** <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);  (*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 */  int 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 ){#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    return yy_default[stateno];  }else{    return yy_action[i];  }}/*** Find the appropriate action for a parser given the non-terminal