My Project
Loading...
Searching...
No Matches
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 , MRES_MAP_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 ,
  PRUNE_MAP_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 223 of file tok.h.

◆ UNKNOWN

#define UNKNOWN   0

Definition at line 224 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 
MRES_MAP_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 
PRUNE_MAP_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,
133 MSTD_CMD,
136 NAMES_CMD,
141 NPARS_CMD,
143 NVARS_CMD,
144 ORD_CMD,
145 OPEN_CMD,
154 PFAC_CMD,
155 PRIME_CMD,
156 PRINT_CMD,
157 PRUNE_CMD,
160 QRING_CMD,
161 QRDS_CMD,
164 RANK_CMD,
165 READ_CMD,
169 RES_CMD,
177 ROWS_CMD,
178 SBA_CMD,
184 SRES_CMD,
186 STD_CMD,
188 SUBST_CMD,
192 TEST_CMD,
194 TRACE_CMD,
198 UNLOAD_CMD, /* unused*/
203 VDIM_CMD,
206 WEDGE_CMD,
208 WRITE_CMD,
209 /* start system var section: VECHO */
210 VECHO,
211 VCOLMAX,
212 VTIMER,
213 VRTIMER,
214 TRACE,
215 VOICE,
216 VSHORTOUT,
218 /* end system var section: VPRINTLEVEL */
219
220 MAX_TOK /* must be the last, biggest token number */
221};
@ UMINUS
Definition grammar.cc:352
@ ERROR_CMD
Definition tok.h:72
@ PFAC_CMD
Definition tok.h:154
@ PARSTR_CMD
Definition tok.h:153
@ HIGHCORNER_CMD
Definition tok.h:88
@ ELIMINATION_CMD
Definition tok.h:69
@ NCALGEBRA_CMD
Definition tok.h:138
@ REPART_CMD
Definition tok.h:168
@ VCOLMAX
Definition tok.h:211
@ ALIAS_CMD
Definition tok.h:34
@ SIMPLEX_CMD
Definition tok.h:179
@ VARIABLES_CMD
Definition tok.h:201
@ JACOB_CMD
Definition tok.h:103
@ MSTD_CMD
Definition tok.h:133
@ INDEPSET_CMD
Definition tok.h:94
@ BIGINT_CMD
Definition tok.h:38
@ SIMPLIFY_CMD
Definition tok.h:180
@ CRING_CMD
Definition tok.h:56
@ LIST_CMD
Definition tok.h:118
@ FGLMQUOT_CMD
Definition tok.h:84
@ RESTART_CMD
Definition tok.h:172
@ VSHORTOUT
Definition tok.h:216
@ BAREISS_CMD
Definition tok.h:37
@ DEG_CMD
Definition tok.h:60
@ VPRINTLEVEL
Definition tok.h:217
@ LUS_CMD
Definition tok.h:123
@ READ_CMD
Definition tok.h:165
@ CLOSE_CMD
Definition tok.h:49
@ SLIM_GB_CMD
Definition tok.h:181
@ INTVEC_CMD
Definition tok.h:101
@ RANDOM_CMD
Definition tok.h:163
@ COUNT_CMD
Definition tok.h:55
@ FWALK_CMD
Definition tok.h:82
@ MULTIPLICITY_CMD
Definition tok.h:134
@ NAMES_CMD
Definition tok.h:136
@ PACKAGE_CMD
Definition tok.h:150
@ 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:174
@ VANDER_CMD
Definition tok.h:200
@ HOMOG_CMD
Definition tok.h:90
@ NVARS_CMD
Definition tok.h:143
@ MEMORY_CMD
Definition tok.h:124
@ NEWTONPOLY_CMD
Definition tok.h:140
@ DEF_CMD
Definition tok.h:58
@ KBASE_CMD
Definition tok.h:106
@ VECHO
Definition tok.h:210
@ ATTRIB_CMD
Definition tok.h:36
@ LRES_CMD
Definition tok.h:120
@ IMPORTFROM_CMD
Definition tok.h:93
@ SUBST_CMD
Definition tok.h:188
@ CHARSTR_CMD
Definition tok.h:43
@ HRES_CMD
Definition tok.h:91
@ JANET_CMD
Definition tok.h:104
@ REDUCE_CMD
Definition tok.h:166
@ LIFTSTD_CMD
Definition tok.h:115
@ KRES_CMD
Definition tok.h:109
@ MRES_MAP_CMD
Definition tok.h:132
@ BREAKPOINT_CMD
Definition tok.h:41
@ OPTION_CMD
Definition tok.h:148
@ OPEN_CMD
Definition tok.h:145
@ COEFFS_CMD
Definition tok.h:50
@ LEADEXP_CMD
Definition tok.h:113
@ QRDS_CMD
Definition tok.h:161
@ CONTRACT_CMD
Definition tok.h:54
@ CNUMBER_CMD
Definition tok.h:47
@ LIFT_CMD
Definition tok.h:116
@ TRANSPOSE_CMD
Definition tok.h:193
@ LINK_CMD
Definition tok.h:117
@ BRACKET_CMD
Definition tok.h:40
@ STD_CMD
Definition tok.h:186
@ SBA_CMD
Definition tok.h:178
@ WAITALL_CMD
Definition tok.h:205
@ EXECUTE_CMD
Definition tok.h:73
@ TRACE
Definition tok.h:214
@ DET_CMD
Definition tok.h:64
@ DBPRINT_CMD
Definition tok.h:57
@ CHINREM_CMD
Definition tok.h:45
@ RING_LIST_CMD
Definition tok.h:176
@ NUMERATOR_CMD
Definition tok.h:142
@ NC_ALGEBRA_CMD
Definition tok.h:139
@ URSOLVE_CMD
Definition tok.h:199
@ ORD_CMD
Definition tok.h:144
@ QRING_CMD
Definition tok.h:160
@ PRINT_CMD
Definition tok.h:156
@ FMD_CMD
Definition tok.h:80
@ UNIVARIATE_CMD
Definition tok.h:197
@ PARDEG_CMD
Definition tok.h:151
@ MPRES_CMD
Definition tok.h:130
@ NPARS_CMD
Definition tok.h:141
@ PARENT_CMD
Definition tok.h:152
@ MRES_CMD
Definition tok.h:131
@ DIVISION_CMD
Definition tok.h:67
@ PRIME_CMD
Definition tok.h:155
@ LEADCOEF_CMD
Definition tok.h:112
@ EXPORTTO_CMD
Definition tok.h:74
@ IMPART_CMD
Definition tok.h:92
@ NAMEOF_CMD
Definition tok.h:135
@ PRUNE_MAP_CMD
Definition tok.h:158
@ TYPEOF_CMD
Definition tok.h:196
@ KILLATTR_CMD
Definition tok.h:108
@ REGULARITY_CMD
Definition tok.h:167
@ WAIT1ST_CMD
Definition tok.h:204
@ CONTENT_CMD
Definition tok.h:53
@ STRING_CMD
Definition tok.h:187
@ WRITE_CMD
Definition tok.h:208
@ DEGREE_CMD
Definition tok.h:61
@ OPPOSITE_CMD
Definition tok.h:147
@ GETDUMP_CMD
Definition tok.h:87
@ SRES_CMD
Definition tok.h:184
@ WEIGHT_CMD
Definition tok.h:207
@ ALIGN_CMD
Definition tok.h:35
@ MONITOR_CMD
Definition tok.h:129
@ VARSTR_CMD
Definition tok.h:202
@ PRUNE_CMD
Definition tok.h:157
@ STATUS_CMD
Definition tok.h:185
@ DUMP_CMD
Definition tok.h:68
@ RESERVEDNAMELIST_CMD
Definition tok.h:171
@ 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:206
@ SQR_FREE_CMD
Definition tok.h:183
@ DELETE_CMD
Definition tok.h:62
@ SORTVEC_CMD
Definition tok.h:182
@ FACSTD_CMD
Definition tok.h:79
@ MINOR_CMD
Definition tok.h:126
@ VTIMER
Definition tok.h:212
@ QHWEIGHT_CMD
Definition tok.h:159
@ VRTIMER
Definition tok.h:213
@ RINGLIST_CMD
Definition tok.h:175
@ LEAD_CMD
Definition tok.h:111
@ ORDSTR_CMD
Definition tok.h:149
@ LOAD_CMD
Definition tok.h:119
@ DENOMINATOR_CMD
Definition tok.h:63
@ TWOSTD_CMD
Definition tok.h:195
@ FINDUNI_CMD
Definition tok.h:85
@ VOICE
Definition tok.h:215
@ CPOLY_CMD
Definition tok.h:48
@ INTDIV_CMD
Definition tok.h:97
@ TRACE_CMD
Definition tok.h:194
@ INT_CMD
Definition tok.h:96
@ QUOTIENT_CMD
Definition tok.h:162
@ 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:203
@ TEST_CMD
Definition tok.h:192
@ GCD_CMD
Definition tok.h:86
@ SYSTEM_CMD
Definition tok.h:189
@ MINBASE_CMD
Definition tok.h:125
@ SYZYGY_CMD
Definition tok.h:190
@ 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:137
@ ROWS_CMD
Definition tok.h:177
@ RESERVEDNAME_CMD
Definition tok.h:170
@ RESULTANT_CMD
Definition tok.h:173
@ OPPOSE_CMD
Definition tok.h:146
@ TENSOR_CMD
Definition tok.h:191
@ DEFINED_CMD
Definition tok.h:59
@ MAX_TOK
Definition tok.h:220
@ 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:198
@ RES_CMD
Definition tok.h:169
@ RANK_CMD
Definition tok.h:164

Function Documentation

◆ yyparse()

int yyparse ( void )
extern

Definition at line 2149 of file grammar.cc.

2156{
2157/* The lookahead symbol. */
2158int yychar;
2159
2160/* The semantic value of the lookahead symbol. */
2162
2163 /* Number of syntax errors so far. */
2164 int yynerrs;
2165
2166 int yystate;
2167 /* Number of tokens to shift before error messages enabled. */
2168 int yyerrstatus;
2169
2170 /* The stacks and their tools:
2171 `yyss': related to states.
2172 `yyvs': related to semantic values.
2173
2174 Refer to the stacks thru separate pointers, to allow yyoverflow
2175 to reallocate them elsewhere. */
2176
2177 /* The state stack. */
2179 yytype_int16 *yyss;
2180 yytype_int16 *yyssp;
2181
2182 /* The semantic value stack. */
2183 YYSTYPE yyvsa[YYINITDEPTH];
2184 YYSTYPE *yyvs;
2185 YYSTYPE *yyvsp;
2186
2187 YYSIZE_T yystacksize;
2188
2189 int yyn;
2190 int yyresult;
2191 /* Lookahead token as an internal (translated) token number. */
2192 int yytoken;
2193 /* The variables used to return semantic value and location from the
2194 action routines. */
2195 YYSTYPE yyval;
2196
2197#if YYERROR_VERBOSE
2198 /* Buffer for error messages, and its allocated size. */
2199 char yymsgbuf[128];
2200 char *yymsg = yymsgbuf;
2201 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2202#endif
2203
2204#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2205
2206 /* The number of symbols on the RHS of the reduced rule.
2207 Keep to zero when no symbol should be popped. */
2208 int yylen = 0;
2209
2210 yytoken = 0;
2211 yyss = yyssa;
2212 yyvs = yyvsa;
2213 yystacksize = YYINITDEPTH;
2214
2215 YYDPRINTF ((stderr, "Starting parse\n"));
2216
2217 yystate = 0;
2218 yyerrstatus = 0;
2219 yynerrs = 0;
2220 yychar = YYEMPTY; /* Cause a token to be read. */
2221
2222 /* Initialize stack pointers.
2223 Waste one element of value and location stack
2224 so that they stay on the same level as the state stack.
2225 The wasted elements are never initialized. */
2226 yyssp = yyss;
2227 yyvsp = yyvs;
2228
2229 goto yysetstate;
2230
2231/*------------------------------------------------------------.
2232| yynewstate -- Push a new state, which is found in yystate. |
2233`------------------------------------------------------------*/
2234 yynewstate:
2235 /* In all cases, when you get here, the value and location stacks
2236 have just been pushed. So pushing a state here evens the stacks. */
2237 yyssp++;
2238
2239 yysetstate:
2240 *yyssp = yystate;
2241
2242 if (yyss + yystacksize - 1 <= yyssp)
2243 {
2244 /* Get the current used size of the three stacks, in elements. */
2245 YYSIZE_T yysize = yyssp - yyss + 1;
2246
2247#ifdef yyoverflow
2248 {
2249 /* Give user a chance to reallocate the stack. Use copies of
2250 these so that the &'s don't force the real ones into
2251 memory. */
2252 YYSTYPE *yyvs1 = yyvs;
2253 yytype_int16 *yyss1 = yyss;
2254
2255 /* Each stack pointer address is followed by the size of the
2256 data in use in that stack, in bytes. This used to be a
2257 conditional around just the two extra args, but that might
2258 be undefined if yyoverflow is a macro. */
2259 yyoverflow (YY_("memory exhausted"),
2260 &yyss1, yysize * sizeof (*yyssp),
2261 &yyvs1, yysize * sizeof (*yyvsp),
2262 &yystacksize);
2263
2264 yyss = yyss1;
2265 yyvs = yyvs1;
2266 }
2267#else /* no yyoverflow */
2268# ifndef YYSTACK_RELOCATE
2269 goto yyexhaustedlab;
2270# else
2271 /* Extend the stack our own way. */
2272 if (YYMAXDEPTH <= yystacksize)
2273 goto yyexhaustedlab;
2274 yystacksize *= 2;
2275 if (YYMAXDEPTH < yystacksize)
2276 yystacksize = YYMAXDEPTH;
2277
2278 {
2279 yytype_int16 *yyss1 = yyss;
2280 union yyalloc *yyptr =
2281 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2282 if (! yyptr)
2283 goto yyexhaustedlab;
2284 YYSTACK_RELOCATE (yyss_alloc, yyss);
2285 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2286# undef YYSTACK_RELOCATE
2287 if (yyss1 != yyssa)
2288 YYSTACK_FREE (yyss1);
2289 }
2290# endif
2291#endif /* no yyoverflow */
2292
2293 yyssp = yyss + yysize - 1;
2294 yyvsp = yyvs + yysize - 1;
2295
2296 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2297 (unsigned long int) yystacksize));
2298
2299 if (yyss + yystacksize - 1 <= yyssp)
2300 YYABORT;
2301 }
2302
2303 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2304
2305 if (yystate == YYFINAL)
2306 YYACCEPT;
2307
2308 goto yybackup;
2309
2310/*-----------.
2311| yybackup. |
2312`-----------*/
2313yybackup:
2314
2315 /* Do appropriate processing given the current state. Read a
2316 lookahead token if we need one and don't already have one. */
2317
2318 /* First try to decide what to do without reference to lookahead token. */
2319 yyn = yypact[yystate];
2320 if (yyn == YYPACT_NINF)
2321 goto yydefault;
2322
2323 /* Not known => get a lookahead token if don't already have one. */
2324
2325 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2326 if (yychar == YYEMPTY)
2327 {
2328 YYDPRINTF ((stderr, "Reading a token: "));
2329 yychar = YYLEX;
2330 }
2331
2332 if (yychar <= YYEOF)
2333 {
2334 yychar = yytoken = YYEOF;
2335 YYDPRINTF ((stderr, "Now at end of input.\n"));
2336 }
2337 else
2338 {
2339 yytoken = YYTRANSLATE (yychar);
2340 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2341 }
2342
2343 /* If the proper action on seeing token YYTOKEN is to reduce or to
2344 detect an error, take that action. */
2345 yyn += yytoken;
2346 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2347 goto yydefault;
2348 yyn = yytable[yyn];
2349 if (yyn <= 0)
2350 {
2351 if (yyn == 0 || yyn == YYTABLE_NINF)
2352 goto yyerrlab;
2353 yyn = -yyn;
2354 goto yyreduce;
2355 }
2356
2357 /* Count tokens shifted since error; after three, turn off error
2358 status. */
2359 if (yyerrstatus)
2360 yyerrstatus--;
2361
2362 /* Shift the lookahead token. */
2363 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2364
2365 /* Discard the shifted token. */
2366 yychar = YYEMPTY;
2367
2368 yystate = yyn;
2369 *++yyvsp = yylval;
2370
2371 goto yynewstate;
2372
2373
2374/*-----------------------------------------------------------.
2375| yydefault -- do the default action for the current state. |
2376`-----------------------------------------------------------*/
2377yydefault:
2378 yyn = yydefact[yystate];
2379 if (yyn == 0)
2380 goto yyerrlab;
2381 goto yyreduce;
2382
2383
2384/*-----------------------------.
2385| yyreduce -- Do a reduction. |
2386`-----------------------------*/
2387yyreduce:
2388 /* yyn is the number of a rule to reduce with. */
2389 yylen = yyr2[yyn];
2390
2391 /* If YYLEN is nonzero, implement the default value of the action:
2392 `$$ = $1'.
2393
2394 Otherwise, the following line sets YYVAL to garbage.
2395 This behavior is undocumented and Bison
2396 users should not rely upon it. Assigning to YYVAL
2397 unconditionally makes the parser a bit smaller, and it avoids a
2398 GCC warning that YYVAL may be used uninitialized. */
2399 yyval = yyvsp[1-yylen];
2400
2401
2402 YY_REDUCE_PRINT (yyn);
2403 switch (yyn)
2404 {
2405 case 3:
2406
2407/* Line 1464 of yacc.c */
2408#line 322 "grammar.y"
2409 {
2410 if (timerv)
2411 {
2412 writeTime("used time:");
2413 startTimer();
2414 }
2415 if (rtimerv)
2416 {
2417 writeRTime("used real time:");
2418 startRTimer();
2419 }
2420 prompt_char = '>';
2421#ifdef HAVE_SDB
2422 if (sdb_flags & 2) { sdb_flags=1; YYERROR; }
2423#endif
2424 if(siCntrlc)
2425 {
2426 WerrorS("abort...");
2427 while((currentVoice!=NULL) && (currentVoice->prev!=NULL)) exitVoice();
2428 if (currentVoice!=NULL) currentVoice->ifsw=0;
2429 }
2430 if (errorreported) /* also catches abort... */
2431 {
2432 yyerror("");
2433 }
2434 if (inerror==2) PrintLn();
2438 ;}
2439 break;
2440
2441 case 5:
2442
2443/* Line 1464 of yacc.c */
2444#line 357 "grammar.y"
2445 {currentVoice->ifsw=0;;}
2446 break;
2447
2448 case 6:
2449
2450/* Line 1464 of yacc.c */
2451#line 359 "grammar.y"
2452 { (yyvsp[(1) - (2)].lv).CleanUp(); currentVoice->ifsw=0;;}
2453 break;
2454
2455 case 7:
2456
2457/* Line 1464 of yacc.c */
2458#line 361 "grammar.y"
2459 {
2460 YYACCEPT;
2461 ;}
2462 break;
2463
2464 case 8:
2465
2466/* Line 1464 of yacc.c */
2467#line 365 "grammar.y"
2468 {
2469 currentVoice->ifsw=0;
2470 iiDebug();
2471 ;}
2472 break;
2473
2474 case 9:
2475
2476/* Line 1464 of yacc.c */
2477#line 370 "grammar.y"
2478 {currentVoice->ifsw=0;;}
2479 break;
2480
2481 case 10:
2482
2483/* Line 1464 of yacc.c */
2484#line 372 "grammar.y"
2485 {
2486 #ifdef SIQ
2487 siq=0;
2488 #endif
2490 currentVoice->ifsw=0;
2491 if (inerror)
2492 {
2493/* bison failed here*/
2494 if ((inerror!=3) && ((yyvsp[(1) - (2)].i)<UMINUS) && ((yyvsp[(1) - (2)].i)>' '))
2495 {
2496 // 1: yyerror called
2497 // 2: scanner put actual string
2498 // 3: error rule put token+\n
2499 inerror=3;
2500 Print(" error at token `%s`\n",iiTwoOps((yyvsp[(1) - (2)].i)));
2501 }
2502/**/
2503
2504 }
2505 if (!errorreported) WerrorS("...parse error");
2506 yyerror("");
2507 yyerrok;
2508#ifdef HAVE_SDB
2509 if ((sdb_flags & 1) && currentVoice->pi!=NULL)
2510 {
2511 currentVoice->pi->trace_flag |=1;
2512 }
2513 else
2514#endif
2515 if (myynest>0)
2516 {
2517 feBufferTypes t=currentVoice->Typ();
2518 //PrintS("leaving yyparse\n");
2520 if (t==BT_example)
2521 YYACCEPT;
2522 else
2523 YYABORT;
2524 }
2525 else if (currentVoice->prev!=NULL)
2526 {
2527 exitVoice();
2528 }
2529#ifdef HAVE_SDB
2530 if (sdb_flags &2) sdb_flags=1;
2531#endif
2532 ;}
2533 break;
2534
2535 case 18:
2536
2537/* Line 1464 of yacc.c */
2538#line 430 "grammar.y"
2539 {if (currentVoice!=NULL) currentVoice->ifsw=0;;}
2540 break;
2541
2542 case 19:
2543
2544/* Line 1464 of yacc.c */
2545#line 433 "grammar.y"
2546 { omFree((ADDRESS)(yyvsp[(2) - (2)].name)); ;}
2547 break;
2548
2549 case 29:
2550
2551/* Line 1464 of yacc.c */
2552#line 448 "grammar.y"
2553 {
2554 if(iiAssign(&(yyvsp[(1) - (2)].lv),&(yyvsp[(2) - (2)].lv))) YYERROR;
2555 ;}
2556 break;
2557
2558 case 30:
2559
2560/* Line 1464 of yacc.c */
2561#line 455 "grammar.y"
2562 {
2563 if (currRing==NULL) MYYERROR("no ring active (7)");
2564 syMakeMonom(&(yyval.lv),(yyvsp[(1) - (1)].name));
2565 ;}
2566 break;
2567
2568 case 31:
2569
2570/* Line 1464 of yacc.c */
2571#line 460 "grammar.y"
2572 {
2573 syMake(&(yyval.lv),(yyvsp[(1) - (1)].name));
2574 ;}
2575 break;
2576
2577 case 32:
2578
2579/* Line 1464 of yacc.c */
2580#line 464 "grammar.y"
2581 {
2582 if(iiExprArith2(&(yyval.lv), &(yyvsp[(1) - (3)].lv), COLONCOLON, &(yyvsp[(3) - (3)].lv))) YYERROR;
2583 ;}
2584 break;
2585
2586 case 33:
2587
2588/* Line 1464 of yacc.c */
2589#line 468 "grammar.y"
2590 {
2591 if(iiExprArith2(&(yyval.lv), &(yyvsp[(1) - (3)].lv), '.', &(yyvsp[(3) - (3)].lv))) YYERROR;
2592 ;}
2593 break;
2594
2595 case 34:
2596
2597/* Line 1464 of yacc.c */
2598#line 472 "grammar.y"
2599 {
2600 if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'(')) YYERROR;
2601 ;}
2602 break;
2603
2604 case 35:
2605
2606/* Line 1464 of yacc.c */
2607#line 476 "grammar.y"
2608 {
2609 if ((yyvsp[(1) - (4)].lv).next==NULL)
2610 {
2611 (yyvsp[(1) - (4)].lv).next=(leftv)omAllocBin(sleftv_bin);
2612 memcpy((yyvsp[(1) - (4)].lv).next,&(yyvsp[(3) - (4)].lv),sizeof(sleftv));
2613 if(iiExprArithM(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'(')) YYERROR;
2614 }
2615 else if ((yyvsp[(1) - (4)].lv).rtyp==UNKNOWN)
2616 { // for x(i)(j)
2617 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'(',&(yyvsp[(3) - (4)].lv))) YYERROR;
2618 }
2619 else YYERROR;
2620 ;}
2621 break;
2622
2623 case 36:
2624
2625/* Line 1464 of yacc.c */
2626#line 490 "grammar.y"
2627 {
2628 if (currRing==NULL) MYYERROR("no ring active (8)");
2629 int j = 0;
2630 memset(&(yyval.lv),0,sizeof(sleftv));
2631 (yyval.lv).rtyp=VECTOR_CMD;
2632 leftv v = &(yyvsp[(2) - (3)].lv);
2633 while (v!=NULL)
2634 {
2635 int i,t;
2636 sleftv tmp;
2637 memset(&tmp,0,sizeof(tmp));
2638 i=iiTestConvert((t=v->Typ()),POLY_CMD);
2639 if((i==0) || (iiConvert(t /*v->Typ()*/,POLY_CMD,i,v,&tmp)))
2640 {
2641 pDelete((poly *)&(yyval.lv).data);
2642 (yyvsp[(2) - (3)].lv).CleanUp();
2643 MYYERROR("expected '[poly,...'");
2644 }
2645 poly p = (poly)tmp.CopyD(POLY_CMD);
2646 pSetCompP(p,++j);
2647 (yyval.lv).data = (void *)pAdd((poly)(yyval.lv).data,p);
2648 v->next=tmp.next;tmp.next=NULL;
2649 tmp.CleanUp();
2650 v=v->next;
2651 }
2652 (yyvsp[(2) - (3)].lv).CleanUp();
2653 ;}
2654 break;
2655
2656 case 37:
2657
2658/* Line 1464 of yacc.c */
2659#line 518 "grammar.y"
2660 {
2661 memset(&(yyval.lv),0,sizeof((yyval.lv)));
2662 int i = atoi((yyvsp[(1) - (1)].name));
2663 /*remember not to omFree($1)
2664 *because it is a part of the scanner buffer*/
2665 (yyval.lv).rtyp = INT_CMD;
2666 (yyval.lv).data = (void *)(long)i;
2667
2668 /* check: out of range input */
2669 int l = strlen((yyvsp[(1) - (1)].name))+2;
2670 number n;
2671 if (l >= MAX_INT_LEN)
2672 {
2673 char tmp[MAX_INT_LEN+5];
2674 snprintf(tmp,MAX_INT_LEN+5,"%d",i);
2675 if (strcmp(tmp,(yyvsp[(1) - (1)].name))!=0)
2676 {
2677 n_Read((yyvsp[(1) - (1)].name),&n,coeffs_BIGINT);
2678 (yyval.lv).rtyp=BIGINT_CMD;
2679 (yyval.lv).data = n;
2680 }
2681 }
2682 ;}
2683 break;
2684
2685 case 38:
2686
2687/* Line 1464 of yacc.c */
2688#line 542 "grammar.y"
2689 {
2690 memset(&(yyval.lv),0,sizeof((yyval.lv)));
2691 (yyval.lv).rtyp = (yyvsp[(1) - (1)].i);
2692 (yyval.lv).data = (yyval.lv).Data();
2693 ;}
2694 break;
2695
2696 case 39:
2697
2698/* Line 1464 of yacc.c */
2699#line 548 "grammar.y"
2700 {
2701 memset(&(yyval.lv),0,sizeof((yyval.lv)));
2702 (yyval.lv).rtyp = STRING_CMD;
2703 (yyval.lv).data = (yyvsp[(1) - (1)].name);
2704 ;}
2705 break;
2706
2707 case 40:
2708
2709/* Line 1464 of yacc.c */
2710#line 554 "grammar.y"
2711 {
2712 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2713 ;}
2714 break;
2715
2716 case 41:
2717
2718/* Line 1464 of yacc.c */
2719#line 558 "grammar.y"
2720 {
2721 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2722 ;}
2723 break;
2724
2725 case 42:
2726
2727/* Line 1464 of yacc.c */
2728#line 562 "grammar.y"
2729 {
2730 if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2731 ;}
2732 break;
2733
2734 case 43:
2735
2736/* Line 1464 of yacc.c */
2737#line 566 "grammar.y"
2738 {
2739 if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2740 ;}
2741 break;
2742
2743 case 44:
2744
2745/* Line 1464 of yacc.c */
2746#line 570 "grammar.y"
2747 {
2748 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2749 ;}
2750 break;
2751
2752 case 45:
2753
2754/* Line 1464 of yacc.c */
2755#line 574 "grammar.y"
2756 {
2757 if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2758 ;}
2759 break;
2760
2761 case 46:
2762
2763/* Line 1464 of yacc.c */
2764#line 578 "grammar.y"
2765 {
2766 if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2767 ;}
2768 break;
2769
2770 case 47:
2771
2772/* Line 1464 of yacc.c */
2773#line 582 "grammar.y"
2774 {
2775 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2776 ;}
2777 break;
2778
2779 case 48:
2780
2781/* Line 1464 of yacc.c */
2782#line 586 "grammar.y"
2783 {
2784 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2785 ;}
2786 break;
2787
2788 case 49:
2789
2790/* Line 1464 of yacc.c */
2791#line 590 "grammar.y"
2792 {
2793 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2794 ;}
2795 break;
2796
2797 case 50:
2798
2799/* Line 1464 of yacc.c */
2800#line 594 "grammar.y"
2801 {
2802 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2803 ;}
2804 break;
2805
2806 case 51:
2807
2808/* Line 1464 of yacc.c */
2809#line 598 "grammar.y"
2810 {
2811 if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2812 ;}
2813 break;
2814
2815 case 52:
2816
2817/* Line 1464 of yacc.c */
2818#line 602 "grammar.y"
2819 {
2820 if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2821 ;}
2822 break;
2823
2824 case 53:
2825
2826/* Line 1464 of yacc.c */
2827#line 606 "grammar.y"
2828 {
2829 if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2830 ;}
2831 break;
2832
2833 case 54:
2834
2835/* Line 1464 of yacc.c */
2836#line 610 "grammar.y"
2837 {
2838 if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2839 ;}
2840 break;
2841
2842 case 55:
2843
2844/* Line 1464 of yacc.c */
2845#line 614 "grammar.y"
2846 {
2847 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2848 ;}
2849 break;
2850
2851 case 56:
2852
2853/* Line 1464 of yacc.c */
2854#line 618 "grammar.y"
2855 {
2856 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2857 ;}
2858 break;
2859
2860 case 57:
2861
2862/* Line 1464 of yacc.c */
2863#line 622 "grammar.y"
2864 {
2865 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2866 ;}
2867 break;
2868
2869 case 58:
2870
2871/* Line 1464 of yacc.c */
2872#line 626 "grammar.y"
2873 {
2874 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2875 ;}
2876 break;
2877
2878 case 59:
2879
2880/* Line 1464 of yacc.c */
2881#line 630 "grammar.y"
2882 {
2883 if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2884 ;}
2885 break;
2886
2887 case 60:
2888
2889/* Line 1464 of yacc.c */
2890#line 634 "grammar.y"
2891 {
2892 int b=iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i)); // handle branchTo
2893 if (b==TRUE) YYERROR;
2894 if (b==2) YYACCEPT;
2895 ;}
2896 break;
2897
2898 case 61:
2899
2900/* Line 1464 of yacc.c */
2901#line 640 "grammar.y"
2902 {
2903 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2904 ;}
2905 break;
2906
2907 case 62:
2908
2909/* Line 1464 of yacc.c */
2910#line 644 "grammar.y"
2911 {
2912 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2913 ;}
2914 break;
2915
2916 case 63:
2917
2918/* Line 1464 of yacc.c */
2919#line 648 "grammar.y"
2920 {
2921 if(iiExprArith3(&(yyval.lv),RING_CMD,&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2922 ;}
2923 break;
2924
2925 case 64:
2926
2927/* Line 1464 of yacc.c */
2928#line 652 "grammar.y"
2929 {
2930 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),RING_CMD)) YYERROR;
2931 ;}
2932 break;
2933
2934 case 65:
2935
2936/* Line 1464 of yacc.c */
2937#line 656 "grammar.y"
2938 {
2939 if (iiARROW(&(yyval.lv),(yyvsp[(1) - (3)].name),(yyvsp[(3) - (3)].name))) YYERROR;
2940 omFree((ADDRESS)(yyvsp[(3) - (3)].name));
2941 ;}
2942 break;
2943
2944 case 66:
2945
2946/* Line 1464 of yacc.c */
2947#line 660 "grammar.y"
2948 { (yyval.lv) = (yyvsp[(2) - (3)].lv); ;}
2949 break;
2950
2951 case 67:
2952
2953/* Line 1464 of yacc.c */
2954#line 665 "grammar.y"
2955 {
2956 leftv v = &(yyvsp[(1) - (3)].lv);
2957 while (v->next!=NULL)
2958 {
2959 v=v->next;
2960 }
2961 v->next = (leftv)omAllocBin(sleftv_bin);
2962 memcpy(v->next,&((yyvsp[(3) - (3)].lv)),sizeof(sleftv));
2963 (yyval.lv) = (yyvsp[(1) - (3)].lv);
2964 ;}
2965 break;
2966
2967 case 71:
2968
2969/* Line 1464 of yacc.c */
2970#line 681 "grammar.y"
2971 {
2972 if(iiExprArith3(&(yyval.lv),'[',&(yyvsp[(1) - (6)].lv),&(yyvsp[(3) - (6)].lv),&(yyvsp[(5) - (6)].lv))) YYERROR;
2973 ;}
2974 break;
2975
2976 case 72:
2977
2978/* Line 1464 of yacc.c */
2979#line 685 "grammar.y"
2980 {
2981 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'[',&(yyvsp[(3) - (4)].lv))) YYERROR;
2982 ;}
2983 break;
2984
2985 case 73:
2986
2987/* Line 1464 of yacc.c */
2988#line 689 "grammar.y"
2989 {
2990 if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
2991 ;}
2992 break;
2993
2994 case 74:
2995
2996/* Line 1464 of yacc.c */
2997#line 693 "grammar.y"
2998 {
2999 if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3000 ;}
3001 break;
3002
3003 case 75:
3004
3005/* Line 1464 of yacc.c */
3006#line 697 "grammar.y"
3007 {
3008 if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3009 ;}
3010 break;
3011
3012 case 76:
3013
3014/* Line 1464 of yacc.c */
3015#line 701 "grammar.y"
3016 {
3017 if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3018 ;}
3019 break;
3020
3021 case 77:
3022
3023/* Line 1464 of yacc.c */
3024#line 705 "grammar.y"
3025 {
3026 if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3027 ;}
3028 break;
3029
3030 case 78:
3031
3032/* Line 1464 of yacc.c */
3033#line 709 "grammar.y"
3034 {
3035 if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), 0, &(yyvsp[(5) - (6)].lv))) YYERROR;
3036 ;}
3037 break;
3038
3039 case 79:
3040
3041/* Line 1464 of yacc.c */
3042#line 713 "grammar.y"
3043 {
3044 (yyval.lv)=(yyvsp[(2) - (3)].lv);
3045 ;}
3046 break;
3047
3048 case 80:
3049
3050/* Line 1464 of yacc.c */
3051#line 717 "grammar.y"
3052 {
3053 #ifdef SIQ
3054 siq++;
3055 if (siq>0)
3056 { if (iiExprArith2(&(yyval.lv),&(yyvsp[(2) - (5)].lv),'=',&(yyvsp[(4) - (5)].lv))) YYERROR; }
3057 else
3058 #endif
3059 {
3060 memset(&(yyval.lv),0,sizeof((yyval.lv)));
3061 (yyval.lv).rtyp=NONE;
3062 if (iiAssign(&(yyvsp[(2) - (5)].lv),&(yyvsp[(4) - (5)].lv))) YYERROR;
3063 }
3064 #ifdef SIQ
3065 siq--;
3066 #endif
3067 ;}
3068 break;
3069
3070 case 81:
3071
3072/* Line 1464 of yacc.c */
3073#line 734 "grammar.y"
3074 {
3075 iiTestAssume(&(yyvsp[(2) - (5)].lv),&(yyvsp[(4) - (5)].lv));
3076 memset(&(yyval.lv),0,sizeof((yyval.lv)));
3077 (yyval.lv).rtyp=NONE;
3078 ;}
3079 break;
3080
3081 case 82:
3082
3083/* Line 1464 of yacc.c */
3084#line 740 "grammar.y"
3085 {
3086 #ifdef SIQ
3087 siq--;
3088 #endif
3089 ;}
3090 break;
3091
3092 case 83:
3093
3094/* Line 1464 of yacc.c */
3095#line 746 "grammar.y"
3096 {
3097 #ifdef SIQ
3098 if (siq<=0) (yyvsp[(4) - (5)].lv).Eval();
3099 #endif
3100 (yyval.lv)=(yyvsp[(4) - (5)].lv);
3101 #ifdef SIQ
3102 siq++;
3103 #endif
3104 ;}
3105 break;
3106
3107 case 84:
3108
3109/* Line 1464 of yacc.c */
3110#line 758 "grammar.y"
3111 {
3112 #ifdef SIQ
3113 siq++;
3114 #endif
3115 ;}
3116 break;
3117
3118 case 85:
3119
3120/* Line 1464 of yacc.c */
3121#line 766 "grammar.y"
3122 {
3123 #ifdef SIQ
3124 siq++;
3125 #endif
3126 ;}
3127 break;
3128
3129 case 86:
3130
3131/* Line 1464 of yacc.c */
3132#line 774 "grammar.y"
3133 {
3134 #ifdef SIQ
3135 siq--;
3136 #endif
3137 ;}
3138 break;
3139
3140 case 87:
3141
3142/* Line 1464 of yacc.c */
3143#line 783 "grammar.y"
3144 {
3145 if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (2)].lv),PLUSPLUS)) YYERROR;
3146 ;}
3147 break;
3148
3149 case 88:
3150
3151/* Line 1464 of yacc.c */
3152#line 787 "grammar.y"
3153 {
3154 if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (2)].lv),MINUSMINUS)) YYERROR;
3155 ;}
3156 break;
3157
3158 case 89:
3159
3160/* Line 1464 of yacc.c */
3161#line 791 "grammar.y"
3162 {
3163 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'+',&(yyvsp[(3) - (3)].lv))) YYERROR;
3164 ;}
3165 break;
3166
3167 case 90:
3168
3169/* Line 1464 of yacc.c */
3170#line 795 "grammar.y"
3171 {
3172 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'-',&(yyvsp[(3) - (3)].lv))) YYERROR;
3173 ;}
3174 break;
3175
3176 case 91:
3177
3178/* Line 1464 of yacc.c */
3179#line 799 "grammar.y"
3180 { /* also for *,% */
3181 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3182 ;}
3183 break;
3184
3185 case 92:
3186
3187/* Line 1464 of yacc.c */
3188#line 803 "grammar.y"
3189 {
3190 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'^',&(yyvsp[(3) - (3)].lv))) YYERROR;
3191 ;}
3192 break;
3193
3194 case 93:
3195
3196/* Line 1464 of yacc.c */
3197#line 807 "grammar.y"
3198 { /* also for > */
3199 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3200 ;}
3201 break;
3202
3203 case 94:
3204
3205/* Line 1464 of yacc.c */
3206#line 811 "grammar.y"
3207 { /* also for |*/
3208 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3209 ;}
3210 break;
3211
3212 case 95:
3213
3214/* Line 1464 of yacc.c */
3215#line 815 "grammar.y"
3216 {
3217 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),NOTEQUAL,&(yyvsp[(3) - (3)].lv))) YYERROR;
3218 ;}
3219 break;
3220
3221 case 96:
3222
3223/* Line 1464 of yacc.c */
3224#line 819 "grammar.y"
3225 {
3226 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),EQUAL_EQUAL,&(yyvsp[(3) - (3)].lv))) YYERROR;
3227 ;}
3228 break;
3229
3230 case 97:
3231
3232/* Line 1464 of yacc.c */
3233#line 823 "grammar.y"
3234 {
3235 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),DOTDOT,&(yyvsp[(3) - (3)].lv))) YYERROR;
3236 ;}
3237 break;
3238
3239 case 98:
3240
3241/* Line 1464 of yacc.c */
3242#line 827 "grammar.y"
3243 {
3244 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),':',&(yyvsp[(3) - (3)].lv))) YYERROR;
3245 ;}
3246 break;
3247
3248 case 99:
3249
3250/* Line 1464 of yacc.c */
3251#line 831 "grammar.y"
3252 {
3253 if (siq>0)
3254 { if (iiExprArith1(&(yyval.lv),&(yyvsp[(2) - (2)].lv),NOT)) YYERROR; }
3255 else
3256 {
3257 memset(&(yyval.lv),0,sizeof((yyval.lv)));
3258 int i; TESTSETINT((yyvsp[(2) - (2)].lv),i);
3259 (yyval.lv).rtyp = INT_CMD;
3260 (yyval.lv).data = (void *)(long)(i == 0 ? 1 : 0);
3261 }
3262 ;}
3263 break;
3264
3265 case 100:
3266
3267/* Line 1464 of yacc.c */
3268#line 843 "grammar.y"
3269 {
3270 if(iiExprArith1(&(yyval.lv),&(yyvsp[(2) - (2)].lv),'-')) YYERROR;
3271 ;}
3272 break;
3273
3274 case 102:
3275
3276/* Line 1464 of yacc.c */
3277#line 851 "grammar.y"
3278 {
3279 if ((yyvsp[(1) - (2)].lv).rtyp==0)
3280 {
3281 Werror("`%s` is undefined",(yyvsp[(1) - (2)].lv).Fullname());
3282 YYERROR;
3283 }
3284 else if (((yyvsp[(1) - (2)].lv).rtyp==MODUL_CMD)
3285 // matrix m; m[2]=...
3286 && ((yyvsp[(1) - (2)].lv).e!=NULL) && ((yyvsp[(1) - (2)].lv).e->next==NULL))
3287 {
3288 MYYERROR("matrix must have 2 indices");
3289 }
3290 (yyval.lv) = (yyvsp[(1) - (2)].lv);
3291 ;}
3292 break;
3293
3294 case 104:
3295
3296/* Line 1464 of yacc.c */
3297#line 871 "grammar.y"
3298 {
3299 if ((yyvsp[(2) - (3)].lv).Typ()!=STRING_CMD)
3300 {
3301 MYYERROR("string expression expected");
3302 }
3303 (yyval.name) = (char *)(yyvsp[(2) - (3)].lv).CopyD(STRING_CMD);
3304 (yyvsp[(2) - (3)].lv).CleanUp();
3305 ;}
3306 break;
3307
3308 case 105:
3309
3310/* Line 1464 of yacc.c */
3311#line 883 "grammar.y"
3312 {
3313 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3314 YYERROR;
3315 ;}
3316 break;
3317
3318 case 106:
3319
3320/* Line 1464 of yacc.c */
3321#line 888 "grammar.y"
3322 {
3323 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3324 YYERROR;
3325 ;}
3326 break;
3327
3328 case 107:
3329
3330/* Line 1464 of yacc.c */
3331#line 893 "grammar.y"
3332 {
3333 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3334 ;}
3335 break;
3336
3337 case 108:
3338
3339/* Line 1464 of yacc.c */
3340#line 897 "grammar.y"
3341 {
3342 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3343 ;}
3344 break;
3345
3346 case 109:
3347
3348/* Line 1464 of yacc.c */
3349#line 901 "grammar.y"
3350 {
3351 int r; TESTSETINT((yyvsp[(4) - (8)].lv),r);
3352 int c; TESTSETINT((yyvsp[(7) - (8)].lv),c);
3353 leftv v;
3354 idhdl h;
3355 if (((yyvsp[(1) - (8)].i) == MATRIX_CMD) || ((yyvsp[(1) - (8)].i) == SMATRIX_CMD ))
3356 {
3357 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&(currRing->idroot), TRUE)) YYERROR;
3358 v=&(yyval.lv);
3359 h=(idhdl)v->data;
3360 idDelete(&IDIDEAL(h));
3361 if ((yyvsp[(1) - (8)].i) == MATRIX_CMD)
3362 IDMATRIX(h) = mpNew(r,c);
3363 else
3364 IDIDEAL(h) = idInit(c,r);
3365 if (IDMATRIX(h)==NULL) YYERROR;
3366 }
3367 else if (((yyvsp[(1) - (8)].i) == INTMAT_CMD)||((yyvsp[(1) - (8)].i) == BIGINTMAT_CMD))
3368 {
3369 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
3370 YYERROR;
3371 v=&(yyval.lv);
3372 h=(idhdl)v->data;
3373 if ((yyvsp[(1) - (8)].i)==INTMAT_CMD)
3374 {
3375 delete IDINTVEC(h);
3376 IDINTVEC(h) = new intvec(r,c,0);
3377 }
3378 else
3379 {
3380 delete IDBIMAT(h);
3381 IDBIMAT(h) = new bigintmat(r, c, coeffs_BIGINT);
3382 }
3383 if (IDINTVEC(h)==NULL) YYERROR;
3384 }
3385 ;}
3386 break;
3387
3388 case 110:
3389
3390/* Line 1464 of yacc.c */
3391#line 938 "grammar.y"
3392 {
3393 if (((yyvsp[(1) - (2)].i) == MATRIX_CMD)||((yyvsp[(1) - (2)].i) == SMATRIX_CMD))
3394 {
3395 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3396 }
3397 else if (((yyvsp[(1) - (2)].i) == INTMAT_CMD)||((yyvsp[(1) - (2)].i) == BIGINTMAT_CMD))
3398 {
3399 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3400 YYERROR;
3401 if ((yyvsp[(1) - (2)].i) == INTMAT_CMD)
3402 {
3403 leftv v=&(yyval.lv);
3404 idhdl h;
3405 do
3406 {
3407 h=(idhdl)v->data;
3408 delete IDINTVEC(h);
3409 IDINTVEC(h) = new intvec(1,1,0);
3410 v=v->next;
3411 } while (v!=NULL);
3412 }
3413 }
3414 ;}
3415 break;
3416
3417 case 111:
3418
3419/* Line 1464 of yacc.c */
3420#line 962 "grammar.y"
3421 {
3422 int t=(yyvsp[(1) - (3)].lv).Typ();
3423 sleftv r;
3424 memset(&r,0,sizeof(sleftv));
3425 if ((BEGIN_RING<t) && (t<END_RING))
3426 {
3427 if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&(currRing->idroot), TRUE))
3428 YYERROR;
3429 }
3430 else
3431 {
3432 if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&((yyvsp[(3) - (3)].lv).req_packhdl->idroot)))
3433 YYERROR;
3434 }
3435 leftv v=&(yyvsp[(1) - (3)].lv);
3436 while (v->next!=NULL) v=v->next;
3437 v->next=(leftv)omAllocBin(sleftv_bin);
3438 memcpy(v->next,&r,sizeof(sleftv));
3439 (yyval.lv)=(yyvsp[(1) - (3)].lv);
3440 ;}
3441 break;
3442
3443 case 112:
3444
3445/* Line 1464 of yacc.c */
3446#line 983 "grammar.y"
3447 {
3448 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3449 YYERROR;
3450 ;}
3451 break;
3452
3453 case 115:
3454
3455/* Line 1464 of yacc.c */
3456#line 996 "grammar.y"
3457 {
3458 leftv v = &(yyvsp[(2) - (5)].lv);
3459 while (v->next!=NULL)
3460 {
3461 v=v->next;
3462 }
3463 v->next = (leftv)omAllocBin(sleftv_bin);
3464 memcpy(v->next,&((yyvsp[(4) - (5)].lv)),sizeof(sleftv));
3465 (yyval.lv) = (yyvsp[(2) - (5)].lv);
3466 ;}
3467 break;
3468
3469 case 116:
3470
3471/* Line 1464 of yacc.c */
3472#line 1010 "grammar.y"
3473 {
3474 // let rInit take care of any errors
3475 (yyval.i)=rOrderName((yyvsp[(1) - (1)].name));
3476 ;}
3477 break;
3478
3479 case 117:
3480
3481/* Line 1464 of yacc.c */
3482#line 1018 "grammar.y"
3483 {
3484 memset(&(yyval.lv),0,sizeof((yyval.lv)));
3485 intvec *iv = new intvec(2);
3486 (*iv)[0] = 1;
3487 (*iv)[1] = (yyvsp[(1) - (1)].i);
3488 (yyval.lv).rtyp = INTVEC_CMD;
3489 (yyval.lv).data = (void *)iv;
3490 ;}
3491 break;
3492
3493 case 118:
3494
3495/* Line 1464 of yacc.c */
3496#line 1027 "grammar.y"
3497 {
3498 memset(&(yyval.lv),0,sizeof((yyval.lv)));
3499 leftv sl = &(yyvsp[(3) - (4)].lv);
3500 int slLength;
3501 {
3502 slLength = exprlist_length(sl);
3503 int l = 2 + slLength;
3504 intvec *iv = new intvec(l);
3505 (*iv)[0] = slLength;
3506 (*iv)[1] = (yyvsp[(1) - (4)].i);
3507
3508 int i = 2;
3509 while ((i<l) && (sl!=NULL))
3510 {
3511 if (sl->Typ() == INT_CMD)
3512 {
3513 (*iv)[i++] = (int)((long)(sl->Data()));
3514 }
3515 else if ((sl->Typ() == INTVEC_CMD)
3516 ||(sl->Typ() == INTMAT_CMD))
3517 {
3518 intvec *ivv = (intvec *)(sl->Data());
3519 int ll = 0,l = ivv->length();
3520 for (; l>0; l--)
3521 {
3522 (*iv)[i++] = (*ivv)[ll++];
3523 }
3524 }
3525 else
3526 {
3527 delete iv;
3528 (yyvsp[(3) - (4)].lv).CleanUp();
3529 MYYERROR("wrong type in ordering");
3530 }
3531 sl = sl->next;
3532 }
3533 (yyval.lv).rtyp = INTVEC_CMD;
3534 (yyval.lv).data = (void *)iv;
3535 }
3536 (yyvsp[(3) - (4)].lv).CleanUp();
3537 ;}
3538 break;
3539
3540 case 120:
3541
3542/* Line 1464 of yacc.c */
3543#line 1073 "grammar.y"
3544 {
3545 (yyval.lv) = (yyvsp[(1) - (3)].lv);
3546 (yyval.lv).next = (sleftv *)omAllocBin(sleftv_bin);
3547 memcpy((yyval.lv).next,&(yyvsp[(3) - (3)].lv),sizeof(sleftv));
3548 ;}
3549 break;
3550
3551 case 122:
3552
3553/* Line 1464 of yacc.c */
3554#line 1083 "grammar.y"
3555 {
3556 (yyval.lv) = (yyvsp[(2) - (3)].lv);
3557 ;}
3558 break;
3559
3560 case 123:
3561
3562/* Line 1464 of yacc.c */
3563#line 1089 "grammar.y"
3564 {
3566 ;}
3567 break;
3568
3569 case 128:
3570
3571/* Line 1464 of yacc.c */
3572#line 1107 "grammar.y"
3573 { newFile((yyvsp[(2) - (2)].name)); omFree((yyvsp[(2) - (2)].name)); ;}
3574 break;
3575
3576 case 129:
3577
3578/* Line 1464 of yacc.c */
3579#line 1112 "grammar.y"
3580 {
3581 feHelp((yyvsp[(2) - (3)].name));
3582 omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3583 ;}
3584 break;
3585
3586 case 130:
3587
3588/* Line 1464 of yacc.c */
3589#line 1117 "grammar.y"
3590 {
3591 feHelp(NULL);
3592 ;}
3593 break;
3594
3595 case 131:
3596
3597/* Line 1464 of yacc.c */
3598#line 1124 "grammar.y"
3599 {
3600 singular_example((yyvsp[(2) - (3)].name));
3601 omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3602 ;}
3603 break;
3604
3605 case 132:
3606
3607/* Line 1464 of yacc.c */
3608#line 1132 "grammar.y"
3609 {
3610 if (basePack!=(yyvsp[(2) - (2)].lv).req_packhdl)
3611 {
3612 if(iiExport(&(yyvsp[(2) - (2)].lv),0,currPack)) YYERROR;
3613 }
3614 else
3615 if (iiExport(&(yyvsp[(2) - (2)].lv),0)) YYERROR;
3616 ;}
3617 break;
3618
3619 case 133:
3620
3621/* Line 1464 of yacc.c */
3622#line 1144 "grammar.y"
3623 {
3624 leftv v=&(yyvsp[(2) - (2)].lv);
3625 if (v->rtyp!=IDHDL)
3626 {
3627 if (v->name!=NULL)
3628 {
3629 Werror("`%s` is undefined in kill",v->name);
3630 omFree((ADDRESS)v->name); v->name=NULL;
3631 }
3632 else WerrorS("kill what ?");
3633 }
3634 else
3635 {
3636 killhdl((idhdl)v->data,v->req_packhdl);
3637 }
3638 ;}
3639 break;
3640
3641 case 134:
3642
3643/* Line 1464 of yacc.c */
3644#line 1161 "grammar.y"
3645 {
3646 leftv v=&(yyvsp[(3) - (3)].lv);
3647 if (v->rtyp!=IDHDL)
3648 {
3649 if (v->name!=NULL)
3650 {
3651 Werror("`%s` is undefined in kill",v->name);
3652 omFree((ADDRESS)v->name); v->name=NULL;
3653 }
3654 else WerrorS("kill what ?");
3655 }
3656 else
3657 {
3658 killhdl((idhdl)v->data,v->req_packhdl);
3659 }
3660 ;}
3661 break;
3662
3663 case 135:
3664
3665/* Line 1464 of yacc.c */
3666#line 1181 "grammar.y"
3667 {
3668 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3669 ;}
3670 break;
3671
3672 case 136:
3673
3674/* Line 1464 of yacc.c */
3675#line 1185 "grammar.y"
3676 {
3677 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3678 ;}
3679 break;
3680
3681 case 137:
3682
3683/* Line 1464 of yacc.c */
3684#line 1189 "grammar.y"
3685 {
3686 if ((yyvsp[(3) - (4)].i)==QRING_CMD) (yyvsp[(3) - (4)].i)=RING_CMD;
3687 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3688 ;}
3689 break;
3690
3691 case 138:
3692
3693/* Line 1464 of yacc.c */
3694#line 1194 "grammar.y"
3695 {
3696 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3697 ;}
3698 break;
3699
3700 case 139:
3701
3702/* Line 1464 of yacc.c */
3703#line 1198 "grammar.y"
3704 {
3705 list_cmd(RING_CMD,NULL,"// ",TRUE);
3706 ;}
3707 break;
3708
3709 case 140:
3710
3711/* Line 1464 of yacc.c */
3712#line 1202 "grammar.y"
3713 {
3714 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3715 ;}
3716 break;
3717
3718 case 141:
3719
3720/* Line 1464 of yacc.c */
3721#line 1206 "grammar.y"
3722 {
3723 list_cmd(PROC_CMD,NULL,"// ",TRUE);
3724 ;}
3725 break;
3726
3727 case 142:
3728
3729/* Line 1464 of yacc.c */
3730#line 1210 "grammar.y"
3731 {
3732 list_cmd(0,(yyvsp[(3) - (4)].lv).Fullname(),"// ",TRUE);
3733 (yyvsp[(3) - (4)].lv).CleanUp();
3734 ;}
3735 break;
3736
3737 case 143:
3738
3739/* Line 1464 of yacc.c */
3740#line 1215 "grammar.y"
3741 {
3742 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3743 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3744 (yyvsp[(3) - (6)].lv).CleanUp();
3745 ;}
3746 break;
3747
3748 case 144:
3749
3750/* Line 1464 of yacc.c */
3751#line 1221 "grammar.y"
3752 {
3753 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3754 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3755 (yyvsp[(3) - (6)].lv).CleanUp();
3756 ;}
3757 break;
3758
3759 case 145:
3760
3761/* Line 1464 of yacc.c */
3762#line 1227 "grammar.y"
3763 {
3764 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3765 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3766 (yyvsp[(3) - (6)].lv).CleanUp();
3767 ;}
3768 break;
3769
3770 case 146:
3771
3772/* Line 1464 of yacc.c */
3773#line 1233 "grammar.y"
3774 {
3775 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3776 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3777 (yyvsp[(3) - (6)].lv).CleanUp();
3778 ;}
3779 break;
3780
3781 case 147:
3782
3783/* Line 1464 of yacc.c */
3784#line 1239 "grammar.y"
3785 {
3786 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3787 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3788 (yyvsp[(3) - (6)].lv).CleanUp();
3789 ;}
3790 break;
3791
3792 case 148:
3793
3794/* Line 1464 of yacc.c */
3795#line 1245 "grammar.y"
3796 {
3797 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3798 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3799 (yyvsp[(3) - (6)].lv).CleanUp();
3800 ;}
3801 break;
3802
3803 case 149:
3804
3805/* Line 1464 of yacc.c */
3806#line 1251 "grammar.y"
3807 {
3808 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3809 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3810 (yyvsp[(3) - (6)].lv).CleanUp();
3811 ;}
3812 break;
3813
3814 case 150:
3815
3816/* Line 1464 of yacc.c */
3817#line 1263 "grammar.y"
3818 {
3819 list_cmd(-1,NULL,"// ",TRUE);
3820 ;}
3821 break;
3822
3823 case 151:
3824
3825/* Line 1464 of yacc.c */
3826#line 1269 "grammar.y"
3828 break;
3829
3830 case 152:
3831
3832/* Line 1464 of yacc.c */
3833#line 1278 "grammar.y"
3834 {
3835 const char *ring_name = (yyvsp[(2) - (8)].lv).name;
3836 ring b=
3837 rInit(&(yyvsp[(4) - (8)].lv), /* characteristik and list of parameters*/
3838 &(yyvsp[(6) - (8)].lv), /* names of ringvariables */
3839 &(yyvsp[(8) - (8)].lv)); /* ordering */
3840 idhdl newRingHdl=NULL;
3841
3842 if (b!=NULL)
3843 {
3844 newRingHdl=enterid(ring_name, myynest, RING_CMD,
3845 &((yyvsp[(2) - (8)].lv).req_packhdl->idroot),FALSE);
3846 (yyvsp[(2) - (8)].lv).CleanUp();
3847 if (newRingHdl!=NULL)
3848 {
3849 IDRING(newRingHdl)=b;
3850 }
3851 else
3852 {
3853 rKill(b);
3854 }
3855 }
3857 if (newRingHdl==NULL)
3858 {
3859 MYYERROR("cannot make ring");
3860 }
3861 else
3862 {
3863 rSetHdl(newRingHdl);
3864 }
3865 ;}
3866 break;
3867
3868 case 153:
3869
3870/* Line 1464 of yacc.c */
3871#line 1311 "grammar.y"
3872 {
3873 const char *ring_name = (yyvsp[(2) - (2)].lv).name;
3874 if (!inerror) rDefault(ring_name);
3876 (yyvsp[(2) - (2)].lv).CleanUp();
3877 ;}
3878 break;
3879
3880 case 154:
3881
3882/* Line 1464 of yacc.c */
3883#line 1318 "grammar.y"
3884 {
3886 if (iiAssignCR(&(yyvsp[(2) - (4)].lv),&(yyvsp[(4) - (4)].lv))) YYERROR;
3887 ;}
3888 break;
3889
3890 case 155:
3891
3892/* Line 1464 of yacc.c */
3893#line 1323 "grammar.y"
3894 {
3896 sleftv tmp;
3897 (yyvsp[(4) - (7)].lv).next=(leftv)omAlloc(sizeof(sleftv));
3898 memcpy((yyvsp[(4) - (7)].lv).next,&(yyvsp[(6) - (7)].lv),sizeof(sleftv));
3899 memset(&(yyvsp[(6) - (7)].lv),0,sizeof(sleftv));
3900 if (iiExprArithM(&tmp,&(yyvsp[(4) - (7)].lv),'[')) YYERROR;
3901 if (iiAssignCR(&(yyvsp[(2) - (7)].lv),&tmp)) YYERROR;
3902 ;}
3903 break;
3904
3905 case 156:
3906
3907/* Line 1464 of yacc.c */
3908#line 1336 "grammar.y"
3909 {
3910 if (((yyvsp[(1) - (2)].i)!=LIB_CMD)||(jjLOAD((yyvsp[(2) - (2)].name),TRUE))) YYERROR;
3911 omFree((yyvsp[(2) - (2)].name));
3912 ;}
3913 break;
3914
3915 case 159:
3916
3917/* Line 1464 of yacc.c */
3918#line 1346 "grammar.y"
3919 {
3920 if (((yyvsp[(1) - (2)].i)==KEEPRING_CMD) && (myynest==0))
3921 MYYERROR("only inside a proc allowed");
3922 const char * n=(yyvsp[(2) - (2)].lv).Name();
3923 if (((yyvsp[(2) - (2)].lv).Typ()==RING_CMD)
3924 && ((yyvsp[(2) - (2)].lv).rtyp==IDHDL))
3925 {
3926 idhdl h=(idhdl)(yyvsp[(2) - (2)].lv).data;
3927 if ((yyvsp[(2) - (2)].lv).e!=NULL) h=rFindHdl((ring)(yyvsp[(2) - (2)].lv).Data(),NULL);
3928 //Print("setring %s lev %d (ptr:%x)\n",IDID(h),IDLEV(h),IDRING(h));
3929 if ((yyvsp[(1) - (2)].i)==KEEPRING_CMD)
3930 {
3931 if (h!=NULL)
3932 {
3933 if (IDLEV(h)!=0)
3934 {
3935 if (iiExport(&(yyvsp[(2) - (2)].lv),myynest-1)) YYERROR;
3936#if 1
3937 idhdl p=IDRING(h)->idroot;
3938 idhdl root=p;
3939 int prevlev=myynest-1;
3940 while (p!=NULL)
3941 {
3942 if (IDLEV(p)==myynest)
3943 {
3944 idhdl old=root->get(IDID(p),prevlev);
3945 if (old!=NULL)
3946 {
3947 if (BVERBOSE(V_REDEFINE))
3948 Warn("redefining %s",IDID(p));
3949 killhdl2(old,&root,IDRING(h));
3950 IDRING(h)->idroot=root;
3951 }
3952 IDLEV(p)=prevlev;
3953 }
3954 p=IDNEXT(p);
3955 }
3956#endif
3957 }
3959 }
3960 else
3961 {
3962 Werror("%s is no identifier",n);
3963 (yyvsp[(2) - (2)].lv).CleanUp();
3964 YYERROR;
3965 }
3966 }
3967 if (h!=NULL) rSetHdl(h);
3968 else
3969 {
3970 Werror("cannot find the name of the basering %s",n);
3971 (yyvsp[(2) - (2)].lv).CleanUp();
3972 YYERROR;
3973 }
3974 (yyvsp[(2) - (2)].lv).CleanUp();
3975 }
3976 else
3977 {
3978 Werror("%s is no name of a ring/qring",n);
3979 (yyvsp[(2) - (2)].lv).CleanUp();
3980 YYERROR;
3981 }
3982 ;}
3983 break;
3984
3985 case 160:
3986
3987/* Line 1464 of yacc.c */
3988#line 1414 "grammar.y"
3989 {
3990 type_cmd(&((yyvsp[(2) - (2)].lv)));
3991 ;}
3992 break;
3993
3994 case 161:
3995
3996/* Line 1464 of yacc.c */
3997#line 1418 "grammar.y"
3998 {
3999 //Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
4000 #ifdef SIQ
4001 if ((yyvsp[(1) - (1)].lv).rtyp!=COMMAND)
4002 {
4003 #endif
4004 if ((yyvsp[(1) - (1)].lv).Typ()==UNKNOWN)
4005 {
4006 if ((yyvsp[(1) - (1)].lv).name!=NULL)
4007 {
4008 Werror("`%s` is undefined",(yyvsp[(1) - (1)].lv).name);
4009 omFree((ADDRESS)(yyvsp[(1) - (1)].lv).name);
4010 }
4011 YYERROR;
4012 }
4013 #ifdef SIQ
4014 }
4015 #endif
4016 (yyvsp[(1) - (1)].lv).Print(&sLastPrinted);
4017 (yyvsp[(1) - (1)].lv).CleanUp(currRing);
4019 ;}
4020 break;
4021
4022 case 162:
4023
4024/* Line 1464 of yacc.c */
4025#line 1447 "grammar.y"
4026 {
4027 int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4028 if (i!=0)
4029 {
4030 newBuffer( (yyvsp[(5) - (5)].name), BT_if);
4031 }
4032 else
4033 {
4034 omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4035 currentVoice->ifsw=1;
4036 }
4037 ;}
4038 break;
4039
4040 case 163:
4041
4042/* Line 1464 of yacc.c */
4043#line 1460 "grammar.y"
4044 {
4045 if (currentVoice->ifsw==1)
4046 {
4047 currentVoice->ifsw=0;
4048 newBuffer( (yyvsp[(2) - (2)].name), BT_else);
4049 }
4050 else
4051 {
4052 if (currentVoice->ifsw!=2)
4053 {
4054 Warn("`else` without `if` in level %d",myynest);
4055 }
4056 omFree((ADDRESS)(yyvsp[(2) - (2)].name));
4057 }
4058 currentVoice->ifsw=0;
4059 ;}
4060 break;
4061
4062 case 164:
4063
4064/* Line 1464 of yacc.c */
4065#line 1477 "grammar.y"
4066 {
4067 int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4068 if (i)
4069 {
4071 }
4072 currentVoice->ifsw=0;
4073 ;}
4074 break;
4075
4076 case 165:
4077
4078/* Line 1464 of yacc.c */
4079#line 1486 "grammar.y"
4080 {
4082 currentVoice->ifsw=0;
4083 ;}
4084 break;
4085
4086 case 166:
4087
4088/* Line 1464 of yacc.c */
4089#line 1491 "grammar.y"
4090 {
4092 currentVoice->ifsw=0;
4093 ;}
4094 break;
4095
4096 case 167:
4097
4098/* Line 1464 of yacc.c */
4099#line 1499 "grammar.y"
4100 {
4101 /* -> if(!$2) break; $3; continue;*/
4102 size_t len= strlen((yyvsp[(2) - (3)].name)) + strlen((yyvsp[(3) - (3)].name)) + 36;
4103 char * s = (char *)omAlloc( len);
4104 snprintf(s,len,"whileif (!(%s)) break;\n%scontinue;\n " ,(yyvsp[(2) - (3)].name),(yyvsp[(3) - (3)].name));
4106 omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4107 omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4108 ;}
4109 break;
4110
4111 case 168:
4112
4113/* Line 1464 of yacc.c */
4114#line 1512 "grammar.y"
4115 {
4116 /* $2 */
4117 /* if (!$3) break; $5; $4; continue; */
4118 size_t len= strlen((yyvsp[(3) - (5)].name))+strlen((yyvsp[(4) - (5)].name))+strlen((yyvsp[(5) - (5)].name))+36;
4119 char *s=(char*)omAlloc(len);
4120 snprintf(s,len,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
4121 ,(yyvsp[(3) - (5)].name),(yyvsp[(5) - (5)].name),(yyvsp[(4) - (5)].name));
4122 omFree((ADDRESS)(yyvsp[(3) - (5)].name));
4123 omFree((ADDRESS)(yyvsp[(4) - (5)].name));
4124 omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4126 len=strlen((yyvsp[(2) - (5)].name)) + 3;
4127 s = (char *)omAlloc( len);
4128 snprintf(s,len,"%s;\n",(yyvsp[(2) - (5)].name));
4129 omFree((ADDRESS)(yyvsp[(2) - (5)].name));
4130 newBuffer(s,BT_if);
4131 ;}
4132 break;
4133
4134 case 169:
4135
4136/* Line 1464 of yacc.c */
4137#line 1533 "grammar.y"
4138 {
4139 idhdl h = enterid((yyvsp[(2) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4140 if (h==NULL) {omFree((ADDRESS)(yyvsp[(2) - (3)].name));omFree((ADDRESS)(yyvsp[(3) - (3)].name)); YYERROR;}
4141 iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(2) - (3)].name), 0, 0);
4142 IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+31);;
4143 sprintf(IDPROC(h)->data.s.body,"parameter list #;\n%s;return();\n\n",(yyvsp[(3) - (3)].name));
4144 omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4145 omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4146 ;}
4147 break;
4148
4149 case 170:
4150
4151/* Line 1464 of yacc.c */
4152#line 1543 "grammar.y"
4153 {
4154 idhdl h = enterid((yyvsp[(1) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4155 if (h==NULL)
4156 {
4157 omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4158 omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4159 omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4160 YYERROR;
4161 }
4162 char *args=iiProcArgs((yyvsp[(2) - (3)].name),FALSE);
4163 omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4164 iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (3)].name), 0, 0);
4165 IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+strlen(args)+14);;
4166 sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(3) - (3)].name));
4167 omFree((ADDRESS)args);
4168 omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4169 omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4170 ;}
4171 break;
4172
4173 case 171:
4174
4175/* Line 1464 of yacc.c */
4176#line 1562 "grammar.y"
4177 {
4178 omFree((ADDRESS)(yyvsp[(3) - (4)].name));
4179 idhdl h = enterid((yyvsp[(1) - (4)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4180 if (h==NULL)
4181 {
4182 omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4183 omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4184 omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4185 YYERROR;
4186 }
4187 char *args=iiProcArgs((yyvsp[(2) - (4)].name),FALSE);
4188 omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4189 iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (4)].name), 0, 0);
4190 omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4191 IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(4) - (4)].name))+strlen(args)+14);;
4192 sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(4) - (4)].name));
4193 omFree((ADDRESS)args);
4194 omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4195 ;}
4196 break;
4197
4198 case 172:
4199
4200/* Line 1464 of yacc.c */
4201#line 1585 "grammar.y"
4202 {
4203 // decl. of type proc p(int i)
4204 if ((yyvsp[(1) - (2)].i)==PARAMETER) { if (iiParameter(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4205 else { if (iiAlias(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4206 ;}
4207 break;
4208
4209 case 173:
4210
4211/* Line 1464 of yacc.c */
4212#line 1591 "grammar.y"
4213 {
4214 // decl. of type proc p(i)
4215 sleftv tmp_expr;
4216 if ((yyvsp[(1) - (2)].i)==ALIAS_CMD) MYYERROR("alias requires a type");
4217 if ((iiDeclCommand(&tmp_expr,&(yyvsp[(2) - (2)].lv),myynest,DEF_CMD,&IDROOT))
4218 || (iiParameter(&tmp_expr)))
4219 YYERROR;
4220 ;}
4221 break;
4222
4223 case 174:
4224
4225/* Line 1464 of yacc.c */
4226#line 1603 "grammar.y"
4227 {
4228 iiSetReturn(&(yyvsp[(3) - (4)].lv));
4229 (yyvsp[(3) - (4)].lv).CleanUp();
4231 ;}
4232 break;
4233
4234 case 175:
4235
4236/* Line 1464 of yacc.c */
4237#line 1609 "grammar.y"
4238 {
4239 if ((yyvsp[(1) - (3)].i)==RETURN)
4240 {
4241 iiRETURNEXPR.Init();
4242 iiRETURNEXPR.rtyp=NONE;
4244 }
4245 ;}
4246 break;
4247
4248
4249
4250/* Line 1464 of yacc.c */
4251#line 4252 "grammar.cc"
4252 default: break;
4253 }
4254 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4255
4256 YYPOPSTACK (yylen);
4257 yylen = 0;
4258 YY_STACK_PRINT (yyss, yyssp);
4259
4260 *++yyvsp = yyval;
4261
4262 /* Now `shift' the result of the reduction. Determine what state
4263 that goes to, based on the state we popped back to and the rule
4264 number reduced by. */
4265
4266 yyn = yyr1[yyn];
4267
4268 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4269 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4270 yystate = yytable[yystate];
4271 else
4272 yystate = yydefgoto[yyn - YYNTOKENS];
4273
4274 goto yynewstate;
4275
4276
4277/*------------------------------------.
4278| yyerrlab -- here on detecting error |
4279`------------------------------------*/
4280yyerrlab:
4281 /* If not already recovering from an error, report this error. */
4282 if (!yyerrstatus)
4283 {
4284 ++yynerrs;
4285#if ! YYERROR_VERBOSE
4286 yyerror (YY_("syntax error"));
4287#else
4288 {
4289 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
4290 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
4291 {
4292 YYSIZE_T yyalloc = 2 * yysize;
4293 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
4294 yyalloc = YYSTACK_ALLOC_MAXIMUM;
4295 if (yymsg != yymsgbuf)
4296 YYSTACK_FREE (yymsg);
4297 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
4298 if (yymsg)
4299 yymsg_alloc = yyalloc;
4300 else
4301 {
4302 yymsg = yymsgbuf;
4303 yymsg_alloc = sizeof yymsgbuf;
4304 }
4305 }
4306
4307 if (0 < yysize && yysize <= yymsg_alloc)
4308 {
4309 (void) yysyntax_error (yymsg, yystate, yychar);
4310 yyerror (yymsg);
4311 }
4312 else
4313 {
4314 yyerror (YY_("syntax error"));
4315 if (yysize != 0)
4316 goto yyexhaustedlab;
4317 }
4318 }
4319#endif
4320 }
4321
4322
4323
4324 if (yyerrstatus == 3)
4325 {
4326 /* If just tried and failed to reuse lookahead token after an
4327 error, discard it. */
4328
4329 if (yychar <= YYEOF)
4330 {
4331 /* Return failure if at end of input. */
4332 if (yychar == YYEOF)
4333 YYABORT;
4334 }
4335 else
4336 {
4337 yydestruct ("Error: discarding",
4338 yytoken, &yylval);
4339 yychar = YYEMPTY;
4340 }
4341 }
4342
4343 /* Else will try to reuse lookahead token after shifting the error
4344 token. */
4345 goto yyerrlab1;
4346
4347
4348/*---------------------------------------------------.
4349| yyerrorlab -- error raised explicitly by YYERROR. |
4350`---------------------------------------------------*/
4351yyerrorlab:
4352
4353 /* Pacify compilers like GCC when the user code never invokes
4354 YYERROR and the label yyerrorlab therefore never appears in user
4355 code. */
4356 if (/*CONSTCOND*/ 0)
4357 goto yyerrorlab;
4358
4359 /* Do not reclaim the symbols of the rule which action triggered
4360 this YYERROR. */
4361 YYPOPSTACK (yylen);
4362 yylen = 0;
4363 YY_STACK_PRINT (yyss, yyssp);
4364 yystate = *yyssp;
4365 goto yyerrlab1;
4366
4367
4368/*-------------------------------------------------------------.
4369| yyerrlab1 -- common code for both syntax error and YYERROR. |
4370`-------------------------------------------------------------*/
4371yyerrlab1:
4372 yyerrstatus = 3; /* Each real token shifted decrements this. */
4373
4374 for (;;)
4375 {
4376 yyn = yypact[yystate];
4377 if (yyn != YYPACT_NINF)
4378 {
4379 yyn += YYTERROR;
4380 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4381 {
4382 yyn = yytable[yyn];
4383 if (0 < yyn)
4384 break;
4385 }
4386 }
4387
4388 /* Pop the current state because it cannot handle the error token. */
4389 if (yyssp == yyss)
4390 YYABORT;
4391
4392
4393 yydestruct ("Error: popping",
4394 yystos[yystate], yyvsp);
4395 YYPOPSTACK (1);
4396 yystate = *yyssp;
4397 YY_STACK_PRINT (yyss, yyssp);
4398 }
4399
4400 *++yyvsp = yylval;
4401
4402
4403 /* Shift the error token. */
4404 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4405
4406 yystate = yyn;
4407 goto yynewstate;
4408
4409
4410/*-------------------------------------.
4411| yyacceptlab -- YYACCEPT comes here. |
4412`-------------------------------------*/
4413yyacceptlab:
4414 yyresult = 0;
4415 goto yyreturn;
4416
4417/*-----------------------------------.
4418| yyabortlab -- YYABORT comes here. |
4419`-----------------------------------*/
4420yyabortlab:
4421 yyresult = 1;
4422 goto yyreturn;
4423
4424#if !defined(yyoverflow) || YYERROR_VERBOSE
4425/*-------------------------------------------------.
4426| yyexhaustedlab -- memory exhaustion comes here. |
4427`-------------------------------------------------*/
4428yyexhaustedlab:
4429 yyerror (YY_("memory exhausted"));
4430 yyresult = 2;
4431 /* Fall through. */
4432#endif
4433
4434yyreturn:
4435 if (yychar != YYEMPTY)
4436 yydestruct ("Cleanup: discarding lookahead",
4437 yytoken, &yylval);
4438 /* Do not reclaim the symbols of the rule which action triggered
4439 this YYABORT or YYACCEPT. */
4440 YYPOPSTACK (yylen);
4441 YY_STACK_PRINT (yyss, yyssp);
4442 while (yyssp != yyss)
4443 {
4444 yydestruct ("Cleanup: popping",
4445 yystos[*yyssp], yyvsp);
4446 YYPOPSTACK (1);
4447 }
4448#ifndef yyoverflow
4449 if (yyss != yyssa)
4450 YYSTACK_FREE (yyss);
4451#endif
4452#if YYERROR_VERBOSE
4453 if (yymsg != yymsgbuf)
4454 YYSTACK_FREE (yymsg);
4455#endif
4456 /* Make sure YYID is used. */
4457 return YYID (yyresult);
4458}
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
void * ADDRESS
Definition auxiliary.h:120
int l
Definition cfEzgcd.cc:100
int i
Definition cfEzgcd.cc:132
int p
Definition cfModGcd.cc:4086
CanonicalForm b
Definition cfModGcd.cc:4111
Matrices of numbers.
Definition bigintmat.h:51
idhdl get(const char *s, int lev)
Definition ipid.cc:63
int length() const
Definition intvec.h:95
Class used for (list of) interpreter objects.
Definition subexpr.h:83
void * CopyD(int t)
Definition subexpr.cc:714
int Typ()
Definition subexpr.cc:1048
void * Data()
Definition subexpr.cc:1192
leftv next
Definition subexpr.h:86
void CleanUp(ring r=currRing)
Definition subexpr.cc:351
static FORCE_INLINE const char * n_Read(const char *s, number *a, const coeffs r)
!!! Recommendation: This method is too cryptic to be part of the user- !!! interface....
Definition coeffs.h:599
#define Print
Definition emacs.cc:80
#define Warn
Definition emacs.cc:77
const CanonicalForm int s
Definition facAbsFact.cc:51
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
int j
Definition facHensel.cc:110
VAR short errorreported
Definition feFopen.cc:23
void WerrorS(const char *s)
Definition feFopen.cc:24
VAR int myynest
Definition febase.cc:41
void feHelp(char *str)
Definition fehelp.cc:90
EXTERN_VAR char prompt_char
Definition feread.h:10
BOOLEAN exitBuffer(feBufferTypes typ)
Definition fevoices.cc:236
void newBuffer(char *s, feBufferTypes t, procinfo *pi, int lineno)
Definition fevoices.cc:166
BOOLEAN contBuffer(feBufferTypes typ)
Definition fevoices.cc:304
VAR Voice * currentVoice
Definition fevoices.cc:49
BOOLEAN newFile(char *fname)
Definition fevoices.cc:129
BOOLEAN exitVoice()
Definition fevoices.cc:341
feBufferTypes
Definition fevoices.h:17
@ BT_else
Definition fevoices.h:25
@ BT_if
Definition fevoices.h:24
@ BT_break
Definition fevoices.h:19
@ BT_example
Definition fevoices.h:21
@ BT_proc
Definition fevoices.h:20
int iiTestConvert(int inputType, int outputType)
Definition gentable.cc:298
const char * iiTwoOps(int t)
Definition gentable.cc:258
#define YYID(n)
Definition grammar.cc:439
static const yytype_uint8 yyr1[]
Definition grammar.cc:821
#define YYLEX
Definition grammar.cc:1685
#define YYMAXDEPTH
Definition grammar.cc:166
@ PLUSPLUS
Definition grammar.cc:274
@ NOT
Definition grammar.cc:272
@ END_RING
Definition grammar.cc:311
@ MINUSMINUS
Definition grammar.cc:271
@ PARAMETER
Definition grammar.cc:350
@ MATRIX_CMD
Definition grammar.cc:287
@ KEEPRING_CMD
Definition grammar.cc:298
@ BIGINTMAT_CMD
Definition grammar.cc:278
@ RETURN
Definition grammar.cc:349
@ EQUAL_EQUAL
Definition grammar.cc:268
@ PROC_CMD
Definition grammar.cc:281
@ BEGIN_RING
Definition grammar.cc:283
@ INTMAT_CMD
Definition grammar.cc:280
@ LIB_CMD
Definition grammar.cc:328
@ MODUL_CMD
Definition grammar.cc:288
@ SMATRIX_CMD
Definition grammar.cc:292
@ VECTOR_CMD
Definition grammar.cc:293
@ NOTEQUAL
Definition grammar.cc:273
@ DOTDOT
Definition grammar.cc:267
@ COLONCOLON
Definition grammar.cc:275
@ POLY_CMD
Definition grammar.cc:290
@ RING_CMD
Definition grammar.cc:282
#define YYSTACK_FREE
Definition grammar.cc:495
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition grammar.cc:1702
int cmdtok
Definition grammar.cc:174
BOOLEAN expected_parms
Definition grammar.cc:173
#define yyerrok
Definition grammar.cc:1589
const char * currid
Definition grammar.cc:171
#define TESTSETINT(a, i)
Definition grammar.cc:177
#define YYEOF
Definition grammar.cc:1592
#define YYABORT
Definition grammar.cc:1595
static const yytype_int16 yydefgoto[]
Definition grammar.cc:914
#define YY_REDUCE_PRINT(Rule)
Definition grammar.cc:1835
#define YYTABLE_NINF
Definition grammar.cc:984
static const yytype_int16 yypact[]
Definition grammar.cc:926
#define MYYERROR(a)
Definition grammar.cc:185
#define YYPACT_NINF
Definition grammar.cc:925
#define YYFINAL
Definition grammar.cc:582
static const yytype_int16 yypgoto[]
Definition grammar.cc:971
static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep)
Definition grammar.cc:2089
#define YYNTOKENS
Definition grammar.cc:587
#define YY_STACK_PRINT(Bottom, Top)
Definition grammar.cc:1797
#define YYSIZE_T
Definition grammar.cc:410
#define YYSTACK_ALLOC_MAXIMUM
Definition grammar.cc:497
#define YY_(msgid)
Definition grammar.cc:426
void yyerror(const char *fmt)
Definition grammar.cc:187
BOOLEAN yyInRingConstruction
Definition grammar.cc:172
static const yytype_int16 yytable[]
Definition grammar.cc:985
static const yytype_uint8 yyr2[]
Definition grammar.cc:844
#define YYACCEPT
Definition grammar.cc:1594
#define YYTRANSLATE(YYX)
Definition grammar.cc:599
static const yytype_uint8 yystos[]
Definition grammar.cc:1545
#define YYTERROR
Definition grammar.cc:1634
#define YYPOPSTACK(N)
short int yytype_int16
Definition grammar.cc:399
#define YYEMPTY
Definition grammar.cc:1591
#define YYLAST
Definition grammar.cc:584
#define YYINITDEPTH
Definition grammar.cc:1854
#define YYERROR
Definition grammar.cc:1596
static const yytype_int16 yycheck[]
Definition grammar.cc:1264
#define YYSTACK_ALLOC
Definition grammar.cc:494
#define YYDPRINTF(Args)
Definition grammar.cc:1696
static const yytype_uint8 yydefact[]
Definition grammar.cc:869
#define idDelete(H)
delete an ideal
Definition ideals.h:29
EXTERN_VAR int inerror
BOOLEAN jjLOAD(const char *s, BOOLEAN autoexport)
load lib/module given in v
Definition iparith.cc:5567
BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
Definition iparith.cc:9141
BOOLEAN iiExprArith1(leftv res, leftv a, int op)
Definition iparith.cc:9330
BOOLEAN iiExprArithM(leftv res, leftv a, int op)
Definition iparith.cc:9631
BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
Definition iparith.cc:9540
BOOLEAN iiAssign(leftv l, leftv r, BOOLEAN toplevel)
Definition ipassign.cc:2097
BOOLEAN iiConvert(int inputType, int outputType, int index, leftv input, leftv output, const struct sConvertTypes *dConvertTypes)
Definition ipconv.cc:450
void killhdl2(idhdl h, idhdl *ih, ring r)
Definition ipid.cc:422
idhdl enterid(const char *s, int lev, int t, idhdl *root, BOOLEAN init, BOOLEAN search)
Definition ipid.cc:256
VAR package basePack
Definition ipid.cc:56
VAR package currPack
Definition ipid.cc:55
BOOLEAN iiAlias(leftv p)
Definition ipid.cc:821
void killhdl(idhdl h, package proot)
Definition ipid.cc:391
#define IDMATRIX(a)
Definition ipid.h:134
#define IDNEXT(a)
Definition ipid.h:118
EXTERN_VAR omBin sleftv_bin
Definition ipid.h:145
#define IDPROC(a)
Definition ipid.h:140
#define IDINTVEC(a)
Definition ipid.h:128
#define IDBIMAT(a)
Definition ipid.h:129
#define IDIDEAL(a)
Definition ipid.h:133
#define IDID(a)
Definition ipid.h:122
#define IDROOT
Definition ipid.h:19
#define IDLEV(a)
Definition ipid.h:121
#define IDRING(a)
Definition ipid.h:127
char * iiProcArgs(char *e, BOOLEAN withParenth)
Definition iplib.cc:114
INST_VAR sleftv iiRETURNEXPR
Definition iplib.cc:483
VAR ring * iiLocalRing
Definition iplib.cc:482
procinfo * iiInitSingularProcinfo(procinfov pi, const char *libname, const char *procname, int, long pos, BOOLEAN pstatic)
Definition iplib.cc:1059
BOOLEAN iiParameter(leftv p)
Definition ipshell.cc:1380
int iiDeclCommand(leftv sy, leftv name, int lev, int t, idhdl *root, BOOLEAN isring, BOOLEAN init_b)
Definition ipshell.cc:1202
void rKill(ring r)
Definition ipshell.cc:6174
BOOLEAN iiApply(leftv res, leftv a, int op, leftv proc)
Definition ipshell.cc:6424
void list_cmd(int typ, const char *what, const char *prefix, BOOLEAN iterate, BOOLEAN fullname)
Definition ipshell.cc:426
ring rInit(leftv pn, leftv rv, leftv ord)
Definition ipshell.cc:5621
BOOLEAN iiARROW(leftv r, char *a, char *s)
Definition ipshell.cc:6473
int exprlist_length(leftv v)
Definition ipshell.cc:551
BOOLEAN iiTestAssume(leftv a, leftv b)
Definition ipshell.cc:6446
void iiSetReturn(const leftv source)
Definition ipshell.cc:6627
BOOLEAN iiAssignCR(leftv r, leftv arg)
Definition ipshell.cc:6508
idhdl rFindHdl(ring r, idhdl n)
Definition ipshell.cc:1695
void iiDebug()
Definition ipshell.cc:1069
const char * lastreserved
Definition ipshell.cc:83
void type_cmd(leftv v)
Definition ipshell.cc:255
void rSetHdl(idhdl h)
Definition ipshell.cc:5122
BOOLEAN iiExport(leftv v, int toLev)
Definition ipshell.cc:1506
void singular_example(char *str)
Definition misc_ip.cc:431
STATIC_VAR Poly * h
Definition janet.cc:971
ListNode * next
Definition janet.h:31
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition matpol.cc:37
const int MAX_INT_LEN
Definition mylimits.h:13
#define omAlloc(size)
#define omAllocBin(bin)
#define omFree(addr)
#define NULL
Definition omList.c:12
VAR BOOLEAN siCntrlc
Definition options.c:14
#define BVERBOSE(a)
Definition options.h:35
#define V_REDEFINE
Definition options.h:45
VAR coeffs coeffs_BIGINT
Definition polys.cc:14
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
#define pAdd(p, q)
Definition polys.h:204
#define pDelete(p_ptr)
Definition polys.h:187
#define pSetCompP(a, i)
Definition polys.h:304
int yynerrs
Definition readcf.cc:927
int yychar
Definition readcf.cc:922
void PrintLn()
Definition reporter.cc:310
void Werror(const char *fmt,...)
Definition reporter.cc:189
rRingOrder_t rOrderName(char *ordername)
Definition ring.cc:512
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
Definition ring.cc:103
idrec * idhdl
Definition ring.h:22
VAR int sdb_flags
Definition sdb.cc:31
ideal idInit(int idsize, int rank)
initialise an ideal / module
sleftv * leftv
Definition structs.h:53
#define YYSTYPE
Definition stype.h:19
EXTERN_VAR YYSTYPE yylval
Definition stype.h:20
void syMake(leftv v, const char *id, package pa)
Definition subexpr.cc:1613
INST_VAR sleftv sLastPrinted
Definition subexpr.cc:46
VAR BOOLEAN siq
Definition subexpr.cc:48
void syMakeMonom(leftv v, const char *id)
Definition subexpr.cc:1917
int name
New type name for int.
void writeRTime(const char *v)
Definition timer.cc:173
int startTimer()
Definition timer.cc:66
VAR int rtimerv
Definition timer.cc:126
void writeTime(const char *v)
Definition timer.cc:101
VAR int timerv
Definition timer.cc:17
void startRTimer()
Definition timer.cc:131
#define IDHDL
Definition tok.h:31
#define NONE
Definition tok.h:223
#define COMMAND
Definition tok.h:29
#define UNKNOWN
Definition tok.h:224

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.