CalcGrammar.cpp File Reference

Go to the source code of this file.

Classes
struct	YYLTYPE
union	yyalloc
Typedefs
typedef int	YYSTYPE
typedef YYTYPE_UINT8	yytype_uint8
typedef unsigned char	yytype_uint8
typedef YYTYPE_INT8	yytype_int8
typedef signed char	yytype_int8
typedef short int	yytype_int8
typedef YYTYPE_UINT16	yytype_uint16
typedef unsigned short int	yytype_uint16
typedef YYTYPE_INT16	yytype_int16
typedef short int	yytype_int16
Enumerations
enum	yytokentype {   UNSIGNED_INTEGER = 258, NEGATIVE_INTEGER = 259, REAL = 260, STRING = 261,   UNKNOWN_TOKEN = 262, COMMA = 263, TERM = 264, CODE_START = 265,   LPAREN = 266, RPAREN = 267, WS = 268, AT = 269,   REG_LOCAL = 270, REG_STATUS = 271, REG_LITERAL = 272, REG_INPUT = 273,   REG_OUTPUT = 274, VALUES = 275, TYPE_FIXED = 276, TYPE_VARIABLE = 277,   OPCODE = 278, NAME = 279, UNSIGNED_INTEGER = 258, NEGATIVE_INTEGER = 259,   REAL = 260, STRING = 261, UNKNOWN_TOKEN = 262, COMMA = 263,   TERM = 264, CODE_START = 265, LPAREN = 266, RPAREN = 267,   WS = 268, AT = 269, REG_LOCAL = 270, REG_STATUS = 271,   REG_LITERAL = 272, REG_INPUT = 273, REG_OUTPUT = 274, VALUES = 275,   TYPE_FIXED = 276, TYPE_VARIABLE = 277, OPCODE = 278, NAME = 279,   UNSIGNED_INTEGER = 258, NEGATIVE_INTEGER = 259, REAL = 260, STRING = 261,   UNKNOWN_TOKEN = 262, COMMA = 263, TERM = 264, CODE_START = 265,   LPAREN = 266, RPAREN = 267, WS = 268, AT = 269,   REG_LOCAL = 270, REG_STATUS = 271, REG_LITERAL = 272, REG_INPUT = 273,   REG_OUTPUT = 274, VALUES = 275, TYPE_FIXED = 276, TYPE_VARIABLE = 277,   OPCODE = 278, NAME = 279, UNSIGNED_INTEGER = 258, NEGATIVE_INTEGER = 259,   REAL = 260, STRING = 261, UNKNOWN_TOKEN = 262, COMMA = 263,   TERM = 264, CODE_START = 265, LPAREN = 266, RPAREN = 267,   WS = 268, AT = 269, REG_LOCAL = 270, REG_STATUS = 271,   REG_LITERAL = 272, REG_INPUT = 273, REG_OUTPUT = 274, VALUES = 275,   TYPE_FIXED = 276, TYPE_VARIABLE = 277, OPCODE = 278, NAME = 279,   UNSIGNED_INTEGER = 258, NEGATIVE_INTEGER = 259, REAL = 260, STRING = 261,   UNKNOWN_TOKEN = 262, COMMA = 263, TERM = 264, CODE_START = 265,   LPAREN = 266, RPAREN = 267, WS = 268, AT = 269,   REG_LOCAL = 270, REG_STATUS = 271, REG_LITERAL = 272, REG_INPUT = 273,   REG_OUTPUT = 274, VALUES = 275, TYPE_FIXED = 276, TYPE_VARIABLE = 277,   OPCODE = 278, NAME = 279, UNSIGNED_INTEGER = 258, NEGATIVE_INTEGER = 259,   REAL = 260, STRING = 261, UNKNOWN_TOKEN = 262, COMMA = 263,   TERM = 264, CODE_START = 265, LPAREN = 266, RPAREN = 267,   WS = 268, AT = 269, REG_LOCAL = 270, REG_STATUS = 271,   REG_LITERAL = 272, REG_INPUT = 273, REG_OUTPUT = 274, VALUES = 275,   TYPE_FIXED = 276, TYPE_VARIABLE = 277, OPCODE = 278, NAME = 279 }
Functions
	FENNEL_BEGIN_CPPFILE ("$Id: //open/dev/fennel/calculator/CalcGrammar.ypp#2 $")
int	CalcYYlex (YYSTYPE *, YYLTYPE *, void *)
void	CalcYYerror (const char *)
static int	YYID (int i) static int YYID(i) int i
void	free (void *)
static void	yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, YYLTYPE const *const yylocationp) static void yy_symbol_value_print(yyoutput
static YYSIZE_T	yystrlen (const char *yystr) static YYSIZE_T yystrlen(yystr) const char *yystr
int	yyparse ()
int	yyparse (void *YYPARSE_PARAM) int yyparse(YYPARSE_PARAM) void *YYPARSE_PARAM
	FENNEL_END_CPPFILE ("$Id: //open/dev/fennel/calculator/CalcGrammar.ypp#2 $")
Variables
static const yytype_uint8	yytranslate []
static const yytype_uint8	yyprhs []
static const yytype_int8	yyrhs []
static const yytype_uint8	yyrline []
static const char *const	yytname []
static const yytype_uint16	yytoknum []
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_int8	yytable []
static const yytype_int8	yycheck []
static const yytype_uint8	yystos []
static void	yytype
static void	yyvaluep
static void yylocationp FILE *	yyoutput
int	yytype
YYSTYPE const *const	yyvaluep
YYLTYPE const *const	yylocationp
int	yytype
YYSTYPE const *const	yyvaluep
YYLTYPE const *const	yylocationp
yytype_int16 *	top
YYLTYPE *	yylsp
int	yyrule
const char *	yysrc
int	yytype
YYSTYPE *	yyvaluep
YYLTYPE *	yylocationp

---

Typedef Documentation

typedef int YYSTYPE

Definition at line 178 of file CalcGrammar.cpp.

typedef short int yytype_int16

Definition at line 232 of file CalcGrammar.cpp.

typedef YYTYPE_INT16 yytype_int16

Definition at line 230 of file CalcGrammar.cpp.

typedef short int yytype_int8

Definition at line 220 of file CalcGrammar.cpp.

typedef signed char yytype_int8

Definition at line 218 of file CalcGrammar.cpp.

typedef YYTYPE_INT8 yytype_int8

Definition at line 215 of file CalcGrammar.cpp.

typedef unsigned short int yytype_uint16

Definition at line 226 of file CalcGrammar.cpp.

typedef YYTYPE_UINT16 yytype_uint16

Definition at line 224 of file CalcGrammar.cpp.

typedef unsigned char yytype_uint8

Definition at line 211 of file CalcGrammar.cpp.

typedef YYTYPE_UINT8 yytype_uint8

Definition at line 209 of file CalcGrammar.cpp.

---

Enumeration Type Documentation

enum yytokentype

Enumerator:

UNSIGNED_INTEGER
NEGATIVE_INTEGER
REAL
STRING
UNKNOWN_TOKEN
COMMA
TERM
CODE_START
LPAREN
RPAREN
WS
AT
REG_LOCAL
REG_STATUS
REG_LITERAL
REG_INPUT
REG_OUTPUT
VALUES
TYPE_FIXED
TYPE_VARIABLE
OPCODE
NAME
UNSIGNED_INTEGER
NEGATIVE_INTEGER
REAL
STRING
UNKNOWN_TOKEN
COMMA
TERM
CODE_START
LPAREN
RPAREN
WS
AT
REG_LOCAL
REG_STATUS
REG_LITERAL
REG_INPUT
REG_OUTPUT
VALUES
TYPE_FIXED
TYPE_VARIABLE
OPCODE
NAME
UNSIGNED_INTEGER
NEGATIVE_INTEGER
REAL
STRING
UNKNOWN_TOKEN
COMMA
TERM
CODE_START
LPAREN
RPAREN
WS
AT
REG_LOCAL
REG_STATUS
REG_LITERAL
REG_INPUT
REG_OUTPUT
VALUES
TYPE_FIXED
TYPE_VARIABLE
OPCODE
NAME
UNSIGNED_INTEGER
NEGATIVE_INTEGER
REAL
STRING
UNKNOWN_TOKEN
COMMA
TERM
CODE_START
LPAREN
RPAREN
WS
AT
REG_LOCAL
REG_STATUS
REG_LITERAL
REG_INPUT
REG_OUTPUT
VALUES
TYPE_FIXED
TYPE_VARIABLE
OPCODE
NAME
UNSIGNED_INTEGER
NEGATIVE_INTEGER
REAL
STRING
UNKNOWN_TOKEN
COMMA
TERM
CODE_START
LPAREN
RPAREN
WS
AT
REG_LOCAL
REG_STATUS
REG_LITERAL
REG_INPUT
REG_OUTPUT
VALUES
TYPE_FIXED
TYPE_VARIABLE
OPCODE
NAME
UNSIGNED_INTEGER
NEGATIVE_INTEGER
REAL
STRING
UNKNOWN_TOKEN
COMMA
TERM
CODE_START
LPAREN
RPAREN
WS
AT
REG_LOCAL
REG_STATUS
REG_LITERAL
REG_INPUT
REG_OUTPUT
VALUES
TYPE_FIXED
TYPE_VARIABLE
OPCODE
NAME

Definition at line 76 of file CalcGrammar.cpp.

                    {
     UNSIGNED_INTEGER = 258,
     NEGATIVE_INTEGER = 259,
     REAL = 260,
     STRING = 261,
     UNKNOWN_TOKEN = 262,
     COMMA = 263,
     TERM = 264,
     CODE_START = 265,
     LPAREN = 266,
     RPAREN = 267,
     WS = 268,
     AT = 269,
     REG_LOCAL = 270,
     REG_STATUS = 271,
     REG_LITERAL = 272,
     REG_INPUT = 273,
     REG_OUTPUT = 274,
     VALUES = 275,
     TYPE_FIXED = 276,
     TYPE_VARIABLE = 277,
     OPCODE = 278,
     NAME = 279
   };

---

Function Documentation

void CalcYYerror

(

const char *

)

Definition at line 1912 of file CalcGrammar.cpp.

{
    throw CalcAssemblerException(s);
}

int CalcYYlex	(	YYSTYPE *	,
		YYLTYPE *	,
		void *
	)

Definition at line 1895 of file CalcGrammar.cpp.

References CalcAssembler::getLexer(), CalcLexer::getLocation(), CalcLexer::getValue(), and CalcLexer::yylex().

{
    /* Check that we are being passed valid input */
    assert(lvalp);
    assert(llocp);
    assert(parm);

    CalcAssembler* pAssembler = (CalcAssembler*) parm;
    CalcLexer& lexer = pAssembler->getLexer();

    int token = lexer.yylex();
    *lvalp = lexer.getValue();
    *llocp = lexer.getLocation();

    return token;
}

FENNEL_BEGIN_CPPFILE

(

"$Id: //open/dev/fennel/calculator/CalcGrammar.ypp#2 $"

)

FENNEL_END_CPPFILE

(

"$Id: //open/dev/fennel/calculator/CalcGrammar.ypp#2 $"

)

void free

(

void *

)

Referenced by CalcYYfree(), VMAllocator::deallocate(), operator delete[](), FlatFileBuffer::read(), and Backtrace::writeDemangled().

static void yy_symbol_value_print	(	FILE *	yyoutput,
		int	yytype,
		YYSTYPE const *const	yyvaluep,
		YYLTYPE const *const	yylocationp
	)			[static]

static int YYID

(

int

i

)

[static]

Referenced by yyparse().

int yyparse

(

void *

YYPARSE_PARAM

)

int yyparse

(

)

Definition at line 1227 of file CalcGrammar.cpp.

References YYLTYPE::first_column, YYLTYPE::first_line, YYLTYPE::last_column, YYLTYPE::last_line, YYID(), yyalloc::yyls, and yylsp.

{
  /* The look-ahead symbol.  */
int yychar;

/* The semantic value of the look-ahead symbol.  */
YYSTYPE yylval;

/* Number of syntax errors so far.  */
int yynerrs;
/* Location data for the look-ahead symbol.  */
YYLTYPE yylloc;

  int yystate;
  int yyn;
  int yyresult;
  /* Number of tokens to shift before error messages enabled.  */
  int yyerrstatus;
  /* Look-ahead token as an internal (translated) token number.  */
  int yytoken = 0;
#if YYERROR_VERBOSE
  /* Buffer for error messages, and its allocated size.  */
  char yymsgbuf[128];
  char *yymsg = yymsgbuf;
  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif

  /* Three stacks and their tools:
     `yyss': related to states,
     `yyvs': related to semantic values,
     `yyls': related to locations.

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

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

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

  /* The location stack.  */
  YYLTYPE yylsa[YYINITDEPTH];
  YYLTYPE *yyls = yylsa;
  YYLTYPE *yylsp;
  /* The locations where the error started and ended.  */
  YYLTYPE yyerror_range[2];

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

  YYSIZE_T yystacksize = YYINITDEPTH;

  /* The variables used to return semantic value and location from the
     action routines.  */
  YYSTYPE yyval;
  YYLTYPE yyloc;

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

  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;
  yylsp = yyls;
#if YYLTYPE_IS_TRIVIAL
  /* Initialize the default location before parsing starts.  */
  yylloc.first_line   = yylloc.last_line   = 1;
  yylloc.first_column = yylloc.last_column = 0;
#endif

  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;
    YYLTYPE *yyls1 = yyls;

    /* 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),
            &yyls1, yysize * sizeof (*yylsp),
            &yystacksize);
    yyls = yyls1;
    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);
    YYSTACK_RELOCATE (yyvs);
    YYSTACK_RELOCATE (yyls);
#  undef YYSTACK_RELOCATE
    if (yyss1 != yyssa)
      YYSTACK_FREE (yyss1);
      }
# endif
#endif /* no yyoverflow */

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

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

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

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

  goto yybackup;

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

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

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

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

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

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

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

  if (yyn == YYFINAL)
    YYACCEPT;

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

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

  /* Discard the shifted token unless it is eof.  */
  if (yychar != YYEOF)
    yychar = YYEMPTY;

  yystate = yyn;
  *++yyvsp = yylval;
  *++yylsp = yylloc;
  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];

  /* Default location.  */
  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
  YY_REDUCE_PRINT (yyn);
  switch (yyn)
    {
        case 2:
#line 107 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->init(); ;}
    break;

  case 3:
#line 109 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->bindRegisters(); ;}
    break;

  case 8:
#line 120 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->selectRegisterSet((yyvsp[(1) - (1)].u.v_regset)); ;}
    break;

  case 10:
#line 124 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->allocateTuples(); ;}
    break;

  case 11:
#line 125 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->allocateTuples(); ;}
    break;

  case 13:
#line 128 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->selectRegisterSet((yyvsp[(1) - (1)].u.v_regset)); ;}
    break;

  case 15:
#line 132 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->bindLiteralDone(); ;}
    break;

  case 19:
#line 138 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->bindNextLiteral<uint64_t>((yyvsp[(1) - (1)].u.v_uint64)); ;}
    break;

  case 20:
#line 139 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->bindNextLiteral<int64_t>((yyvsp[(1) - (1)].u.v_int64));  ;}
    break;

  case 21:
#line 140 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->bindNextLiteral<double>((yyvsp[(1) - (1)].u.v_double));   ;}
    break;

  case 22:
#line 141 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->bindNextLiteral<string>((yyvsp[(1) - (1)].v_string));   ;}
    break;

  case 23:
#line 142 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->bindNextLiteral<PConstBuffer>(NULL); ;}
    break;

  case 28:
#line 148 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->addRegister((yyvsp[(1) - (1)].u.v_type)); ;}
    break;

  case 29:
#line 150 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->addRegister((yyvsp[(1) - (3)].u.v_type), (yyvsp[(3) - (3)].u.v_uint64)); ;}
    break;

  case 33:
#line 160 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->addInstruction((yyvsp[(1) - (1)].u.p_inst)); ;}
    break;

  case 34:
#line 162 "CalcGrammar.ypp"
    { ((CalcAssembler*) parm)->addInstruction((yyvsp[(2) - (2)].u.p_inst)); ;}
    break;

  case 35:
#line 166 "CalcGrammar.ypp"
    {
              (yyval.u.p_inst) = ((CalcAssembler*) parm)->createInstruction((yyvsp[(1) - (7)].v_opcode), (yyvsp[(2) - (7)].u.p_regref), (yyvsp[(4) - (7)].u.p_regref), (yyvsp[(6) - (7)].u.p_regref), (yyloc));
            ;}
    break;

  case 36:
#line 171 "CalcGrammar.ypp"
    {
              (yyval.u.p_inst) = ((CalcAssembler*) parm)->createInstruction((yyvsp[(1) - (5)].v_opcode), (yyvsp[(2) - (5)].u.p_regref), (yyvsp[(4) - (5)].u.p_regref), (yyloc));
            ;}
    break;

  case 37:
#line 176 "CalcGrammar.ypp"
    {
              (yyval.u.p_inst) = ((CalcAssembler*) parm)->createInstruction((yyvsp[(1) - (3)].v_opcode), (yyvsp[(2) - (3)].u.p_regref), (yyloc));
            ;}
    break;

  case 38:
#line 181 "CalcGrammar.ypp"
    {
              (yyval.u.p_inst) = ((CalcAssembler*) parm)->createInstruction((yyvsp[(1) - (3)].v_opcode), (yyvsp[(2) - (3)].u.v_pc), (yyloc));
            ;}
    break;

  case 39:
#line 186 "CalcGrammar.ypp"
    {
              (yyval.u.p_inst) = ((CalcAssembler*) parm)->createInstruction((yyvsp[(1) - (5)].v_opcode), (yyvsp[(2) - (5)].u.v_pc), (yyvsp[(4) - (5)].u.p_regref), (yyloc));
            ;}
    break;

  case 40:
#line 191 "CalcGrammar.ypp"
    {
              (yyval.u.p_inst) = ((CalcAssembler*) parm)->createInstruction((yyvsp[(1) - (6)].v_opcode), (yyvsp[(2) - (6)].v_string), (yyvsp[(4) - (6)].v_register_list), (yyloc));
            ;}
    break;

  case 41:
#line 196 "CalcGrammar.ypp"
    {
              (yyval.u.p_inst) = ((CalcAssembler*) parm)->createInstruction((yyvsp[(1) - (2)].v_opcode), (yyloc));
            ;}
    break;

  case 43:
#line 204 "CalcGrammar.ypp"
    { (yyval.u.v_pc) = (yyvsp[(2) - (2)].u.v_uint64); ((CalcAssembler*) parm)->saveMaxPC((yyval.u.v_pc)); ;}
    break;

  case 52:
#line 213 "CalcGrammar.ypp"
    { (yyval.v_register_list).push_back((yyvsp[(1) - (1)].u.p_regref)); ;}
    break;

  case 53:
#line 214 "CalcGrammar.ypp"
    { (yyval.v_register_list) = (yyvsp[(1) - (3)].v_register_list); (yyval.v_register_list).push_back((yyvsp[(3) - (3)].u.p_regref)); ;}
    break;

  case 54:
#line 217 "CalcGrammar.ypp"
    { (yyval.u.p_regref) = ((CalcAssembler*) parm)->getRegister((yyvsp[(1) - (2)].u.v_regset), (yyvsp[(2) - (2)].u.v_uint64)); ;}
    break;

  case 55:
#line 218 "CalcGrammar.ypp"
    { (yyval.u.p_regref) = ((CalcAssembler*) parm)->getRegister((yyvsp[(1) - (2)].u.v_regset), (yyvsp[(2) - (2)].u.v_uint64)); ;}
    break;

  case 56:
#line 219 "CalcGrammar.ypp"
    { (yyval.u.p_regref) = ((CalcAssembler*) parm)->getRegister((yyvsp[(1) - (2)].u.v_regset), (yyvsp[(2) - (2)].u.v_uint64)); ;}
    break;

  case 57:
#line 220 "CalcGrammar.ypp"
    { (yyval.u.p_regref) = ((CalcAssembler*) parm)->getRegister((yyvsp[(1) - (2)].u.v_regset), (yyvsp[(2) - (2)].u.v_uint64)); ;}
    break;

  case 58:
#line 221 "CalcGrammar.ypp"
    { (yyval.u.p_regref) = ((CalcAssembler*) parm)->getRegister((yyvsp[(1) - (2)].u.v_regset), (yyvsp[(2) - (2)].u.v_uint64)); ;}
    break;


/* Line 1267 of yacc.c.  */
#line 1673 "CalcGrammar.tab.cpp"
      default: break;
    }
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);

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

  *++yyvsp = yyval;
  *++yylsp = yyloc;

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

  yyerror_range[0] = yylloc;

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

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

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


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

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

  yyerror_range[0] = yylsp[1-yylen];
  /* 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;

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

  if (yyn == YYFINAL)
    YYACCEPT;

  *++yyvsp = yylval;

  yyerror_range[1] = yylloc;
  /* Using YYLLOC is tempting, but would change the location of
     the look-ahead.  YYLOC is available though.  */
  YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
  *++yylsp = yyloc;

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

  yystate = yyn;
  goto yynewstate;


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

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

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

yyreturn:
  if (yychar != YYEOF && yychar != YYEMPTY)
     yydestruct ("Cleanup: discarding lookahead",
         yytoken, &yylval, &yylloc);
  /* 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, yylsp);
      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);
}

static YYSIZE_T yystrlen

(

const char *

yystr

)

const [static]

---

Variable Documentation

yytype_int16* top

Definition at line 859 of file CalcGrammar.cpp.

const yytype_int8 yycheck[] [static]

Initial value:

{
      71,    72,     0,    74,    15,    16,    17,    18,    19,    21,
      22,     8,    20,     9,    85,    12,    10,    88,    14,    15,
      16,    17,    18,    19,     3,     4,     5,     6,    24,    15,
      16,    17,    18,    19,    47,    48,    49,    50,    51,    15,
      16,     9,    18,    19,     8,     9,     8,     9,     8,     9,
       8,     9,     8,    23,     3,     8,     3,    11,     8,    62,
      34,     9,    19,     9,     9,     9,     9,     9,     9,     9,
       9,    30,    -1,    -1,    -1,    -1,    -1,    32,    -1,    -1,
      32,    32
}

Definition at line 639 of file CalcGrammar.cpp.

const yytype_uint8 yydefact[] [static]

Initial value:

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

Definition at line 572 of file CalcGrammar.cpp.

const yytype_int8 yydefgoto[] [static]

Initial value:

{
      -1,     1,     2,    12,     8,     9,    10,    17,    15,    20,
      16,    19,    28,    63,    41,    42,    11,    23,    24,    33,
      34,    35,    65,    53,    54,    55,    79,    80,    57,    81,
      59,    82
}

Definition at line 587 of file CalcGrammar.cpp.

YYLTYPE* yylocationp

Definition at line 1169 of file CalcGrammar.cpp.

YYLTYPE const* const yylocationp

Definition at line 833 of file CalcGrammar.cpp.

YYLTYPE const* const yylocationp

Definition at line 799 of file CalcGrammar.cpp.

YYLTYPE* yylsp

Definition at line 887 of file CalcGrammar.cpp.

Referenced by yyparse().

void yylocationp FILE* yyoutput

Definition at line 795 of file CalcGrammar.cpp.

const yytype_int8 yypact[] [static]

Initial value:

{
     -72,     2,    24,   -72,   -72,   -72,   -72,   -72,   -72,   -11,
     -72,   -72,     6,   -72,   -72,   -72,   -72,   -12,    32,   -12,
      -8,   -72,    44,   -72,    36,    30,    38,    21,   -72,    51,
     -12,   -72,     4,   -72,    30,   -72,   -72,   -72,   -72,   -72,
     -72,    47,   -72,   -72,   -72,   -72,    53,    53,    53,    53,
      53,    53,    46,    40,    50,    52,    54,   -72,    55,   -72,
      56,   -72,    21,    57,   -72,   -72,   -72,   -72,   -72,   -72,
     -72,    14,    14,   -72,    14,   -72,   -72,   -72,   -72,     3,
     -72,   -72,   -72,    58,    42,    14,    59,   -72,    14,   -72,
     -72,   -72,    60,   -72
}

Definition at line 598 of file CalcGrammar.cpp.

const yytype_int8 yypgoto[] [static]

Initial value:

{
     -72,   -72,   -72,   -72,   -72,   -72,    61,   -72,   -72,   -72,
     -72,   -72,   -72,   -72,   -72,    -3,   -72,    41,    43,   -72,
     -72,    26,   -13,   -72,   -72,   -71,   -72,    45,   -72,    48,
     -72,    49
}

Definition at line 613 of file CalcGrammar.cpp.

const yytype_uint8 yyprhs[] [static]

Initial value:

{
       0,     0,     3,     4,     5,    12,    15,    17,    20,    21,
      26,    27,    28,    32,    33,    38,    39,    44,    46,    50,
      52,    54,    56,    58,    59,    61,    63,    65,    67,    69,
      73,    75,    79,    81,    83,    86,    94,   100,   104,   108,
     114,   121,   124,   126,   129,   131,   133,   135,   137,   139,
     141,   143,   145,   147,   151,   154,   157,   160,   163
}

Definition at line 473 of file CalcGrammar.cpp.

const yytype_uint8 yyr1[] [static]

Initial value:

{
       0,    25,    27,    28,    26,    29,    30,    30,    32,    31,
      33,    34,    33,    36,    35,    38,    37,    39,    39,    40,
      40,    40,    40,    40,    41,    41,    41,    41,    42,    42,
      43,    43,    44,    45,    45,    46,    46,    46,    46,    46,
      46,    46,    47,    48,    49,    49,    49,    50,    50,    50,
      50,    50,    51,    51,    52,    53,    54,    55,    56
}

Definition at line 548 of file CalcGrammar.cpp.

const yytype_uint8 yyr2[] [static]

Initial value:

{
       0,     2,     0,     0,     6,     2,     1,     2,     0,     4,
       0,     0,     3,     0,     4,     0,     4,     1,     3,     1,
       1,     1,     1,     0,     1,     1,     1,     1,     1,     3,
       1,     3,     1,     1,     2,     7,     5,     3,     3,     5,
       6,     2,     1,     2,     1,     1,     1,     1,     1,     1,
       1,     1,     1,     3,     2,     2,     2,     2,     2
}

Definition at line 559 of file CalcGrammar.cpp.

const yytype_int8 yyrhs[] [static]

Initial value:

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

Definition at line 484 of file CalcGrammar.cpp.

const yytype_uint8 yyrline[] [static]

Initial value:

{
       0,   107,   107,   109,   107,   114,   117,   117,   120,   120,
     124,   125,   125,   128,   128,   132,   132,   135,   135,   138,
     139,   140,   141,   142,   145,   145,   145,   145,   148,   149,
     153,   154,   157,   160,   161,   165,   170,   175,   180,   185,
     190,   195,   201,   204,   207,   207,   207,   210,   210,   210,
     210,   210,   213,   214,   217,   218,   219,   220,   221
}

Definition at line 506 of file CalcGrammar.cpp.

int yyrule

Definition at line 889 of file CalcGrammar.cpp.

const char* yysrc

Definition at line 981 of file CalcGrammar.cpp.

const yytype_uint8 yystos[] [static]

Initial value:

{
       0,    26,    27,     0,    15,    16,    18,    19,    29,    30,
      31,    41,    28,    17,    31,    33,    35,    32,    10,    36,
      34,    21,    22,    42,    43,     9,    43,    20,    37,     8,
       8,     9,    23,    44,    45,    46,     9,     3,     4,     5,
       6,    39,    40,     3,    42,     9,    14,    15,    16,    17,
      18,    19,    24,    48,    49,    50,    52,    53,    54,    55,
      56,    46,     8,    38,     3,    47,    47,    47,    47,    47,
      47,    11,     8,     9,     8,     9,    40,     9,    50,    51,
      52,    54,    56,    50,    50,     8,    12,     9,     8,     9,
      50,     9,    50,     9
}

Definition at line 654 of file CalcGrammar.cpp.

const yytype_int8 yytable[] [static]

Initial value:

{
      78,    83,     3,    84,     4,     5,    13,     6,     7,    21,
      22,    85,    27,    45,    90,    86,    18,    92,    46,    47,
      48,    49,    50,    51,    37,    38,    39,    40,    52,    47,
      48,    49,    50,    51,    66,    67,    68,    69,    70,     4,
       5,    25,     6,     7,    30,    31,    30,    36,    72,    73,
      88,    89,    29,    32,    43,    62,    64,    71,    74,    76,
      61,    75,    26,   -47,   -50,   -48,    77,    87,    91,    93,
      14,    44,     0,     0,     0,     0,     0,    56,     0,     0,
      58,    60
}

Definition at line 626 of file CalcGrammar.cpp.

const char* const yytname[] [static]

Initial value:

{
  "$end", "error", "$undefined", "UNSIGNED_INTEGER", "NEGATIVE_INTEGER",
  "REAL", "STRING", "UNKNOWN_TOKEN", "COMMA", "TERM", "CODE_START",
  "LPAREN", "RPAREN", "WS", "AT", "REG_LOCAL", "REG_STATUS", "REG_LITERAL",
  "REG_INPUT", "REG_OUTPUT", "VALUES", "TYPE_FIXED", "TYPE_VARIABLE",
  "OPCODE", "NAME", "$accept", "program", "@1", "@2", "preamble",
  "register_sets", "register_set", "@3", "literal_set_values", "@4",
  "literal_set", "@5", "literal_values", "@6", "literal_defs",
  "literal_def", "set_name", "type_size", "type_size_list", "program_text",
  "instructions", "instruction", "index", "location", "result", "operand",
  "operand_list", "output_reg", "input_reg", "status_reg", "literal_reg",
  "local_reg", 0
}

Definition at line 520 of file CalcGrammar.cpp.

const yytype_uint16 yytoknum[] [static]

Initial value:

{
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
     275,   276,   277,   278,   279
}

Definition at line 539 of file CalcGrammar.cpp.

const yytype_uint8 yytranslate[] [static]

Definition at line 438 of file CalcGrammar.cpp.

int yytype

Definition at line 1166 of file CalcGrammar.cpp.

int yytype

Definition at line 830 of file CalcGrammar.cpp.

int yytype

Definition at line 797 of file CalcGrammar.cpp.

void yytype

Definition at line 795 of file CalcGrammar.cpp.

YYSTYPE* yyvaluep

Definition at line 1168 of file CalcGrammar.cpp.

YYSTYPE const* const yyvaluep

Definition at line 832 of file CalcGrammar.cpp.

YYSTYPE const* const yyvaluep

Definition at line 798 of file CalcGrammar.cpp.

void yyvaluep

Definition at line 795 of file CalcGrammar.cpp.

---