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 <stddef.h>
#include <stdlib.h>

Go to the source code of this file.

Macros

#define YYBISON   1
 
#define YYBISON_VERSION   "3.0.4"
 
#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_NULLPTR   0
 
#define YYERROR_VERBOSE   0
 
#define YYDEBUG   0
 
#define YYTOKENTYPE
 
#define NUM   258
 
#define NEG   259
 
#define YYSIZE_T   size_t
 
#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)
 
#define YY_(Msgid)   Msgid
 
#define YY_ATTRIBUTE(Spec)   /* empty */
 
#define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
 
#define YY_ATTRIBUTE_UNUSED   YY_ATTRIBUTE ((__unused__))
 
#define _Noreturn   YY_ATTRIBUTE ((__noreturn__))
 
#define YYUSE(E)   ((void) (E))
 
#define YY_INITIAL_VALUE(Value)   Value
 
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
 
#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)   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
#define YYPACT_NINF   -8
 
#define yypact_value_is_default(Yystate)   (!!((Yystate) == (-8)))
 
#define YYTABLE_NINF   -1
 
#define yytable_value_is_error(Yytable_value)   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 unsigned char yytype_uint8
 
typedef signed char yytype_int8
 
typedef unsigned short int yytype_uint16
 
typedef short int yytype_int16
 

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,
  IDEAL_CMD = 274, MAP_CMD = 275, MATRIX_CMD = 276, MODUL_CMD = 277,
  NUMBER_CMD = 278, POLY_CMD = 279, RESOLUTION_CMD = 280, VECTOR_CMD = 281,
  BETTI_CMD = 282, E_CMD = 283, FETCH_CMD = 284, FREEMODULE_CMD = 285,
  KEEPRING_CMD = 286, IMAP_CMD = 287, KOSZUL_CMD = 288, MAXID_CMD = 289,
  MONOM_CMD = 290, PAR_CMD = 291, PREIMAGE_CMD = 292, VAR_CMD = 293,
  VALTVARS = 294, VMAXDEG = 295, VMAXMULT = 296, VNOETHER = 297,
  VMINPOLY = 298, END_RING = 299, CMD_1 = 300, CMD_2 = 301,
  CMD_3 = 302, CMD_12 = 303, CMD_13 = 304, CMD_23 = 305,
  CMD_123 = 306, CMD_M = 307, ROOT_DECL = 308, ROOT_DECL_LIST = 309,
  RING_DECL = 310, RING_DECL_LIST = 311, EXAMPLE_CMD = 312, EXPORT_CMD = 313,
  HELP_CMD = 314, KILL_CMD = 315, LIB_CMD = 316, LISTVAR_CMD = 317,
  SETRING_CMD = 318, TYPE_CMD = 319, STRINGTOK = 320, BLOCKTOK = 321,
  INT_CONST = 322, UNKNOWN_IDENT = 323, RINGVAR = 324, PROC_DEF = 325,
  APPLY = 326, ASSUME_CMD = 327, BREAK_CMD = 328, CONTINUE_CMD = 329,
  ELSE_CMD = 330, EVAL = 331, QUOTE = 332, FOR_CMD = 333,
  IF_CMD = 334, SYS_BREAK = 335, WHILE_CMD = 336, RETURN = 337,
  PARAMETER = 338, SYSVAR = 339, UMINUS = 340, 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, IDEAL_CMD = 274,
  MAP_CMD = 275, MATRIX_CMD = 276, MODUL_CMD = 277, NUMBER_CMD = 278,
  POLY_CMD = 279, RESOLUTION_CMD = 280, VECTOR_CMD = 281, BETTI_CMD = 282,
  E_CMD = 283, FETCH_CMD = 284, FREEMODULE_CMD = 285, KEEPRING_CMD = 286,
  IMAP_CMD = 287, KOSZUL_CMD = 288, MAXID_CMD = 289, MONOM_CMD = 290,
  PAR_CMD = 291, PREIMAGE_CMD = 292, VAR_CMD = 293, VALTVARS = 294,
  VMAXDEG = 295, VMAXMULT = 296, VNOETHER = 297, VMINPOLY = 298,
  END_RING = 299, CMD_1 = 300, CMD_2 = 301, CMD_3 = 302,
  CMD_12 = 303, CMD_13 = 304, CMD_23 = 305, CMD_123 = 306,
  CMD_M = 307, ROOT_DECL = 308, ROOT_DECL_LIST = 309, RING_DECL = 310,
  RING_DECL_LIST = 311, EXAMPLE_CMD = 312, EXPORT_CMD = 313, HELP_CMD = 314,
  KILL_CMD = 315, LIB_CMD = 316, LISTVAR_CMD = 317, SETRING_CMD = 318,
  TYPE_CMD = 319, STRINGTOK = 320, BLOCKTOK = 321, INT_CONST = 322,
  UNKNOWN_IDENT = 323, RINGVAR = 324, PROC_DEF = 325, APPLY = 326,
  ASSUME_CMD = 327, BREAK_CMD = 328, CONTINUE_CMD = 329, ELSE_CMD = 330,
  EVAL = 331, QUOTE = 332, FOR_CMD = 333, IF_CMD = 334,
  SYS_BREAK = 335, WHILE_CMD = 336, RETURN = 337, PARAMETER = 338,
  SYSVAR = 339, UMINUS = 340, 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_uint8 yytranslate []
 
static const yytype_int8 yypact []
 
static const yytype_uint8 yydefact []
 
static const yytype_int8 yypgoto []
 
static const yytype_int8 yydefgoto []
 
static const yytype_uint8 yytable []
 
static const yytype_int8 yycheck []
 
static const yytype_uint8 yystos []
 
static const yytype_uint8 yyr1 []
 
static const yytype_uint8 yyr2 []
 
int yychar
 
int yynerrs
 

Macro Definition Documentation

◆ _Noreturn

#define _Noreturn   YY_ATTRIBUTE ((__noreturn__))

Definition at line 260 of file readcf.cc.

◆ CERR

#define CERR   std::cerr

Definition at line 89 of file readcf.cc.

◆ EXIT_SUCCESS

#define EXIT_SUCCESS   0

Definition at line 340 of file readcf.cc.

◆ ISTREAM

#define ISTREAM   std::istream

Definition at line 88 of file readcf.cc.

◆ NEG

#define NEG   259

Definition at line 162 of file readcf.cc.

◆ NUM

#define NUM   258

Definition at line 161 of file readcf.cc.

◆ YY_

#define YY_ (   Msgid)    Msgid

Definition at line 233 of file readcf.cc.

◆ YY_ATTRIBUTE

#define YY_ATTRIBUTE (   Spec)    /* empty */

Definition at line 243 of file readcf.cc.

◆ YY_ATTRIBUTE_PURE

#define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))

Definition at line 248 of file readcf.cc.

◆ YY_ATTRIBUTE_UNUSED

#define YY_ATTRIBUTE_UNUSED   YY_ATTRIBUTE ((__unused__))

Definition at line 252 of file readcf.cc.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

Definition at line 283 of file readcf.cc.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_END

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

Definition at line 284 of file readcf.cc.

◆ YY_INITIAL_VALUE

#define YY_INITIAL_VALUE (   Value)    Value

Definition at line 280 of file readcf.cc.

◆ YY_NULLPTR

#define YY_NULLPTR   0

Definition at line 130 of file readcf.cc.

◆ YY_REDUCE_PRINT

#define YY_REDUCE_PRINT (   Rule)

Definition at line 749 of file readcf.cc.

◆ YY_STACK_PRINT

#define YY_STACK_PRINT (   Bottom,
  Top 
)

Definition at line 748 of file readcf.cc.

◆ YY_SYMBOL_PRINT

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

Definition at line 747 of file readcf.cc.

◆ YYABORT

#define YYABORT   goto yyabortlab

Definition at line 594 of file readcf.cc.

◆ YYACCEPT

#define YYACCEPT   goto yyacceptlab

Definition at line 593 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)
if(0 > strat->sl)
Definition: myNF.cc:73
#define YY_(Msgid)
Definition: readcf.cc:233
int yychar
Definition: readcf.cc:1013
#define YYEMPTY
Definition: readcf.cc:590

Definition at line 600 of file readcf.cc.

◆ YYBISON

#define YYBISON   1

Definition at line 44 of file readcf.cc.

◆ YYBISON_VERSION

#define YYBISON_VERSION   "3.0.4"

Definition at line 47 of file readcf.cc.

◆ yyclearin

#define yyclearin   (yychar = YYEMPTY)

Definition at line 589 of file readcf.cc.

◆ YYDEBUG

#define YYDEBUG   0

Definition at line 145 of file readcf.cc.

◆ YYDPRINTF

#define YYDPRINTF (   Args)

Definition at line 746 of file readcf.cc.

◆ YYEMPTY

#define YYEMPTY   (-2)

Definition at line 590 of file readcf.cc.

◆ YYEOF

#define YYEOF   0

Definition at line 591 of file readcf.cc.

◆ YYERRCODE

#define YYERRCODE   256

Definition at line 619 of file readcf.cc.

◆ yyerrok

#define yyerrok   (yyerrstatus = 0)

Definition at line 588 of file readcf.cc.

◆ YYERROR

#define YYERROR   goto yyerrorlab

Definition at line 595 of file readcf.cc.

◆ YYERROR_VERBOSE

#define YYERROR_VERBOSE   0

Definition at line 139 of file readcf.cc.

◆ YYFINAL

#define YYFINAL   2

Definition at line 420 of file readcf.cc.

◆ YYFREE

#define YYFREE   free

Definition at line 350 of file readcf.cc.

◆ YYINITDEPTH

#define YYINITDEPTH   200

Definition at line 755 of file readcf.cc.

◆ YYLAST

#define YYLAST   44

Definition at line 422 of file readcf.cc.

◆ YYMALLOC

#define YYMALLOC   malloc

Definition at line 344 of file readcf.cc.

◆ YYMAXDEPTH

#define YYMAXDEPTH   10000

Definition at line 766 of file readcf.cc.

◆ YYMAXUTOK

#define YYMAXUTOK   259

Definition at line 436 of file readcf.cc.

◆ YYNNTS

#define YYNNTS   4

Definition at line 427 of file readcf.cc.

◆ YYNRULES

#define YYNRULES   14

Definition at line 429 of file readcf.cc.

◆ YYNSTATES

#define YYNSTATES   25

Definition at line 431 of file readcf.cc.

◆ YYNTOKENS

#define YYNTOKENS   13

Definition at line 425 of file readcf.cc.

◆ YYPACT_NINF

#define YYPACT_NINF   -8

Definition at line 502 of file readcf.cc.

◆ yypact_value_is_default

#define yypact_value_is_default (   Yystate)    (!!((Yystate) == (-8)))

Definition at line 504 of file readcf.cc.

◆ YYPOPSTACK

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

◆ YYPULL

#define YYPULL   1

Definition at line 59 of file readcf.cc.

◆ YYPURE

#define YYPURE   0

Definition at line 53 of file readcf.cc.

◆ YYPUSH

#define YYPUSH   0

Definition at line 56 of file readcf.cc.

◆ YYRECOVERING

#define YYRECOVERING ( )    (!!yyerrstatus)

Definition at line 598 of file readcf.cc.

◆ YYSIZE_MAXIMUM

#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)

Definition at line 223 of file readcf.cc.

◆ YYSIZE_T

#define YYSIZE_T   size_t

Definition at line 217 of file readcf.cc.

◆ YYSKELETON_NAME

#define YYSKELETON_NAME   "yacc.c"

Definition at line 50 of file readcf.cc.

◆ YYSTACK_ALLOC

#define YYSTACK_ALLOC   YYMALLOC

Definition at line 330 of file readcf.cc.

◆ YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

Definition at line 333 of file readcf.cc.

◆ YYSTACK_FREE

#define YYSTACK_FREE   YYFREE

Definition at line 331 of file readcf.cc.

◆ YYSTYPE

#define YYSTYPE   ParseUtil

Definition at line 106 of file readcf.cc.

◆ YYTABLE_NINF

#define YYTABLE_NINF   -1

Definition at line 507 of file readcf.cc.

◆ yytable_value_is_error

#define yytable_value_is_error (   Yytable_value)    0

Definition at line 509 of file readcf.cc.

◆ YYTERROR

#define YYTERROR   1

Definition at line 618 of file readcf.cc.

◆ YYTOKENTYPE

#define YYTOKENTYPE

Definition at line 153 of file readcf.cc.

◆ YYTRANSLATE

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

Definition at line 438 of file readcf.cc.

◆ YYUNDEFTOK

#define YYUNDEFTOK   2

Definition at line 435 of file readcf.cc.

◆ YYUSE

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

Definition at line 266 of file readcf.cc.

Typedef Documentation

◆ yytype_int16

typedef short int yytype_int16

Definition at line 207 of file readcf.cc.

◆ yytype_int8

typedef signed char yytype_int8

Definition at line 195 of file readcf.cc.

◆ yytype_uint16

typedef unsigned short int yytype_uint16

Definition at line 201 of file readcf.cc.

◆ yytype_uint8

typedef unsigned char yytype_uint8

Definition at line 189 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 
IDEAL_CMD 
MAP_CMD 
MATRIX_CMD 
MODUL_CMD 
NUMBER_CMD 
POLY_CMD 
RESOLUTION_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 
IDEAL_CMD 
MAP_CMD 
MATRIX_CMD 
MODUL_CMD 
NUMBER_CMD 
POLY_CMD 
RESOLUTION_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 154 of file readcf.cc.

155  {
156  NUM = 258,
157  NEG = 259
158  };
#define NEG
Definition: readcf.cc:162
#define NUM
Definition: readcf.cc:161

Function Documentation

◆ readCF()

CanonicalForm readCF ( ISTREAM str)

Definition at line 1616 of file readcf.cc.

1617 {
1618  CanonicalForm theRetvalue;
1619  retvalue = new CanonicalForm();
1620 #ifdef BISONPP
1621  YY_parse_CLASS my_parser;
1622  defaultin = &str;
1623  if ( my_parser.yyparse() == 0 ) {
1624  theRetvalue = *retvalue;
1625  delete retvalue;
1626  return theRetvalue;
1627  }
1628  else {
1629  delete retvalue;
1630  return 0;
1631  }
1632 #else
1633  defaultin = &str;
1634  if ( yyparse() == 0 ) {
1635  theRetvalue = *retvalue;
1636  delete retvalue;
1637  return theRetvalue;
1638  }
1639  else {
1640  delete retvalue;
1641  return 0;
1642  }
1643 #endif
1644 }
static CanonicalForm * retvalue
Definition: readcf.cc:121
static ISTREAM * defaultin
Definition: readcf.cc:119
factory&#39;s main class
Definition: canonicalform.h:75
int yyparse(void)
Definition: readcf.cc:1026

◆ readString()

char * readString ( ISTREAM s)
static

Definition at line 1646 of file readcf.cc.

1647 {
1648  static char * buffer = 0;
1649  static int bufsize = 0;
1650 
1651  if ( buffer == 0 ) {
1652  bufsize = 10000;
1653  buffer = new char[bufsize];
1654  }
1655  int i = 0, c, goon = 1;
1656  while ( goon ) {
1657  while ( isdigit( c = s.get() ) && i < bufsize - 2 ) {
1658  buffer[i] = c;
1659  i++;
1660  }
1661  if ( isdigit( c ) ) {
1662  bufsize += 1000;
1663  char * newbuffer = (char*)memcpy( new char[bufsize], buffer, bufsize - 1000 );
1664  delete [] buffer;
1665  buffer = newbuffer;
1666  buffer[i] = c;
1667  i++;
1668  }
1669  else {
1670  goon = 0;
1671  buffer[i] = '\0';
1672  s.putback( c );
1673  }
1674  }
1675  return buffer;
1676 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
int i
Definition: cfEzgcd.cc:123

◆ yydestruct()

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

Definition at line 997 of file readcf.cc.

998 {
999  YYUSE (yyvaluep);
1000  if (!yymsg)
1001  yymsg = "Deleting";
1002  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1003 
1005  YYUSE (yytype);
1007 }
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: readcf.cc:284
#define YYUSE(E)
Definition: readcf.cc:266
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: readcf.cc:747
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: readcf.cc:283

◆ yyerror()

void yyerror ( char *  s)

Definition at line 1555 of file readcf.cc.

1557 {
1558  CERR << s << "\n";
1559 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
#define CERR
Definition: readcf.cc:89

◆ yylex()

int yylex ( )

Definition at line 1564 of file readcf.cc.

1566 {
1567  int c;
1568 
1569  while ((c = defaultin->get()) == ' ' || c == '\t' || c == '\n' ) ;
1570  if ( isdigit( c ) ) {
1571  defaultin->putback( c );
1573  return NUM;
1574  }
1575  else if ( isalpha( c ) ) {
1576  // look for generators of GF(q)
1577  if ( getCharacteristic() > 0 && getGFDegree() > 1 && c == gf_name ) {
1578 #ifdef BISONPP
1579  this->yylval = getGFGenerator();
1580 #else
1581  yylval = getGFGenerator();
1582 #endif
1583  }
1584  else if ( c == getDefaultVarName() ) {
1585  int cc;
1586  cc = defaultin->get();
1587  if ( cc == '_' ) {
1589 #ifdef BISONPP
1590  this->yylval = Variable( index.getintval() );
1591 #else
1592  yylval = Variable( index.getintval() );
1593 #endif
1594  }
1595  else {
1596  defaultin->putback( cc );
1597 #ifdef BISONPP
1598  this->yylval = Variable( (char)c );
1599 #else
1600  yylval = Variable( (char)c );
1601 #endif
1602  }
1603  }
1604  else {
1605 #ifdef BISONPP
1606  this->yylval = Variable( (char)c );
1607 #else
1608  yylval = Variable( (char)c );
1609 #endif
1610  }
1611  return NUM;
1612  }
1613  return c;
1614 }
static char * readString(ISTREAM &)
Definition: readcf.cc:1646
factory&#39;s class for variables
Definition: factory.h:115
static ISTREAM * defaultin
Definition: readcf.cc:119
char gf_name
Definition: gfops.cc:52
int getCharacteristic()
Definition: cf_char.cc:51
char getDefaultVarName()
Definition: variable.cc:244
#define NUM
Definition: readcf.cc:161
CanonicalForm getGFGenerator()
Definition: cf_char.cc:62
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:592
YYSTYPE yylval
Definition: readcf.cc:1016
int getGFDegree()
Definition: cf_char.cc:56

◆ yyparse()

int yyparse ( void  )

Definition at line 1026 of file readcf.cc.

1027 {
1028  int yystate;
1029  /* Number of tokens to shift before error messages enabled. */
1030  int yyerrstatus;
1031 
1032  /* The stacks and their tools:
1033  'yyss': related to states.
1034  'yyvs': related to semantic values.
1035 
1036  Refer to the stacks through separate pointers, to allow yyoverflow
1037  to reallocate them elsewhere. */
1038 
1039  /* The state stack. */
1040  yytype_int16 yyssa[YYINITDEPTH];
1041  yytype_int16 *yyss;
1042  yytype_int16 *yyssp;
1043 
1044  /* The semantic value stack. */
1045  YYSTYPE yyvsa[YYINITDEPTH];
1046  YYSTYPE *yyvs;
1047  YYSTYPE *yyvsp;
1048 
1049  YYSIZE_T yystacksize;
1050 
1051  int yyn;
1052  int yyresult;
1053  /* Lookahead token as an internal (translated) token number. */
1054  int yytoken = 0;
1055  /* The variables used to return semantic value and location from the
1056  action routines. */
1057  YYSTYPE yyval;
1058 
1059 #if YYERROR_VERBOSE
1060  /* Buffer for error messages, and its allocated size. */
1061  char yymsgbuf[128];
1062  char *yymsg = yymsgbuf;
1063  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1064 #endif
1065 
1066 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1067 
1068  /* The number of symbols on the RHS of the reduced rule.
1069  Keep to zero when no symbol should be popped. */
1070  int yylen = 0;
1071 
1072  yyssp = yyss = yyssa;
1073  yyvsp = yyvs = yyvsa;
1074  yystacksize = YYINITDEPTH;
1075 
1076  YYDPRINTF ((stderr, "Starting parse\n"));
1077 
1078  yystate = 0;
1079  yyerrstatus = 0;
1080  yynerrs = 0;
1081  yychar = YYEMPTY; /* Cause a token to be read. */
1082  goto yysetstate;
1083 
1084 /*------------------------------------------------------------.
1085 | yynewstate -- Push a new state, which is found in yystate. |
1086 `------------------------------------------------------------*/
1087  yynewstate:
1088  /* In all cases, when you get here, the value and location stacks
1089  have just been pushed. So pushing a state here evens the stacks. */
1090  yyssp++;
1091 
1092  yysetstate:
1093  *yyssp = yystate;
1094 
1095  if (yyss + yystacksize - 1 <= yyssp)
1096  {
1097  /* Get the current used size of the three stacks, in elements. */
1098  YYSIZE_T yysize = yyssp - yyss + 1;
1099 
1100 #ifdef yyoverflow
1101  {
1102  /* Give user a chance to reallocate the stack. Use copies of
1103  these so that the &'s don't force the real ones into
1104  memory. */
1105  YYSTYPE *yyvs1 = yyvs;
1106  yytype_int16 *yyss1 = yyss;
1107 
1108  /* Each stack pointer address is followed by the size of the
1109  data in use in that stack, in bytes. This used to be a
1110  conditional around just the two extra args, but that might
1111  be undefined if yyoverflow is a macro. */
1112  yyoverflow (YY_("memory exhausted"),
1113  &yyss1, yysize * sizeof (*yyssp),
1114  &yyvs1, yysize * sizeof (*yyvsp),
1115  &yystacksize);
1116 
1117  yyss = yyss1;
1118  yyvs = yyvs1;
1119  }
1120 #else /* no yyoverflow */
1121 # ifndef YYSTACK_RELOCATE
1122  goto yyexhaustedlab;
1123 # else
1124  /* Extend the stack our own way. */
1125  if (YYMAXDEPTH <= yystacksize)
1126  goto yyexhaustedlab;
1127  yystacksize *= 2;
1128  if (YYMAXDEPTH < yystacksize)
1129  yystacksize = YYMAXDEPTH;
1130 
1131  {
1132  yytype_int16 *yyss1 = yyss;
1133  union yyalloc *yyptr =
1134  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1135  if (! yyptr)
1136  goto yyexhaustedlab;
1137  YYSTACK_RELOCATE (yyss_alloc, yyss);
1138  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1139 # undef YYSTACK_RELOCATE
1140  if (yyss1 != yyssa)
1141  YYSTACK_FREE (yyss1);
1142  }
1143 # endif
1144 #endif /* no yyoverflow */
1145 
1146  yyssp = yyss + yysize - 1;
1147  yyvsp = yyvs + yysize - 1;
1148 
1149  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1150  (unsigned long int) yystacksize));
1151 
1152  if (yyss + yystacksize - 1 <= yyssp)
1153  YYABORT;
1154  }
1155 
1156  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1157 
1158  if (yystate == YYFINAL)
1159  YYACCEPT;
1160 
1161  goto yybackup;
1162 
1163 /*-----------.
1164 | yybackup. |
1165 `-----------*/
1166 yybackup:
1167 
1168  /* Do appropriate processing given the current state. Read a
1169  lookahead token if we need one and don't already have one. */
1170 
1171  /* First try to decide what to do without reference to lookahead token. */
1172  yyn = yypact[yystate];
1173  if (yypact_value_is_default (yyn))
1174  goto yydefault;
1175 
1176  /* Not known => get a lookahead token if don't already have one. */
1177 
1178  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1179  if (yychar == YYEMPTY)
1180  {
1181  YYDPRINTF ((stderr, "Reading a token: "));
1182  yychar = yylex ();
1183  }
1184 
1185  if (yychar <= YYEOF)
1186  {
1187  yychar = yytoken = YYEOF;
1188  YYDPRINTF ((stderr, "Now at end of input.\n"));
1189  }
1190  else
1191  {
1192  yytoken = YYTRANSLATE (yychar);
1193  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1194  }
1195 
1196  /* If the proper action on seeing token YYTOKEN is to reduce or to
1197  detect an error, take that action. */
1198  yyn += yytoken;
1199  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1200  goto yydefault;
1201  yyn = yytable[yyn];
1202  if (yyn <= 0)
1203  {
1204  if (yytable_value_is_error (yyn))
1205  goto yyerrlab;
1206  yyn = -yyn;
1207  goto yyreduce;
1208  }
1209 
1210  /* Count tokens shifted since error; after three, turn off error
1211  status. */
1212  if (yyerrstatus)
1213  yyerrstatus--;
1214 
1215  /* Shift the lookahead token. */
1216  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1217 
1218  /* Discard the shifted token. */
1219  yychar = YYEMPTY;
1220 
1221  yystate = yyn;
1223  *++yyvsp = yylval;
1225 
1226  goto yynewstate;
1227 
1228 
1229 /*-----------------------------------------------------------.
1230 | yydefault -- do the default action for the current state. |
1231 `-----------------------------------------------------------*/
1232 yydefault:
1233  yyn = yydefact[yystate];
1234  if (yyn == 0)
1235  goto yyerrlab;
1236  goto yyreduce;
1237 
1238 
1239 /*-----------------------------.
1240 | yyreduce -- Do a reduction. |
1241 `-----------------------------*/
1242 yyreduce:
1243  /* yyn is the number of a rule to reduce with. */
1244  yylen = yyr2[yyn];
1245 
1246  /* If YYLEN is nonzero, implement the default value of the action:
1247  '$$ = $1'.
1248 
1249  Otherwise, the following line sets YYVAL to garbage.
1250  This behavior is undocumented and Bison
1251  users should not rely upon it. Assigning to YYVAL
1252  unconditionally makes the parser a bit smaller, and it avoids a
1253  GCC warning that YYVAL may be used uninitialized. */
1254  yyval = yyvsp[1-yylen];
1255 
1256 
1257  YY_REDUCE_PRINT (yyn);
1258  switch (yyn)
1259  {
1260  case 5:
1261 #line 78 "readcf.yy" /* yacc.c:1646 */
1262  { *retvalue = (yyvsp[-1]).getval(); return 0; }
1263 #line 1264 "readcf.cc" /* yacc.c:1646 */
1264  break;
1265 
1266  case 6:
1267 #line 81 "readcf.yy" /* yacc.c:1646 */
1268  { (yyval) = (yyvsp[0]); }
1269 #line 1270 "readcf.cc" /* yacc.c:1646 */
1270  break;
1271 
1272  case 7:
1273 #line 82 "readcf.yy" /* yacc.c:1646 */
1274  { (yyval) = (yyvsp[-2]).getval() + (yyvsp[0]).getval(); }
1275 #line 1276 "readcf.cc" /* yacc.c:1646 */
1276  break;
1277 
1278  case 8:
1279 #line 83 "readcf.yy" /* yacc.c:1646 */
1280  { (yyval) = (yyvsp[-2]).getval() - (yyvsp[0]).getval(); }
1281 #line 1282 "readcf.cc" /* yacc.c:1646 */
1282  break;
1283 
1284  case 9:
1285 #line 84 "readcf.yy" /* yacc.c:1646 */
1286  { (yyval) = (yyvsp[-2]).getval() * (yyvsp[0]).getval(); }
1287 #line 1288 "readcf.cc" /* yacc.c:1646 */
1288  break;
1289 
1290  case 10:
1291 #line 85 "readcf.yy" /* yacc.c:1646 */
1292  { (yyval) = (yyvsp[-2]).getval() / (yyvsp[0]).getval(); }
1293 #line 1294 "readcf.cc" /* yacc.c:1646 */
1294  break;
1295 
1296  case 11:
1297 #line 86 "readcf.yy" /* yacc.c:1646 */
1298  { (yyval) = -(yyvsp[0]).getval(); }
1299 #line 1300 "readcf.cc" /* yacc.c:1646 */
1300  break;
1301 
1302  case 12:
1303 #line 87 "readcf.yy" /* yacc.c:1646 */
1304  { (yyval) = (yyvsp[0]).getval(); }
1305 #line 1306 "readcf.cc" /* yacc.c:1646 */
1306  break;
1307 
1308  case 13:
1309 #line 88 "readcf.yy" /* yacc.c:1646 */
1310  { (yyval) = power( (yyvsp[-2]).getval(), (yyvsp[0]).getintval() ); }
1311 #line 1312 "readcf.cc" /* yacc.c:1646 */
1312  break;
1313 
1314  case 14:
1315 #line 89 "readcf.yy" /* yacc.c:1646 */
1316  { (yyval) = (yyvsp[-1]).getval(); }
1317 #line 1318 "readcf.cc" /* yacc.c:1646 */
1318  break;
1319 
1320 
1321 #line 1322 "readcf.cc" /* yacc.c:1646 */
1322  default: break;
1323  }
1324  /* User semantic actions sometimes alter yychar, and that requires
1325  that yytoken be updated with the new translation. We take the
1326  approach of translating immediately before every use of yytoken.
1327  One alternative is translating here after every semantic action,
1328  but that translation would be missed if the semantic action invokes
1329  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1330  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1331  incorrect destructor might then be invoked immediately. In the
1332  case of YYERROR or YYBACKUP, subsequent parser actions might lead
1333  to an incorrect destructor call or verbose syntax error message
1334  before the lookahead is translated. */
1335  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1336 
1337  YYPOPSTACK (yylen);
1338  yylen = 0;
1339  YY_STACK_PRINT (yyss, yyssp);
1340 
1341  *++yyvsp = yyval;
1342 
1343  /* Now 'shift' the result of the reduction. Determine what state
1344  that goes to, based on the state we popped back to and the rule
1345  number reduced by. */
1346 
1347  yyn = yyr1[yyn];
1348 
1349  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1350  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1351  yystate = yytable[yystate];
1352  else
1353  yystate = yydefgoto[yyn - YYNTOKENS];
1354 
1355  goto yynewstate;
1356 
1357 
1358 /*--------------------------------------.
1359 | yyerrlab -- here on detecting error. |
1360 `--------------------------------------*/
1361 yyerrlab:
1362  /* Make sure we have latest lookahead translation. See comments at
1363  user semantic actions for why this is necessary. */
1364  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1365 
1366  /* If not already recovering from an error, report this error. */
1367  if (!yyerrstatus)
1368  {
1369  ++yynerrs;
1370 #if ! YYERROR_VERBOSE
1371  yyerror (YY_("syntax error"));
1372 #else
1373 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1374  yyssp, yytoken)
1375  {
1376  char const *yymsgp = YY_("syntax error");
1377  int yysyntax_error_status;
1378  yysyntax_error_status = YYSYNTAX_ERROR;
1379  if (yysyntax_error_status == 0)
1380  yymsgp = yymsg;
1381  else if (yysyntax_error_status == 1)
1382  {
1383  if (yymsg != yymsgbuf)
1384  YYSTACK_FREE (yymsg);
1385  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1386  if (!yymsg)
1387  {
1388  yymsg = yymsgbuf;
1389  yymsg_alloc = sizeof yymsgbuf;
1390  yysyntax_error_status = 2;
1391  }
1392  else
1393  {
1394  yysyntax_error_status = YYSYNTAX_ERROR;
1395  yymsgp = yymsg;
1396  }
1397  }
1398  yyerror (yymsgp);
1399  if (yysyntax_error_status == 2)
1400  goto yyexhaustedlab;
1401  }
1402 # undef YYSYNTAX_ERROR
1403 #endif
1404  }
1405 
1406 
1407 
1408  if (yyerrstatus == 3)
1409  {
1410  /* If just tried and failed to reuse lookahead token after an
1411  error, discard it. */
1412 
1413  if (yychar <= YYEOF)
1414  {
1415  /* Return failure if at end of input. */
1416  if (yychar == YYEOF)
1417  YYABORT;
1418  }
1419  else
1420  {
1421  yydestruct ("Error: discarding",
1422  yytoken, &yylval);
1423  yychar = YYEMPTY;
1424  }
1425  }
1426 
1427  /* Else will try to reuse lookahead token after shifting the error
1428  token. */
1429  goto yyerrlab1;
1430 
1431 
1432 /*---------------------------------------------------.
1433 | yyerrorlab -- error raised explicitly by YYERROR. |
1434 `---------------------------------------------------*/
1435 yyerrorlab:
1436 
1437  /* Pacify compilers like GCC when the user code never invokes
1438  YYERROR and the label yyerrorlab therefore never appears in user
1439  code. */
1440  if (/*CONSTCOND*/ 0)
1441  goto yyerrorlab;
1442 
1443  /* Do not reclaim the symbols of the rule whose action triggered
1444  this YYERROR. */
1445  YYPOPSTACK (yylen);
1446  yylen = 0;
1447  YY_STACK_PRINT (yyss, yyssp);
1448  yystate = *yyssp;
1449  goto yyerrlab1;
1450 
1451 
1452 /*-------------------------------------------------------------.
1453 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1454 `-------------------------------------------------------------*/
1455 yyerrlab1:
1456  yyerrstatus = 3; /* Each real token shifted decrements this. */
1457 
1458  for (;;)
1459  {
1460  yyn = yypact[yystate];
1461  if (!yypact_value_is_default (yyn))
1462  {
1463  yyn += YYTERROR;
1464  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1465  {
1466  yyn = yytable[yyn];
1467  if (0 < yyn)
1468  break;
1469  }
1470  }
1471 
1472  /* Pop the current state because it cannot handle the error token. */
1473  if (yyssp == yyss)
1474  YYABORT;
1475 
1476 
1477  yydestruct ("Error: popping",
1478  yystos[yystate], yyvsp);
1479  YYPOPSTACK (1);
1480  yystate = *yyssp;
1481  YY_STACK_PRINT (yyss, yyssp);
1482  }
1483 
1485  *++yyvsp = yylval;
1487 
1488 
1489  /* Shift the error token. */
1490  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1491 
1492  yystate = yyn;
1493  goto yynewstate;
1494 
1495 
1496 /*-------------------------------------.
1497 | yyacceptlab -- YYACCEPT comes here. |
1498 `-------------------------------------*/
1499 yyacceptlab:
1500  yyresult = 0;
1501  goto yyreturn;
1502 
1503 /*-----------------------------------.
1504 | yyabortlab -- YYABORT comes here. |
1505 `-----------------------------------*/
1506 yyabortlab:
1507  yyresult = 1;
1508  goto yyreturn;
1509 
1510 #if !defined yyoverflow || YYERROR_VERBOSE
1511 /*-------------------------------------------------.
1512 | yyexhaustedlab -- memory exhaustion comes here. |
1513 `-------------------------------------------------*/
1514 yyexhaustedlab:
1515  yyerror (YY_("memory exhausted"));
1516  yyresult = 2;
1517  /* Fall through. */
1518 #endif
1519 
1520 yyreturn:
1521  if (yychar != YYEMPTY)
1522  {
1523  /* Make sure we have latest lookahead translation. See comments at
1524  user semantic actions for why this is necessary. */
1525  yytoken = YYTRANSLATE (yychar);
1526  yydestruct ("Cleanup: discarding lookahead",
1527  yytoken, &yylval);
1528  }
1529  /* Do not reclaim the symbols of the rule whose action triggered
1530  this YYABORT or YYACCEPT. */
1531  YYPOPSTACK (yylen);
1532  YY_STACK_PRINT (yyss, yyssp);
1533  while (yyssp != yyss)
1534  {
1535  yydestruct ("Cleanup: popping",
1536  yystos[*yyssp], yyvsp);
1537  YYPOPSTACK (1);
1538  }
1539 #ifndef yyoverflow
1540  if (yyss != yyssa)
1541  YYSTACK_FREE (yyss);
1542 #endif
1543 #if YYERROR_VERBOSE
1544  if (yymsg != yymsgbuf)
1545  YYSTACK_FREE (yymsg);
1546 #endif
1547  return yyresult;
1548 }
#define YY_STACK_PRINT(Bottom, Top)
Definition: readcf.cc:748
CanonicalForm power(const CanonicalForm &f, int n)
exponentiation
static const yytype_uint8 yytable[]
Definition: readcf.cc:546
#define YYLAST
Definition: readcf.cc:422
#define YYSTACK_FREE
Definition: readcf.cc:331
void yyerror(char *s)
Definition: readcf.cc:1555
static CanonicalForm * retvalue
Definition: readcf.cc:121
static const yytype_uint8 yystos[]
Definition: readcf.cc:566
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: readcf.cc:284
static const yytype_uint8 yyr1[]
Definition: readcf.cc:574
#define YYFINAL
Definition: readcf.cc:420
#define YYPOPSTACK(N)
#define YYDPRINTF(Args)
Definition: readcf.cc:746
#define YY_(Msgid)
Definition: readcf.cc:233
#define YYNTOKENS
Definition: readcf.cc:425
#define YYTERROR
Definition: readcf.cc:618
#define YY_REDUCE_PRINT(Rule)
Definition: readcf.cc:749
#define YYSTACK_ALLOC
Definition: readcf.cc:330
int yychar
Definition: readcf.cc:1013
static const yytype_int8 yydefgoto[]
Definition: readcf.cc:538
static const yytype_int8 yycheck[]
Definition: readcf.cc:555
short int yytype_int16
Definition: grammar.cc:396
#define YYABORT
Definition: readcf.cc:594
static const yytype_uint8 yydefact[]
Definition: readcf.cc:524
#define YYEOF
Definition: readcf.cc:591
int yylex()
Definition: readcf.cc:1564
int yynerrs
Definition: readcf.cc:1018
#define YYEMPTY
Definition: readcf.cc:590
YYSTYPE yylval
Definition: readcf.cc:1016
#define YYACCEPT
Definition: readcf.cc:593
#define YYSTYPE
Definition: readcf.cc:106
#define YYINITDEPTH
Definition: readcf.cc:755
#define yypact_value_is_default(Yystate)
Definition: readcf.cc:504
#define YYMAXDEPTH
Definition: readcf.cc:766
#define YYSIZE_T
Definition: readcf.cc:217
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: readcf.cc:747
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: readcf.cc:283
static const yytype_uint8 yyr2[]
Definition: readcf.cc:581
#define yytable_value_is_error(Yytable_value)
Definition: readcf.cc:509
InternalCF * getval() const
#define YYTRANSLATE(YYX)
Definition: readcf.cc:438
static const yytype_int8 yypact[]
Definition: readcf.cc:514
static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep)
Definition: readcf.cc:997
static const yytype_int8 yypgoto[]
Definition: readcf.cc:532

Variable Documentation

◆ defaultin

ISTREAM* defaultin = 0
static

Definition at line 119 of file readcf.cc.

◆ retvalue

CanonicalForm* retvalue = 0
static

Definition at line 121 of file readcf.cc.

◆ yychar

int yychar

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

◆ yydefact

const yytype_uint8 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 524 of file readcf.cc.

◆ yydefgoto

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

Definition at line 538 of file readcf.cc.

◆ yylval

YYSTYPE yylval

Definition at line 1016 of file readcf.cc.

◆ yynerrs

int yynerrs

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

◆ yypgoto

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

Definition at line 532 of file readcf.cc.

◆ yyr1

const yytype_uint8 yyr1[]
static
Initial value:
=
{
0, 13, 14, 14, 15, 15, 16, 16, 16, 16,
16, 16, 16, 16, 16
}

Definition at line 574 of file readcf.cc.

◆ yyr2

const yytype_uint8 yyr2[]
static
Initial value:
=
{
0, 2, 0, 2, 1, 2, 1, 3, 3, 3,
3, 2, 2, 3, 3
}

Definition at line 581 of file readcf.cc.

◆ yystos

const yytype_uint8 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 566 of file readcf.cc.

◆ yytable

const yytype_uint8 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 546 of file readcf.cc.

◆ yytranslate

const yytype_uint8 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 443 of file readcf.cc.