My Project  UNKNOWN_GIT_VERSION
Macros | Typedefs | Enumerations | Functions | Variables
readcf.cc File Reference
#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>

Go to the source code of this file.

Macros

#define YYBISON   1
 
#define YYBISON_VERSION   "3.5"
 
#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)   static_cast<Type> (Val)
 
#define YY_REINTERPRET_CAST(Type, Val)   reinterpret_cast<Type> (Val)
 
#define YY_NULLPTR   0
 
#define YYERROR_VERBOSE   0
 
#define YYDEBUG   0
 
#define YYTOKENTYPE
 
#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)   YY_CAST (YYPTRDIFF_T, sizeof (X))
 
#define YY_(Msgid)   Msgid
 
#define YY_ATTRIBUTE_PURE
 
#define YY_ATTRIBUTE_UNUSED
 
#define YYUSE(E)   ((void) (E))
 
#define YY_INITIAL_VALUE(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)   ((void) (0 && (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 YYUNDEFTOK   2
 
#define YYMAXUTOK   259
 
#define YYTRANSLATE(YYX)   (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
#define YYPACT_NINF   (-8)
 
#define yypact_value_is_default(Yyn)   ((Yyn) == YYPACT_NINF)
 
#define YYTABLE_NINF   (-1)
 
#define yytable_value_is_error(Yyn)   0
 
#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 YYRECOVERING()   (!!yyerrstatus)
 
#define YYBACKUP(Token, Value)
 
#define YYTERROR   1
 
#define YYERRCODE   256
 
#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 signed char yytype_int8
 
typedef short yytype_int16
 
typedef unsigned char yytype_uint8
 
typedef unsigned short yytype_uint16
 
typedef yytype_int8 yy_state_t
 
typedef int yy_state_fast_t
 

Enumerations

enum  yytokentype {
  DOTDOT = 258, EQUAL_EQUAL = 259, GE = 260, LE = 261,
  MINUSMINUS = 262, NOT = 263, NOTEQUAL = 264, PLUSPLUS = 265,
  COLONCOLON = 266, ARROW = 267, GRING_CMD = 268, BIGINTMAT_CMD = 269,
  INTMAT_CMD = 270, PROC_CMD = 271, RING_CMD = 272, BEGIN_RING = 273,
  BUCKET_CMD = 274, IDEAL_CMD = 275, MAP_CMD = 276, MATRIX_CMD = 277,
  MODUL_CMD = 278, NUMBER_CMD = 279, POLY_CMD = 280, RESOLUTION_CMD = 281,
  SMATRIX_CMD = 282, VECTOR_CMD = 283, BETTI_CMD = 284, E_CMD = 285,
  FETCH_CMD = 286, FREEMODULE_CMD = 287, KEEPRING_CMD = 288, IMAP_CMD = 289,
  KOSZUL_CMD = 290, MAXID_CMD = 291, MONOM_CMD = 292, PAR_CMD = 293,
  PREIMAGE_CMD = 294, VAR_CMD = 295, VALTVARS = 296, VMAXDEG = 297,
  VMAXMULT = 298, VNOETHER = 299, VMINPOLY = 300, END_RING = 301,
  CMD_1 = 302, CMD_2 = 303, CMD_3 = 304, CMD_12 = 305,
  CMD_13 = 306, CMD_23 = 307, CMD_123 = 308, CMD_M = 309,
  ROOT_DECL = 310, ROOT_DECL_LIST = 311, RING_DECL = 312, RING_DECL_LIST = 313,
  EXAMPLE_CMD = 314, EXPORT_CMD = 315, HELP_CMD = 316, KILL_CMD = 317,
  LIB_CMD = 318, LISTVAR_CMD = 319, SETRING_CMD = 320, TYPE_CMD = 321,
  STRINGTOK = 322, BLOCKTOK = 323, INT_CONST = 324, UNKNOWN_IDENT = 325,
  RINGVAR = 326, PROC_DEF = 327, APPLY = 328, ASSUME_CMD = 329,
  BREAK_CMD = 330, CONTINUE_CMD = 331, ELSE_CMD = 332, EVAL = 333,
  QUOTE = 334, FOR_CMD = 335, IF_CMD = 336, SYS_BREAK = 337,
  WHILE_CMD = 338, RETURN = 339, PARAMETER = 340, SYSVAR = 341,
  UMINUS = 342, DOTDOT = 258, EQUAL_EQUAL = 259, GE = 260,
  LE = 261, MINUSMINUS = 262, NOT = 263, NOTEQUAL = 264,
  PLUSPLUS = 265, COLONCOLON = 266, ARROW = 267, GRING_CMD = 268,
  BIGINTMAT_CMD = 269, INTMAT_CMD = 270, PROC_CMD = 271, RING_CMD = 272,
  BEGIN_RING = 273, BUCKET_CMD = 274, IDEAL_CMD = 275, MAP_CMD = 276,
  MATRIX_CMD = 277, MODUL_CMD = 278, NUMBER_CMD = 279, POLY_CMD = 280,
  RESOLUTION_CMD = 281, SMATRIX_CMD = 282, VECTOR_CMD = 283, BETTI_CMD = 284,
  E_CMD = 285, FETCH_CMD = 286, FREEMODULE_CMD = 287, KEEPRING_CMD = 288,
  IMAP_CMD = 289, KOSZUL_CMD = 290, MAXID_CMD = 291, MONOM_CMD = 292,
  PAR_CMD = 293, PREIMAGE_CMD = 294, VAR_CMD = 295, VALTVARS = 296,
  VMAXDEG = 297, VMAXMULT = 298, VNOETHER = 299, VMINPOLY = 300,
  END_RING = 301, CMD_1 = 302, CMD_2 = 303, CMD_3 = 304,
  CMD_12 = 305, CMD_13 = 306, CMD_23 = 307, CMD_123 = 308,
  CMD_M = 309, ROOT_DECL = 310, ROOT_DECL_LIST = 311, RING_DECL = 312,
  RING_DECL_LIST = 313, EXAMPLE_CMD = 314, EXPORT_CMD = 315, HELP_CMD = 316,
  KILL_CMD = 317, LIB_CMD = 318, LISTVAR_CMD = 319, SETRING_CMD = 320,
  TYPE_CMD = 321, STRINGTOK = 322, BLOCKTOK = 323, INT_CONST = 324,
  UNKNOWN_IDENT = 325, RINGVAR = 326, PROC_DEF = 327, APPLY = 328,
  ASSUME_CMD = 329, BREAK_CMD = 330, CONTINUE_CMD = 331, ELSE_CMD = 332,
  EVAL = 333, QUOTE = 334, FOR_CMD = 335, IF_CMD = 336,
  SYS_BREAK = 337, WHILE_CMD = 338, RETURN = 339, PARAMETER = 340,
  SYSVAR = 341, UMINUS = 342, NUM = 258, NEG = 259
}
 

Functions

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

Variables

static ISTREAMdefaultin = 0
 
static CanonicalFormretvalue = 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 93 of file readcf.cc.

◆ EXIT_SUCCESS

#define EXIT_SUCCESS   0

Definition at line 417 of file readcf.cc.

◆ ISTREAM

#define ISTREAM   std::istream

Definition at line 92 of file readcf.cc.

◆ NEG

#define NEG   259

Definition at line 179 of file readcf.cc.

◆ NUM

#define NUM   258

Definition at line 178 of file readcf.cc.

◆ YY_

#define YY_ (   Msgid)    Msgid

Definition at line 307 of file readcf.cc.

◆ YY_ASSERT

#define YY_ASSERT (   E)    ((void) (0 && (E)))

Definition at line 366 of file readcf.cc.

◆ YY_ATTRIBUTE_PURE

#define YY_ATTRIBUTE_PURE

Definition at line 315 of file readcf.cc.

◆ YY_ATTRIBUTE_UNUSED

#define YY_ATTRIBUTE_UNUSED

Definition at line 323 of file readcf.cc.

◆ YY_CAST

#define YY_CAST (   Type,
  Val 
)    static_cast<Type> (Val)

Definition at line 132 of file readcf.cc.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

Definition at line 346 of file readcf.cc.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_END

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

Definition at line 347 of file readcf.cc.

◆ YY_IGNORE_USELESS_CAST_BEGIN

#define YY_IGNORE_USELESS_CAST_BEGIN

Definition at line 361 of file readcf.cc.

◆ YY_IGNORE_USELESS_CAST_END

#define YY_IGNORE_USELESS_CAST_END

Definition at line 362 of file readcf.cc.

◆ YY_INITIAL_VALUE

#define YY_INITIAL_VALUE (   Value)    Value

Definition at line 343 of file readcf.cc.

◆ YY_NULLPTR

#define YY_NULLPTR   0

Definition at line 144 of file readcf.cc.

◆ YY_REDUCE_PRINT

#define YY_REDUCE_PRINT (   Rule)

Definition at line 829 of file readcf.cc.

◆ YY_REINTERPRET_CAST

#define YY_REINTERPRET_CAST (   Type,
  Val 
)    reinterpret_cast<Type> (Val)

Definition at line 133 of file readcf.cc.

◆ YY_STACK_PRINT

#define YY_STACK_PRINT (   Bottom,
  Top 
)

Definition at line 828 of file readcf.cc.

◆ YY_SYMBOL_PRINT

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

Definition at line 827 of file readcf.cc.

◆ YYABORT

#define YYABORT   goto yyabortlab

Definition at line 672 of file readcf.cc.

◆ YYACCEPT

#define YYACCEPT   goto yyacceptlab

Definition at line 671 of file readcf.cc.

◆ YYBACKUP

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

Definition at line 678 of file readcf.cc.

◆ YYBISON

#define YYBISON   1

Definition at line 48 of file readcf.cc.

◆ YYBISON_VERSION

#define YYBISON_VERSION   "3.5"

Definition at line 51 of file readcf.cc.

◆ yyclearin

#define yyclearin   (yychar = YYEMPTY)

Definition at line 667 of file readcf.cc.

◆ YYDEBUG

#define YYDEBUG   0

Definition at line 162 of file readcf.cc.

◆ YYDPRINTF

#define YYDPRINTF (   Args)

Definition at line 826 of file readcf.cc.

◆ YYEMPTY

#define YYEMPTY   (-2)

Definition at line 668 of file readcf.cc.

◆ YYEOF

#define YYEOF   0

Definition at line 669 of file readcf.cc.

◆ YYERRCODE

#define YYERRCODE   256

Definition at line 697 of file readcf.cc.

◆ yyerrok

#define yyerrok   (yyerrstatus = 0)

Definition at line 666 of file readcf.cc.

◆ YYERROR

#define YYERROR   goto yyerrorlab

Definition at line 673 of file readcf.cc.

◆ YYERROR_VERBOSE

#define YYERROR_VERBOSE   0

Definition at line 156 of file readcf.cc.

◆ YYFINAL

#define YYFINAL   2

Definition at line 497 of file readcf.cc.

◆ YYFREE

#define YYFREE   free

Definition at line 427 of file readcf.cc.

◆ YYINITDEPTH

#define YYINITDEPTH   200

Definition at line 835 of file readcf.cc.

◆ YYLAST

#define YYLAST   44

Definition at line 499 of file readcf.cc.

◆ YYMALLOC

#define YYMALLOC   malloc

Definition at line 421 of file readcf.cc.

◆ YYMAXDEPTH

#define YYMAXDEPTH   10000

Definition at line 846 of file readcf.cc.

◆ YYMAXUTOK

#define YYMAXUTOK   259

Definition at line 511 of file readcf.cc.

◆ YYNNTS

#define YYNNTS   4

Definition at line 504 of file readcf.cc.

◆ YYNRULES

#define YYNRULES   14

Definition at line 506 of file readcf.cc.

◆ YYNSTATES

#define YYNSTATES   25

Definition at line 508 of file readcf.cc.

◆ YYNTOKENS

#define YYNTOKENS   13

Definition at line 502 of file readcf.cc.

◆ YYPACT_NINF

#define YYPACT_NINF   (-8)

Definition at line 580 of file readcf.cc.

◆ yypact_value_is_default

#define yypact_value_is_default (   Yyn)    ((Yyn) == YYPACT_NINF)

Definition at line 582 of file readcf.cc.

◆ YYPOPSTACK

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

◆ YYPTRDIFF_MAXIMUM

#define YYPTRDIFF_MAXIMUM   LONG_MAX

Definition at line 268 of file readcf.cc.

◆ YYPTRDIFF_T

#define YYPTRDIFF_T   long

Definition at line 267 of file readcf.cc.

◆ YYPULL

#define YYPULL   1

Definition at line 63 of file readcf.cc.

◆ YYPURE

#define YYPURE   0

Definition at line 57 of file readcf.cc.

◆ YYPUSH

#define YYPUSH   0

Definition at line 60 of file readcf.cc.

◆ YYRECOVERING

#define YYRECOVERING ( )    (!!yyerrstatus)

Definition at line 676 of file readcf.cc.

◆ YYSIZE_MAXIMUM

#define YYSIZE_MAXIMUM
Value:

Definition at line 285 of file readcf.cc.

◆ YYSIZE_T

#define YYSIZE_T   unsigned

Definition at line 281 of file readcf.cc.

◆ YYSIZEOF

#define YYSIZEOF (   X)    YY_CAST (YYPTRDIFF_T, sizeof (X))

Definition at line 291 of file readcf.cc.

◆ YYSKELETON_NAME

#define YYSKELETON_NAME   "yacc.c"

Definition at line 54 of file readcf.cc.

◆ YYSTACK_ALLOC

#define YYSTACK_ALLOC   YYMALLOC

Definition at line 407 of file readcf.cc.

◆ YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

Definition at line 410 of file readcf.cc.

◆ YYSTACK_FREE

#define YYSTACK_FREE   YYFREE

Definition at line 408 of file readcf.cc.

◆ YYSTYPE

#define YYSTYPE   ParseUtil

Definition at line 110 of file readcf.cc.

◆ YYTABLE_NINF

#define YYTABLE_NINF   (-1)

Definition at line 585 of file readcf.cc.

◆ yytable_value_is_error

#define yytable_value_is_error (   Yyn)    0

Definition at line 587 of file readcf.cc.

◆ YYTERROR

#define YYTERROR   1

Definition at line 696 of file readcf.cc.

◆ YYTOKENTYPE

#define YYTOKENTYPE

Definition at line 170 of file readcf.cc.

◆ YYTRANSLATE

#define YYTRANSLATE (   YYX)    (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

Definition at line 516 of file readcf.cc.

◆ YYUNDEFTOK

#define YYUNDEFTOK   2

Definition at line 510 of file readcf.cc.

◆ YYUSE

#define YYUSE (   E)    ((void) (E))

Definition at line 329 of file readcf.cc.

Typedef Documentation

◆ yy_state_fast_t

typedef int yy_state_fast_t

Definition at line 297 of file readcf.cc.

◆ yy_state_t

Definition at line 294 of file readcf.cc.

◆ yytype_int16

typedef short yytype_int16

Definition at line 231 of file readcf.cc.

◆ yytype_int8

typedef signed char yytype_int8

Definition at line 223 of file readcf.cc.

◆ yytype_uint16

typedef unsigned short yytype_uint16

Definition at line 251 of file readcf.cc.

◆ yytype_uint8

typedef unsigned char yytype_uint8

Definition at line 240 of file readcf.cc.

Enumeration Type Documentation

◆ yytokentype

Enumerator
DOTDOT 
EQUAL_EQUAL 
GE 
LE 
MINUSMINUS 
NOT 
NOTEQUAL 
PLUSPLUS 
COLONCOLON 
ARROW 
GRING_CMD 
BIGINTMAT_CMD 
INTMAT_CMD 
PROC_CMD 
RING_CMD 
BEGIN_RING 
BUCKET_CMD 
IDEAL_CMD 
MAP_CMD 
MATRIX_CMD 
MODUL_CMD 
NUMBER_CMD 
POLY_CMD 
RESOLUTION_CMD 
SMATRIX_CMD 
VECTOR_CMD 
BETTI_CMD 
E_CMD 
FETCH_CMD 
FREEMODULE_CMD 
KEEPRING_CMD 
IMAP_CMD 
KOSZUL_CMD 
MAXID_CMD 
MONOM_CMD 
PAR_CMD 
PREIMAGE_CMD 
VAR_CMD 
VALTVARS 
VMAXDEG 
VMAXMULT 
VNOETHER 
VMINPOLY 
END_RING 
CMD_1 
CMD_2 
CMD_3 
CMD_12 
CMD_13 
CMD_23 
CMD_123 
CMD_M 
ROOT_DECL 
ROOT_DECL_LIST 
RING_DECL 
RING_DECL_LIST 
EXAMPLE_CMD 
EXPORT_CMD 
HELP_CMD 
KILL_CMD 
LIB_CMD 
LISTVAR_CMD 
SETRING_CMD 
TYPE_CMD 
STRINGTOK 
BLOCKTOK 
INT_CONST 
UNKNOWN_IDENT 
RINGVAR 
PROC_DEF 
APPLY 
ASSUME_CMD 
BREAK_CMD 
CONTINUE_CMD 
ELSE_CMD 
EVAL 
QUOTE 
FOR_CMD 
IF_CMD 
SYS_BREAK 
WHILE_CMD 
RETURN 
PARAMETER 
SYSVAR 
UMINUS 
DOTDOT 
EQUAL_EQUAL 
GE 
LE 
MINUSMINUS 
NOT 
NOTEQUAL 
PLUSPLUS 
COLONCOLON 
ARROW 
GRING_CMD 
BIGINTMAT_CMD 
INTMAT_CMD 
PROC_CMD 
RING_CMD 
BEGIN_RING 
BUCKET_CMD 
IDEAL_CMD 
MAP_CMD 
MATRIX_CMD 
MODUL_CMD 
NUMBER_CMD 
POLY_CMD 
RESOLUTION_CMD 
SMATRIX_CMD 
VECTOR_CMD 
BETTI_CMD 
E_CMD 
FETCH_CMD 
FREEMODULE_CMD 
KEEPRING_CMD 
IMAP_CMD 
KOSZUL_CMD 
MAXID_CMD 
MONOM_CMD 
PAR_CMD 
PREIMAGE_CMD 
VAR_CMD 
VALTVARS 
VMAXDEG 
VMAXMULT 
VNOETHER 
VMINPOLY 
END_RING 
CMD_1 
CMD_2 
CMD_3 
CMD_12 
CMD_13 
CMD_23 
CMD_123 
CMD_M 
ROOT_DECL 
ROOT_DECL_LIST 
RING_DECL 
RING_DECL_LIST 
EXAMPLE_CMD 
EXPORT_CMD 
HELP_CMD 
KILL_CMD 
LIB_CMD 
LISTVAR_CMD 
SETRING_CMD 
TYPE_CMD 
STRINGTOK 
BLOCKTOK 
INT_CONST 
UNKNOWN_IDENT 
RINGVAR 
PROC_DEF 
APPLY 
ASSUME_CMD 
BREAK_CMD 
CONTINUE_CMD 
ELSE_CMD 
EVAL 
QUOTE 
FOR_CMD 
IF_CMD 
SYS_BREAK 
WHILE_CMD 
RETURN 
PARAMETER 
SYSVAR 
UMINUS 
NUM 
NEG 

Definition at line 171 of file readcf.cc.

172  {
173  NUM = 258,
174  NEG = 259
175  };

Function Documentation

◆ readCF()

CanonicalForm readCF ( ISTREAM str)

Definition at line 1717 of file readcf.cc.

1718 {
1719  CanonicalForm theRetvalue;
1720  retvalue = new CanonicalForm();
1721 #ifdef BISONPP
1722  YY_parse_CLASS my_parser;
1723  defaultin = &str;
1724  if ( my_parser.yyparse() == 0 ) {
1725  theRetvalue = *retvalue;
1726  delete retvalue;
1727  return theRetvalue;
1728  }
1729  else {
1730  delete retvalue;
1731  return 0;
1732  }
1733 #else
1734  defaultin = &str;
1735  if ( yyparse() == 0 ) {
1736  theRetvalue = *retvalue;
1737  delete retvalue;
1738  return theRetvalue;
1739  }
1740  else {
1741  delete retvalue;
1742  return 0;
1743  }
1744 #endif
1745 }

◆ readString()

char * readString ( ISTREAM s)
static

Definition at line 1747 of file readcf.cc.

1748 {
1749  static char * buffer = 0;
1750  static int bufsize = 0;
1751 
1752  if ( buffer == 0 ) {
1753  bufsize = 10000;
1754  buffer = new char[bufsize];
1755  }
1756  int i = 0, c, goon = 1;
1757  while ( goon ) {
1758  while ( isdigit( c = s.get() ) && i < bufsize - 2 ) {
1759  buffer[i] = c;
1760  i++;
1761  }
1762  if ( isdigit( c ) ) {
1763  bufsize += 1000;
1764  char * newbuffer = (char*)memcpy( new char[bufsize], buffer, bufsize - 1000 );
1765  delete [] buffer;
1766  buffer = newbuffer;
1767  buffer[i] = c;
1768  i++;
1769  }
1770  else {
1771  goon = 0;
1772  buffer[i] = '\0';
1773  s.putback( c );
1774  }
1775  }
1776  return buffer;
1777 }

◆ yydestruct()

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

Definition at line 1087 of file readcf.cc.

1088 {
1089  YYUSE (yyvaluep);
1090  if (!yymsg)
1091  yymsg = "Deleting";
1092  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1093 
1095  YYUSE (yytype);
1097 }

◆ yyerror()

void yyerror ( char *  s)

Definition at line 1656 of file readcf.cc.

1658 {
1659  CERR << s << "\n";
1660 }

◆ yylex()

int yylex ( )

Definition at line 1665 of file readcf.cc.

1667 {
1668  int c;
1669 
1670  while ((c = defaultin->get()) == ' ' || c == '\t' || c == '\n' ) ;
1671  if ( isdigit( c ) ) {
1672  defaultin->putback( c );
1674  return NUM;
1675  }
1676  else if ( isalpha( c ) ) {
1677  // look for generators of GF(q)
1678  if ( getCharacteristic() > 0 && getGFDegree() > 1 && c == gf_name ) {
1679 #ifdef BISONPP
1680  this->yylval = getGFGenerator();
1681 #else
1682  yylval = getGFGenerator();
1683 #endif
1684  }
1685  else if ( c == getDefaultVarName() ) {
1686  int cc;
1687  cc = defaultin->get();
1688  if ( cc == '_' ) {
1690 #ifdef BISONPP
1691  this->yylval = Variable( index.getintval() );
1692 #else
1693  yylval = Variable( index.getintval() );
1694 #endif
1695  }
1696  else {
1697  defaultin->putback( cc );
1698 #ifdef BISONPP
1699  this->yylval = Variable( (char)c );
1700 #else
1701  yylval = Variable( (char)c );
1702 #endif
1703  }
1704  }
1705  else {
1706 #ifdef BISONPP
1707  this->yylval = Variable( (char)c );
1708 #else
1709  yylval = Variable( (char)c );
1710 #endif
1711  }
1712  return NUM;
1713  }
1714  return c;
1715 }

◆ yyparse()

int yyparse ( void  )

Definition at line 1116 of file readcf.cc.

1117 {
1118  yy_state_fast_t yystate;
1119  /* Number of tokens to shift before error messages enabled. */
1120  int yyerrstatus;
1121 
1122  /* The stacks and their tools:
1123  'yyss': related to states.
1124  'yyvs': related to semantic values.
1125 
1126  Refer to the stacks through separate pointers, to allow yyoverflow
1127  to reallocate them elsewhere. */
1128 
1129  /* The state stack. */
1130  yy_state_t yyssa[YYINITDEPTH];
1131  yy_state_t *yyss;
1132  yy_state_t *yyssp;
1133 
1134  /* The semantic value stack. */
1135  YYSTYPE yyvsa[YYINITDEPTH];
1136  YYSTYPE *yyvs;
1137  YYSTYPE *yyvsp;
1138 
1139  YYPTRDIFF_T yystacksize;
1140 
1141  int yyn;
1142  int yyresult;
1143  /* Lookahead token as an internal (translated) token number. */
1144  int yytoken = 0;
1145  /* The variables used to return semantic value and location from the
1146  action routines. */
1147  YYSTYPE yyval;
1148 
1149 #if YYERROR_VERBOSE
1150  /* Buffer for error messages, and its allocated size. */
1151  char yymsgbuf[128];
1152  char *yymsg = yymsgbuf;
1153  YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
1154 #endif
1155 
1156 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1157 
1158  /* The number of symbols on the RHS of the reduced rule.
1159  Keep to zero when no symbol should be popped. */
1160  int yylen = 0;
1161 
1162  yyssp = yyss = yyssa;
1163  yyvsp = yyvs = yyvsa;
1164  yystacksize = YYINITDEPTH;
1165 
1166  YYDPRINTF ((stderr, "Starting parse\n"));
1167 
1168  yystate = 0;
1169  yyerrstatus = 0;
1170  yynerrs = 0;
1171  yychar = YYEMPTY; /* Cause a token to be read. */
1172  goto yysetstate;
1173 
1174 
1175 /*------------------------------------------------------------.
1176 | yynewstate -- push a new state, which is found in yystate. |
1177 `------------------------------------------------------------*/
1178 yynewstate:
1179  /* In all cases, when you get here, the value and location stacks
1180  have just been pushed. So pushing a state here evens the stacks. */
1181  yyssp++;
1182 
1183 
1184 /*--------------------------------------------------------------------.
1185 | yysetstate -- set current state (the top of the stack) to yystate. |
1186 `--------------------------------------------------------------------*/
1187 yysetstate:
1188  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1189  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1191  *yyssp = YY_CAST (yy_state_t, yystate);
1193 
1194  if (yyss + yystacksize - 1 <= yyssp)
1195 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1196  goto yyexhaustedlab;
1197 #else
1198  {
1199  /* Get the current used size of the three stacks, in elements. */
1200  YYPTRDIFF_T yysize = yyssp - yyss + 1;
1201 
1202 # if defined yyoverflow
1203  {
1204  /* Give user a chance to reallocate the stack. Use copies of
1205  these so that the &'s don't force the real ones into
1206  memory. */
1207  yy_state_t *yyss1 = yyss;
1208  YYSTYPE *yyvs1 = yyvs;
1209 
1210  /* Each stack pointer address is followed by the size of the
1211  data in use in that stack, in bytes. This used to be a
1212  conditional around just the two extra args, but that might
1213  be undefined if yyoverflow is a macro. */
1214  yyoverflow (YY_("memory exhausted"),
1215  &yyss1, yysize * YYSIZEOF (*yyssp),
1216  &yyvs1, yysize * YYSIZEOF (*yyvsp),
1217  &yystacksize);
1218  yyss = yyss1;
1219  yyvs = yyvs1;
1220  }
1221 # else /* defined YYSTACK_RELOCATE */
1222  /* Extend the stack our own way. */
1223  if (YYMAXDEPTH <= yystacksize)
1224  goto yyexhaustedlab;
1225  yystacksize *= 2;
1226  if (YYMAXDEPTH < yystacksize)
1227  yystacksize = YYMAXDEPTH;
1228 
1229  {
1230  yy_state_t *yyss1 = yyss;
1231  union yyalloc *yyptr =
1232  YY_CAST (union yyalloc *,
1233  YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1234  if (! yyptr)
1235  goto yyexhaustedlab;
1236  YYSTACK_RELOCATE (yyss_alloc, yyss);
1237  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1238 # undef YYSTACK_RELOCATE
1239  if (yyss1 != yyssa)
1240  YYSTACK_FREE (yyss1);
1241  }
1242 # endif
1243 
1244  yyssp = yyss + yysize - 1;
1245  yyvsp = yyvs + yysize - 1;
1246 
1248  YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1249  YY_CAST (long, yystacksize)));
1251 
1252  if (yyss + yystacksize - 1 <= yyssp)
1253  YYABORT;
1254  }
1255 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1256 
1257  if (yystate == YYFINAL)
1258  YYACCEPT;
1259 
1260  goto yybackup;
1261 
1262 
1263 /*-----------.
1264 | yybackup. |
1265 `-----------*/
1266 yybackup:
1267  /* Do appropriate processing given the current state. Read a
1268  lookahead token if we need one and don't already have one. */
1269 
1270  /* First try to decide what to do without reference to lookahead token. */
1271  yyn = yypact[yystate];
1272  if (yypact_value_is_default (yyn))
1273  goto yydefault;
1274 
1275  /* Not known => get a lookahead token if don't already have one. */
1276 
1277  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1278  if (yychar == YYEMPTY)
1279  {
1280  YYDPRINTF ((stderr, "Reading a token: "));
1281  yychar = yylex ();
1282  }
1283 
1284  if (yychar <= YYEOF)
1285  {
1286  yychar = yytoken = YYEOF;
1287  YYDPRINTF ((stderr, "Now at end of input.\n"));
1288  }
1289  else
1290  {
1291  yytoken = YYTRANSLATE (yychar);
1292  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1293  }
1294 
1295  /* If the proper action on seeing token YYTOKEN is to reduce or to
1296  detect an error, take that action. */
1297  yyn += yytoken;
1298  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1299  goto yydefault;
1300  yyn = yytable[yyn];
1301  if (yyn <= 0)
1302  {
1303  if (yytable_value_is_error (yyn))
1304  goto yyerrlab;
1305  yyn = -yyn;
1306  goto yyreduce;
1307  }
1308 
1309  /* Count tokens shifted since error; after three, turn off error
1310  status. */
1311  if (yyerrstatus)
1312  yyerrstatus--;
1313 
1314  /* Shift the lookahead token. */
1315  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1316  yystate = yyn;
1318  *++yyvsp = yylval;
1320 
1321  /* Discard the shifted token. */
1322  yychar = YYEMPTY;
1323  goto yynewstate;
1324 
1325 
1326 /*-----------------------------------------------------------.
1327 | yydefault -- do the default action for the current state. |
1328 `-----------------------------------------------------------*/
1329 yydefault:
1330  yyn = yydefact[yystate];
1331  if (yyn == 0)
1332  goto yyerrlab;
1333  goto yyreduce;
1334 
1335 
1336 /*-----------------------------.
1337 | yyreduce -- do a reduction. |
1338 `-----------------------------*/
1339 yyreduce:
1340  /* yyn is the number of a rule to reduce with. */
1341  yylen = yyr2[yyn];
1342 
1343  /* If YYLEN is nonzero, implement the default value of the action:
1344  '$$ = $1'.
1345 
1346  Otherwise, the following line sets YYVAL to garbage.
1347  This behavior is undocumented and Bison
1348  users should not rely upon it. Assigning to YYVAL
1349  unconditionally makes the parser a bit smaller, and it avoids a
1350  GCC warning that YYVAL may be used uninitialized. */
1351  yyval = yyvsp[1-yylen];
1352 
1353 
1354  YY_REDUCE_PRINT (yyn);
1355  switch (yyn)
1356  {
1357  case 5:
1358 #line 78 "readcf.yy"
1359  { *retvalue = yyvsp[-1].getval(); return 0; }
1360 #line 1361 "readcf.cc"
1361  break;
1362 
1363  case 6:
1364 #line 81 "readcf.yy"
1365  { yyval = yyvsp[0]; }
1366 #line 1367 "readcf.cc"
1367  break;
1368 
1369  case 7:
1370 #line 82 "readcf.yy"
1371  { yyval = yyvsp[-2].getval() + yyvsp[0].getval(); }
1372 #line 1373 "readcf.cc"
1373  break;
1374 
1375  case 8:
1376 #line 83 "readcf.yy"
1377  { yyval = yyvsp[-2].getval() - yyvsp[0].getval(); }
1378 #line 1379 "readcf.cc"
1379  break;
1380 
1381  case 9:
1382 #line 84 "readcf.yy"
1383  { yyval = yyvsp[-2].getval() * yyvsp[0].getval(); }
1384 #line 1385 "readcf.cc"
1385  break;
1386 
1387  case 10:
1388 #line 85 "readcf.yy"
1389  { yyval = yyvsp[-2].getval() / yyvsp[0].getval(); }
1390 #line 1391 "readcf.cc"
1391  break;
1392 
1393  case 11:
1394 #line 86 "readcf.yy"
1395  { yyval = -yyvsp[0].getval(); }
1396 #line 1397 "readcf.cc"
1397  break;
1398 
1399  case 12:
1400 #line 87 "readcf.yy"
1401  { yyval = yyvsp[0].getval(); }
1402 #line 1403 "readcf.cc"
1403  break;
1404 
1405  case 13:
1406 #line 88 "readcf.yy"
1407  { yyval = power( yyvsp[-2].getval(), yyvsp[0].getintval() ); }
1408 #line 1409 "readcf.cc"
1409  break;
1410 
1411  case 14:
1412 #line 89 "readcf.yy"
1413  { yyval = yyvsp[-1].getval(); }
1414 #line 1415 "readcf.cc"
1415  break;
1416 
1417 
1418 #line 1419 "readcf.cc"
1419 
1420  default: break;
1421  }
1422  /* User semantic actions sometimes alter yychar, and that requires
1423  that yytoken be updated with the new translation. We take the
1424  approach of translating immediately before every use of yytoken.
1425  One alternative is translating here after every semantic action,
1426  but that translation would be missed if the semantic action invokes
1427  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1428  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1429  incorrect destructor might then be invoked immediately. In the
1430  case of YYERROR or YYBACKUP, subsequent parser actions might lead
1431  to an incorrect destructor call or verbose syntax error message
1432  before the lookahead is translated. */
1433  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1434 
1435  YYPOPSTACK (yylen);
1436  yylen = 0;
1437  YY_STACK_PRINT (yyss, yyssp);
1438 
1439  *++yyvsp = yyval;
1440 
1441  /* Now 'shift' the result of the reduction. Determine what state
1442  that goes to, based on the state we popped back to and the rule
1443  number reduced by. */
1444  {
1445  const int yylhs = yyr1[yyn] - YYNTOKENS;
1446  const int yyi = yypgoto[yylhs] + *yyssp;
1447  yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1448  ? yytable[yyi]
1449  : yydefgoto[yylhs]);
1450  }
1451 
1452  goto yynewstate;
1453 
1454 
1455 /*--------------------------------------.
1456 | yyerrlab -- here on detecting error. |
1457 `--------------------------------------*/
1458 yyerrlab:
1459  /* Make sure we have latest lookahead translation. See comments at
1460  user semantic actions for why this is necessary. */
1461  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1462 
1463  /* If not already recovering from an error, report this error. */
1464  if (!yyerrstatus)
1465  {
1466  ++yynerrs;
1467 #if ! YYERROR_VERBOSE
1468  yyerror (YY_("syntax error"));
1469 #else
1470 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1471  yyssp, yytoken)
1472  {
1473  char const *yymsgp = YY_("syntax error");
1474  int yysyntax_error_status;
1475  yysyntax_error_status = YYSYNTAX_ERROR;
1476  if (yysyntax_error_status == 0)
1477  yymsgp = yymsg;
1478  else if (yysyntax_error_status == 1)
1479  {
1480  if (yymsg != yymsgbuf)
1481  YYSTACK_FREE (yymsg);
1482  yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
1483  if (!yymsg)
1484  {
1485  yymsg = yymsgbuf;
1486  yymsg_alloc = sizeof yymsgbuf;
1487  yysyntax_error_status = 2;
1488  }
1489  else
1490  {
1491  yysyntax_error_status = YYSYNTAX_ERROR;
1492  yymsgp = yymsg;
1493  }
1494  }
1495  yyerror (yymsgp);
1496  if (yysyntax_error_status == 2)
1497  goto yyexhaustedlab;
1498  }
1499 # undef YYSYNTAX_ERROR
1500 #endif
1501  }
1502 
1503 
1504 
1505  if (yyerrstatus == 3)
1506  {
1507  /* If just tried and failed to reuse lookahead token after an
1508  error, discard it. */
1509 
1510  if (yychar <= YYEOF)
1511  {
1512  /* Return failure if at end of input. */
1513  if (yychar == YYEOF)
1514  YYABORT;
1515  }
1516  else
1517  {
1518  yydestruct ("Error: discarding",
1519  yytoken, &yylval);
1520  yychar = YYEMPTY;
1521  }
1522  }
1523 
1524  /* Else will try to reuse lookahead token after shifting the error
1525  token. */
1526  goto yyerrlab1;
1527 
1528 
1529 /*---------------------------------------------------.
1530 | yyerrorlab -- error raised explicitly by YYERROR. |
1531 `---------------------------------------------------*/
1532 yyerrorlab:
1533  /* Pacify compilers when the user code never invokes YYERROR and the
1534  label yyerrorlab therefore never appears in user code. */
1535  if (0)
1536  YYERROR;
1537 
1538  /* Do not reclaim the symbols of the rule whose action triggered
1539  this YYERROR. */
1540  YYPOPSTACK (yylen);
1541  yylen = 0;
1542  YY_STACK_PRINT (yyss, yyssp);
1543  yystate = *yyssp;
1544  goto yyerrlab1;
1545 
1546 
1547 /*-------------------------------------------------------------.
1548 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1549 `-------------------------------------------------------------*/
1550 yyerrlab1:
1551  yyerrstatus = 3; /* Each real token shifted decrements this. */
1552 
1553  for (;;)
1554  {
1555  yyn = yypact[yystate];
1556  if (!yypact_value_is_default (yyn))
1557  {
1558  yyn += YYTERROR;
1559  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1560  {
1561  yyn = yytable[yyn];
1562  if (0 < yyn)
1563  break;
1564  }
1565  }
1566 
1567  /* Pop the current state because it cannot handle the error token. */
1568  if (yyssp == yyss)
1569  YYABORT;
1570 
1571 
1572  yydestruct ("Error: popping",
1573  yystos[yystate], yyvsp);
1574  YYPOPSTACK (1);
1575  yystate = *yyssp;
1576  YY_STACK_PRINT (yyss, yyssp);
1577  }
1578 
1580  *++yyvsp = yylval;
1582 
1583 
1584  /* Shift the error token. */
1585  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1586 
1587  yystate = yyn;
1588  goto yynewstate;
1589 
1590 
1591 /*-------------------------------------.
1592 | yyacceptlab -- YYACCEPT comes here. |
1593 `-------------------------------------*/
1594 yyacceptlab:
1595  yyresult = 0;
1596  goto yyreturn;
1597 
1598 
1599 /*-----------------------------------.
1600 | yyabortlab -- YYABORT comes here. |
1601 `-----------------------------------*/
1602 yyabortlab:
1603  yyresult = 1;
1604  goto yyreturn;
1605 
1606 
1607 #if !defined yyoverflow || YYERROR_VERBOSE
1608 /*-------------------------------------------------.
1609 | yyexhaustedlab -- memory exhaustion comes here. |
1610 `-------------------------------------------------*/
1611 yyexhaustedlab:
1612  yyerror (YY_("memory exhausted"));
1613  yyresult = 2;
1614  /* Fall through. */
1615 #endif
1616 
1617 
1618 /*-----------------------------------------------------.
1619 | yyreturn -- parsing is finished, return the result. |
1620 `-----------------------------------------------------*/
1621 yyreturn:
1622  if (yychar != YYEMPTY)
1623  {
1624  /* Make sure we have latest lookahead translation. See comments at
1625  user semantic actions for why this is necessary. */
1626  yytoken = YYTRANSLATE (yychar);
1627  yydestruct ("Cleanup: discarding lookahead",
1628  yytoken, &yylval);
1629  }
1630  /* Do not reclaim the symbols of the rule whose action triggered
1631  this YYABORT or YYACCEPT. */
1632  YYPOPSTACK (yylen);
1633  YY_STACK_PRINT (yyss, yyssp);
1634  while (yyssp != yyss)
1635  {
1636  yydestruct ("Cleanup: popping",
1637  yystos[*yyssp], yyvsp);
1638  YYPOPSTACK (1);
1639  }
1640 #ifndef yyoverflow
1641  if (yyss != yyssa)
1642  YYSTACK_FREE (yyss);
1643 #endif
1644 #if YYERROR_VERBOSE
1645  if (yymsg != yymsgbuf)
1646  YYSTACK_FREE (yymsg);
1647 #endif
1648  return yyresult;
1649 }

Variable Documentation

◆ defaultin

ISTREAM* defaultin = 0
static

Definition at line 123 of file readcf.cc.

◆ retvalue

CanonicalForm* retvalue = 0
static

Definition at line 125 of file readcf.cc.

◆ yychar

int yychar

Definition at line 1103 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 633 of file readcf.cc.

◆ 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 602 of file readcf.cc.

◆ yydefgoto

const yytype_int8 yydefgoto[]
static
Initial value:
=
{
-1, 1, 8, 9
}

Definition at line 616 of file readcf.cc.

◆ yylval

YYSTYPE yylval

Definition at line 1106 of file readcf.cc.

◆ yynerrs

int yynerrs

Definition at line 1108 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 592 of file readcf.cc.

◆ yypgoto

const yytype_int8 yypgoto[]
static
Initial value:
=
{
-8, -8, -8, -4
}

Definition at line 610 of file readcf.cc.

◆ 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 652 of file readcf.cc.

◆ 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 659 of file readcf.cc.

◆ 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 644 of file readcf.cc.

◆ 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 624 of file readcf.cc.

◆ 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 521 of file readcf.cc.

yystos
static const yytype_int8 yystos[]
Definition: readcf.cc:644
yytable_value_is_error
#define yytable_value_is_error(Yyn)
Definition: readcf.cc:587
yyparse
int yyparse(void)
Definition: readcf.cc:1116
yypact_value_is_default
#define yypact_value_is_default(Yyn)
Definition: readcf.cc:582
retvalue
static CanonicalForm * retvalue
Definition: readcf.cc:125
yyr1
static const yytype_int8 yyr1[]
Definition: readcf.cc:652
YYNSTATES
#define YYNSTATES
Definition: readcf.cc:508
YYPOPSTACK
#define YYPOPSTACK(N)
NEG
#define NEG
Definition: readcf.cc:179
yy_state_fast_t
int yy_state_fast_t
Definition: readcf.cc:297
readString
static char * readString(ISTREAM &)
Definition: readcf.cc:1747
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: readcf.cc:828
YY_IGNORE_MAYBE_UNINITIALIZED_END
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: readcf.cc:347
power
CanonicalForm power(const CanonicalForm &f, int n)
exponentiation
Definition: canonicalform.cc:1837
NUM
#define NUM
Definition: readcf.cc:178
YY_IGNORE_USELESS_CAST_END
#define YY_IGNORE_USELESS_CAST_END
Definition: readcf.cc:362
defaultin
static ISTREAM * defaultin
Definition: readcf.cc:123
YYPTRDIFF_MAXIMUM
#define YYPTRDIFF_MAXIMUM
Definition: readcf.cc:268
yyr2
static const yytype_int8 yyr2[]
Definition: readcf.cc:659
yyerror
void yyerror(char *s)
Definition: readcf.cc:1656
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition: readcf.cc:407
gf_name
char gf_name
Definition: gfops.cc:52
getCharacteristic
int getCharacteristic()
Definition: cf_char.cc:51
YYFINAL
#define YYFINAL
Definition: readcf.cc:497
YYTERROR
#define YYTERROR
Definition: readcf.cc:696
yychar
int yychar
Definition: readcf.cc:1103
YYSIZEOF
#define YYSIZEOF(X)
Definition: readcf.cc:291
CanonicalForm
factory's main class
Definition: canonicalform.h:77
getDefaultVarName
char getDefaultVarName()
Definition: variable.cc:244
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: readcf.cc:829
YY_
#define YY_(Msgid)
Definition: readcf.cc:307
i
int i
Definition: cfEzgcd.cc:125
YYNTOKENS
#define YYNTOKENS
Definition: readcf.cc:502
CERR
#define CERR
Definition: readcf.cc:93
yycheck
static const yytype_int8 yycheck[]
Definition: readcf.cc:633
getGFGenerator
CanonicalForm getGFGenerator()
Definition: cf_char.cc:62
yydefact
static const yytype_int8 yydefact[]
Definition: readcf.cc:602
yytable
static const yytype_int8 yytable[]
Definition: readcf.cc:624
YYDPRINTF
#define YYDPRINTF(Args)
Definition: readcf.cc:826
yynerrs
int yynerrs
Definition: readcf.cc:1108
YYINITDEPTH
#define YYINITDEPTH
Definition: readcf.cc:835
yydefgoto
static const yytype_int8 yydefgoto[]
Definition: readcf.cc:616
getGFDegree
int getGFDegree()
Definition: cf_char.cc:56
yylval
YYSTYPE yylval
Definition: readcf.cc:1106
YYABORT
#define YYABORT
Definition: readcf.cc:672
YYEOF
#define YYEOF
Definition: readcf.cc:669
YYSTYPE
#define YYSTYPE
Definition: readcf.cc:110
Variable
factory's class for variables
Definition: factory.h:117
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: readcf.cc:827
yypact
static const yytype_int8 yypact[]
Definition: readcf.cc:592
YYACCEPT
#define YYACCEPT
Definition: readcf.cc:671
YYERROR
#define YYERROR
Definition: readcf.cc:673
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition: readcf.cc:516
YY_IGNORE_USELESS_CAST_BEGIN
#define YY_IGNORE_USELESS_CAST_BEGIN
Definition: readcf.cc:361
YYUSE
#define YYUSE(E)
Definition: readcf.cc:329
yylex
int yylex()
Definition: readcf.cc:1665
YYEMPTY
#define YYEMPTY
Definition: readcf.cc:668
YYSIZE_T
#define YYSIZE_T
Definition: readcf.cc:281
yypgoto
static const yytype_int8 yypgoto[]
Definition: readcf.cc:610
YY_CAST
#define YY_CAST(Type, Val)
Definition: readcf.cc:132
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
ParseUtil
Definition: parseutil.h:14
yydestruct
static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep)
Definition: readcf.cc:1087
YY_ASSERT
#define YY_ASSERT(E)
Definition: readcf.cc:366
index
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:592
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: readcf.cc:346
YYSTACK_FREE
#define YYSTACK_FREE
Definition: readcf.cc:408
YYMAXDEPTH
#define YYMAXDEPTH
Definition: readcf.cc:846
if
if(yy_init)
Definition: libparse.cc:1418
YYLAST
#define YYLAST
Definition: readcf.cc:499
YYPTRDIFF_T
#define YYPTRDIFF_T
Definition: readcf.cc:267
CanonicalForm::getval
InternalCF * getval() const
Definition: canonicalform.cc:31
yy_state_t
yytype_int8 yy_state_t
Definition: readcf.cc:294