My Project
Macros | Enumerations | Functions | Variables
tok.h File Reference
#include "kernel/mod2.h"
#include "Singular/grammar.h"

Go to the source code of this file.

Macros

#define LOGIC_OP   '&'
 
#define MULDIV_OP   '/'
 
#define COMP_OP   '<'
 
#define COMMAND   UMINUS+2 /* in tok.h */
 
#define ANY_TYPE   UMINUS+3
 
#define IDHDL   UMINUS+4
 
#define NONE   END_RING
 
#define UNKNOWN   0
 

Enumerations

enum  {
  ALIAS_CMD = UMINUS + 15 , ALIGN_CMD , ATTRIB_CMD , BAREISS_CMD ,
  BIGINT_CMD , BRANCHTO_CMD , BRACKET_CMD , BREAKPOINT_CMD ,
  CHARACTERISTIC_CMD , CHARSTR_CMD , CHAR_SERIES_CMD , CHINREM_CMD ,
  CMATRIX_CMD , CNUMBER_CMD , CPOLY_CMD , CLOSE_CMD ,
  COEFFS_CMD , COEF_CMD , COLS_CMD , CONTENT_CMD ,
  CONTRACT_CMD , COUNT_CMD , CRING_CMD , DBPRINT_CMD ,
  DEF_CMD , DEFINED_CMD , DEG_CMD , DEGREE_CMD ,
  DELETE_CMD , DENOMINATOR_CMD , DET_CMD , DIFF_CMD ,
  DIM_CMD , DIVISION_CMD , DUMP_CMD , ELIMINATION_CMD ,
  END_GRAMMAR , ENVELOPE_CMD , ERROR_CMD , EXECUTE_CMD ,
  EXPORTTO_CMD , EXTGCD_CMD , FAC_CMD , FAREY_CMD ,
  FIND_CMD , FACSTD_CMD , FMD_CMD , FRES_CMD ,
  FWALK_CMD , FGLM_CMD , FGLMQUOT_CMD , FINDUNI_CMD ,
  GCD_CMD , GETDUMP_CMD , HIGHCORNER_CMD , HILBERT_CMD ,
  HOMOG_CMD , HRES_CMD , IMPART_CMD , IMPORTFROM_CMD ,
  INDEPSET_CMD , INSERT_CMD , INT_CMD , INTDIV_CMD ,
  INTERPOLATE_CMD , INTERRED_CMD , INTERSECT_CMD , INTVEC_CMD ,
  IS_RINGVAR , JACOB_CMD , JANET_CMD , JET_CMD ,
  KBASE_CMD , KERNEL_CMD , KILLATTR_CMD , KRES_CMD ,
  LAGSOLVE_CMD , LEAD_CMD , LEADCOEF_CMD , LEADEXP_CMD ,
  LEADMONOM_CMD , LIFTSTD_CMD , LIFT_CMD , LINK_CMD ,
  LIST_CMD , LOAD_CMD , LRES_CMD , LU_CMD ,
  LUI_CMD , LUS_CMD , MEMORY_CMD , MINBASE_CMD ,
  MINOR_CMD , MINRES_CMD , MODULO_CMD , MONITOR_CMD ,
  MPRES_CMD , MRES_CMD , MSTD_CMD , MULTIPLICITY_CMD ,
  NAMEOF_CMD , NAMES_CMD , NEWSTRUCT_CMD , NCALGEBRA_CMD ,
  NC_ALGEBRA_CMD , NEWTONPOLY_CMD , NPARS_CMD , NUMERATOR_CMD ,
  NVARS_CMD , ORD_CMD , OPEN_CMD , OPPOSE_CMD ,
  OPPOSITE_CMD , OPTION_CMD , ORDSTR_CMD , PACKAGE_CMD ,
  PARDEG_CMD , PARENT_CMD , PARSTR_CMD , PFAC_CMD ,
  PRIME_CMD , PRINT_CMD , PRUNE_CMD , QHWEIGHT_CMD ,
  QRING_CMD , QRDS_CMD , QUOTIENT_CMD , RANDOM_CMD ,
  RANK_CMD , READ_CMD , REDUCE_CMD , REGULARITY_CMD ,
  REPART_CMD , RES_CMD , RESERVEDNAME_CMD , RESERVEDNAMELIST_CMD ,
  RESTART_CMD , RESULTANT_CMD , RIGHTSTD_CMD , RINGLIST_CMD ,
  RING_LIST_CMD , ROWS_CMD , SBA_CMD , SIMPLEX_CMD ,
  SIMPLIFY_CMD , SLIM_GB_CMD , SORTVEC_CMD , SQR_FREE_CMD ,
  SRES_CMD , STATUS_CMD , STD_CMD , STRING_CMD ,
  SUBST_CMD , SYSTEM_CMD , SYZYGY_CMD , TENSOR_CMD ,
  TEST_CMD , TRANSPOSE_CMD , TRACE_CMD , TWOSTD_CMD ,
  TYPEOF_CMD , UNIVARIATE_CMD , UNLOAD_CMD , URSOLVE_CMD ,
  VANDER_CMD , VARIABLES_CMD , VARSTR_CMD , VDIM_CMD ,
  WAIT1ST_CMD , WAITALL_CMD , WEDGE_CMD , WEIGHT_CMD ,
  WRITE_CMD , VECHO , VCOLMAX , VTIMER ,
  VRTIMER , TRACE , VOICE , VSHORTOUT ,
  VPRINTLEVEL , MAX_TOK
}
 

Functions

int yyparse (void)
 

Variables

EXTERN_VAR int yylineno
 
EXTERN_VAR char my_yylinebuf [80]
 

Macro Definition Documentation

◆ ANY_TYPE

#define ANY_TYPE   UMINUS+3

Definition at line 30 of file tok.h.

◆ COMMAND

#define COMMAND   UMINUS+2 /* in tok.h */

Definition at line 29 of file tok.h.

◆ COMP_OP

#define COMP_OP   '<'

Definition at line 27 of file tok.h.

◆ IDHDL

#define IDHDL   UMINUS+4

Definition at line 31 of file tok.h.

◆ LOGIC_OP

#define LOGIC_OP   '&'

Definition at line 25 of file tok.h.

◆ MULDIV_OP

#define MULDIV_OP   '/'

Definition at line 26 of file tok.h.

◆ NONE

#define NONE   END_RING

Definition at line 221 of file tok.h.

◆ UNKNOWN

#define UNKNOWN   0

Definition at line 222 of file tok.h.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
ALIAS_CMD 
ALIGN_CMD 
ATTRIB_CMD 
BAREISS_CMD 
BIGINT_CMD 
BRANCHTO_CMD 
BRACKET_CMD 
BREAKPOINT_CMD 
CHARACTERISTIC_CMD 
CHARSTR_CMD 
CHAR_SERIES_CMD 
CHINREM_CMD 
CMATRIX_CMD 
CNUMBER_CMD 
CPOLY_CMD 
CLOSE_CMD 
COEFFS_CMD 
COEF_CMD 
COLS_CMD 
CONTENT_CMD 
CONTRACT_CMD 
COUNT_CMD 
CRING_CMD 
DBPRINT_CMD 
DEF_CMD 
DEFINED_CMD 
DEG_CMD 
DEGREE_CMD 
DELETE_CMD 
DENOMINATOR_CMD 
DET_CMD 
DIFF_CMD 
DIM_CMD 
DIVISION_CMD 
DUMP_CMD 
ELIMINATION_CMD 
END_GRAMMAR 
ENVELOPE_CMD 
ERROR_CMD 
EXECUTE_CMD 
EXPORTTO_CMD 
EXTGCD_CMD 
FAC_CMD 
FAREY_CMD 
FIND_CMD 
FACSTD_CMD 
FMD_CMD 
FRES_CMD 
FWALK_CMD 
FGLM_CMD 
FGLMQUOT_CMD 
FINDUNI_CMD 
GCD_CMD 
GETDUMP_CMD 
HIGHCORNER_CMD 
HILBERT_CMD 
HOMOG_CMD 
HRES_CMD 
IMPART_CMD 
IMPORTFROM_CMD 
INDEPSET_CMD 
INSERT_CMD 
INT_CMD 
INTDIV_CMD 
INTERPOLATE_CMD 
INTERRED_CMD 
INTERSECT_CMD 
INTVEC_CMD 
IS_RINGVAR 
JACOB_CMD 
JANET_CMD 
JET_CMD 
KBASE_CMD 
KERNEL_CMD 
KILLATTR_CMD 
KRES_CMD 
LAGSOLVE_CMD 
LEAD_CMD 
LEADCOEF_CMD 
LEADEXP_CMD 
LEADMONOM_CMD 
LIFTSTD_CMD 
LIFT_CMD 
LINK_CMD 
LIST_CMD 
LOAD_CMD 
LRES_CMD 
LU_CMD 
LUI_CMD 
LUS_CMD 
MEMORY_CMD 
MINBASE_CMD 
MINOR_CMD 
MINRES_CMD 
MODULO_CMD 
MONITOR_CMD 
MPRES_CMD 
MRES_CMD 
MSTD_CMD 
MULTIPLICITY_CMD 
NAMEOF_CMD 
NAMES_CMD 
NEWSTRUCT_CMD 
NCALGEBRA_CMD 
NC_ALGEBRA_CMD 
NEWTONPOLY_CMD 
NPARS_CMD 
NUMERATOR_CMD 
NVARS_CMD 
ORD_CMD 
OPEN_CMD 
OPPOSE_CMD 
OPPOSITE_CMD 
OPTION_CMD 
ORDSTR_CMD 
PACKAGE_CMD 
PARDEG_CMD 
PARENT_CMD 
PARSTR_CMD 
PFAC_CMD 
PRIME_CMD 
PRINT_CMD 
PRUNE_CMD 
QHWEIGHT_CMD 
QRING_CMD 
QRDS_CMD 
QUOTIENT_CMD 
RANDOM_CMD 
RANK_CMD 
READ_CMD 
REDUCE_CMD 
REGULARITY_CMD 
REPART_CMD 
RES_CMD 
RESERVEDNAME_CMD 
RESERVEDNAMELIST_CMD 
RESTART_CMD 
RESULTANT_CMD 
RIGHTSTD_CMD 
RINGLIST_CMD 
RING_LIST_CMD 
ROWS_CMD 
SBA_CMD 
SIMPLEX_CMD 
SIMPLIFY_CMD 
SLIM_GB_CMD 
SORTVEC_CMD 
SQR_FREE_CMD 
SRES_CMD 
STATUS_CMD 
STD_CMD 
STRING_CMD 
SUBST_CMD 
SYSTEM_CMD 
SYZYGY_CMD 
TENSOR_CMD 
TEST_CMD 
TRANSPOSE_CMD 
TRACE_CMD 
TWOSTD_CMD 
TYPEOF_CMD 
UNIVARIATE_CMD 
UNLOAD_CMD 
URSOLVE_CMD 
VANDER_CMD 
VARIABLES_CMD 
VARSTR_CMD 
VDIM_CMD 
WAIT1ST_CMD 
WAITALL_CMD 
WEDGE_CMD 
WEIGHT_CMD 
WRITE_CMD 
VECHO 
VCOLMAX 
VTIMER 
VRTIMER 
TRACE 
VOICE 
VSHORTOUT 
VPRINTLEVEL 
MAX_TOK 

Definition at line 33 of file tok.h.

33 {
34 ALIAS_CMD = UMINUS + 15,
58 DEF_CMD,
60 DEG_CMD,
64 DET_CMD,
66 DIM_CMD,
76 FAC_CMD,
80 FMD_CMD,
86 GCD_CMD,
96 INT_CMD,
103 JACOB_CMD,
104 JANET_CMD,
105 JET_CMD,
106 KBASE_CMD,
109 KRES_CMD,
111 LEAD_CMD,
116 LIFT_CMD,
117 LINK_CMD,
118 LIST_CMD,
119 LOAD_CMD,
120 LRES_CMD,
121 LU_CMD,
122 LUI_CMD,
123 LUS_CMD,
126 MINOR_CMD,
130 MPRES_CMD,
131 MRES_CMD,
132 MSTD_CMD,
135 NAMES_CMD,
140 NPARS_CMD,
142 NVARS_CMD,
143 ORD_CMD,
144 OPEN_CMD,
153 PFAC_CMD,
154 PRIME_CMD,
155 PRINT_CMD,
156 PRUNE_CMD,
158 QRING_CMD,
159 QRDS_CMD,
162 RANK_CMD,
163 READ_CMD,
167 RES_CMD,
175 ROWS_CMD,
176 SBA_CMD,
182 SRES_CMD,
184 STD_CMD,
186 SUBST_CMD,
190 TEST_CMD,
192 TRACE_CMD,
196 UNLOAD_CMD, /* unused*/
201 VDIM_CMD,
204 WEDGE_CMD,
206 WRITE_CMD,
207 /* start system var section: VECHO */
208 VECHO,
209 VCOLMAX,
210 VTIMER,
211 VRTIMER,
212 TRACE,
213 VOICE,
214 VSHORTOUT,
216 /* end system var section: VPRINTLEVEL */
217
218 MAX_TOK /* must be the last, biggest token number */
219};
@ UMINUS
Definition: grammar.cc:351
@ ERROR_CMD
Definition: tok.h:72
@ PFAC_CMD
Definition: tok.h:153
@ PARSTR_CMD
Definition: tok.h:152
@ HIGHCORNER_CMD
Definition: tok.h:88
@ ELIMINATION_CMD
Definition: tok.h:69
@ NCALGEBRA_CMD
Definition: tok.h:137
@ REPART_CMD
Definition: tok.h:166
@ VCOLMAX
Definition: tok.h:209
@ ALIAS_CMD
Definition: tok.h:34
@ SIMPLEX_CMD
Definition: tok.h:177
@ VARIABLES_CMD
Definition: tok.h:199
@ JACOB_CMD
Definition: tok.h:103
@ MSTD_CMD
Definition: tok.h:132
@ INDEPSET_CMD
Definition: tok.h:94
@ BIGINT_CMD
Definition: tok.h:38
@ SIMPLIFY_CMD
Definition: tok.h:178
@ CRING_CMD
Definition: tok.h:56
@ LIST_CMD
Definition: tok.h:118
@ FGLMQUOT_CMD
Definition: tok.h:84
@ RESTART_CMD
Definition: tok.h:170
@ VSHORTOUT
Definition: tok.h:214
@ BAREISS_CMD
Definition: tok.h:37
@ DEG_CMD
Definition: tok.h:60
@ VPRINTLEVEL
Definition: tok.h:215
@ LUS_CMD
Definition: tok.h:123
@ READ_CMD
Definition: tok.h:163
@ CLOSE_CMD
Definition: tok.h:49
@ SLIM_GB_CMD
Definition: tok.h:179
@ INTVEC_CMD
Definition: tok.h:101
@ RANDOM_CMD
Definition: tok.h:161
@ COUNT_CMD
Definition: tok.h:55
@ FWALK_CMD
Definition: tok.h:82
@ MULTIPLICITY_CMD
Definition: tok.h:133
@ NAMES_CMD
Definition: tok.h:135
@ PACKAGE_CMD
Definition: tok.h:149
@ BRANCHTO_CMD
Definition: tok.h:39
@ END_GRAMMAR
Definition: tok.h:70
@ MODULO_CMD
Definition: tok.h:128
@ JET_CMD
Definition: tok.h:105
@ CMATRIX_CMD
Definition: tok.h:46
@ HILBERT_CMD
Definition: tok.h:89
@ DIFF_CMD
Definition: tok.h:65
@ RIGHTSTD_CMD
Definition: tok.h:172
@ VANDER_CMD
Definition: tok.h:198
@ HOMOG_CMD
Definition: tok.h:90
@ NVARS_CMD
Definition: tok.h:142
@ MEMORY_CMD
Definition: tok.h:124
@ NEWTONPOLY_CMD
Definition: tok.h:139
@ DEF_CMD
Definition: tok.h:58
@ KBASE_CMD
Definition: tok.h:106
@ VECHO
Definition: tok.h:208
@ ATTRIB_CMD
Definition: tok.h:36
@ LRES_CMD
Definition: tok.h:120
@ IMPORTFROM_CMD
Definition: tok.h:93
@ SUBST_CMD
Definition: tok.h:186
@ CHARSTR_CMD
Definition: tok.h:43
@ HRES_CMD
Definition: tok.h:91
@ JANET_CMD
Definition: tok.h:104
@ REDUCE_CMD
Definition: tok.h:164
@ LIFTSTD_CMD
Definition: tok.h:115
@ KRES_CMD
Definition: tok.h:109
@ BREAKPOINT_CMD
Definition: tok.h:41
@ OPTION_CMD
Definition: tok.h:147
@ OPEN_CMD
Definition: tok.h:144
@ COEFFS_CMD
Definition: tok.h:50
@ LEADEXP_CMD
Definition: tok.h:113
@ QRDS_CMD
Definition: tok.h:159
@ CONTRACT_CMD
Definition: tok.h:54
@ CNUMBER_CMD
Definition: tok.h:47
@ LIFT_CMD
Definition: tok.h:116
@ TRANSPOSE_CMD
Definition: tok.h:191
@ LINK_CMD
Definition: tok.h:117
@ BRACKET_CMD
Definition: tok.h:40
@ STD_CMD
Definition: tok.h:184
@ SBA_CMD
Definition: tok.h:176
@ WAITALL_CMD
Definition: tok.h:203
@ EXECUTE_CMD
Definition: tok.h:73
@ TRACE
Definition: tok.h:212
@ DET_CMD
Definition: tok.h:64
@ DBPRINT_CMD
Definition: tok.h:57
@ CHINREM_CMD
Definition: tok.h:45
@ RING_LIST_CMD
Definition: tok.h:174
@ NUMERATOR_CMD
Definition: tok.h:141
@ NC_ALGEBRA_CMD
Definition: tok.h:138
@ URSOLVE_CMD
Definition: tok.h:197
@ ORD_CMD
Definition: tok.h:143
@ QRING_CMD
Definition: tok.h:158
@ PRINT_CMD
Definition: tok.h:155
@ FMD_CMD
Definition: tok.h:80
@ UNIVARIATE_CMD
Definition: tok.h:195
@ PARDEG_CMD
Definition: tok.h:150
@ MPRES_CMD
Definition: tok.h:130
@ NPARS_CMD
Definition: tok.h:140
@ PARENT_CMD
Definition: tok.h:151
@ MRES_CMD
Definition: tok.h:131
@ DIVISION_CMD
Definition: tok.h:67
@ PRIME_CMD
Definition: tok.h:154
@ LEADCOEF_CMD
Definition: tok.h:112
@ EXPORTTO_CMD
Definition: tok.h:74
@ IMPART_CMD
Definition: tok.h:92
@ NAMEOF_CMD
Definition: tok.h:134
@ TYPEOF_CMD
Definition: tok.h:194
@ KILLATTR_CMD
Definition: tok.h:108
@ REGULARITY_CMD
Definition: tok.h:165
@ WAIT1ST_CMD
Definition: tok.h:202
@ CONTENT_CMD
Definition: tok.h:53
@ STRING_CMD
Definition: tok.h:185
@ WRITE_CMD
Definition: tok.h:206
@ DEGREE_CMD
Definition: tok.h:61
@ OPPOSITE_CMD
Definition: tok.h:146
@ GETDUMP_CMD
Definition: tok.h:87
@ SRES_CMD
Definition: tok.h:182
@ WEIGHT_CMD
Definition: tok.h:205
@ ALIGN_CMD
Definition: tok.h:35
@ MONITOR_CMD
Definition: tok.h:129
@ VARSTR_CMD
Definition: tok.h:200
@ PRUNE_CMD
Definition: tok.h:156
@ STATUS_CMD
Definition: tok.h:183
@ DUMP_CMD
Definition: tok.h:68
@ RESERVEDNAMELIST_CMD
Definition: tok.h:169
@ FIND_CMD
Definition: tok.h:78
@ ENVELOPE_CMD
Definition: tok.h:71
@ COEF_CMD
Definition: tok.h:51
@ INTERRED_CMD
Definition: tok.h:99
@ WEDGE_CMD
Definition: tok.h:204
@ SQR_FREE_CMD
Definition: tok.h:181
@ DELETE_CMD
Definition: tok.h:62
@ SORTVEC_CMD
Definition: tok.h:180
@ FACSTD_CMD
Definition: tok.h:79
@ MINOR_CMD
Definition: tok.h:126
@ VTIMER
Definition: tok.h:210
@ QHWEIGHT_CMD
Definition: tok.h:157
@ VRTIMER
Definition: tok.h:211
@ RINGLIST_CMD
Definition: tok.h:173
@ LEAD_CMD
Definition: tok.h:111
@ ORDSTR_CMD
Definition: tok.h:148
@ LOAD_CMD
Definition: tok.h:119
@ DENOMINATOR_CMD
Definition: tok.h:63
@ TWOSTD_CMD
Definition: tok.h:193
@ FINDUNI_CMD
Definition: tok.h:85
@ VOICE
Definition: tok.h:213
@ CPOLY_CMD
Definition: tok.h:48
@ INTDIV_CMD
Definition: tok.h:97
@ TRACE_CMD
Definition: tok.h:192
@ INT_CMD
Definition: tok.h:96
@ QUOTIENT_CMD
Definition: tok.h:160
@ INTERSECT_CMD
Definition: tok.h:100
@ KERNEL_CMD
Definition: tok.h:107
@ INSERT_CMD
Definition: tok.h:95
@ LUI_CMD
Definition: tok.h:122
@ EXTGCD_CMD
Definition: tok.h:75
@ VDIM_CMD
Definition: tok.h:201
@ TEST_CMD
Definition: tok.h:190
@ GCD_CMD
Definition: tok.h:86
@ SYSTEM_CMD
Definition: tok.h:187
@ MINBASE_CMD
Definition: tok.h:125
@ SYZYGY_CMD
Definition: tok.h:188
@ FAREY_CMD
Definition: tok.h:77
@ INTERPOLATE_CMD
Definition: tok.h:98
@ LEADMONOM_CMD
Definition: tok.h:114
@ DIM_CMD
Definition: tok.h:66
@ NEWSTRUCT_CMD
Definition: tok.h:136
@ ROWS_CMD
Definition: tok.h:175
@ RESERVEDNAME_CMD
Definition: tok.h:168
@ RESULTANT_CMD
Definition: tok.h:171
@ OPPOSE_CMD
Definition: tok.h:145
@ TENSOR_CMD
Definition: tok.h:189
@ DEFINED_CMD
Definition: tok.h:59
@ MAX_TOK
Definition: tok.h:218
@ FRES_CMD
Definition: tok.h:81
@ IS_RINGVAR
Definition: tok.h:102
@ CHARACTERISTIC_CMD
Definition: tok.h:42
@ LU_CMD
Definition: tok.h:121
@ COLS_CMD
Definition: tok.h:52
@ FAC_CMD
Definition: tok.h:76
@ MINRES_CMD
Definition: tok.h:127
@ LAGSOLVE_CMD
Definition: tok.h:110
@ CHAR_SERIES_CMD
Definition: tok.h:44
@ FGLM_CMD
Definition: tok.h:83
@ UNLOAD_CMD
Definition: tok.h:196
@ RES_CMD
Definition: tok.h:167
@ RANK_CMD
Definition: tok.h:162

Function Documentation

◆ yyparse()

int yyparse ( void  )

Definition at line 945 of file readcf.cc.

946{
947 yy_state_fast_t yystate = 0;
948 /* Number of tokens to shift before error messages enabled. */
949 int yyerrstatus = 0;
950
951 /* Refer to the stacks through separate pointers, to allow yyoverflow
952 to reallocate them elsewhere. */
953
954 /* Their size. */
955 YYPTRDIFF_T yystacksize = YYINITDEPTH;
956
957 /* The state stack: array, bottom, top. */
958 yy_state_t yyssa[YYINITDEPTH];
959 yy_state_t *yyss = yyssa;
960 yy_state_t *yyssp = yyss;
961
962 /* The semantic value stack: array, bottom, top. */
963 YYSTYPE yyvsa[YYINITDEPTH];
964 YYSTYPE *yyvs = yyvsa;
965 YYSTYPE *yyvsp = yyvs;
966
967 int yyn;
968 /* The return value of yyparse. */
969 int yyresult;
970 /* Lookahead symbol kind. */
972 /* The variables used to return semantic value and location from the
973 action routines. */
974 YYSTYPE yyval;
975
976
977
978#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
979
980 /* The number of symbols on the RHS of the reduced rule.
981 Keep to zero when no symbol should be popped. */
982 int yylen = 0;
983
984 YYDPRINTF ((stderr, "Starting parse\n"));
985
986 yychar = YYEMPTY; /* Cause a token to be read. */
987 goto yysetstate;
988
989
990/*------------------------------------------------------------.
991| yynewstate -- push a new state, which is found in yystate. |
992`------------------------------------------------------------*/
993yynewstate:
994 /* In all cases, when you get here, the value and location stacks
995 have just been pushed. So pushing a state here evens the stacks. */
996 yyssp++;
997
998
999/*--------------------------------------------------------------------.
1000| yysetstate -- set current state (the top of the stack) to yystate. |
1001`--------------------------------------------------------------------*/
1002yysetstate:
1003 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1004 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1006 *yyssp = YY_CAST (yy_state_t, yystate);
1008 YY_STACK_PRINT (yyss, yyssp);
1009
1010 if (yyss + yystacksize - 1 <= yyssp)
1011#if !defined yyoverflow && !defined YYSTACK_RELOCATE
1012 goto yyexhaustedlab;
1013#else
1014 {
1015 /* Get the current used size of the three stacks, in elements. */
1016 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1017
1018# if defined yyoverflow
1019 {
1020 /* Give user a chance to reallocate the stack. Use copies of
1021 these so that the &'s don't force the real ones into
1022 memory. */
1023 yy_state_t *yyss1 = yyss;
1024 YYSTYPE *yyvs1 = yyvs;
1025
1026 /* Each stack pointer address is followed by the size of the
1027 data in use in that stack, in bytes. This used to be a
1028 conditional around just the two extra args, but that might
1029 be undefined if yyoverflow is a macro. */
1030 yyoverflow (YY_("memory exhausted"),
1031 &yyss1, yysize * YYSIZEOF (*yyssp),
1032 &yyvs1, yysize * YYSIZEOF (*yyvsp),
1033 &yystacksize);
1034 yyss = yyss1;
1035 yyvs = yyvs1;
1036 }
1037# else /* defined YYSTACK_RELOCATE */
1038 /* Extend the stack our own way. */
1039 if (YYMAXDEPTH <= yystacksize)
1040 goto yyexhaustedlab;
1041 yystacksize *= 2;
1042 if (YYMAXDEPTH < yystacksize)
1043 yystacksize = YYMAXDEPTH;
1044
1045 {
1046 yy_state_t *yyss1 = yyss;
1047 union yyalloc *yyptr =
1048 YY_CAST (union yyalloc *,
1049 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1050 if (! yyptr)
1051 goto yyexhaustedlab;
1052 YYSTACK_RELOCATE (yyss_alloc, yyss);
1053 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1054# undef YYSTACK_RELOCATE
1055 if (yyss1 != yyssa)
1056 YYSTACK_FREE (yyss1);
1057 }
1058# endif
1059
1060 yyssp = yyss + yysize - 1;
1061 yyvsp = yyvs + yysize - 1;
1062
1064 YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1065 YY_CAST (long, yystacksize)));
1067
1068 if (yyss + yystacksize - 1 <= yyssp)
1069 YYABORT;
1070 }
1071#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1072
1073 if (yystate == YYFINAL)
1074 YYACCEPT;
1075
1076 goto yybackup;
1077
1078
1079/*-----------.
1080| yybackup. |
1081`-----------*/
1082yybackup:
1083 /* Do appropriate processing given the current state. Read a
1084 lookahead token if we need one and don't already have one. */
1085
1086 /* First try to decide what to do without reference to lookahead token. */
1087 yyn = yypact[yystate];
1088 if (yypact_value_is_default (yyn))
1089 goto yydefault;
1090
1091 /* Not known => get a lookahead token if don't already have one. */
1092
1093 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
1094 if (yychar == YYEMPTY)
1095 {
1096 YYDPRINTF ((stderr, "Reading a token\n"));
1097 yychar = yylex ();
1098 }
1099
1100 if (yychar <= YYEOF)
1101 {
1102 yychar = YYEOF;
1103 yytoken = YYSYMBOL_YYEOF;
1104 YYDPRINTF ((stderr, "Now at end of input.\n"));
1105 }
1106 else if (yychar == YYerror)
1107 {
1108 /* The scanner already issued an error message, process directly
1109 to error recovery. But do not keep the error token as
1110 lookahead, it is too special and may lead us to an endless
1111 loop in error recovery. */
1112 yychar = YYUNDEF;
1113 yytoken = YYSYMBOL_YYerror;
1114 goto yyerrlab1;
1115 }
1116 else
1117 {
1118 yytoken = YYTRANSLATE (yychar);
1119 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1120 }
1121
1122 /* If the proper action on seeing token YYTOKEN is to reduce or to
1123 detect an error, take that action. */
1124 yyn += yytoken;
1125 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1126 goto yydefault;
1127 yyn = yytable[yyn];
1128 if (yyn <= 0)
1129 {
1130 if (yytable_value_is_error (yyn))
1131 goto yyerrlab;
1132 yyn = -yyn;
1133 goto yyreduce;
1134 }
1135
1136 /* Count tokens shifted since error; after three, turn off error
1137 status. */
1138 if (yyerrstatus)
1139 yyerrstatus--;
1140
1141 /* Shift the lookahead token. */
1142 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1143 yystate = yyn;
1145 *++yyvsp = yylval;
1147
1148 /* Discard the shifted token. */
1149 yychar = YYEMPTY;
1150 goto yynewstate;
1151
1152
1153/*-----------------------------------------------------------.
1154| yydefault -- do the default action for the current state. |
1155`-----------------------------------------------------------*/
1156yydefault:
1157 yyn = yydefact[yystate];
1158 if (yyn == 0)
1159 goto yyerrlab;
1160 goto yyreduce;
1161
1162
1163/*-----------------------------.
1164| yyreduce -- do a reduction. |
1165`-----------------------------*/
1166yyreduce:
1167 /* yyn is the number of a rule to reduce with. */
1168 yylen = yyr2[yyn];
1169
1170 /* If YYLEN is nonzero, implement the default value of the action:
1171 '$$ = $1'.
1172
1173 Otherwise, the following line sets YYVAL to garbage.
1174 This behavior is undocumented and Bison
1175 users should not rely upon it. Assigning to YYVAL
1176 unconditionally makes the parser a bit smaller, and it avoids a
1177 GCC warning that YYVAL may be used uninitialized. */
1178 yyval = yyvsp[1-yylen];
1179
1180
1181 YY_REDUCE_PRINT (yyn);
1182 switch (yyn)
1183 {
1184 case 5: /* line: exp ';' */
1185#line 78 "readcf.yy"
1186 { *retvalue = yyvsp[-1].getval(); return 0; }
1187#line 1188 "readcf.cc"
1188 break;
1189
1190 case 6: /* exp: NUM */
1191#line 81 "readcf.yy"
1192 { yyval = yyvsp[0]; }
1193#line 1194 "readcf.cc"
1194 break;
1195
1196 case 7: /* exp: exp '+' exp */
1197#line 82 "readcf.yy"
1198 { yyval = yyvsp[-2].getval() + yyvsp[0].getval(); }
1199#line 1200 "readcf.cc"
1200 break;
1201
1202 case 8: /* exp: exp '-' exp */
1203#line 83 "readcf.yy"
1204 { yyval = yyvsp[-2].getval() - yyvsp[0].getval(); }
1205#line 1206 "readcf.cc"
1206 break;
1207
1208 case 9: /* exp: exp '*' exp */
1209#line 84 "readcf.yy"
1210 { yyval = yyvsp[-2].getval() * yyvsp[0].getval(); }
1211#line 1212 "readcf.cc"
1212 break;
1213
1214 case 10: /* exp: exp '/' exp */
1215#line 85 "readcf.yy"
1216 { yyval = yyvsp[-2].getval() / yyvsp[0].getval(); }
1217#line 1218 "readcf.cc"
1218 break;
1219
1220 case 11: /* exp: '-' exp */
1221#line 86 "readcf.yy"
1222 { yyval = -yyvsp[0].getval(); }
1223#line 1224 "readcf.cc"
1224 break;
1225
1226 case 12: /* exp: '+' exp */
1227#line 87 "readcf.yy"
1228 { yyval = yyvsp[0].getval(); }
1229#line 1230 "readcf.cc"
1230 break;
1231
1232 case 13: /* exp: exp '^' NUM */
1233#line 88 "readcf.yy"
1234 { yyval = power( yyvsp[-2].getval(), yyvsp[0].getintval() ); }
1235#line 1236 "readcf.cc"
1236 break;
1237
1238 case 14: /* exp: '(' exp ')' */
1239#line 89 "readcf.yy"
1240 { yyval = yyvsp[-1].getval(); }
1241#line 1242 "readcf.cc"
1242 break;
1243
1244
1245#line 1246 "readcf.cc"
1246
1247 default: break;
1248 }
1249 /* User semantic actions sometimes alter yychar, and that requires
1250 that yytoken be updated with the new translation. We take the
1251 approach of translating immediately before every use of yytoken.
1252 One alternative is translating here after every semantic action,
1253 but that translation would be missed if the semantic action invokes
1254 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1255 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1256 incorrect destructor might then be invoked immediately. In the
1257 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1258 to an incorrect destructor call or verbose syntax error message
1259 before the lookahead is translated. */
1260 YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
1261
1262 YYPOPSTACK (yylen);
1263 yylen = 0;
1264
1265 *++yyvsp = yyval;
1266
1267 /* Now 'shift' the result of the reduction. Determine what state
1268 that goes to, based on the state we popped back to and the rule
1269 number reduced by. */
1270 {
1271 const int yylhs = yyr1[yyn] - YYNTOKENS;
1272 const int yyi = yypgoto[yylhs] + *yyssp;
1273 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1274 ? yytable[yyi]
1275 : yydefgoto[yylhs]);
1276 }
1277
1278 goto yynewstate;
1279
1280
1281/*--------------------------------------.
1282| yyerrlab -- here on detecting error. |
1283`--------------------------------------*/
1284yyerrlab:
1285 /* Make sure we have latest lookahead translation. See comments at
1286 user semantic actions for why this is necessary. */
1288 /* If not already recovering from an error, report this error. */
1289 if (!yyerrstatus)
1290 {
1291 ++yynerrs;
1292 yyerror (YY_("syntax error"));
1293 }
1294
1295 if (yyerrstatus == 3)
1296 {
1297 /* If just tried and failed to reuse lookahead token after an
1298 error, discard it. */
1299
1300 if (yychar <= YYEOF)
1301 {
1302 /* Return failure if at end of input. */
1303 if (yychar == YYEOF)
1304 YYABORT;
1305 }
1306 else
1307 {
1308 yydestruct ("Error: discarding",
1309 yytoken, &yylval);
1310 yychar = YYEMPTY;
1311 }
1312 }
1313
1314 /* Else will try to reuse lookahead token after shifting the error
1315 token. */
1316 goto yyerrlab1;
1317
1318
1319/*---------------------------------------------------.
1320| yyerrorlab -- error raised explicitly by YYERROR. |
1321`---------------------------------------------------*/
1322yyerrorlab:
1323 /* Pacify compilers when the user code never invokes YYERROR and the
1324 label yyerrorlab therefore never appears in user code. */
1325 if (0)
1326 YYERROR;
1327
1328 /* Do not reclaim the symbols of the rule whose action triggered
1329 this YYERROR. */
1330 YYPOPSTACK (yylen);
1331 yylen = 0;
1332 YY_STACK_PRINT (yyss, yyssp);
1333 yystate = *yyssp;
1334 goto yyerrlab1;
1335
1336
1337/*-------------------------------------------------------------.
1338| yyerrlab1 -- common code for both syntax error and YYERROR. |
1339`-------------------------------------------------------------*/
1340yyerrlab1:
1341 yyerrstatus = 3; /* Each real token shifted decrements this. */
1342
1343 /* Pop stack until we find a state that shifts the error token. */
1344 for (;;)
1345 {
1346 yyn = yypact[yystate];
1347 if (!yypact_value_is_default (yyn))
1348 {
1349 yyn += YYSYMBOL_YYerror;
1350 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
1351 {
1352 yyn = yytable[yyn];
1353 if (0 < yyn)
1354 break;
1355 }
1356 }
1357
1358 /* Pop the current state because it cannot handle the error token. */
1359 if (yyssp == yyss)
1360 YYABORT;
1361
1362
1363 yydestruct ("Error: popping",
1364 YY_ACCESSING_SYMBOL (yystate), yyvsp);
1365 YYPOPSTACK (1);
1366 yystate = *yyssp;
1367 YY_STACK_PRINT (yyss, yyssp);
1368 }
1369
1371 *++yyvsp = yylval;
1373
1374
1375 /* Shift the error token. */
1376 YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
1377
1378 yystate = yyn;
1379 goto yynewstate;
1380
1381
1382/*-------------------------------------.
1383| yyacceptlab -- YYACCEPT comes here. |
1384`-------------------------------------*/
1385yyacceptlab:
1386 yyresult = 0;
1387 goto yyreturn;
1388
1389
1390/*-----------------------------------.
1391| yyabortlab -- YYABORT comes here. |
1392`-----------------------------------*/
1393yyabortlab:
1394 yyresult = 1;
1395 goto yyreturn;
1396
1397
1398#if !defined yyoverflow
1399/*-------------------------------------------------.
1400| yyexhaustedlab -- memory exhaustion comes here. |
1401`-------------------------------------------------*/
1402yyexhaustedlab:
1403 yyerror (YY_("memory exhausted"));
1404 yyresult = 2;
1405 goto yyreturn;
1406#endif
1407
1408
1409/*-------------------------------------------------------.
1410| yyreturn -- parsing is finished, clean up and return. |
1411`-------------------------------------------------------*/
1412yyreturn:
1413 if (yychar != YYEMPTY)
1414 {
1415 /* Make sure we have latest lookahead translation. See comments at
1416 user semantic actions for why this is necessary. */
1417 yytoken = YYTRANSLATE (yychar);
1418 yydestruct ("Cleanup: discarding lookahead",
1419 yytoken, &yylval);
1420 }
1421 /* Do not reclaim the symbols of the rule whose action triggered
1422 this YYABORT or YYACCEPT. */
1423 YYPOPSTACK (yylen);
1424 YY_STACK_PRINT (yyss, yyssp);
1425 while (yyssp != yyss)
1426 {
1427 yydestruct ("Cleanup: popping",
1428 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
1429 YYPOPSTACK (1);
1430 }
1431#ifndef yyoverflow
1432 if (yyss != yyssa)
1433 YYSTACK_FREE (yyss);
1434#endif
1435
1436 return yyresult;
1437}
CanonicalForm power(const CanonicalForm &f, int n)
exponentiation
InternalCF * getval() const
int yynerrs
Definition: readcf.cc:935
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: readcf.cc:386
#define YYMAXDEPTH
Definition: readcf.cc:902
void yyerror(char *s)
Definition: readcf.cc:1445
#define YYSTACK_FREE
Definition: readcf.cc:448
yysymbol_kind_t
Definition: readcf.cc:198
@ YYSYMBOL_YYerror
Definition: readcf.cc:201
@ YYSYMBOL_YYEOF
Definition: readcf.cc:200
@ YYSYMBOL_YYEMPTY
Definition: readcf.cc:199
#define YY_ASSERT(E)
Definition: readcf.cc:406
#define YY_(Msgid)
Definition: readcf.cc:346
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: readcf.cc:387
static const yytype_int8 yydefact[]
Definition: readcf.cc:657
#define YYNSTATES
Definition: readcf.cc:547
#define YYSTYPE
Definition: readcf.cc:111
#define YY_IGNORE_USELESS_CAST_END
Definition: readcf.cc:402
#define YYEOF
Definition: readcf.cc:177
#define YYABORT
Definition: readcf.cc:727
static const yytype_int8 yycheck[]
Definition: readcf.cc:688
#define YY_REDUCE_PRINT(Rule)
Definition: readcf.cc:885
#define YY_CAST(Type, Val)
Definition: readcf.cc:133
static void yydestruct(const char *yymsg, yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
Definition: readcf.cc:915
YYSTYPE yylval
Definition: readcf.cc:933
#define YYerror
Definition: readcf.cc:178
#define YYUNDEF
Definition: readcf.cc:179
static const yytype_int8 yypact[]
Definition: readcf.cc:647
#define YYFINAL
Definition: readcf.cc:536
#define YY_ACCESSING_SYMBOL(State)
Accessing symbol of state STATE.
Definition: readcf.cc:602
#define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
Definition: readcf.cc:883
#define YYNTOKENS
Definition: readcf.cc:541
#define YY_STACK_PRINT(Bottom, Top)
Definition: readcf.cc:884
#define YYSIZE_T
Definition: readcf.cc:319
#define YY_IGNORE_USELESS_CAST_BEGIN
Definition: readcf.cc:401
static const yytype_int8 yyr2[]
Definition: readcf.cc:714
static const yytype_int8 yytable[]
Definition: readcf.cc:679
#define YYPTRDIFF_T
Definition: readcf.cc:305
int yychar
Definition: readcf.cc:930
int yylex()
Definition: readcf.cc:1454
#define YYACCEPT
Definition: readcf.cc:726
#define yytable_value_is_error(Yyn)
Definition: readcf.cc:642
#define YYTRANSLATE(YYX)
Definition: readcf.cc:555
static const yytype_int8 yypgoto[]
Definition: readcf.cc:665
static const yytype_int8 yyr1[]
Definition: readcf.cc:707
#define YYPOPSTACK(N)
int yy_state_fast_t
Definition: readcf.cc:336
static const yytype_int8 yydefgoto[]
Definition: readcf.cc:671
static CanonicalForm * retvalue
Definition: readcf.cc:126
#define YYEMPTY
Definition: readcf.cc:176
#define YYLAST
Definition: readcf.cc:538
#define yypact_value_is_default(Yyn)
Definition: readcf.cc:637
#define YYINITDEPTH
Definition: readcf.cc:891
#define YYERROR
Definition: readcf.cc:728
#define YYSIZEOF(X)
Definition: readcf.cc:329
#define YYSTACK_ALLOC
Definition: readcf.cc:447
yytype_int8 yy_state_t
Definition: readcf.cc:333
#define YYDPRINTF(Args)
Definition: readcf.cc:882

Variable Documentation

◆ my_yylinebuf

EXTERN_VAR char my_yylinebuf[80]

Definition at line 16 of file tok.h.

◆ yylineno

EXTERN_VAR int yylineno

Definition at line 15 of file tok.h.