ce_parse.c File Reference

#include "cppvalue.h"
#include "constexp.h"
#include "message.h"
#include <stdio.h>
#include <stdlib.h>

Go to the source code of this file.

Classes
union	yyalloc

Macros
#define	YYBISON   1
#define	YYBISON_VERSION   "2.4.1"
#define	YYSKELETON_NAME   "yacc.c"
#define	YYPURE   0
#define	YYPUSH   0
#define	YYPULL   1
#define	YYLSP_NEEDED   0
#define	yyparse   ce_parsexpYYparse
#define	yylex   ce_parsexpYYlex
#define	yyerror   ce_parsexpYYerror
#define	yylval   ce_parsexpYYlval
#define	yychar   ce_parsexpYYchar
#define	yydebug   ce_parsexpYYdebug
#define	yynerrs   ce_parsexpYYnerrs
#define	YYSTYPE   CPPValue
#define	YYDEBUG   0
#define	YYERROR_VERBOSE   0
#define	YYTOKEN_TABLE   0
#define	YYTOKENTYPE
#define	YYSIZE_T   unsigned int
#define	YYSIZE_MAXIMUM   ((YYSIZE_T) -1)
#define	YY_(msgid)   msgid
#define	YYUSE(e)   ((void) (e))
#define	YYID(n)   (n)
#define	YYSTACK_ALLOC   YYMALLOC
#define	YYSTACK_FREE   YYFREE
#define	YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM
#define	YYMALLOC   malloc
#define	YYFREE   free
#define	YYSTACK_GAP_MAXIMUM   (sizeof (union yyalloc) - 1)
#define	YYSTACK_BYTES(N)
#define	YYCOPY(To, From, Count)
#define	YYSTACK_RELOCATE(Stack_alloc, Stack)
#define	YYFINAL   31
#define	YYLAST   63
#define	YYNTOKENS   32
#define	YYNNTS   16
#define	YYNRULES   44
#define	YYNSTATES   73
#define	YYUNDEFTOK   2
#define	YYMAXUTOK   286
#define	YYTRANSLATE(YYX)   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
#define	YYPACT_NINF   -29
#define	YYTABLE_NINF   -1
#define	yyerrok   (yyerrstatus = 0)
#define	yyclearin   (yychar = YYEMPTY)
#define	YYEMPTY   (-2)
#define	YYEOF   0
#define	YYACCEPT   goto yyacceptlab
#define	YYABORT   goto yyabortlab
#define	YYERROR   goto yyerrorlab
#define	YYFAIL   goto yyerrlab
#define	YYRECOVERING()   (!!yyerrstatus)
#define	YYBACKUP(Token, Value)
#define	YYTERROR   1
#define	YYERRCODE   256
#define	YYRHSLOC(Rhs, K)   ((Rhs)[K])
#define	YYLLOC_DEFAULT(Current, Rhs, N)
#define	YY_LOCATION_PRINT(File, Loc)   ((void) 0)
#define	YYLEX   yylex ()
#define	YYDPRINTF(Args)
#define	YY_SYMBOL_PRINT(Title, Type, Value, Location)
#define	YY_STACK_PRINT(Bottom, Top)
#define	YY_REDUCE_PRINT(Rule)
#define	YYINITDEPTH   200
#define	YYMAXDEPTH   10000
#define	YYPOPSTACK(N)    (yyvsp -= (N), yyssp -= (N))

Typedefs
typedef unsigned char	yytype_uint8
typedef short int	yytype_int8
typedef unsigned short int	yytype_uint16
typedef short int	yytype_int16

Enumerations
enum	yytokentype {   TOK_QUESTIONMARK = 258, TOK_COLON = 259, TOK_OR = 260, TOK_AND = 261,   TOK_BITWISEOR = 262, TOK_BITWISEXOR = 263, TOK_AMPERSAND = 264, TOK_NOTEQUAL = 265,   TOK_EQUAL = 266, TOK_LESSTHAN = 267, TOK_GREATERTHAN = 268, TOK_LESSTHANOREQUALTO = 269,   TOK_GREATERTHANOREQUALTO = 270, TOK_SHIFTLEFT = 271, TOK_SHIFTRIGHT = 272, TOK_PLUS = 273,   TOK_MINUS = 274, TOK_STAR = 275, TOK_DIVIDE = 276, TOK_MOD = 277,   TOK_TILDE = 278, TOK_NOT = 279, TOK_LPAREN = 280, TOK_RPAREN = 281,   TOK_OCTALINT = 282, TOK_DECIMALINT = 283, TOK_HEXADECIMALINT = 284, TOK_CHARACTER = 285,   TOK_FLOAT = 286, TOK_QUESTIONMARK = 258, TOK_COLON = 259, TOK_OR = 260,   TOK_AND = 261, TOK_BITWISEOR = 262, TOK_BITWISEXOR = 263, TOK_AMPERSAND = 264,   TOK_NOTEQUAL = 265, TOK_EQUAL = 266, TOK_LESSTHAN = 267, TOK_GREATERTHAN = 268,   TOK_LESSTHANOREQUALTO = 269, TOK_GREATERTHANOREQUALTO = 270, TOK_SHIFTLEFT = 271, TOK_SHIFTRIGHT = 272,   TOK_PLUS = 273, TOK_MINUS = 274, TOK_STAR = 275, TOK_DIVIDE = 276,   TOK_MOD = 277, TOK_TILDE = 278, TOK_NOT = 279, TOK_LPAREN = 280,   TOK_RPAREN = 281, TOK_OCTALINT = 282, TOK_DECIMALINT = 283, TOK_HEXADECIMALINT = 284,   TOK_CHARACTER = 285, TOK_FLOAT = 286, TOK_QUESTIONMARK = 258, TOK_COLON = 259,   TOK_OR = 260, TOK_AND = 261, TOK_BITWISEOR = 262, TOK_BITWISEXOR = 263,   TOK_AMPERSAND = 264, TOK_NOTEQUAL = 265, TOK_EQUAL = 266, TOK_LESSTHAN = 267,   TOK_GREATERTHAN = 268, TOK_LESSTHANOREQUALTO = 269, TOK_GREATERTHANOREQUALTO = 270, TOK_SHIFTLEFT = 271,   TOK_SHIFTRIGHT = 272, TOK_PLUS = 273, TOK_MINUS = 274, TOK_STAR = 275,   TOK_DIVIDE = 276, TOK_MOD = 277, TOK_TILDE = 278, TOK_NOT = 279,   TOK_LPAREN = 280, TOK_RPAREN = 281, TOK_OCTALINT = 282, TOK_DECIMALINT = 283,   TOK_HEXADECIMALINT = 284, TOK_CHARACTER = 285, TOK_FLOAT = 286, TOK_QUESTIONMARK = 258,   TOK_COLON = 259, TOK_OR = 260, TOK_AND = 261, TOK_BITWISEOR = 262,   TOK_BITWISEXOR = 263, TOK_AMPERSAND = 264, TOK_NOTEQUAL = 265, TOK_EQUAL = 266,   TOK_LESSTHAN = 267, TOK_GREATERTHAN = 268, TOK_LESSTHANOREQUALTO = 269, TOK_GREATERTHANOREQUALTO = 270,   TOK_SHIFTLEFT = 271, TOK_SHIFTRIGHT = 272, TOK_PLUS = 273, TOK_MINUS = 274,   TOK_STAR = 275, TOK_DIVIDE = 276, TOK_MOD = 277, TOK_TILDE = 278,   TOK_NOT = 279, TOK_LPAREN = 280, TOK_RPAREN = 281, TOK_OCTALINT = 282,   TOK_DECIMALINT = 283, TOK_HEXADECIMALINT = 284, TOK_CHARACTER = 285, TOK_FLOAT = 286 }

Functions
int	constexpYYerror (const char *s)
int	constexpYYlex ()
static void	yydestruct (char *yymsg, int yytype, YYSTYPE *yyvaluep) const
int	yyparse ()

Variables
static const yytype_uint8	yytranslate []
static const yytype_uint8	yyr1 []
static const yytype_uint8	yyr2 []
static const yytype_uint8	yydefact []
static const yytype_int8	yydefgoto []
static const yytype_int8	yypact []
static const yytype_int8	yypgoto []
static const yytype_uint8	yytable []
static const yytype_int8	yycheck []
static const yytype_uint8	yystos []
int	yychar
YYSTYPE	yylval
int	yynerrs

Macro Definition Documentation

#define YY_

(

msgid

)

msgid

Definition at line 231 of file ce_parse.c.

#define YY_LOCATION_PRINT	(		File,
			Loc
	)		((void) 0)

Definition at line 698 of file ce_parse.c.

#define YY_REDUCE_PRINT

(

Rule

)

Definition at line 871 of file ce_parse.c.

#define YY_STACK_PRINT	(		Bottom,
			Top
	)

Definition at line 870 of file ce_parse.c.

#define YY_SYMBOL_PRINT	(		Title,
			Type,
			Value,
			Location
	)

Definition at line 869 of file ce_parse.c.

#define YYABORT   goto yyabortlab

Definition at line 627 of file ce_parse.c.

#define YYACCEPT   goto yyacceptlab

Definition at line 626 of file ce_parse.c.

#define YYBACKUP	(		Token,
			Value
	)

Value:

do								\
  if (yychar == YYEMPTY && yylen == 1)                          \
    {                                                           \
      yychar = (Token);                                         \
      yylval = (Value);                                         \
      yytoken = YYTRANSLATE (yychar);                           \
      YYPOPSTACK (1);                                           \
      goto yybackup;                                            \
    }                                                           \
  else                                                          \
    {                                                           \
      yyerror (YY_("syntax error: cannot back up")); \
      YYERROR;                                                  \
    }                                                           \
while (YYID (0))

Definition at line 639 of file ce_parse.c.

#define YYBISON   1

Definition at line 46 of file ce_parse.c.

#define YYBISON_VERSION   "2.4.1"

Definition at line 49 of file ce_parse.c.

#define yychar   ce_parsexpYYchar

Definition at line 71 of file ce_parse.c.

#define yyclearin   (yychar = YYEMPTY)

Definition at line 622 of file ce_parse.c.

#define YYCOPY	(		To,
			From,
			Count
	)

Value:

do                                      \
        {                                       \
          YYSIZE_T yyi;                         \
	  for (yyi = 0; yyi < (Count); yyi++)  \
            (To)[yyi] = (From)[yyi];            \
        }                                       \
      while (YYID (0))

Definition at line 357 of file ce_parse.c.

#define yydebug   ce_parsexpYYdebug

Definition at line 72 of file ce_parse.c.

#define YYDEBUG   0

Definition at line 107 of file ce_parse.c.

#define YYDPRINTF

(

Args

)

Definition at line 868 of file ce_parse.c.

#define YYEMPTY   (-2)

Definition at line 623 of file ce_parse.c.

#define YYEOF   0

Definition at line 624 of file ce_parse.c.

#define YYERRCODE   256

Definition at line 658 of file ce_parse.c.

#define yyerrok   (yyerrstatus = 0)

Definition at line 621 of file ce_parse.c.

#define yyerror   ce_parsexpYYerror

Definition at line 69 of file ce_parse.c.

#define YYERROR   goto yyerrorlab

Definition at line 628 of file ce_parse.c.

#define YYERROR_VERBOSE   0

Definition at line 115 of file ce_parse.c.

#define YYFAIL   goto yyerrlab

Definition at line 635 of file ce_parse.c.

#define YYFINAL   31

Definition at line 387 of file ce_parse.c.

#define YYFREE   free

Definition at line 320 of file ce_parse.c.

#define YYID

(

n

)

(n)

Definition at line 244 of file ce_parse.c.

#define YYINITDEPTH   200

Definition at line 877 of file ce_parse.c.

#define YYLAST   63

Definition at line 389 of file ce_parse.c.

#define yylex   ce_parsexpYYlex

Definition at line 68 of file ce_parse.c.

#define YYLEX   yylex ()

Definition at line 708 of file ce_parse.c.

#define YYLLOC_DEFAULT	(		Current,
			Rhs,
			N
	)

Value:

do									\
      if (YYID (N))                                                    \
        {                                                               \
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
        }                                                               \
      else                                                              \
        {                                                               \
          (Current).first_line   = (Current).last_line   =              \
            YYRHSLOC (Rhs, 0).last_line;                                \
          (Current).first_column = (Current).last_column =              \
            YYRHSLOC (Rhs, 0).last_column;                              \
        }                                                               \
    while (YYID (0))

Definition at line 667 of file ce_parse.c.

#define YYLSP_NEEDED   0

Definition at line 64 of file ce_parse.c.

#define yylval   ce_parsexpYYlval

Definition at line 70 of file ce_parse.c.

#define YYMALLOC   malloc

Definition at line 313 of file ce_parse.c.

#define YYMAXDEPTH   10000

Definition at line 888 of file ce_parse.c.

#define YYMAXUTOK   286

Definition at line 402 of file ce_parse.c.

#define yynerrs   ce_parsexpYYnerrs

Definition at line 73 of file ce_parse.c.

#define YYNNTS   16

Definition at line 394 of file ce_parse.c.

#define YYNRULES   44

Definition at line 396 of file ce_parse.c.

#define YYNSTATES   73

Definition at line 398 of file ce_parse.c.

#define YYNTOKENS   32

Definition at line 392 of file ce_parse.c.

#define YYPACT_NINF   -29

Definition at line 560 of file ce_parse.c.

int yyparse   ce_parsexpYYparse

Definition at line 67 of file ce_parse.c.

#define YYPOPSTACK

(

N

)

(yyvsp -= (N), yyssp -= (N))

#define YYPULL   1

Definition at line 61 of file ce_parse.c.

#define YYPURE   0

Definition at line 55 of file ce_parse.c.

#define YYPUSH   0

Definition at line 58 of file ce_parse.c.

#define YYRECOVERING

(

)

(!!yyerrstatus)

Definition at line 637 of file ce_parse.c.

#define YYRHSLOC	(		Rhs,
			K
	)		((Rhs)[K])

Definition at line 665 of file ce_parse.c.

#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)

Definition at line 221 of file ce_parse.c.

#define YYSIZE_T   unsigned int

Definition at line 217 of file ce_parse.c.

#define YYSKELETON_NAME   "yacc.c"

Definition at line 52 of file ce_parse.c.

#define YYSTACK_ALLOC   YYMALLOC

Definition at line 299 of file ce_parse.c.

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

Definition at line 302 of file ce_parse.c.

#define YYSTACK_BYTES

(

N

)

Value:

((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
      + YYSTACK_GAP_MAXIMUM)

Definition at line 346 of file ce_parse.c.

#define YYSTACK_FREE   YYFREE

Definition at line 300 of file ce_parse.c.

#define YYSTACK_GAP_MAXIMUM   (sizeof (union yyalloc) - 1)

Definition at line 342 of file ce_parse.c.

#define YYSTACK_RELOCATE	(		Stack_alloc,
			Stack
	)

Value:

do                                                                      \
      {                                                                 \
	YYSIZE_T yynewbytes;                                           \
	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                   \
        Stack = &yyptr->Stack_alloc;                                    \
        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
        yyptr += yynewbytes / sizeof (*yyptr);                          \
      }                                                                 \
    while (YYID (0))

Definition at line 373 of file ce_parse.c.

#define YYSTYPE   CPPValue

Definition at line 88 of file ce_parse.c.

#define YYTABLE_NINF   -1

Definition at line 584 of file ce_parse.c.

#define YYTERROR   1

Definition at line 657 of file ce_parse.c.

#define YYTOKEN_TABLE   0

Definition at line 120 of file ce_parse.c.

#define YYTOKENTYPE

Definition at line 126 of file ce_parse.c.

#define YYTRANSLATE

(

YYX

)

((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

Definition at line 404 of file ce_parse.c.

#define YYUNDEFTOK   2

Definition at line 401 of file ce_parse.c.

#define YYUSE

(

e

)

((void) (e))

Definition at line 237 of file ce_parse.c.

Typedef Documentation

typedef short int yytype_int16

Definition at line 204 of file ce_parse.c.

typedef short int yytype_int8

Definition at line 192 of file ce_parse.c.

typedef unsigned short int yytype_uint16

Definition at line 198 of file ce_parse.c.

typedef unsigned char yytype_uint8

Definition at line 183 of file ce_parse.c.

Enumeration Type Documentation

enum yytokentype

Enumerator
TOK_QUESTIONMARK
TOK_COLON
TOK_OR
TOK_AND
TOK_BITWISEOR
TOK_BITWISEXOR
TOK_AMPERSAND
TOK_NOTEQUAL
TOK_EQUAL
TOK_LESSTHAN
TOK_GREATERTHAN
TOK_LESSTHANOREQUALTO
TOK_GREATERTHANOREQUALTO
TOK_SHIFTLEFT
TOK_SHIFTRIGHT
TOK_PLUS
TOK_MINUS
TOK_STAR
TOK_DIVIDE
TOK_MOD
TOK_TILDE
TOK_NOT
TOK_LPAREN
TOK_RPAREN
TOK_OCTALINT
TOK_DECIMALINT
TOK_HEXADECIMALINT
TOK_CHARACTER
TOK_FLOAT
TOK_QUESTIONMARK
TOK_COLON
TOK_OR
TOK_AND
TOK_BITWISEOR
TOK_BITWISEXOR
TOK_AMPERSAND
TOK_NOTEQUAL
TOK_EQUAL
TOK_LESSTHAN
TOK_GREATERTHAN
TOK_LESSTHANOREQUALTO
TOK_GREATERTHANOREQUALTO
TOK_SHIFTLEFT
TOK_SHIFTRIGHT
TOK_PLUS
TOK_MINUS
TOK_STAR
TOK_DIVIDE
TOK_MOD
TOK_TILDE
TOK_NOT
TOK_LPAREN
TOK_RPAREN
TOK_OCTALINT
TOK_DECIMALINT
TOK_HEXADECIMALINT
TOK_CHARACTER
TOK_FLOAT
TOK_QUESTIONMARK
TOK_COLON
TOK_OR
TOK_AND
TOK_BITWISEOR
TOK_BITWISEXOR
TOK_AMPERSAND
TOK_NOTEQUAL
TOK_EQUAL
TOK_LESSTHAN
TOK_GREATERTHAN
TOK_LESSTHANOREQUALTO
TOK_GREATERTHANOREQUALTO
TOK_SHIFTLEFT
TOK_SHIFTRIGHT
TOK_PLUS
TOK_MINUS
TOK_STAR
TOK_DIVIDE
TOK_MOD
TOK_TILDE
TOK_NOT
TOK_LPAREN
TOK_RPAREN
TOK_OCTALINT
TOK_DECIMALINT
TOK_HEXADECIMALINT
TOK_CHARACTER
TOK_FLOAT
TOK_QUESTIONMARK
TOK_COLON
TOK_OR
TOK_AND
TOK_BITWISEOR
TOK_BITWISEXOR
TOK_AMPERSAND
TOK_NOTEQUAL
TOK_EQUAL
TOK_LESSTHAN
TOK_GREATERTHAN
TOK_LESSTHANOREQUALTO
TOK_GREATERTHANOREQUALTO
TOK_SHIFTLEFT
TOK_SHIFTRIGHT
TOK_PLUS
TOK_MINUS
TOK_STAR
TOK_DIVIDE
TOK_MOD
TOK_TILDE
TOK_NOT
TOK_LPAREN
TOK_RPAREN
TOK_OCTALINT
TOK_DECIMALINT
TOK_HEXADECIMALINT
TOK_CHARACTER
TOK_FLOAT

Definition at line 129 of file ce_parse.c.

                    {
     TOK_QUESTIONMARK = 258,
     TOK_COLON = 259,
     TOK_OR = 260,
     TOK_AND = 261,
     TOK_BITWISEOR = 262,
     TOK_BITWISEXOR = 263,
     TOK_AMPERSAND = 264,
     TOK_NOTEQUAL = 265,
     TOK_EQUAL = 266,
     TOK_LESSTHAN = 267,
     TOK_GREATERTHAN = 268,
     TOK_LESSTHANOREQUALTO = 269,
     TOK_GREATERTHANOREQUALTO = 270,
     TOK_SHIFTLEFT = 271,
     TOK_SHIFTRIGHT = 272,
     TOK_PLUS = 273,
     TOK_MINUS = 274,
     TOK_STAR = 275,
     TOK_DIVIDE = 276,
     TOK_MOD = 277,
     TOK_TILDE = 278,
     TOK_NOT = 279,
     TOK_LPAREN = 280,
     TOK_RPAREN = 281,
     TOK_OCTALINT = 282,
     TOK_DECIMALINT = 283,
     TOK_HEXADECIMALINT = 284,
     TOK_CHARACTER = 285,
     TOK_FLOAT = 286
   };

Function Documentation

int constexpYYerror

(

const char *

s

)

Definition at line 93 of file ce_parse.c.

{
  warn(g_constExpFileName,g_constExpLineNr,
       "preprocessing issue while doing constant expression evaluation: %s",s);
  return 0;
}

int constexpYYlex

(

)

static void yydestruct ( char *  yymsg, int  yytype, YYSTYPE *  yyvaluep  ) const

static

Definition at line 1115 of file ce_parse.c.

{
  YYUSE (yyvaluep);

  if (!yymsg)
    yymsg = "Deleting";
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);

  switch (yytype)
    {

      default:
        break;
    }
}

int yyparse

(

)

Definition at line 1183 of file ce_parse.c.

{


    int yystate;
    /* Number of tokens to shift before error messages enabled.  */
    int yyerrstatus;

    /* The stacks and their tools:
       `yyss': related to states.
       `yyvs': related to semantic values.

       Refer to the stacks thru separate pointers, to allow yyoverflow
       to reallocate them elsewhere.  */

    /* The state stack.  */
    yytype_int16 yyssa[YYINITDEPTH];
    yytype_int16 *yyss;
    yytype_int16 *yyssp;

    /* The semantic value stack.  */
    YYSTYPE yyvsa[YYINITDEPTH];
    YYSTYPE *yyvs;
    YYSTYPE *yyvsp;

    YYSIZE_T yystacksize;

  int yyn;
  int yyresult;
  /* Lookahead token as an internal (translated) token number.  */
  int yytoken;
  /* The variables used to return semantic value and location from the
     action routines.  */
  YYSTYPE yyval;

#if YYERROR_VERBOSE
  /* Buffer for error messages, and its allocated size.  */
  char yymsgbuf[128];
  char *yymsg = yymsgbuf;
  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif

#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))

  /* The number of symbols on the RHS of the reduced rule.
     Keep to zero when no symbol should be popped.  */
  int yylen = 0;

  yytoken = 0;
  yyss = yyssa;
  yyvs = yyvsa;
  yystacksize = YYINITDEPTH;

  YYDPRINTF ((stderr, "Starting parse\n"));

  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = YYEMPTY; /* Cause a token to be read.  */

  /* Initialize stack pointers.
     Waste one element of value and location stack
     so that they stay on the same level as the state stack.
     The wasted elements are never initialized.  */
  yyssp = yyss;
  yyvsp = yyvs;

  goto yysetstate;

/*------------------------------------------------------------.
| yynewstate -- Push a new state, which is found in yystate.  |
`------------------------------------------------------------*/
 yynewstate:
  /* In all cases, when you get here, the value and location stacks
     have just been pushed.  So pushing a state here evens the stacks.  */
  yyssp++;

 yysetstate:
  *yyssp = yystate;

  if (yyss + yystacksize - 1 <= yyssp)
    {
      /* Get the current used size of the three stacks, in elements.  */
      YYSIZE_T yysize = yyssp - yyss + 1;

#ifdef yyoverflow
      {
        /* Give user a chance to reallocate the stack.  Use copies of
           these so that the &'s don't force the real ones into
           memory.  */
        YYSTYPE *yyvs1 = yyvs;
        yytype_int16 *yyss1 = yyss;

        /* Each stack pointer address is followed by the size of the
           data in use in that stack, in bytes.  This used to be a
           conditional around just the two extra args, but that might
           be undefined if yyoverflow is a macro.  */
        yyoverflow (YY_("memory exhausted"),
                    &yyss1, yysize * sizeof (*yyssp),
                    &yyvs1, yysize * sizeof (*yyvsp),
                    &yystacksize);

        yyss = yyss1;
        yyvs = yyvs1;
      }
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
      goto yyexhaustedlab;
# else
      /* Extend the stack our own way.  */
      if (YYMAXDEPTH <= yystacksize)
        goto yyexhaustedlab;
      yystacksize *= 2;
      if (YYMAXDEPTH < yystacksize)
        yystacksize = YYMAXDEPTH;

      {
        yytype_int16 *yyss1 = yyss;
        union yyalloc *yyptr =
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
        if (! yyptr)
          goto yyexhaustedlab;
        YYSTACK_RELOCATE (yyss_alloc, yyss);
        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
#  undef YYSTACK_RELOCATE
        if (yyss1 != yyssa)
          YYSTACK_FREE (yyss1);
      }
# endif
#endif /* no yyoverflow */

      yyssp = yyss + yysize - 1;
      yyvsp = yyvs + yysize - 1;

      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
                  (unsigned long int) yystacksize));

      if (yyss + yystacksize - 1 <= yyssp)
        YYABORT;
    }

  YYDPRINTF ((stderr, "Entering state %d\n", yystate));

  if (yystate == YYFINAL)
    YYACCEPT;

  goto yybackup;

/*-----------.
| yybackup.  |
`-----------*/
yybackup:

  /* Do appropriate processing given the current state.  Read a
     lookahead token if we need one and don't already have one.  */

  /* First try to decide what to do without reference to lookahead token.  */
  yyn = yypact[yystate];
  if (yyn == YYPACT_NINF)
    goto yydefault;

  /* Not known => get a lookahead token if don't already have one.  */

  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
  if (yychar == YYEMPTY)
    {
      YYDPRINTF ((stderr, "Reading a token: "));
      yychar = YYLEX;
    }

  if (yychar <= YYEOF)
    {
      yychar = yytoken = YYEOF;
      YYDPRINTF ((stderr, "Now at end of input.\n"));
    }
  else
    {
      yytoken = YYTRANSLATE (yychar);
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
    }

  /* If the proper action on seeing token YYTOKEN is to reduce or to
     detect an error, take that action.  */
  yyn += yytoken;
  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
    goto yydefault;
  yyn = yytable[yyn];
  if (yyn <= 0)
    {
      if (yyn == 0 || yyn == YYTABLE_NINF)
        goto yyerrlab;
      yyn = -yyn;
      goto yyreduce;
    }

  /* Count tokens shifted since error; after three, turn off error
     status.  */
  if (yyerrstatus)
    yyerrstatus--;

  /* Shift the lookahead token.  */
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);

  /* Discard the shifted token.  */
  yychar = YYEMPTY;

  yystate = yyn;
  *++yyvsp = yylval;

  goto yynewstate;


/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state.  |
`-----------------------------------------------------------*/
yydefault:
  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;
  goto yyreduce;


/*-----------------------------.
| yyreduce -- Do a reduction.  |
`-----------------------------*/
yyreduce:
  /* yyn is the number of a rule to reduce with.  */
  yylen = yyr2[yyn];

  /* If YYLEN is nonzero, implement the default value of the action:
     `$$ = $1'.

     Otherwise, the following line sets YYVAL to garbage.
     This behavior is undocumented and Bison
     users should not rely upon it.  Assigning to YYVAL
     unconditionally makes the parser a bit smaller, and it avoids a
     GCC warning that YYVAL may be used uninitialized.  */
  yyval = yyvsp[1-yylen];


  YY_REDUCE_PRINT (yyn);
  switch (yyn)
    {
        case 2:

    { g_resultValue = (yyvsp[(1) - (1)]); return 0; ;}
    break;

  case 3:

    { (yyval) = (yyvsp[(1) - (1)]); ;}
    break;

  case 4:

    {
                       bool c = ((yyvsp[(1) - (5)]).isInt() ? ((long)(yyvsp[(1) - (5)]) != 0) : ((double)(yyvsp[(1) - (5)]) != 0.0));
                       (yyval) = c ? (yyvsp[(3) - (5)]) : (yyvsp[(5) - (5)]);
                     ;}
    break;

  case 5:

    { (yyval) = (yyvsp[(1) - (1)]); ;}
    break;

  case 6:

    {
                         (yyval) = CPPValue( (long)((long)(yyvsp[(1) - (3)]) || (long)(yyvsp[(3) - (3)])) );
                       ;}
    break;

  case 7:

    { (yyval) = (yyvsp[(1) - (1)]); ;}
    break;

  case 8:

    {
                          (yyval) = CPPValue( (long)((long)(yyvsp[(1) - (3)]) && (long)(yyvsp[(3) - (3)])) );
                        ;}
    break;

  case 9:

    { (yyval) = (yyvsp[(1) - (1)]); ;}
    break;

  case 10:

    { 
                           (yyval) = CPPValue( (long)(yyvsp[(1) - (3)]) | (long)(yyvsp[(3) - (3)]) );
                         ;}
    break;

  case 11:

    { (yyval) = (yyvsp[(1) - (1)]); ;}
    break;

  case 12:

    {
                           (yyval) = CPPValue( (long)(yyvsp[(1) - (3)]) ^ (long)(yyvsp[(3) - (3)]) );
                         ;}
    break;

  case 13:

    { (yyval) = (yyvsp[(1) - (1)]); ;}
    break;

  case 14:

    { 
                  (yyval) = CPPValue( (long)(yyvsp[(1) - (3)]) & (long)(yyvsp[(3) - (3)]) );
                ;}
    break;

  case 15:

    { (yyval) = (yyvsp[(1) - (1)]); ;}
    break;

  case 16:

    { 
                       (yyval) = CPPValue( (long)((double)(yyvsp[(1) - (3)]) == (double)(yyvsp[(3) - (3)])) );
                     ;}
    break;

  case 17:

    {
                       (yyval) = CPPValue( (long)((double)(yyvsp[(1) - (3)]) != (double)(yyvsp[(3) - (3)])) );
                     ;}
    break;

  case 18:

    { (yyval) = (yyvsp[(1) - (1)]); ;}
    break;

  case 19:

    { 
                         (yyval) = CPPValue( (long)((double)(yyvsp[(1) - (3)]) < (double)(yyvsp[(3) - (3)])) );
                       ;}
    break;

  case 20:

    {
                         (yyval) = CPPValue( (long)((double)(yyvsp[(1) - (3)]) > (double)(yyvsp[(3) - (3)])) );
                       ;}
    break;

  case 21:

    {
                         (yyval) = CPPValue( (long)((double)(yyvsp[(1) - (3)]) <= (double)(yyvsp[(3) - (3)])) );
                       ;}
    break;

  case 22:

    {
                         (yyval) = CPPValue( (long)((double)(yyvsp[(1) - (3)]) >= (double)(yyvsp[(3) - (3)])) );
                       ;}
    break;

  case 23:

    { (yyval) = (yyvsp[(1) - (1)]); ;}
    break;

  case 24:

    {
                    (yyval) = CPPValue( (long)(yyvsp[(1) - (3)]) << (long)(yyvsp[(3) - (3)]) ); 
                  ;}
    break;

  case 25:

    {
                    (yyval) = CPPValue( (long)(yyvsp[(1) - (3)]) >> (long)(yyvsp[(3) - (3)]) );
                  ;}
    break;

  case 26:

    { (yyval) = (yyvsp[(1) - (1)]); ;}
    break;

  case 27:

    {
                       if (!(yyvsp[(1) - (3)]).isInt() || !(yyvsp[(3) - (3)]).isInt())
                       {
                         (yyval) = CPPValue( (double)(yyvsp[(1) - (3)]) + (double)(yyvsp[(3) - (3)]) );
                       }
                       else     
                       {
                         (yyval) = CPPValue( (long)(yyvsp[(1) - (3)]) + (long)(yyvsp[(3) - (3)]) );
                       }
                     ;}
    break;

  case 28:

    {
                       if (!(yyvsp[(1) - (3)]).isInt() || !(yyvsp[(3) - (3)]).isInt())
                       {
                         (yyval) = CPPValue( (double)(yyvsp[(1) - (3)]) - (double)(yyvsp[(3) - (3)]) );
                       }
                       else     
                       {
                         (yyval) = CPPValue( (long)(yyvsp[(1) - (3)]) - (long)(yyvsp[(3) - (3)]) );
                       }
                     ;}
    break;

  case 29:

    { (yyval) = (yyvsp[(1) - (1)]); ;}
    break;

  case 30:

    { 
                             if (!(yyvsp[(1) - (3)]).isInt() || !(yyvsp[(3) - (3)]).isInt())
                             {
                               (yyval) = CPPValue( (double)(yyvsp[(1) - (3)]) * (double)(yyvsp[(3) - (3)]) );
                             }
                             else
                             {
                               (yyval) = CPPValue( (long)(yyvsp[(1) - (3)]) * (long)(yyvsp[(3) - (3)]) );
                             }
                           ;}
    break;

  case 31:

    { 
                             if (!(yyvsp[(1) - (3)]).isInt() || !(yyvsp[(3) - (3)]).isInt())
                             {
                               (yyval) = CPPValue( (double)(yyvsp[(1) - (3)]) / (double)(yyvsp[(3) - (3)]) );
                             }
                             else
                             {
                               long value = (yyvsp[(3) - (3)]);
                               if (value==0) value=1;
                               (yyval) = CPPValue( (long)(yyvsp[(1) - (3)]) / value );
                             }
                           ;}
    break;

  case 32:

    { 
                             long value = (yyvsp[(3) - (3)]);
                             if (value==0) value=1;
                             (yyval) = CPPValue( (long)(yyvsp[(1) - (3)]) % value );
                           ;}
    break;

  case 33:

    { (yyval) = (yyvsp[(1) - (1)]); ;}
    break;

  case 34:

    { (yyval) = (yyvsp[(1) - (2)]); ;}
    break;

  case 35:

    { 
                    if ((yyvsp[(2) - (2)]).isInt()) 
                      (yyval) = CPPValue(-(long)(yyvsp[(2) - (2)]));
                    else
                      (yyval) = CPPValue(-(double)(yyvsp[(2) - (2)]));
                  ;}
    break;

  case 36:

    {
                    (yyval) = CPPValue(~(long)(yyvsp[(2) - (2)]));
                  ;}
    break;

  case 37:

    {
                    (yyval) = CPPValue((long)!(long)(yyvsp[(2) - (2)]));
                  ;}
    break;

  case 38:

    { (yyval) = (yyvsp[(1) - (1)]); ;}
    break;

  case 39:

    { (yyval) = (yyvsp[(2) - (3)]); ;}
    break;

  case 40:

    { (yyval) = parseOctal(); ;}
    break;

  case 41:

    { (yyval) = parseDecimal(); ;}
    break;

  case 42:

    { (yyval) = parseHexadecimal(); ;}
    break;

  case 43:

    { (yyval) = parseCharacter(); ;}
    break;

  case 44:

    { (yyval) = parseFloat(); ;}
    break;



      default: break;
    }
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);

  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);

  *++yyvsp = yyval;

  /* Now `shift' the result of the reduction.  Determine what state
     that goes to, based on the state we popped back to and the rule
     number reduced by.  */

  yyn = yyr1[yyn];

  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    yystate = yytable[yystate];
  else
    yystate = yydefgoto[yyn - YYNTOKENS];

  goto yynewstate;


/*------------------------------------.
| yyerrlab -- here on detecting error |
`------------------------------------*/
yyerrlab:
  /* If not already recovering from an error, report this error.  */
  if (!yyerrstatus)
    {
      ++yynerrs;
#if ! YYERROR_VERBOSE
      yyerror (YY_("syntax error"));
#else
      {
        YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
        if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
          {
            YYSIZE_T yyalloc = 2 * yysize;
            if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
              yyalloc = YYSTACK_ALLOC_MAXIMUM;
            if (yymsg != yymsgbuf)
              YYSTACK_FREE (yymsg);
            yymsg = (char *) YYSTACK_ALLOC (yyalloc);
            if (yymsg)
              yymsg_alloc = yyalloc;
            else
              {
                yymsg = yymsgbuf;
                yymsg_alloc = sizeof yymsgbuf;
              }
          }

        if (0 < yysize && yysize <= yymsg_alloc)
          {
            (void) yysyntax_error (yymsg, yystate, yychar);
            yyerror (yymsg);
          }
        else
          {
            yyerror (YY_("syntax error"));
            if (yysize != 0)
              goto yyexhaustedlab;
          }
      }
#endif
    }



  if (yyerrstatus == 3)
    {
      /* If just tried and failed to reuse lookahead token after an
         error, discard it.  */

      if (yychar <= YYEOF)
        {
          /* Return failure if at end of input.  */
          if (yychar == YYEOF)
            YYABORT;
        }
      else
        {
          yydestruct ("Error: discarding",
                      yytoken, &yylval);
          yychar = YYEMPTY;
        }
    }

  /* Else will try to reuse lookahead token after shifting the error
     token.  */
  goto yyerrlab1;


/*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR.  |
`---------------------------------------------------*/
yyerrorlab:

  /* Pacify compilers like GCC when the user code never invokes
     YYERROR and the label yyerrorlab therefore never appears in user
     code.  */
  if (/*CONSTCOND*/ 0)
     goto yyerrorlab;

  /* Do not reclaim the symbols of the rule which action triggered
     this YYERROR.  */
  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);
  yystate = *yyssp;
  goto yyerrlab1;


/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR.  |
`-------------------------------------------------------------*/
yyerrlab1:
  yyerrstatus = 3;      /* Each real token shifted decrements this.  */

  for (;;)
    {
      yyn = yypact[yystate];
      if (yyn != YYPACT_NINF)
        {
          yyn += YYTERROR;
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
            {
              yyn = yytable[yyn];
              if (0 < yyn)
                break;
            }
        }

      /* Pop the current state because it cannot handle the error token.  */
      if (yyssp == yyss)
        YYABORT;


      yydestruct ("Error: popping",
                  yystos[yystate], yyvsp);
      YYPOPSTACK (1);
      yystate = *yyssp;
      YY_STACK_PRINT (yyss, yyssp);
    }

  *++yyvsp = yylval;


  /* Shift the error token.  */
  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);

  yystate = yyn;
  goto yynewstate;


/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here.  |
`-------------------------------------*/
yyacceptlab:
  yyresult = 0;
  goto yyreturn;

/*-----------------------------------.
| yyabortlab -- YYABORT comes here.  |
`-----------------------------------*/
yyabortlab:
  yyresult = 1;
  goto yyreturn;

#if !defined(yyoverflow) || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here.  |
`-------------------------------------------------*/
yyexhaustedlab:
  yyerror (YY_("memory exhausted"));
  yyresult = 2;
  /* Fall through.  */
#endif

yyreturn:
  if (yychar != YYEMPTY)
     yydestruct ("Cleanup: discarding lookahead",
                 yytoken, &yylval);
  /* Do not reclaim the symbols of the rule which action triggered
     this YYABORT or YYACCEPT.  */
  YYPOPSTACK (yylen);
  YY_STACK_PRINT (yyss, yyssp);
  while (yyssp != yyss)
    {
      yydestruct ("Cleanup: popping",
                  yystos[*yyssp], yyvsp);
      YYPOPSTACK (1);
    }
#ifndef yyoverflow
  if (yyss != yyssa)
    YYSTACK_FREE (yyss);
#endif
#if YYERROR_VERBOSE
  if (yymsg != yymsgbuf)
    YYSTACK_FREE (yymsg);
#endif
  /* Make sure YYID is used.  */
  return YYID (yyresult);
}

Variable Documentation

int yychar

Definition at line 1152 of file ce_parse.c.

const yytype_int8 yycheck[]

static

Initial value:

=
{
       1,     2,     3,     4,    32,    18,    19,     3,     7,     5,
      23,    24,    25,     0,    27,    28,    29,    30,    31,    12,
      13,    14,    15,    40,    41,    42,    43,     8,    20,    21,
      22,    10,    11,    16,    17,     6,    18,    19,     4,     5,
      38,    39,     9,    71,    44,    45,    26,    48,    49,    50,
       5,    46,    47,     5,    -1,    33,    -1,    34,    -1,    35,
      -1,    36,    -1,    37
}

Definition at line 596 of file ce_parse.c.

const yytype_uint8 yydefact[]

static

Initial value:

=
{
       0,     0,     0,     0,     0,     0,    40,    41,    42,    43,
      44,     0,     2,     3,     5,     7,     9,    11,    13,    15,
      18,    23,    26,    29,    33,    38,    34,    35,    36,    37,
       0,     1,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,    39,     0,     6,     8,    10,    12,    14,    17,    16,
      19,    20,    21,    22,    24,    25,    27,    28,    30,    31,
      32,     0,     4
}

Definition at line 539 of file ce_parse.c.

const yytype_int8 yydefgoto[]

static

Initial value:

=
{
      -1,    11,    12,    13,    14,    15,    16,    17,    18,    19,
      20,    21,    22,    23,    24,    25
}

Definition at line 552 of file ce_parse.c.

YYSTYPE yylval

Definition at line 1155 of file ce_parse.c.

int yynerrs

Definition at line 1158 of file ce_parse.c.

const yytype_int8 yypact[]

static

Initial value:

=
{
     -13,   -13,   -13,   -13,   -13,   -13,   -29,   -29,   -29,   -29,
     -29,    13,   -29,     4,    29,     1,    19,    33,    21,     7,
      17,    18,     8,   -29,   -29,   -29,   -29,   -29,   -29,   -29,
      20,   -29,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
     -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
     -13,   -29,    34,    29,     1,    19,    33,    21,     7,     7,
      17,    17,    17,    17,    18,    18,     8,     8,   -29,   -29,
     -29,   -13,    45
}

Definition at line 561 of file ce_parse.c.

const yytype_int8 yypgoto[]

static

Initial value:

=
{
     -29,   -29,    48,   -28,    22,    23,    24,    25,    26,     2,
     -17,     0,     5,    -1,   -29,   -29
}

Definition at line 574 of file ce_parse.c.

const yytype_uint8 yyr1[]

static

Initial value:

=
{
       0,    32,    33,    34,    34,    35,    35,    36,    36,    37,
      37,    38,    38,    39,    39,    40,    40,    40,    41,    41,
      41,    41,    41,    42,    42,    42,    43,    43,    43,    44,
      44,    44,    44,    45,    45,    45,    45,    45,    46,    46,
      47,    47,    47,    47,    47
}

Definition at line 517 of file ce_parse.c.

const yytype_uint8 yyr2[]

static

Initial value:

=
{
       0,     2,     1,     1,     5,     1,     3,     1,     3,     1,
       3,     1,     3,     1,     3,     1,     3,     3,     1,     3,
       3,     3,     3,     1,     3,     3,     1,     3,     3,     1,
       3,     3,     3,     1,     2,     2,     2,     2,     1,     3,
       1,     1,     1,     1,     1
}

Definition at line 527 of file ce_parse.c.

const yytype_uint8 yystos[]

static

Initial value:

=
{
       0,    18,    19,    23,    24,    25,    27,    28,    29,    30,
      31,    33,    34,    35,    36,    37,    38,    39,    40,    41,
      42,    43,    44,    45,    46,    47,    45,    45,    45,    45,
      34,     0,     3,     5,     6,     7,     8,     9,    10,    11,
      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
      22,    26,    35,    36,    37,    38,    39,    40,    41,    41,
      42,    42,    42,    42,    43,    43,    44,    44,    45,    45,
      45,     4,    35
}

Definition at line 609 of file ce_parse.c.

const yytype_uint8 yytable[]

static

Initial value:

=
{
      26,    27,    28,    29,    52,     1,     2,    32,    35,    33,
       3,     4,     5,    31,     6,     7,     8,     9,    10,    40,
      41,    42,    43,    60,    61,    62,    63,    36,    48,    49,
      50,    38,    39,    44,    45,    34,    46,    47,    71,    33,
      58,    59,    37,    72,    64,    65,    51,    68,    69,    70,
      33,    66,    67,    30,     0,    53,     0,    54,     0,    55,
       0,    56,     0,    57
}

Definition at line 585 of file ce_parse.c.

const yytype_uint8 yytranslate[]

static

Definition at line 408 of file ce_parse.c.