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

Go to the source code of this file.

Macros

#define YYBISON   1
 
#define YYBISON_VERSION   "3.4.1"
 
#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 YYUSE(E)   ((void) (E))
 
#define YY_INITIAL_VALUE(Value)   Value
 
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 
#define YY_IGNORE_MAYBE_UNINITIALIZED_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)   ((unsigned) (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 yytype_uint16
 
typedef short 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,
  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_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

◆ CERR

#define CERR   std::cerr

Definition at line 93 of file readcf.cc.

◆ EXIT_SUCCESS

#define EXIT_SUCCESS   0

Definition at line 339 of file readcf.cc.

◆ ISTREAM

#define ISTREAM   std::istream

Definition at line 92 of file readcf.cc.

◆ NEG

#define NEG   259

Definition at line 170 of file readcf.cc.

◆ NUM

#define NUM   258

Definition at line 169 of file readcf.cc.

◆ YY_

#define YY_ (   Msgid)    Msgid

Definition at line 239 of file readcf.cc.

◆ YY_ASSERT

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

Definition at line 288 of file readcf.cc.

◆ YY_ATTRIBUTE

#define YY_ATTRIBUTE (   Spec)    /* empty */

Definition at line 249 of file readcf.cc.

◆ YY_ATTRIBUTE_PURE

#define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))

Definition at line 254 of file readcf.cc.

◆ YY_ATTRIBUTE_UNUSED

#define YY_ATTRIBUTE_UNUSED   YY_ATTRIBUTE ((__unused__))

Definition at line 258 of file readcf.cc.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

Definition at line 280 of file readcf.cc.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_END

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

Definition at line 281 of file readcf.cc.

◆ YY_INITIAL_VALUE

#define YY_INITIAL_VALUE (   Value)    Value

Definition at line 277 of file readcf.cc.

◆ YY_NULLPTR

#define YY_NULLPTR   0

Definition at line 135 of file readcf.cc.

◆ YY_REDUCE_PRINT

#define YY_REDUCE_PRINT (   Rule)

Definition at line 748 of file readcf.cc.

◆ YY_STACK_PRINT

#define YY_STACK_PRINT (   Bottom,
  Top 
)

Definition at line 747 of file readcf.cc.

◆ YY_SYMBOL_PRINT

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

Definition at line 746 of file readcf.cc.

◆ YYABORT

#define YYABORT   goto yyabortlab

Definition at line 593 of file readcf.cc.

◆ YYACCEPT

#define YYACCEPT   goto yyacceptlab

Definition at line 592 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)
#define YY_(Msgid)
Definition: readcf.cc:239
if(yy_init)
Definition: libparse.cc:1418
int yychar
Definition: readcf.cc:1017
#define YYEMPTY
Definition: readcf.cc:589

Definition at line 599 of file readcf.cc.

◆ YYBISON

#define YYBISON   1

Definition at line 48 of file readcf.cc.

◆ YYBISON_VERSION

#define YYBISON_VERSION   "3.4.1"

Definition at line 51 of file readcf.cc.

◆ yyclearin

#define yyclearin   (yychar = YYEMPTY)

Definition at line 588 of file readcf.cc.

◆ YYDEBUG

#define YYDEBUG   0

Definition at line 153 of file readcf.cc.

◆ YYDPRINTF

#define YYDPRINTF (   Args)

Definition at line 745 of file readcf.cc.

◆ YYEMPTY

#define YYEMPTY   (-2)

Definition at line 589 of file readcf.cc.

◆ YYEOF

#define YYEOF   0

Definition at line 590 of file readcf.cc.

◆ YYERRCODE

#define YYERRCODE   256

Definition at line 618 of file readcf.cc.

◆ yyerrok

#define yyerrok   (yyerrstatus = 0)

Definition at line 587 of file readcf.cc.

◆ YYERROR

#define YYERROR   goto yyerrorlab

Definition at line 594 of file readcf.cc.

◆ YYERROR_VERBOSE

#define YYERROR_VERBOSE   0

Definition at line 147 of file readcf.cc.

◆ YYFINAL

#define YYFINAL   2

Definition at line 419 of file readcf.cc.

◆ YYFREE

#define YYFREE   free

Definition at line 349 of file readcf.cc.

◆ YYINITDEPTH

#define YYINITDEPTH   200

Definition at line 754 of file readcf.cc.

◆ YYLAST

#define YYLAST   44

Definition at line 421 of file readcf.cc.

◆ YYMALLOC

#define YYMALLOC   malloc

Definition at line 343 of file readcf.cc.

◆ YYMAXDEPTH

#define YYMAXDEPTH   10000

Definition at line 765 of file readcf.cc.

◆ YYMAXUTOK

#define YYMAXUTOK   259

Definition at line 433 of file readcf.cc.

◆ YYNNTS

#define YYNNTS   4

Definition at line 426 of file readcf.cc.

◆ YYNRULES

#define YYNRULES   14

Definition at line 428 of file readcf.cc.

◆ YYNSTATES

#define YYNSTATES   25

Definition at line 430 of file readcf.cc.

◆ YYNTOKENS

#define YYNTOKENS   13

Definition at line 424 of file readcf.cc.

◆ YYPACT_NINF

#define YYPACT_NINF   -8

Definition at line 501 of file readcf.cc.

◆ yypact_value_is_default

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

Definition at line 503 of file readcf.cc.

◆ YYPOPSTACK

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

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

◆ YYSIZE_MAXIMUM

#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)

Definition at line 229 of file readcf.cc.

◆ YYSIZE_T

#define YYSIZE_T   size_t

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

◆ YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

Definition at line 332 of file readcf.cc.

◆ YYSTACK_FREE

#define YYSTACK_FREE   YYFREE

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

◆ yytable_value_is_error

#define yytable_value_is_error (   Yytable_value)    0

Definition at line 508 of file readcf.cc.

◆ YYTERROR

#define YYTERROR   1

Definition at line 617 of file readcf.cc.

◆ YYTOKENTYPE

#define YYTOKENTYPE

Definition at line 161 of file readcf.cc.

◆ YYTRANSLATE

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

Definition at line 437 of file readcf.cc.

◆ YYUNDEFTOK

#define YYUNDEFTOK   2

Definition at line 432 of file readcf.cc.

◆ YYUSE

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

Definition at line 263 of file readcf.cc.

Typedef Documentation

◆ yytype_int16

typedef short yytype_int16

Definition at line 213 of file readcf.cc.

◆ yytype_int8

typedef signed char yytype_int8

Definition at line 201 of file readcf.cc.

◆ yytype_uint16

typedef unsigned short yytype_uint16

Definition at line 207 of file readcf.cc.

◆ yytype_uint8

typedef unsigned char yytype_uint8

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

163  {
164  NUM = 258,
165  NEG = 259
166  };
#define NEG
Definition: readcf.cc:170
#define NUM
Definition: readcf.cc:169

Function Documentation

◆ readCF()

CanonicalForm readCF ( ISTREAM str)

Definition at line 1627 of file readcf.cc.

1628 {
1629  CanonicalForm theRetvalue;
1630  retvalue = new CanonicalForm();
1631 #ifdef BISONPP
1632  YY_parse_CLASS my_parser;
1633  defaultin = &str;
1634  if ( my_parser.yyparse() == 0 ) {
1635  theRetvalue = *retvalue;
1636  delete retvalue;
1637  return theRetvalue;
1638  }
1639  else {
1640  delete retvalue;
1641  return 0;
1642  }
1643 #else
1644  defaultin = &str;
1645  if ( yyparse() == 0 ) {
1646  theRetvalue = *retvalue;
1647  delete retvalue;
1648  return theRetvalue;
1649  }
1650  else {
1651  delete retvalue;
1652  return 0;
1653  }
1654 #endif
1655 }
static CanonicalForm * retvalue
Definition: readcf.cc:125
static ISTREAM * defaultin
Definition: readcf.cc:123
factory's main class
Definition: canonicalform.h:77
int yyparse(void)
Definition: readcf.cc:1030

◆ readString()

char * readString ( ISTREAM s)
static

Definition at line 1657 of file readcf.cc.

1658 {
1659  static char * buffer = 0;
1660  static int bufsize = 0;
1661 
1662  if ( buffer == 0 ) {
1663  bufsize = 10000;
1664  buffer = new char[bufsize];
1665  }
1666  int i = 0, c, goon = 1;
1667  while ( goon ) {
1668  while ( isdigit( c = s.get() ) && i < bufsize - 2 ) {
1669  buffer[i] = c;
1670  i++;
1671  }
1672  if ( isdigit( c ) ) {
1673  bufsize += 1000;
1674  char * newbuffer = (char*)memcpy( new char[bufsize], buffer, bufsize - 1000 );
1675  delete [] buffer;
1676  buffer = newbuffer;
1677  buffer[i] = c;
1678  i++;
1679  }
1680  else {
1681  goon = 0;
1682  buffer[i] = '\0';
1683  s.putback( c );
1684  }
1685  }
1686  return buffer;
1687 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
int i
Definition: cfEzgcd.cc:125

◆ yydestruct()

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

Definition at line 1001 of file readcf.cc.

1002 {
1003  YYUSE (yyvaluep);
1004  if (!yymsg)
1005  yymsg = "Deleting";
1006  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1007 
1009  YYUSE (yytype);
1011 }
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: readcf.cc:281
#define YYUSE(E)
Definition: readcf.cc:263
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: readcf.cc:746
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: readcf.cc:280

◆ yyerror()

void yyerror ( char *  s)

Definition at line 1566 of file readcf.cc.

1568 {
1569  CERR << s << "\n";
1570 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
#define CERR
Definition: readcf.cc:93

◆ yylex()

int yylex ( )

Definition at line 1575 of file readcf.cc.

1577 {
1578  int c;
1579 
1580  while ((c = defaultin->get()) == ' ' || c == '\t' || c == '\n' ) ;
1581  if ( isdigit( c ) ) {
1582  defaultin->putback( c );
1584  return NUM;
1585  }
1586  else if ( isalpha( c ) ) {
1587  // look for generators of GF(q)
1588  if ( getCharacteristic() > 0 && getGFDegree() > 1 && c == gf_name ) {
1589 #ifdef BISONPP
1590  this->yylval = getGFGenerator();
1591 #else
1592  yylval = getGFGenerator();
1593 #endif
1594  }
1595  else if ( c == getDefaultVarName() ) {
1596  int cc;
1597  cc = defaultin->get();
1598  if ( cc == '_' ) {
1600 #ifdef BISONPP
1601  this->yylval = Variable( index.getintval() );
1602 #else
1603  yylval = Variable( index.getintval() );
1604 #endif
1605  }
1606  else {
1607  defaultin->putback( cc );
1608 #ifdef BISONPP
1609  this->yylval = Variable( (char)c );
1610 #else
1611  yylval = Variable( (char)c );
1612 #endif
1613  }
1614  }
1615  else {
1616 #ifdef BISONPP
1617  this->yylval = Variable( (char)c );
1618 #else
1619  yylval = Variable( (char)c );
1620 #endif
1621  }
1622  return NUM;
1623  }
1624  return c;
1625 }
static char * readString(ISTREAM &)
Definition: readcf.cc:1657
factory's class for variables
Definition: factory.h:117
static ISTREAM * defaultin
Definition: readcf.cc:123
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:169
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:1020
int getGFDegree()
Definition: cf_char.cc:56

◆ yyparse()

int yyparse ( void  )

Definition at line 1030 of file readcf.cc.

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

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 1017 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 554 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 523 of file readcf.cc.

◆ yydefgoto

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

Definition at line 537 of file readcf.cc.

◆ yylval

YYSTYPE yylval

Definition at line 1020 of file readcf.cc.

◆ yynerrs

int yynerrs

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

◆ yypgoto

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

Definition at line 531 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 573 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 580 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 565 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 545 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 442 of file readcf.cc.