|
funkalicious 0.1
|
|
funkalicious 0.1
|
Include dependency graph for getChainPotential_parser.c:Go to the source code of this file.
Classes | |
| union | YYSTYPE |
| union | yyalloc |
Defines | |
| #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 | YYDEBUG 0 |
| #define | YYERROR_VERBOSE 0 |
| #define | YYTOKEN_TABLE 0 |
| #define | YYTOKENTYPE |
| #define | NUMBER 258 |
| #define | WAVEFUNC 259 |
| #define | YYSTYPE_IS_TRIVIAL 1 |
| #define | yystype YYSTYPE |
| #define | YYSTYPE_IS_DECLARED 1 |
| #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 4 |
| #define | YYLAST 2 |
| #define | YYNTOKENS 5 |
| #define | YYNNTS 2 |
| #define | YYNRULES 4 |
| #define | YYNSTATES 5 |
| #define | YYUNDEFTOK 2 |
| #define | YYMAXUTOK 259 |
| #define | YYTRANSLATE(YYX) ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
| #define | YYPACT_NINF -4 |
| #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 union YYSTYPE | YYSTYPE |
| typedef unsigned char | yytype_uint8 |
| typedef short int | yytype_int8 |
| typedef unsigned short int | yytype_uint16 |
| typedef short int | yytype_int16 |
Enumerations | |
| enum | yytokentype { NUMBER = 258, WAVEFUNC = 259, NUMBER = 258, WAVEFUNC = 259 } |
Functions | |
| int | yylex (void) |
| void | yyerror (const char *s) |
| 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_uint8 | yycheck [] |
| static const yytype_uint8 | yystos [] |
| int | yychar |
| YYSTYPE | yylval |
| int | yynerrs |
| #define NUMBER 258 |
Definition at line 133 of file getChainPotential_parser.c.
| #define WAVEFUNC 259 |
Definition at line 134 of file getChainPotential_parser.c.
| #define YY_ | ( | msgid | ) | msgid |
Definition at line 221 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YY_LOCATION_PRINT | ( | File, | |
| Loc | |||
| ) | ((void) 0) |
Definition at line 606 of file getChainPotential_parser.c.
| #define YY_REDUCE_PRINT | ( | Rule | ) |
Definition at line 779 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YY_STACK_PRINT | ( | Bottom, | |
| Top | |||
| ) |
Definition at line 778 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YY_SYMBOL_PRINT | ( | Title, | |
| Type, | |||
| Value, | |||
| Location | |||
| ) |
Definition at line 777 of file getChainPotential_parser.c.
Referenced by yydestruct(), and yyparse().
| #define YYABORT goto yyabortlab |
Definition at line 535 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYACCEPT goto yyacceptlab |
Definition at line 534 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYBACKUP | ( | Token, | |
| 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 547 of file getChainPotential_parser.c.
| #define YYBISON 1 |
Definition at line 46 of file getChainPotential_parser.c.
| #define YYBISON_VERSION "2.4.1" |
Definition at line 49 of file getChainPotential_parser.c.
| #define yyclearin (yychar = YYEMPTY) |
Definition at line 530 of file getChainPotential_parser.c.
| #define YYCOPY | ( | To, | |
| From, | |||
| Count | |||
| ) |
do \ { \ YYSIZE_T yyi; \ for (yyi = 0; yyi < (Count); yyi++) \ (To)[yyi] = (From)[yyi]; \ } \ while (YYID (0))
Definition at line 347 of file getChainPotential_parser.c.
| #define YYDEBUG 0 |
Definition at line 105 of file getChainPotential_parser.c.
| #define YYDPRINTF | ( | Args | ) |
Definition at line 776 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYEMPTY (-2) |
Definition at line 531 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYEOF 0 |
Definition at line 532 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYERRCODE 256 |
Definition at line 566 of file getChainPotential_parser.c.
| #define yyerrok (yyerrstatus = 0) |
Definition at line 529 of file getChainPotential_parser.c.
| #define YYERROR goto yyerrorlab |
Definition at line 536 of file getChainPotential_parser.c.
| #define YYERROR_VERBOSE 0 |
Definition at line 113 of file getChainPotential_parser.c.
| #define YYFAIL goto yyerrlab |
Definition at line 543 of file getChainPotential_parser.c.
| #define YYFINAL 4 |
Definition at line 377 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYFREE free |
Definition at line 310 of file getChainPotential_parser.c.
| #define YYID | ( | n | ) | (n) |
Definition at line 234 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYINITDEPTH 200 |
Definition at line 785 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYLAST 2 |
Definition at line 379 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYLEX yylex () |
Definition at line 616 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYLLOC_DEFAULT | ( | Current, | |
| Rhs, | |||
| N | |||
| ) |
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 575 of file getChainPotential_parser.c.
| #define YYLSP_NEEDED 0 |
Definition at line 64 of file getChainPotential_parser.c.
| #define YYMALLOC malloc |
Definition at line 303 of file getChainPotential_parser.c.
| #define YYMAXDEPTH 10000 |
Definition at line 796 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYMAXUTOK 259 |
Definition at line 392 of file getChainPotential_parser.c.
| #define YYNNTS 2 |
Definition at line 384 of file getChainPotential_parser.c.
| #define YYNRULES 4 |
Definition at line 386 of file getChainPotential_parser.c.
| #define YYNSTATES 5 |
Definition at line 388 of file getChainPotential_parser.c.
| #define YYNTOKENS 5 |
Definition at line 382 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYPACT_NINF -4 |
Definition at line 495 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYPOPSTACK | ( | N | ) | (yyvsp -= (N), yyssp -= (N)) |
Referenced by yyparse().
| #define YYPULL 1 |
Definition at line 61 of file getChainPotential_parser.c.
| #define YYPURE 0 |
Definition at line 55 of file getChainPotential_parser.c.
| #define YYPUSH 0 |
Definition at line 58 of file getChainPotential_parser.c.
| #define YYRECOVERING | ( | ) | (!!yyerrstatus) |
Definition at line 545 of file getChainPotential_parser.c.
| #define YYRHSLOC | ( | Rhs, | |
| K | |||
| ) | ((Rhs)[K]) |
Definition at line 573 of file getChainPotential_parser.c.
| #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) |
Definition at line 211 of file getChainPotential_parser.c.
| #define YYSIZE_T unsigned int |
Definition at line 207 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYSKELETON_NAME "yacc.c" |
Definition at line 52 of file getChainPotential_parser.c.
| #define YYSTACK_ALLOC YYMALLOC |
Definition at line 289 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM |
Definition at line 292 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYSTACK_BYTES | ( | N | ) |
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + YYSTACK_GAP_MAXIMUM)
Definition at line 336 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYSTACK_FREE YYFREE |
Definition at line 290 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) |
Definition at line 332 of file getChainPotential_parser.c.
| #define YYSTACK_RELOCATE | ( | Stack_alloc, | |
| Stack | |||
| ) |
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 363 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define yystype YYSTYPE |
Definition at line 155 of file getChainPotential_parser.c.
| #define YYSTYPE_IS_DECLARED 1 |
Definition at line 156 of file getChainPotential_parser.c.
| #define YYSTYPE_IS_TRIVIAL 1 |
Definition at line 154 of file getChainPotential_parser.c.
| #define YYTABLE_NINF -1 |
Definition at line 511 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYTERROR 1 |
Definition at line 565 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYTOKEN_TABLE 0 |
Definition at line 118 of file getChainPotential_parser.c.
| #define YYTOKENTYPE |
Definition at line 124 of file getChainPotential_parser.c.
| #define YYTRANSLATE | ( | YYX | ) | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
Definition at line 394 of file getChainPotential_parser.c.
Referenced by yyparse().
| #define YYUNDEFTOK 2 |
Definition at line 391 of file getChainPotential_parser.c.
Definition at line 227 of file getChainPotential_parser.c.
Referenced by yydestruct().
| typedef short int yytype_int16 |
Definition at line 194 of file getChainPotential_parser.c.
| typedef short int yytype_int8 |
Definition at line 182 of file getChainPotential_parser.c.
| typedef unsigned short int yytype_uint16 |
Definition at line 188 of file getChainPotential_parser.c.
| typedef unsigned char yytype_uint8 |
Definition at line 173 of file getChainPotential_parser.c.
| enum yytokentype |
Definition at line 127 of file getChainPotential_parser.c.
| static void yydestruct | ( | char * | yymsg, |
| int | yytype, | ||
| YYSTYPE * | yyvaluep | ||
| ) | const [static] |
Definition at line 1023 of file getChainPotential_parser.c.
References YY_SYMBOL_PRINT, and YYUSE.
Referenced by yyparse().
{
YYUSE (yyvaluep);
if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
switch (yytype)
{
default:
break;
}
}
Here is the caller graph for this function:| void yyerror | ( | const char * | s | ) |
Definition at line 1575 of file getChainPotential_parser.c.
Referenced by yyparse().
{
fprintf(stderr, "Error in parser: %s\n", c);
exit(15);
}
Here is the caller graph for this function:| int yylex | ( | void | ) |
| int yyparse | ( | ) |
Definition at line 1091 of file getChainPotential_parser.c.
References YYSTYPE::d, YY_, YY_REDUCE_PRINT, YY_STACK_PRINT, YY_SYMBOL_PRINT, YYABORT, YYACCEPT, yyalloc(), yydestruct(), YYDPRINTF, YYEMPTY, YYEOF, yyerror(), YYFINAL, YYID, YYINITDEPTH, YYLAST, YYLEX, yylval, YYMAXDEPTH, yynerrs, YYNTOKENS, YYPACT_NINF, YYPOPSTACK, YYSIZE_T, yyalloc::yyss_alloc, YYSTACK_ALLOC, YYSTACK_ALLOC_MAXIMUM, YYSTACK_BYTES, YYSTACK_FREE, YYSTACK_RELOCATE, YYTABLE_NINF, YYTERROR, YYTRANSLATE, and yyalloc::yyvs_alloc.
{
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:
/* Line 1455 of yacc.c */
#line 38 "getChainPotential_parser.y"
{}
break;
case 3:
/* Line 1455 of yacc.c */
#line 39 "getChainPotential_parser.y"
{(yyval.d) = (yyvsp[(1) - (1)].d);}
break;
case 4:
/* Line 1455 of yacc.c */
#line 40 "getChainPotential_parser.y"
{(yyval.d) = 0;}
break;
/* Line 1455 of yacc.c */
#line 1362 "src/getChainPotential_parser.c"
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);
}
Here is the call graph for this function:| int yychar |
Definition at line 1060 of file getChainPotential_parser.c.
const yytype_uint8 yycheck[] [static] |
{
3, 4, 0
}
Definition at line 517 of file getChainPotential_parser.c.
const yytype_uint8 yydefact[] [static] |
{
2, 3, 4, 0, 1
}
Definition at line 482 of file getChainPotential_parser.c.
const yytype_int8 yydefgoto[] [static] |
{
-1, 3
}
Definition at line 488 of file getChainPotential_parser.c.
Definition at line 1063 of file getChainPotential_parser.c.
Referenced by yyparse().
| int yynerrs |
Definition at line 1066 of file getChainPotential_parser.c.
Referenced by yyparse().
const yytype_int8 yypact[] [static] |
{
-3, -4, -4, 2, -4
}
Definition at line 496 of file getChainPotential_parser.c.
const yytype_int8 yypgoto[] [static] |
{
-4, -4
}
Definition at line 502 of file getChainPotential_parser.c.
const yytype_uint8 yyr1[] [static] |
{
0, 5, 6, 6, 6
}
Definition at line 468 of file getChainPotential_parser.c.
const yytype_uint8 yyr2[] [static] |
{
0, 2, 0, 1, 1
}
Definition at line 474 of file getChainPotential_parser.c.
const yytype_uint8 yystos[] [static] |
{
0, 3, 4, 6, 0
}
Definition at line 524 of file getChainPotential_parser.c.
const yytype_uint8 yytable[] [static] |
{
1, 2, 4
}
Definition at line 512 of file getChainPotential_parser.c.
const yytype_uint8 yytranslate[] [static] |
{
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 1, 2, 3, 4
}
Definition at line 398 of file getChainPotential_parser.c.
1.7.3