/*

 * My changes over the original lempar.c from SQLite are encased in

 *  #if __MOJOSHADER__ blocks.  --ryan.

 */

#ifndef __MOJOSHADER__

#define __MOJOSHADER__ 1

#endif

#if !__MOJOSHADER__

#define LEMON_SUPPORT_TRACING (!defined(NDEBUG))

#endif

/* Driver template for the LEMON parser generator.

** The original author(s) of lempar.c disclaim copyright to this source code.

** However, changes made for MojoShader fall under the same license as the

** rest of MojoShader. Please see the file LICENSE.txt in the source's root

** directory.

*/

/* First off, code is included that follows the "include" declaration

** in the input grammar 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.  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 YY_NO_ACTION      (YYNSTATE+YYNRULE+2)

#define YY_ACCEPT_ACTION  (YYNSTATE+YYNRULE+1)

#define YY_ERROR_ACTION   (YYNSTATE+YYNRULE)

/* The yyzerominor constant is used to initialize instances of

** YYMINORTYPE objects to zero. */

static const YYMINORTYPE yyzerominor = { 0 };

/* Define the yytestcase() macro to be a no-op if is not already defined

** otherwise.

**

** Applications can choose to define yytestcase() in the %include section

** to a macro that can assist in verifying code coverage.  For production

** code the yytestcase() macro should be turned off.  But it is useful

** for testing.

*/

#ifndef yytestcase

# define yytestcase(X)

#endif

/* Next are the 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.

*/

%%

/* The next table maps tokens into fallback tokens.  If a construct

** like the following:

** 

**      %fallback ID X Y Z.

**

** appears in the grammar, 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 {

  YYACTIONTYPE stateno;  /* The state-number */

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

#ifdef YYTRACKMAXSTACKDEPTH

  int yyidxMax;                 /* Maximum value of yyidx */

#endif

  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;

#if LEMON_SUPPORT_TRACING   /* __MOJOSHADER__ */

#include <stdio.h>

static FILE *yyTraceFILE = 0;

static char *yyTracePrompt = 0;

#endif /* NDEBUG */

#if LEMON_SUPPORT_TRACING   /* __MOJOSHADER__ */

/*

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

*/

#if __MOJOSHADER__

static

#endif

void ParseTrace(FILE *TraceFILE, char *zTracePrompt){

  yyTraceFILE = TraceFILE;

  yyTracePrompt = zTracePrompt;

  if( yyTraceFILE==0 ) yyTracePrompt = 0;

  else if( yyTracePrompt==0 ) yyTraceFILE = 0;

}

#endif /* NDEBUG */

#if LEMON_SUPPORT_TRACING   /* __MOJOSHADER__ */

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

#if LEMON_SUPPORT_TRACING   /* __MOJOSHADER__ */

/* For tracing reduce actions, the names of all rules are required.

*/

static const char *const yyRuleName[] = {

%%

};

#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;

#if LEMON_SUPPORT_TRACING   /* __MOJOSHADER__ */

    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.

*/

#if __MOJOSHADER__

static void *ParseAlloc(void *(*mallocProc)(int,void *), void *malloc_data){

  yyParser *pParser;

  pParser = (yyParser*)(*mallocProc)( (int)sizeof(yyParser), malloc_data );

#else

void *ParseAlloc(void *(*mallocProc)(size_t)){

  yyParser *pParser;

  pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) );

#endif

  if( pParser ){

    pParser->yyidx = -1;

#ifdef YYTRACKMAXSTACKDEPTH

    pParser->yyidxMax = 0;

#endif

#if YYSTACKDEPTH<=0

    pParser->yystack = NULL;

    pParser->yystksz = 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(

  yyParser *yypParser,    /* The parser */

  YYCODETYPE yymajor,     /* Type code for object to destroy */

  YYMINORTYPE *yypminor   /* The object to be destroyed */

){

  ParseARG_FETCH;

  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;

#if LEMON_SUPPORT_TRACING   /* __MOJOSHADER__ */

  if( yyTraceFILE && pParser->yyidx>=0 ){

    fprintf(yyTraceFILE,"%sPopping %s\n",

      yyTracePrompt,

      yyTokenName[yytos->major]);

  }

#endif

  yymajor = yytos->major;

  yy_destructor(pParser, 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>

*/

#if __MOJOSHADER__

static

#endif

void ParseFree(

  void *p,                    /* The parser to be deleted */

#if __MOJOSHADER__

  void (*freeProc)(void*,void*),     /* Function used to reclaim memory */

  void *malloc_data

#else

  void (*freeProc)(void*)     /* Function used to reclaim memory */

#endif

){

  yyParser *pParser = (yyParser*)p;

  if( pParser==0 ) return;

  while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);

#if YYSTACKDEPTH<=0

  free(pParser->yystack);

#endif

#if __MOJOSHADER__

  (*freeProc)((void*)pParser, malloc_data);

#else

  (*freeProc)((void*)pParser);

#endif

}

/*

** Return the peak depth of the stack for a parser.

*/

#ifdef YYTRACKMAXSTACKDEPTH

static int ParseStackPeak(void *p){

  yyParser *pParser = (yyParser*)p;

  return pParser->yyidxMax;

}

#endif

/*

** 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_COUNT

   || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){

    return yy_default[stateno];

  }

  assert( iLookAhead!=YYNOCODE );

  i += iLookAhead;

  if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){

    if( iLookAhead>0 ){

#ifdef YYFALLBACK

      YYCODETYPE iFallback;            /* Fallback token */

      if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])

             && (iFallback = yyFallback[iLookAhead])!=0 ){

#if LEMON_SUPPORT_TRACING   /* __MOJOSHADER__ */

        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( 

#if YY_SHIFT_MIN+YYWILDCARD<0

          j>=0 &&

#endif

#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT

          j<YY_ACTTAB_COUNT &&

#endif

          yy_lookahead[j]==YYWILDCARD

        ){

#if LEMON_SUPPORT_TRACING   /* __MOJOSHADER__ */

          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;

#ifdef YYERRORSYMBOL

  if( stateno>YY_REDUCE_COUNT ){

    return yy_default[stateno];

  }

#else

  assert( stateno<=YY_REDUCE_COUNT );

#endif

  i = yy_reduce_ofst[stateno];

  assert( i!=YY_REDUCE_USE_DFLT );

  assert( iLookAhead!=YYNOCODE );

  i += iLookAhead;

#ifdef YYERRORSYMBOL

  if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){

    return yy_default[stateno];

  }

#else

  assert( i>=0 && i<YY_ACTTAB_COUNT );

  assert( yy_lookahead[i]==iLookAhead );

#endif

  return yy_action[i];

}

/*

** The following routine is called if the stack overflows.

*/

static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){

   ParseARG_FETCH;

   yypParser->yyidx--;

#if LEMON_SUPPORT_TRACING   /* __MOJOSHADER__ */

   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