#include "config.h"
#include "factory/factoryconf.h"
#include <cstring>
#include <ctype.h>
#include <iostream>
#include "cf_assert.h"
#include "canonicalform.h"
#include "cf_defs.h"
#include "gfops.h"
#include "parseutil.h"
#include "variable.h"
#include <limits.h>
#include <stdlib.h>

Macros
#define	YYBISON 30802
#define	YYBISON_VERSION "3.8.2"
#define	YYSKELETON_NAME "yacc.c"
#define	YYPURE 0
#define	YYPUSH 0
#define	YYPULL 1
#define	ISTREAM std::istream
#define	CERR std::cerr
#define	YYSTYPE ParseUtil
#define	YY_CAST(Type, Val)
#define	YY_REINTERPRET_CAST(Type, Val)
#define	YY_NULLPTR 0
#define	YYDEBUG 0
#define	YYTOKENTYPE
#define	YYEMPTY -2
#define	YYEOF 0
#define	YYerror 256
#define	YYUNDEF 257
#define	NUM 258
#define	NEG 259
#define	YYPTRDIFF_T long
#define	YYPTRDIFF_MAXIMUM LONG_MAX
#define	YYSIZE_T unsigned
#define	YYSIZE_MAXIMUM
#define	YYSIZEOF(X)
#define	YY_(Msgid)
#define	YY_ATTRIBUTE_PURE
#define	YY_ATTRIBUTE_UNUSED
#define	YY_USE(E)
#define	YY_INITIAL_VALUE(Value)
#define	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define	YY_IGNORE_MAYBE_UNINITIALIZED_END
#define	YY_IGNORE_USELESS_CAST_BEGIN
#define	YY_IGNORE_USELESS_CAST_END
#define	YY_ASSERT(E)
#define	YYSTACK_ALLOC YYMALLOC
#define	YYSTACK_FREE YYFREE
#define	YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
#define	EXIT_SUCCESS 0
#define	YYMALLOC malloc
#define	YYFREE free
#define	YYFINAL 2
#define	YYLAST 44
#define	YYNTOKENS 13
#define	YYNNTS 4
#define	YYNRULES 14
#define	YYNSTATES 25
#define	YYMAXUTOK 259
#define	YYTRANSLATE(YYX)
#define	YY_ACCESSING_SYMBOL(State)
	Accessing symbol of state STATE.
#define	YYPACT_NINF (-8)
#define	yypact_value_is_default(Yyn)
#define	YYTABLE_NINF (-1)
#define	yytable_value_is_error(Yyn)
#define	yyerrok (yyerrstatus = 0)
#define	yyclearin (yychar = YYEMPTY)
#define	YYACCEPT goto yyacceptlab
#define	YYABORT goto yyabortlab
#define	YYERROR goto yyerrorlab
#define	YYNOMEM goto yyexhaustedlab
#define	YYRECOVERING()
#define	YYBACKUP(Token, Value)
#define	YYERRCODE YYUNDEF
#define	YYDPRINTF(Args)
#define	YY_SYMBOL_PRINT(Title, Kind, Value, Location)
#define	YY_STACK_PRINT(Bottom, Top)
#define	YY_REDUCE_PRINT(Rule)
#define	YYINITDEPTH 200
#define	YYMAXDEPTH 10000
#define	YYPOPSTACK(N)

Typedefs
typedef enum yytokentype	yytoken_kind_t
typedef enum yysymbol_kind_t	yysymbol_kind_t
typedef short	yytype_int16
typedef unsigned short	yytype_uint16
typedef yytype_int8	yy_state_t
typedef int	yy_state_fast_t

Enumerations
enum	yytokentype { YYEMPTY = -2 , YYEOF = 0 , YYerror = 256 , YYUNDEF = 257 , NUM = 258 , NEG = 259 }
enum	yysymbol_kind_t { YYSYMBOL_YYEMPTY = -2 , YYSYMBOL_YYEOF = 0 , YYSYMBOL_YYerror = 1 , YYSYMBOL_YYUNDEF = 2 , YYSYMBOL_NUM = 3 , YYSYMBOL_4_ = 4 , YYSYMBOL_5_ = 5 , YYSYMBOL_6_ = 6 , YYSYMBOL_7_ = 7 , YYSYMBOL_NEG = 8 , YYSYMBOL_9_ = 9 , YYSYMBOL_10_ = 10 , YYSYMBOL_11_ = 11 , YYSYMBOL_12_ = 12 , YYSYMBOL_YYACCEPT = 13 , YYSYMBOL_input = 14 , YYSYMBOL_line = 15 , YYSYMBOL_exp = 16 }
enum	{ YYENOMEM = -2 }

Functions
static char *	readString (ISTREAM &)
void	yyerror (char *s)
int	yylex ()
int	yyparse (void)
static void	yydestruct (const char yymsg, yysymbol_kind_t yykind, YYSTYPE yyvaluep)
CanonicalForm	readCF (ISTREAM &str)

Variables
static ISTREAM *	defaultin = 0
static CanonicalForm *	retvalue = 0
YYSTYPE	yylval
static const yytype_int8	yytranslate []
static const yytype_int8	yypact []
static const yytype_int8	yydefact []
static const yytype_int8	yypgoto []
static const yytype_int8	yydefgoto []
static const yytype_int8	yytable []
static const yytype_int8	yycheck []
static const yytype_int8	yystos []
static const yytype_int8	yyr1 []
static const yytype_int8	yyr2 []
int	yychar
int	yynerrs

Macro Definition Documentation

◆ CERR

#define CERR std::cerr

Definition at line 94 of file readcf.cc.

◆ EXIT_SUCCESS

#define EXIT_SUCCESS 0

Definition at line 465 of file readcf.cc.

◆ ISTREAM

#define ISTREAM std::istream

Definition at line 93 of file readcf.cc.

◆ NEG

#define NEG 259

Definition at line 181 of file readcf.cc.

◆ NUM

#define NUM 258

Definition at line 180 of file readcf.cc.

◆ YY_

#define YY_ ( Msgid )

Value:

Msgid

Definition at line 348 of file readcf.cc.

◆ YY_ACCESSING_SYMBOL

#define YY_ACCESSING_SYMBOL ( State )

Value:

YY_CAST (yysymbol_kind_t, yystos[State])

yystos

static const yytype_uint8 yystos[]

Definition grammar.cc:1545

yysymbol_kind_t

Definition readcf.cc:200

YY_CAST

#define YY_CAST(Type, Val)

Definition readcf.cc:133

Accessing symbol of state STATE.

Definition at line 610 of file readcf.cc.

◆ YY_ASSERT

#define YY_ASSERT ( E )

Value:

((void) (0 && (E)))

E

REvaluation E(1, terms.length(), IntRandom(25))

Definition at line 414 of file readcf.cc.

◆ YY_ATTRIBUTE_PURE

#define YY_ATTRIBUTE_PURE

Definition at line 357 of file readcf.cc.

◆ YY_ATTRIBUTE_UNUSED

#define YY_ATTRIBUTE_UNUSED

Definition at line 365 of file readcf.cc.

◆ YY_CAST

#define YY_CAST	(		Type,
			Val )

Value:

static_cast<Type> (Val)

Definition at line 133 of file readcf.cc.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

Definition at line 394 of file readcf.cc.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_END

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

Definition at line 395 of file readcf.cc.

◆ YY_IGNORE_USELESS_CAST_BEGIN

#define YY_IGNORE_USELESS_CAST_BEGIN

Definition at line 409 of file readcf.cc.

◆ YY_IGNORE_USELESS_CAST_END

#define YY_IGNORE_USELESS_CAST_END

Definition at line 410 of file readcf.cc.

◆ YY_INITIAL_VALUE

#define YY_INITIAL_VALUE ( Value )

Value:

Value

Definition at line 391 of file readcf.cc.

◆ YY_NULLPTR

#define YY_NULLPTR 0

Definition at line 145 of file readcf.cc.

◆ YY_REDUCE_PRINT

#define YY_REDUCE_PRINT ( Rule )

Definition at line 877 of file readcf.cc.

◆ YY_REINTERPRET_CAST

#define YY_REINTERPRET_CAST	(		Type,
			Val )

Value:

reinterpret_cast<Type> (Val)

Definition at line 134 of file readcf.cc.

◆ YY_STACK_PRINT

#define YY_STACK_PRINT	(		Bottom,
			Top )

Definition at line 876 of file readcf.cc.

◆ YY_SYMBOL_PRINT

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

Definition at line 875 of file readcf.cc.

◆ YY_USE

#define YY_USE ( E )

Value:

((void) (E))

Definition at line 371 of file readcf.cc.

◆ YYABORT

#define YYABORT goto yyabortlab

Definition at line 725 of file readcf.cc.

◆ YYACCEPT

#define YYACCEPT goto yyacceptlab

Definition at line 724 of file readcf.cc.

◆ YYBACKUP

#define YYBACKUP	(		Token,
			Value )

Value:

  do                                                              \
    if (yychar == YYEMPTY)                                        \
      {                                                           \
        yychar = (Token);                                         \
        yylval = (Value);                                         \
        YYPOPSTACK (yylen);                                       \
        yystate = *yyssp;                                         \
        goto yybackup;                                            \
      }                                                           \
    else                                                          \
      {                                                           \
        yyerror (YY_("syntax error: cannot back up")); \
        YYERROR;                                                  \
      }                                                           \
  while (0)

Definition at line 732 of file readcf.cc.

#define YYBACKUP(Token, Value)                                    \
  do                                                              \
    if (yychar == YYEMPTY)                                        \
      {                                                           \
        yychar = (Token);                                         \
        yylval = (Value);                                         \
        YYPOPSTACK (yylen);                                       \
        yystate = *yyssp;                                         \
        goto yybackup;                                            \
      }                                                           \
    else                                                          \
      {                                                           \
        yyerror (YY_("syntax error: cannot back up")); \
        YYERROR;                                                  \
      }                                                           \
  while (0)

◆ YYBISON

#define YYBISON 30802

Definition at line 49 of file readcf.cc.

◆ YYBISON_VERSION

#define YYBISON_VERSION "3.8.2"

Definition at line 52 of file readcf.cc.

◆ yyclearin

#define yyclearin (yychar = YYEMPTY)

Definition at line 722 of file readcf.cc.

◆ YYDEBUG

#define YYDEBUG 0

Definition at line 155 of file readcf.cc.

◆ YYDPRINTF

#define YYDPRINTF ( Args )

Value:

((void) 0)

Definition at line 874 of file readcf.cc.

◆ YYEMPTY

#define YYEMPTY -2

Definition at line 176 of file readcf.cc.

◆ YYEOF

#define YYEOF 0

Definition at line 177 of file readcf.cc.

◆ YYERRCODE

#define YYERRCODE YYUNDEF

Definition at line 751 of file readcf.cc.

◆ yyerrok

#define yyerrok (yyerrstatus = 0)

Definition at line 721 of file readcf.cc.

◆ YYERROR

#define YYERROR goto yyerrorlab

Definition at line 726 of file readcf.cc.

◆ YYerror

#define YYerror 256

Definition at line 178 of file readcf.cc.

◆ YYFINAL

#define YYFINAL 2

Definition at line 544 of file readcf.cc.

◆ YYFREE

#define YYFREE free

Definition at line 475 of file readcf.cc.

◆ YYINITDEPTH

#define YYINITDEPTH 200

Definition at line 883 of file readcf.cc.

◆ YYLAST

#define YYLAST 44

Definition at line 546 of file readcf.cc.

◆ YYMALLOC

#define YYMALLOC malloc

Definition at line 469 of file readcf.cc.

◆ YYMAXDEPTH

#define YYMAXDEPTH 10000

Definition at line 894 of file readcf.cc.

◆ YYMAXUTOK

#define YYMAXUTOK 259

Definition at line 558 of file readcf.cc.

◆ YYNNTS

#define YYNNTS 4

Definition at line 551 of file readcf.cc.

◆ YYNOMEM

#define YYNOMEM goto yyexhaustedlab

Definition at line 727 of file readcf.cc.

◆ YYNRULES

#define YYNRULES 14

Definition at line 553 of file readcf.cc.

◆ YYNSTATES

#define YYNSTATES 25

Definition at line 555 of file readcf.cc.

◆ YYNTOKENS

#define YYNTOKENS 13

Definition at line 549 of file readcf.cc.

◆ YYPACT_NINF

#define YYPACT_NINF (-8)

Definition at line 633 of file readcf.cc.

◆ yypact_value_is_default

#define yypact_value_is_default ( Yyn )

Value:

((Yyn) == YYPACT_NINF)

YYPACT_NINF

#define YYPACT_NINF

Definition grammar.cc:925

Definition at line 635 of file readcf.cc.

635#define yypact_value_is_default(Yyn) \

636 ((Yyn) == YYPACT_NINF)

◆ YYPOPSTACK

#define YYPOPSTACK ( N )

Value:

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

N

const CanonicalForm CFMap CFMap & N

Definition cfEzgcd.cc:56

◆ YYPTRDIFF_MAXIMUM

#define YYPTRDIFF_MAXIMUM LONG_MAX

Definition at line 308 of file readcf.cc.

◆ YYPTRDIFF_T

#define YYPTRDIFF_T long

Definition at line 307 of file readcf.cc.

◆ YYPULL

#define YYPULL 1

Definition at line 64 of file readcf.cc.

◆ YYPURE

#define YYPURE 0

Definition at line 58 of file readcf.cc.

◆ YYPUSH

#define YYPUSH 0

Definition at line 61 of file readcf.cc.

◆ YYRECOVERING

#define YYRECOVERING ( )

Value:

(!!yyerrstatus)

Definition at line 730 of file readcf.cc.

◆ YYSIZE_MAXIMUM

#define YYSIZE_MAXIMUM

Value:

  YY_CAST (YYPTRDIFF_T,                                 \
           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
            ? YYPTRDIFF_MAXIMUM                         \
            : YY_CAST (YYSIZE_T, -1)))

Definition at line 325 of file readcf.cc.

#define YYSIZE_MAXIMUM                                  \
  YY_CAST (YYPTRDIFF_T,                                 \
           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
            ? YYPTRDIFF_MAXIMUM                         \
            : YY_CAST (YYSIZE_T, -1)))

◆ YYSIZE_T

#define YYSIZE_T unsigned

Definition at line 321 of file readcf.cc.

◆ YYSIZEOF

#define YYSIZEOF ( X )

Value:

YY_CAST (YYPTRDIFF_T, sizeof (X))

Definition at line 331 of file readcf.cc.

◆ YYSKELETON_NAME

#define YYSKELETON_NAME "yacc.c"

Definition at line 55 of file readcf.cc.

◆ YYSTACK_ALLOC

#define YYSTACK_ALLOC YYMALLOC

Definition at line 455 of file readcf.cc.

◆ YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM

Definition at line 458 of file readcf.cc.

◆ YYSTACK_FREE

#define YYSTACK_FREE YYFREE

Definition at line 456 of file readcf.cc.

◆ YYSTYPE

#define YYSTYPE ParseUtil

Definition at line 111 of file readcf.cc.

◆ YYTABLE_NINF

#define YYTABLE_NINF (-1)

Definition at line 638 of file readcf.cc.

◆ yytable_value_is_error

#define yytable_value_is_error ( Yyn )

Value:

0

Definition at line 640 of file readcf.cc.

640#define yytable_value_is_error(Yyn) \

641 0

◆ YYTOKENTYPE

#define YYTOKENTYPE

Definition at line 163 of file readcf.cc.

◆ YYTRANSLATE

#define YYTRANSLATE ( YYX )

Value:

  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
   : YYSYMBOL_YYUNDEF)

Definition at line 563 of file readcf.cc.

#define YYTRANSLATE(YYX)                                \
  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
   : YYSYMBOL_YYUNDEF)

◆ YYUNDEF

#define YYUNDEF 257

Definition at line 179 of file readcf.cc.

Typedef Documentation

◆ yy_state_fast_t

typedef int yy_state_fast_t

Definition at line 338 of file readcf.cc.

◆ yy_state_t

typedef yytype_int8 yy_state_t

Definition at line 335 of file readcf.cc.

◆ yysymbol_kind_t

typedef enum yysymbol_kind_t yysymbol_kind_t

Definition at line 220 of file readcf.cc.

◆ yytoken_kind_t

typedef enum yytokentype yytoken_kind_t

Definition at line 173 of file readcf.cc.

◆ yytype_int16

typedef short yytype_int16

Definition at line 259 of file readcf.cc.

◆ yytype_uint16

typedef unsigned short yytype_uint16

Definition at line 291 of file readcf.cc.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
YYENOMEM

Definition at line 719 of file readcf.cc.

719{ YYENOMEM = -2 };

YYENOMEM

@ YYENOMEM

Definition readcf.cc:719

◆ yysymbol_kind_t

enum yysymbol_kind_t

Enumerator
YYSYMBOL_YYEMPTY
YYSYMBOL_YYEOF
YYSYMBOL_YYerror
YYSYMBOL_YYUNDEF
YYSYMBOL_NUM
YYSYMBOL_4_
YYSYMBOL_5_
YYSYMBOL_6_
YYSYMBOL_7_
YYSYMBOL_NEG
YYSYMBOL_9_
YYSYMBOL_10_
YYSYMBOL_11_
YYSYMBOL_12_
YYSYMBOL_YYACCEPT
YYSYMBOL_input
YYSYMBOL_line
YYSYMBOL_exp

Definition at line 199 of file readcf.cc.

{
  YYSYMBOL_YYEMPTY = -2,
  YYSYMBOL_YYEOF = 0,                      /* "end of file"  */
  YYSYMBOL_YYerror = 1,                    /* error  */
  YYSYMBOL_YYUNDEF = 2,                    /* "invalid token"  */
  YYSYMBOL_NUM = 3,                        /* NUM  */
  YYSYMBOL_4_ = 4,                         /* '-'  */
  YYSYMBOL_5_ = 5,                         /* '+'  */
  YYSYMBOL_6_ = 6,                         /* '*'  */
  YYSYMBOL_7_ = 7,                         /* '/'  */
  YYSYMBOL_NEG = 8,                        /* NEG  */
  YYSYMBOL_9_ = 9,                         /* '^'  */
  YYSYMBOL_10_ = 10,                       /* ';'  */
  YYSYMBOL_11_ = 11,                       /* '('  */
  YYSYMBOL_12_ = 12,                       /* ')'  */
  YYSYMBOL_YYACCEPT = 13,                  /* $accept  */
  YYSYMBOL_input = 14,                     /* input  */
  YYSYMBOL_line = 15,                      /* line  */
  YYSYMBOL_exp = 16                        /* exp  */
};

◆ yytokentype

enum yytokentype

Enumerator
YYEMPTY
YYEOF
YYerror
YYUNDEF
NUM
NEG

Definition at line 164 of file readcf.cc.

  {
    YYEMPTY = -2,
    YYEOF = 0,                     /* "end of file"  */
    YYerror = 256,                 /* error  */
    YYUNDEF = 257,                 /* "invalid token"  */
    NUM = 258,                     /* NUM  */
    NEG = 259                      /* NEG  */
  };

Function Documentation

◆ readCF()

CanonicalForm readCF ( ISTREAM & str )

Definition at line 1499 of file readcf.cc.

{
    CanonicalForm theRetvalue;
    retvalue = new CanonicalForm();
#ifdef BISONPP
    YY_parse_CLASS my_parser;
    defaultin = &str;
    if ( my_parser.yyparse() == 0 ) {
        theRetvalue = *retvalue;
        delete retvalue;
        return theRetvalue;
    }
    else {
        delete retvalue;
        return 0;
    }
#else
    defaultin = &str;
    if ( yyparse() == 0 ) {
        theRetvalue = *retvalue;
        delete retvalue;
        return theRetvalue;
    }
    else {
        delete retvalue;
        return 0;
    }
#endif
}

◆ readString()

char * readString ( ISTREAM & s )

static

Definition at line 1529 of file readcf.cc.

{
    static char * buffer = 0;
    static int bufsize = 0;
 
    if ( buffer == 0 ) {
        bufsize = 10000;
        buffer = new char[bufsize];
    }
    int i = 0, c, goon = 1;
    while ( goon ) {
        while ( isdigit( c = s.get() ) && i < bufsize - 2 ) {
            buffer[i] = c;
            i++;
        }
        if ( isdigit( c ) ) {
            bufsize += 1000;
            char * newbuffer = (char*)memcpy( new char[bufsize], buffer, bufsize - 1000 );
            delete [] buffer;
            buffer = newbuffer;
            buffer[i] = c;
            i++;
        }
        else {
            goon = 0;
            buffer[i] = '\0';
            s.putback( c );
        }
    }
    return buffer;
}

◆ yydestruct()

void yydestruct	(	const char *	yymsg,
		yysymbol_kind_t	yykind,
		YYSTYPE *	yyvaluep )

static

Definition at line 907 of file readcf.cc.

{
  YY_USE (yyvaluep);
  if (!yymsg)
    yymsg = "Deleting";
  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
 
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  YY_USE (yykind);
  YY_IGNORE_MAYBE_UNINITIALIZED_END
}

◆ yyerror()

void yyerror ( char * s )

Definition at line 1438 of file readcf.cc.

{
    CERR << s << "\n";
}

◆ yylex()

int yylex ( )

Definition at line 1447 of file readcf.cc.

{
    int c;
 
    while ((c = defaultin->get()) == ' ' || c == '\t' || c == '\n' ) ;
    if ( isdigit( c ) ) {
        defaultin->putback( c );
        yylval = ParseUtil( readString( *defaultin ) );
        return NUM;
    }
    else if ( isalpha( c ) ) {
        // look for generators of GF(q)
        if ( getCharacteristic() > 0 && getGFDegree() > 1 && c == gf_name ) {
#ifdef BISONPP
            this->yylval = getGFGenerator();
#else
            yylval = getGFGenerator();
#endif
        }
        else if ( c == getDefaultVarName() ) {
            int cc;
            cc = defaultin->get();
            if ( cc == '_' ) {
                ParseUtil index( readString( *defaultin ) );
#ifdef BISONPP
                this->yylval = Variable( index.getintval() );
#else
                yylval = Variable( index.getintval() );
#endif
            }
            else {
                defaultin->putback( cc );
#ifdef BISONPP
                this->yylval = Variable( (char)c );
#else
                yylval = Variable( (char)c );
#endif
            }
        }
        else {
#ifdef BISONPP
            this->yylval = Variable( (char)c );
#else
            yylval = Variable( (char)c );
#endif
        }
        return NUM;
    }
    return c;
}

◆ yyparse()

int yyparse ( void )

Definition at line 937 of file readcf.cc.

{
    yy_state_fast_t yystate = 0;
    /* Number of tokens to shift before error messages enabled.  */
    int yyerrstatus = 0;
 
    /* Refer to the stacks through separate pointers, to allow yyoverflow
       to reallocate them elsewhere.  */
 
    /* Their size.  */
    YYPTRDIFF_T yystacksize = YYINITDEPTH;
 
    /* The state stack: array, bottom, top.  */
    yy_state_t yyssa[YYINITDEPTH];
    yy_state_t *yyss = yyssa;
    yy_state_t *yyssp = yyss;
 
    /* The semantic value stack: array, bottom, top.  */
    YYSTYPE yyvsa[YYINITDEPTH];
    YYSTYPE *yyvs = yyvsa;
    YYSTYPE *yyvsp = yyvs;
 
  int yyn;
  /* The return value of yyparse.  */
  int yyresult;
  /* Lookahead symbol kind.  */
  yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
  /* The variables used to return semantic value and location from the
     action routines.  */
  YYSTYPE yyval;
 
 
 
#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;
 
  YYDPRINTF ((stderr, "Starting parse\n"));
 
  yychar = YYEMPTY; /* Cause a token to be read.  */
 
  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 -- set current state (the top of the stack) to yystate.  |
`--------------------------------------------------------------------*/
yysetstate:
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
  YY_IGNORE_USELESS_CAST_BEGIN
  *yyssp = YY_CAST (yy_state_t, yystate);
  YY_IGNORE_USELESS_CAST_END
  YY_STACK_PRINT (yyss, yyssp);
 
  if (yyss + yystacksize - 1 <= yyssp)
#if !defined yyoverflow && !defined YYSTACK_RELOCATE
    YYNOMEM;
#else
    {
      /* Get the current used size of the three stacks, in elements.  */
      YYPTRDIFF_T yysize = yyssp - yyss + 1;
 
# if defined 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.  */
        yy_state_t *yyss1 = yyss;
        YYSTYPE *yyvs1 = yyvs;
 
        /* 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 * YYSIZEOF (*yyssp),
                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
                    &yystacksize);
        yyss = yyss1;
        yyvs = yyvs1;
      }
# else /* defined YYSTACK_RELOCATE */
      /* Extend the stack our own way.  */
      if (YYMAXDEPTH <= yystacksize)
        YYNOMEM;
      yystacksize *= 2;
      if (YYMAXDEPTH < yystacksize)
        yystacksize = YYMAXDEPTH;
 
      {
        yy_state_t *yyss1 = yyss;
        union yyalloc *yyptr =
          YY_CAST (union yyalloc *,
                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
        if (! yyptr)
          YYNOMEM;
        YYSTACK_RELOCATE (yyss_alloc, yyss);
        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
#  undef YYSTACK_RELOCATE
        if (yyss1 != yyssa)
          YYSTACK_FREE (yyss1);
      }
# endif
 
      yyssp = yyss + yysize - 1;
      yyvsp = yyvs + yysize - 1;
 
      YY_IGNORE_USELESS_CAST_BEGIN
      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
                  YY_CAST (long, yystacksize)));
      YY_IGNORE_USELESS_CAST_END
 
      if (yyss + yystacksize - 1 <= yyssp)
        YYABORT;
    }
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
 
 
  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 (yypact_value_is_default (yyn))
    goto yydefault;
 
  /* Not known => get a lookahead token if don't already have one.  */
 
  /* YYCHAR is either empty, or end-of-input, or a valid lookahead.  */
  if (yychar == YYEMPTY)
    {
      YYDPRINTF ((stderr, "Reading a token\n"));
      yychar = yylex ();
    }
 
  if (yychar <= YYEOF)
    {
      yychar = YYEOF;
      yytoken = YYSYMBOL_YYEOF;
      YYDPRINTF ((stderr, "Now at end of input.\n"));
    }
  else if (yychar == YYerror)
    {
      /* The scanner already issued an error message, process directly
         to error recovery.  But do not keep the error token as
         lookahead, it is too special and may lead us to an endless
         loop in error recovery. */
      yychar = YYUNDEF;
      yytoken = YYSYMBOL_YYerror;
      goto yyerrlab1;
    }
  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 (yytable_value_is_error (yyn))
        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);
  yystate = yyn;
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END
 
  /* Discard the shifted token.  */
  yychar = YYEMPTY;
  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 5: /* line: exp ';'  */
#line 78 "readcf.yy"
                  { *retvalue = yyvsp[-1].getval(); return 0; }
#line 1182 "readcf.cc"
    break;
 
  case 6: /* exp: NUM  */
#line 81 "readcf.yy"
                                       { yyval = yyvsp[0]; }
#line 1188 "readcf.cc"
    break;
 
  case 7: /* exp: exp '+' exp  */
#line 82 "readcf.yy"
                                     { yyval = yyvsp[-2].getval() + yyvsp[0].getval(); }
#line 1194 "readcf.cc"
    break;
 
  case 8: /* exp: exp '-' exp  */
#line 83 "readcf.yy"
                                     { yyval = yyvsp[-2].getval() - yyvsp[0].getval(); }
#line 1200 "readcf.cc"
    break;
 
  case 9: /* exp: exp '*' exp  */
#line 84 "readcf.yy"
                                     { yyval = yyvsp[-2].getval() * yyvsp[0].getval(); }
#line 1206 "readcf.cc"
    break;
 
  case 10: /* exp: exp '/' exp  */
#line 85 "readcf.yy"
                                     { yyval = yyvsp[-2].getval() / yyvsp[0].getval(); }
#line 1212 "readcf.cc"
    break;
 
  case 11: /* exp: '-' exp  */
#line 86 "readcf.yy"
                                   { yyval = -yyvsp[0].getval(); }
#line 1218 "readcf.cc"
    break;
 
  case 12: /* exp: '+' exp  */
#line 87 "readcf.yy"
                                   { yyval = yyvsp[0].getval(); }
#line 1224 "readcf.cc"
    break;
 
  case 13: /* exp: exp '^' NUM  */
#line 88 "readcf.yy"
                                     { yyval = power( yyvsp[-2].getval(), yyvsp[0].getintval() ); }
#line 1230 "readcf.cc"
    break;
 
  case 14: /* exp: '(' exp ')'  */
#line 89 "readcf.yy"
                                     { yyval = yyvsp[-1].getval(); }
#line 1236 "readcf.cc"
    break;
 
 
#line 1240 "readcf.cc"
 
      default: break;
    }
  /* User semantic actions sometimes alter yychar, and that requires
     that yytoken be updated with the new translation.  We take the
     approach of translating immediately before every use of yytoken.
     One alternative is translating here after every semantic action,
     but that translation would be missed if the semantic action invokes
     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
     incorrect destructor might then be invoked immediately.  In the
     case of YYERROR or YYBACKUP, subsequent parser actions might lead
     to an incorrect destructor call or verbose syntax error message
     before the lookahead is translated.  */
  YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
 
  YYPOPSTACK (yylen);
  yylen = 0;
 
  *++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.  */
  {
    const int yylhs = yyr1[yyn] - YYNTOKENS;
    const int yyi = yypgoto[yylhs] + *yyssp;
    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
               ? yytable[yyi]
               : yydefgoto[yylhs]);
  }
 
  goto yynewstate;
 
 
/*--------------------------------------.
| yyerrlab -- here on detecting error.  |
`--------------------------------------*/
yyerrlab:
  /* Make sure we have latest lookahead translation.  See comments at
     user semantic actions for why this is necessary.  */
  yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
  /* If not already recovering from an error, report this error.  */
  if (!yyerrstatus)
    {
      ++yynerrs;
      yyerror (YY_("syntax error"));
    }
 
  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 when the user code never invokes YYERROR and the
     label yyerrorlab therefore never appears in user code.  */
  if (0)
    YYERROR;
  ++yynerrs;
 
  /* Do not reclaim the symbols of the rule whose 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.  */
 
  /* Pop stack until we find a state that shifts the error token.  */
  for (;;)
    {
      yyn = yypact[yystate];
      if (!yypact_value_is_default (yyn))
        {
          yyn += YYSYMBOL_YYerror;
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
            {
              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",
                  YY_ACCESSING_SYMBOL (yystate), yyvsp);
      YYPOPSTACK (1);
      yystate = *yyssp;
      YY_STACK_PRINT (yyss, yyssp);
    }
 
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END
 
 
  /* Shift the error token.  */
  YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
 
  yystate = yyn;
  goto yynewstate;
 
 
/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here.  |
`-------------------------------------*/
yyacceptlab:
  yyresult = 0;
  goto yyreturnlab;
 
 
/*-----------------------------------.
| yyabortlab -- YYABORT comes here.  |
`-----------------------------------*/
yyabortlab:
  yyresult = 1;
  goto yyreturnlab;
 
 
/*-----------------------------------------------------------.
| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here.  |
`-----------------------------------------------------------*/
yyexhaustedlab:
  yyerror (YY_("memory exhausted"));
  yyresult = 2;
  goto yyreturnlab;
 
 
/*----------------------------------------------------------.
| yyreturnlab -- parsing is finished, clean up and return.  |
`----------------------------------------------------------*/
yyreturnlab:
  if (yychar != YYEMPTY)
    {
      /* Make sure we have latest lookahead translation.  See comments at
         user semantic actions for why this is necessary.  */
      yytoken = YYTRANSLATE (yychar);
      yydestruct ("Cleanup: discarding lookahead",
                  yytoken, &yylval);
    }
  /* Do not reclaim the symbols of the rule whose action triggered
     this YYABORT or YYACCEPT.  */
  YYPOPSTACK (yylen);
  YY_STACK_PRINT (yyss, yyssp);
  while (yyssp != yyss)
    {
      yydestruct ("Cleanup: popping",
                  YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
      YYPOPSTACK (1);
    }
#ifndef yyoverflow
  if (yyss != yyssa)
    YYSTACK_FREE (yyss);
#endif
 
  return yyresult;
}

Variable Documentation

◆ defaultin

ISTREAM* defaultin = 0

static

Definition at line 124 of file readcf.cc.

◆ retvalue

CanonicalForm* retvalue = 0

static

Definition at line 126 of file readcf.cc.

◆ yychar

int yychar

Definition at line 922 of file readcf.cc.

◆ yycheck

const yytype_int8 yycheck[]

static

Initial value:

=
{
       4,     5,     9,     7,     3,    -1,     3,     4,     5,    13,
      14,    15,    16,     0,    11,    -1,     3,     4,     5,    -1,
      -1,    -1,    -1,    10,    11,     4,     5,     6,     7,    -1,
       9,    -1,    -1,    12,     4,     5,     6,     7,    -1,     9,
      10,     6,     7,    -1,     9
}

Definition at line 686 of file readcf.cc.

{
       4,     5,     9,     7,     3,    -1,     3,     4,     5,    13,
      14,    15,    16,     0,    11,    -1,     3,     4,     5,    -1,
      -1,    -1,    -1,    10,    11,     4,     5,     6,     7,    -1,
       9,    -1,    -1,    12,     4,     5,     6,     7,    -1,     9,
      10,     6,     7,    -1,     9
};

◆ yydefact

const yytype_int8 yydefact[]

static

Initial value:

=
{
       2,     0,     1,     6,     0,     0,     4,     0,     3,     0,
      11,    12,     0,     0,     0,     0,     0,     0,     5,    14,
       8,     7,     9,    10,    13
}

Definition at line 655 of file readcf.cc.

{
       2,     0,     1,     6,     0,     0,     4,     0,     3,     0,
      11,    12,     0,     0,     0,     0,     0,     0,     5,    14,
       8,     7,     9,    10,    13
};

◆ yydefgoto

const yytype_int8 yydefgoto[]

static

Initial value:

=
{
       0,     1,     8,     9
}

Definition at line 669 of file readcf.cc.

{
       0,     1,     8,     9
};

◆ yylval

YYSTYPE yylval

Definition at line 925 of file readcf.cc.

◆ yynerrs

int yynerrs

Definition at line 927 of file readcf.cc.

◆ yypact

const yytype_int8 yypact[]

static

Initial value:

=
{
      -8,    13,    -8,    -8,     3,     3,    -8,     3,    -8,    30,
      -7,    -7,    21,     3,     3,     3,     3,     1,    -8,    -8,
      35,    35,    -7,    -7,    -8
}

Definition at line 645 of file readcf.cc.

{
      -8,    13,    -8,    -8,     3,     3,    -8,     3,    -8,    30,
      -7,    -7,    21,     3,     3,     3,     3,     1,    -8,    -8,
      35,    35,    -7,    -7,    -8
};

◆ yypgoto

const yytype_int8 yypgoto[]

static

Initial value:

=
{
      -8,    -8,    -8,    -4
}

Definition at line 663 of file readcf.cc.

{
      -8,    -8,    -8,    -4
};

◆ yyr1

const yytype_int8 yyr1[]

static

Initial value:

=
{
       0,    13,    14,    14,    15,    15,    16,    16,    16,    16,
      16,    16,    16,    16,    16
}

Definition at line 705 of file readcf.cc.

{
       0,    13,    14,    14,    15,    15,    16,    16,    16,    16,
      16,    16,    16,    16,    16
};

◆ yyr2

const yytype_int8 yyr2[]

static

Initial value:

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

Definition at line 712 of file readcf.cc.

{
       0,     2,     0,     2,     1,     2,     1,     3,     3,     3,
       3,     2,     2,     3,     3
};

◆ yystos

const yytype_int8 yystos[]

static

Initial value:

=
{
       0,    14,     0,     3,     4,     5,    10,    11,    15,    16,
      16,    16,    16,     4,     5,     6,     7,     9,    10,    12,
      16,    16,    16,    16,     3
}

Definition at line 697 of file readcf.cc.

{
       0,    14,     0,     3,     4,     5,    10,    11,    15,    16,
      16,    16,    16,     4,     5,     6,     7,     9,    10,    12,
      16,    16,    16,    16,     3
};

◆ yytable

const yytype_int8 yytable[]

static

Initial value:

=
{
      10,    11,    17,    12,    24,     0,     3,     4,     5,    20,
      21,    22,    23,     2,     7,     0,     3,     4,     5,     0,
       0,     0,     0,     6,     7,    13,    14,    15,    16,     0,
      17,     0,     0,    19,    13,    14,    15,    16,     0,    17,
      18,    15,    16,     0,    17
}

Definition at line 677 of file readcf.cc.

{
      10,    11,    17,    12,    24,     0,     3,     4,     5,    20,
      21,    22,    23,     2,     7,     0,     3,     4,     5,     0,
       0,     0,     0,     6,     7,    13,    14,    15,    16,     0,
      17,     0,     0,    19,    13,    14,    15,    16,     0,    17,
      18,    15,    16,     0,    17
};

◆ yytranslate

const yytype_int8 yytranslate[]

static

Initial value:

=
{
       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,
      11,    12,     6,     5,     2,     4,     2,     7,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,    10,
       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,     9,     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,     8
}

Definition at line 570 of file readcf.cc.

{
       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,
      11,    12,     6,     5,     2,     4,     2,     7,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,    10,
       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,     9,     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,     8
};

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ CERR

◆ EXIT_SUCCESS

◆ ISTREAM

◆ NEG

◆ NUM

◆ YY_

◆ YY_ACCESSING_SYMBOL

◆ YY_ASSERT

◆ YY_ATTRIBUTE_PURE

◆ YY_ATTRIBUTE_UNUSED

◆ YY_CAST

◆ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

◆ YY_IGNORE_MAYBE_UNINITIALIZED_END

◆ YY_IGNORE_USELESS_CAST_BEGIN

◆ YY_IGNORE_USELESS_CAST_END

◆ YY_INITIAL_VALUE

◆ YY_NULLPTR

◆ YY_REDUCE_PRINT

◆ YY_REINTERPRET_CAST

◆ YY_STACK_PRINT

◆ YY_SYMBOL_PRINT

◆ YY_USE

◆ YYABORT

◆ YYACCEPT

◆ YYBACKUP

◆ YYBISON

◆ YYBISON_VERSION

◆ yyclearin

◆ YYDEBUG

◆ YYDPRINTF

◆ YYEMPTY

◆ YYEOF

◆ YYERRCODE

◆ yyerrok

◆ YYERROR

◆ YYerror

◆ YYFINAL

◆ YYFREE

◆ YYINITDEPTH

◆ YYLAST

◆ YYMALLOC

◆ YYMAXDEPTH

◆ YYMAXUTOK

◆ YYNNTS

◆ YYNOMEM

◆ YYNRULES

◆ YYNSTATES

◆ YYNTOKENS

◆ YYPACT_NINF

◆ yypact_value_is_default

◆ YYPOPSTACK

◆ YYPTRDIFF_MAXIMUM

◆ YYPTRDIFF_T

◆ YYPULL

◆ YYPURE

◆ YYPUSH

◆ YYRECOVERING

◆ YYSIZE_MAXIMUM

◆ YYSIZE_T

◆ YYSIZEOF

◆ YYSKELETON_NAME

◆ YYSTACK_ALLOC

◆ YYSTACK_ALLOC_MAXIMUM

◆ YYSTACK_FREE

◆ YYSTYPE

◆ YYTABLE_NINF

◆ yytable_value_is_error

◆ YYTOKENTYPE

◆ YYTRANSLATE

◆ YYUNDEF

Typedef Documentation

◆ yy_state_fast_t

◆ yy_state_t

◆ yysymbol_kind_t