My Project  debian-1:4.1.1-p2+ds-4build1
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, RESTART_CMD,
  RESULTANT_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, 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

int yylineno
 
char my_yylinebuf [80]
 

Macro Definition Documentation

◆ ANY_TYPE

#define ANY_TYPE   UMINUS+3

Definition at line 29 of file tok.h.

◆ COMMAND

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

Definition at line 28 of file tok.h.

◆ COMP_OP

#define COMP_OP   '<'

Definition at line 26 of file tok.h.

◆ IDHDL

#define IDHDL   UMINUS+4

Definition at line 30 of file tok.h.

◆ LOGIC_OP

#define LOGIC_OP   '&'

Definition at line 24 of file tok.h.

◆ MULDIV_OP

#define MULDIV_OP   '/'

Definition at line 25 of file tok.h.

◆ NONE

#define NONE   END_RING

Definition at line 217 of file tok.h.

◆ UNKNOWN

#define UNKNOWN   0

Definition at line 218 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 
RESTART_CMD 
RESULTANT_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 
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 32 of file tok.h.

33  {
34  ALIAS_CMD = UMINUS + 15,
35  ALIGN_CMD,
36  ATTRIB_CMD,
38  BIGINT_CMD,
48  CPOLY_CMD,
49  CLOSE_CMD,
50  COEFFS_CMD,
51  COEF_CMD,
52  COLS_CMD,
55  COUNT_CMD,
56  CRING_CMD,
58  DEF_CMD,
60  DEG_CMD,
61  DEGREE_CMD,
62  DELETE_CMD,
64  DET_CMD,
65  DIFF_CMD,
66  DIM_CMD,
68  DUMP_CMD,
72  ERROR_CMD,
75  EXTGCD_CMD,
76  FAC_CMD,
77  FAREY_CMD,
78  FIND_CMD,
79  FACSTD_CMD,
80  FMD_CMD,
81  FRES_CMD,
82  FWALK_CMD,
83  FGLM_CMD,
86  GCD_CMD,
90  HOMOG_CMD,
91  HRES_CMD,
92  IMPART_CMD,
95  INSERT_CMD,
96  INT_CMD,
97  INTDIV_CMD,
101  INTVEC_CMD,
102  IS_RINGVAR,
103  JACOB_CMD,
104  JANET_CMD,
105  JET_CMD,
106  KBASE_CMD,
107  KERNEL_CMD,
108  KILLATTR_CMD,
109  KRES_CMD,
110  LAGSOLVE_CMD,
111  LEAD_CMD,
112  LEADCOEF_CMD,
113  LEADEXP_CMD,
115  LIFTSTD_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,
124  MEMORY_CMD,
125  MINBASE_CMD,
126  MINOR_CMD,
127  MINRES_CMD,
128  MODULO_CMD,
129  MONITOR_CMD,
130  MPRES_CMD,
131  MRES_CMD,
132  MSTD_CMD,
134  NAMEOF_CMD,
135  NAMES_CMD,
140  NPARS_CMD,
142  NVARS_CMD,
143  ORD_CMD,
144  OPEN_CMD,
145  OPPOSE_CMD,
146  OPPOSITE_CMD,
147  OPTION_CMD,
148  ORDSTR_CMD,
149  PACKAGE_CMD,
150  PARDEG_CMD,
151  PARENT_CMD,
152  PARSTR_CMD,
153  PFAC_CMD,
154  PRIME_CMD,
155  PRINT_CMD,
156  PRUNE_CMD,
157  QHWEIGHT_CMD,
158  QRING_CMD,
159  QRDS_CMD,
160  QUOTIENT_CMD,
161  RANDOM_CMD,
162  RANK_CMD,
163  READ_CMD,
164  REDUCE_CMD,
166  REPART_CMD,
167  RES_CMD,
169  RESTART_CMD,
171  RINGLIST_CMD,
173  ROWS_CMD,
174  SBA_CMD,
175  SIMPLEX_CMD,
176  SIMPLIFY_CMD,
177  SLIM_GB_CMD,
178  SORTVEC_CMD,
179  SQR_FREE_CMD,
180  SRES_CMD,
181  STATUS_CMD,
182  STD_CMD,
183  STRING_CMD,
184  SUBST_CMD,
185  SYSTEM_CMD,
186  SYZYGY_CMD,
187  TEST_CMD,
189  TRACE_CMD,
190  TWOSTD_CMD,
191  TYPEOF_CMD,
193  UNLOAD_CMD, /* unused*/
194  URSOLVE_CMD,
195  VANDER_CMD,
197  VARSTR_CMD,
198  VDIM_CMD,
199  WAIT1ST_CMD,
200  WAITALL_CMD,
201  WEDGE_CMD,
202  WEIGHT_CMD,
203  WRITE_CMD,
204  /* start system var section: VECHO */
205  VECHO,
206  VCOLMAX,
207  VTIMER,
208  VRTIMER,
209  TRACE,
210  VOICE,
211  VSHORTOUT,
212  VPRINTLEVEL,
213  /* end system var section: VPRINTLEVEL */
214 
215  MAX_TOK /* must be the last, biggest token number */

Function Documentation

◆ yyparse()

int yyparse ( void  )

Definition at line 2109 of file grammar.cc.

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

Variable Documentation

◆ my_yylinebuf

char my_yylinebuf[80]

Definition at line 42 of file febase.cc.

◆ yylineno

int yylineno

Definition at line 39 of file febase.cc.

DENOMINATOR_CMD
Definition: tok.h:62
QUOTIENT_CMD
Definition: tok.h:159
ATTRIB_CMD
Definition: tok.h:35
YYINITDEPTH
#define YYINITDEPTH
Definition: grammar.cc:1814
YYMAXDEPTH
#define YYMAXDEPTH
Definition: grammar.cc:166
iiConvert
BOOLEAN iiConvert(int inputType, int outputType, int index, leftv input, leftv output, const struct sConvertTypes *dConvertTypes)
Definition: ipconv.cc:400
YY_
#define YY_(msgid)
Definition: grammar.cc:423
FALSE
#define FALSE
Definition: auxiliary.h:94
VANDER_CMD
Definition: tok.h:194
INTDIV_CMD
Definition: tok.h:96
MODULO_CMD
Definition: tok.h:127
sleftv::Data
void * Data()
Definition: subexpr.cc:1133
ALIGN_CMD
Definition: tok.h:34
REGULARITY_CMD
Definition: tok.h:164
EXTGCD_CMD
Definition: tok.h:74
SIMPLIFY_CMD
Definition: tok.h:175
MAX_INT_LEN
const int MAX_INT_LEN
Definition: mylimits.h:12
yyr1
static const yytype_uint8 yyr1[]
Definition: grammar.cc:817
startRTimer
void startRTimer()
Definition: timer.cc:152
j
int j
Definition: facHensel.cc:105
LOAD_CMD
Definition: tok.h:118
TRACE
Definition: tok.h:208
omFree
#define omFree(addr)
Definition: omAllocDecl.h:259
KRES_CMD
Definition: tok.h:108
errorreported
short errorreported
Definition: feFopen.cc:23
idDelete
#define idDelete(H)
delete an ideal
Definition: ideals.h:28
CRING_CMD
Definition: tok.h:55
RES_CMD
Definition: tok.h:166
Voice::Typ
feBufferTypes Typ()
Definition: fevoices.cc:100
bigintmat
Definition: bigintmat.h:50
TEST_CMD
Definition: tok.h:186
lastreserved
const char * lastreserved
Definition: ipshell.cc:79
expected_parms
BOOLEAN expected_parms
Definition: grammar.cc:173
COLONCOLON
Definition: grammar.cc:275
procinfo::trace_flag
char trace_flag
Definition: subexpr.h:61
NOT
Definition: grammar.cc:272
IDBIMAT
#define IDBIMAT(a)
Definition: ipid.h:123
BIGINT_CMD
Definition: tok.h:37
feHelp
void feHelp(char *str)
Definition: fehelp.cc:89
SIMPLEX_CMD
Definition: tok.h:174
iiExprArith1
BOOLEAN iiExprArith1(leftv res, leftv a, int op)
Definition: iparith.cc:8267
LIST_CMD
Definition: tok.h:117
SRES_CMD
Definition: tok.h:179
ENVELOPE_CMD
Definition: tok.h:70
JET_CMD
Definition: tok.h:104
SUBST_CMD
Definition: tok.h:183
NVARS_CMD
Definition: tok.h:141
inerror
int inerror
Definition: grammar.cc:175
ADDRESS
void * ADDRESS
Definition: auxiliary.h:133
enterid
idhdl enterid(const char *s, int lev, int t, idhdl *root, BOOLEAN init, BOOLEAN search)
Definition: ipid.cc:256
YYNTOKENS
#define YYNTOKENS
Definition: grammar.cc:584
MODUL_CMD
Definition: grammar.cc:286
STRING_CMD
Definition: tok.h:182
CNUMBER_CMD
Definition: tok.h:46
iiAssignCR
BOOLEAN iiAssignCR(leftv r, leftv arg)
Definition: ipshell.cc:6446
COUNT_CMD
Definition: tok.h:54
DEFINED_CMD
Definition: tok.h:58
exitVoice
BOOLEAN exitVoice()
Definition: fevoices.cc:330
YYEOF
#define YYEOF
Definition: grammar.cc:1552
currid
const char * currid
Definition: grammar.cc:171
yyInRingConstruction
BOOLEAN yyInRingConstruction
Definition: grammar.cc:172
NONE
#define NONE
Definition: tok.h:217
GCD_CMD
Definition: tok.h:85
YYERROR
#define YYERROR
Definition: grammar.cc:1556
BT_proc
Definition: fevoices.h:20
FWALK_CMD
Definition: tok.h:81
MAX_TOK
Definition: tok.h:214
iiExprArithM
BOOLEAN iiExprArithM(leftv res, leftv a, int op)
Definition: iparith.cc:8570
type_cmd
void type_cmd(leftv v)
Definition: ipshell.cc:245
SYSTEM_CMD
Definition: tok.h:184
INTERPOLATE_CMD
Definition: tok.h:97
INTERSECT_CMD
Definition: tok.h:99
rKill
void rKill(ring r)
Definition: ipshell.cc:6075
iiDeclCommand
int iiDeclCommand(leftv sy, leftv name, int lev, int t, idhdl *root, BOOLEAN isring, BOOLEAN init_b)
Definition: ipshell.cc:1121
ORDSTR_CMD
Definition: tok.h:147
JANET_CMD
Definition: tok.h:103
idrec::get
idhdl get(const char *s, int lev)
Definition: ipid.cc:85
JACOB_CMD
Definition: tok.h:102
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:261
YYEMPTY
#define YYEMPTY
Definition: grammar.cc:1551
RINGLIST_CMD
Definition: tok.h:170
INDEPSET_CMD
Definition: tok.h:93
DEF_CMD
Definition: tok.h:57
iiLocalRing
ring * iiLocalRing
Definition: iplib.cc:453
UNIVARIATE_CMD
Definition: tok.h:191
SQR_FREE_CMD
Definition: tok.h:178
Voice::ifsw
char ifsw
Definition: fevoices.h:78
omAllocBin
#define omAllocBin(bin)
Definition: omAllocDecl.h:203
REDUCE_CMD
Definition: tok.h:163
SORTVEC_CMD
Definition: tok.h:177
pDelete
#define pDelete(p_ptr)
Definition: polys.h:166
PARENT_CMD
Definition: tok.h:150
n_Read
static const FORCE_INLINE 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:598
RING_LIST_CMD
Definition: tok.h:171
currPack
package currPack
Definition: ipid.cc:58
SYZYGY_CMD
Definition: tok.h:185
LEADEXP_CMD
Definition: tok.h:112
DET_CMD
Definition: tok.h:63
iiAlias
BOOLEAN iiAlias(leftv p)
Definition: ipid.cc:754
PRINT_CMD
Definition: tok.h:154
Variable::next
Variable next() const
Definition: factory.h:137
yyerrok
#define yyerrok
Definition: grammar.cc:1549
IDMATRIX
#define IDMATRIX(a)
Definition: ipid.h:128
CONTENT_CMD
Definition: tok.h:52
RESERVEDNAME_CMD
Definition: tok.h:167
NCALGEBRA_CMD
Definition: tok.h:136
YYSTYPE
#define YYSTYPE
Definition: stype.h:18
sleftv
Class used for (list of) interpreter objects.
Definition: subexpr.h:81
idhdl
idrec * idhdl
Definition: ring.h:20
RING_CMD
Definition: grammar.cc:281
EXPORTTO_CMD
Definition: tok.h:73
b
CanonicalForm b
Definition: cfModGcd.cc:4044
BT_example
Definition: fevoices.h:21
currRingHdl
idhdl currRingHdl
Definition: ipid.cc:60
VTIMER
Definition: tok.h:206
OPPOSE_CMD
Definition: tok.h:144
DIM_CMD
Definition: tok.h:65
CONTRACT_CMD
Definition: tok.h:53
TRACE_CMD
Definition: tok.h:188
MATRIX_CMD
Definition: grammar.cc:285
iiTwoOps
const char * iiTwoOps(int t)
Definition: gentable.cc:258
pSetCompP
#define pSetCompP(a, i)
Definition: polys.h:277
KERNEL_CMD
Definition: tok.h:106
HILBERT_CMD
Definition: tok.h:88
LUI_CMD
Definition: tok.h:121
leftv
sleftv * leftv
Definition: structs.h:59
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition: grammar.cc:491
UMINUS
Definition: grammar.cc:349
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition: grammar.cc:596
YYABORT
#define YYABORT
Definition: grammar.cc:1555
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: grammar.cc:1795
VOICE
Definition: tok.h:209
rtimerv
int rtimerv
Definition: timer.cc:147
LRES_CMD
Definition: tok.h:119
IDLEV
#define IDLEV(a)
Definition: ipid.h:115
contBuffer
BOOLEAN contBuffer(feBufferTypes typ)
Definition: fevoices.cc:293
HIGHCORNER_CMD
Definition: tok.h:87
rDefault
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:102
MONITOR_CMD
Definition: tok.h:128
next
ListNode * next
Definition: janet.h:31
QHWEIGHT_CMD
Definition: tok.h:156
VRTIMER
Definition: tok.h:207
yypact
static const yytype_int16 yypact[]
Definition: grammar.cc:922
yytype_int16
short int yytype_int16
Definition: grammar.cc:396
startTimer
void startTimer()
Definition: timer.cc:81
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
RANK_CMD
Definition: tok.h:161
BEGIN_RING
Definition: grammar.cc:282
INSERT_CMD
Definition: tok.h:94
OPEN_CMD
Definition: tok.h:143
NEWSTRUCT_CMD
Definition: tok.h:135
IDINTVEC
#define IDINTVEC(a)
Definition: ipid.h:122
TRUE
#define TRUE
Definition: auxiliary.h:98
NC_ALGEBRA_CMD
Definition: tok.h:137
i
int i
Definition: cfEzgcd.cc:125
FAREY_CMD
Definition: tok.h:76
LIB_CMD
Definition: grammar.cc:325
INT_CMD
Definition: tok.h:95
COMMAND
#define COMMAND
Definition: tok.h:28
CLOSE_CMD
Definition: tok.h:48
BT_else
Definition: fevoices.h:25
CPOLY_CMD
Definition: tok.h:47
HRES_CMD
Definition: tok.h:90
MPRES_CMD
Definition: tok.h:129
GETDUMP_CMD
Definition: tok.h:86
FIND_CMD
Definition: tok.h:77
yydefact
static const yytype_uint8 yydefact[]
Definition: grammar.cc:865
writeRTime
void writeRTime(const char *v)
Definition: timer.cc:194
VPRINTLEVEL
Definition: tok.h:211
Voice::pi
procinfo * pi
Definition: fevoices.h:63
killhdl2
void killhdl2(idhdl h, idhdl *ih, ring r)
Definition: ipid.cc:406
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: grammar.cc:1662
iiProcArgs
char * iiProcArgs(char *e, BOOLEAN withParenth)
Definition: iplib.cc:108
PROC_CMD
Definition: grammar.cc:280
PFAC_CMD
Definition: tok.h:152
syMake
void syMake(leftv v, const char *id, package pa)
Definition: subexpr.cc:1496
ROWS_CMD
Definition: tok.h:172
iiExport
BOOLEAN iiExport(leftv v, int toLev)
Definition: ipshell.cc:1413
currentVoice
Voice * currentVoice
Definition: fevoices.cc:46
MRES_CMD
Definition: tok.h:130
IDROOT
#define IDROOT
Definition: ipid.h:17
sleftv::Init
void Init()
Definition: subexpr.h:106
INTERRED_CMD
Definition: tok.h:98
YYLEX
#define YYLEX
Definition: grammar.cc:1645
h
static Poly * h
Definition: janet.cc:972
ERROR_CMD
Definition: tok.h:71
Voice::prev
Voice * prev
Definition: fevoices.h:61
READ_CMD
Definition: tok.h:162
iiTestAssume
BOOLEAN iiTestAssume(leftv a, leftv b)
Definition: ipshell.cc:6385
MULTIPLICITY_CMD
Definition: tok.h:132
EQUAL_EQUAL
Definition: grammar.cc:268
siCntrlc
BOOLEAN siCntrlc
Definition: options.c:14
FACSTD_CMD
Definition: tok.h:78
IDPROC
#define IDPROC(a)
Definition: ipid.h:134
intvec
Definition: intvec.h:16
WAITALL_CMD
Definition: tok.h:199
newFile
BOOLEAN newFile(char *fname)
Definition: fevoices.cc:118
jjLOAD
BOOLEAN jjLOAD(const char *s, BOOLEAN autoexport)
load lib/module given in v
Definition: iparith.cc:5096
list_cmd
void list_cmd(int typ, const char *what, const char *prefix, BOOLEAN iterate, BOOLEAN fullname)
Definition: ipshell.cc:416
URSOLVE_CMD
Definition: tok.h:193
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:208
PLUSPLUS
Definition: grammar.cc:274
KEEPRING_CMD
Definition: grammar.cc:295
NUMERATOR_CMD
Definition: tok.h:140
BT_break
Definition: fevoices.h:19
MSTD_CMD
Definition: tok.h:131
UNLOAD_CMD
Definition: tok.h:192
DUMP_CMD
Definition: tok.h:67
LU_CMD
Definition: tok.h:120
killhdl
void killhdl(idhdl h, package proot)
Definition: ipid.cc:375
END_RING
Definition: grammar.cc:308
WEDGE_CMD
Definition: tok.h:200
TWOSTD_CMD
Definition: tok.h:189
VECTOR_CMD
Definition: grammar.cc:290
myynest
int myynest
Definition: febase.cc:40
yyerror
void yyerror(const char *fmt)
Definition: grammar.cc:187
NAMES_CMD
Definition: tok.h:134
YYTERROR
#define YYTERROR
Definition: grammar.cc:1594
YYTABLE_NINF
#define YYTABLE_NINF
Definition: grammar.cc:980
iiTestConvert
int iiTestConvert(int inputType, int outputType)
Definition: gentable.cc:298
iiExprArith3
BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
Definition: iparith.cc:8480
YYSTACK_FREE
#define YYSTACK_FREE
Definition: grammar.cc:492
sleftv::CleanUp
void CleanUp(ring r=currRing)
Definition: subexpr.cc:327
yylval
YYSTYPE yylval
cmdtok
int cmdtok
Definition: grammar.cc:174
siq
BOOLEAN siq
Definition: subexpr.cc:52
mpNew
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:35
pAdd
#define pAdd(p, q)
Definition: polys.h:182
DIFF_CMD
Definition: tok.h:64
YYPOPSTACK
#define YYPOPSTACK(N)
STD_CMD
Definition: tok.h:181
FMD_CMD
Definition: tok.h:79
FAC_CMD
Definition: tok.h:75
IDRING
#define IDRING(a)
Definition: ipid.h:121
LEADCOEF_CMD
Definition: tok.h:111
MEMORY_CMD
Definition: tok.h:123
ELIMINATION_CMD
Definition: tok.h:68
TRANSPOSE_CMD
Definition: tok.h:187
END_GRAMMAR
Definition: tok.h:69
RANDOM_CMD
Definition: tok.h:160
BREAKPOINT_CMD
Definition: tok.h:40
feBufferTypes
feBufferTypes
Definition: fevoices.h:15
exprlist_length
int exprlist_length(leftv v)
Definition: ipshell.cc:543
CHAR_SERIES_CMD
Definition: tok.h:43
VARIABLES_CMD
Definition: tok.h:195
UNKNOWN
#define UNKNOWN
Definition: tok.h:218
yydefgoto
static const yytype_int16 yydefgoto[]
Definition: grammar.cc:910
yyr2
static const yytype_uint8 yyr2[]
Definition: grammar.cc:840
RESTART_CMD
Definition: tok.h:168
MINOR_CMD
Definition: tok.h:125
INTVEC_CMD
Definition: tok.h:100
PRUNE_CMD
Definition: tok.h:155
INTMAT_CMD
Definition: grammar.cc:279
rFindHdl
idhdl rFindHdl(ring r, idhdl n)
Definition: ipshell.cc:1594
COLS_CMD
Definition: tok.h:51
coeffs_BIGINT
coeffs coeffs_BIGINT
Definition: ipid.cc:51
YYSIZE_T
#define YYSIZE_T
Definition: grammar.cc:407
idrec
Definition: idrec.h:33
iiInitSingularProcinfo
procinfo * iiInitSingularProcinfo(procinfov pi, const char *libname, const char *procname, int, long pos, BOOLEAN pstatic)
Definition: iplib.cc:990
PARSTR_CMD
Definition: tok.h:151
YYSTACK_ALLOC_MAXIMUM
#define YYSTACK_ALLOC_MAXIMUM
Definition: grammar.cc:494
OPTION_CMD
Definition: tok.h:146
FRES_CMD
Definition: tok.h:80
rInit
ring rInit(leftv pn, leftv rv, leftv ord)
Definition: ipshell.cc:5542
ALIAS_CMD
Definition: tok.h:33
LUS_CMD
Definition: tok.h:122
COEF_CMD
Definition: tok.h:50
VECHO
Definition: tok.h:204
CHARACTERISTIC_CMD
Definition: tok.h:41
PARAMETER
Definition: grammar.cc:347
yytable
static const yytype_int16 yytable[]
Definition: grammar.cc:981
iiExprArith2
BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
Definition: iparith.cc:8078
yycheck
static const yytype_int16 yycheck[]
Definition: grammar.cc:1242
QRDS_CMD
Definition: tok.h:158
SBA_CMD
Definition: tok.h:173
KILLATTR_CMD
Definition: tok.h:107
HOMOG_CMD
Definition: tok.h:89
iiDebug
void iiDebug()
Definition: ipshell.cc:983
LEAD_CMD
Definition: tok.h:110
BVERBOSE
#define BVERBOSE(a)
Definition: options.h:34
Print
#define Print
Definition: emacs.cc:79
BRANCHTO_CMD
Definition: tok.h:38
QRING_CMD
Definition: tok.h:157
iiRETURNEXPR
sleftv iiRETURNEXPR
Definition: iplib.cc:454
REPART_CMD
Definition: tok.h:165
Werror
void Werror(const char *fmt,...)
Definition: reporter.cc:188
YYID
#define YYID(n)
Definition: grammar.cc:436
writeTime
void writeTime(const char *v)
Definition: timer.cc:120
PACKAGE_CMD
Definition: tok.h:148
DEGREE_CMD
Definition: tok.h:60
NEWTONPOLY_CMD
Definition: tok.h:138
name
char name(const Variable &v)
Definition: factory.h:180
OPPOSITE_CMD
Definition: tok.h:145
RESULTANT_CMD
Definition: tok.h:169
IDHDL
#define IDHDL
Definition: tok.h:30
VARSTR_CMD
Definition: tok.h:196
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
ORD_CMD
Definition: tok.h:142
yypgoto
static const yytype_int16 yypgoto[]
Definition: grammar.cc:967
YYPACT_NINF
#define YYPACT_NINF
Definition: grammar.cc:921
sleftv::Typ
int Typ()
Definition: subexpr.cc:991
DELETE_CMD
Definition: tok.h:61
timerv
int timerv
Definition: timer.cc:18
COEFFS_CMD
Definition: tok.h:49
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: grammar.cc:1757
MYYERROR
#define MYYERROR(a)
Definition: grammar.cc:185
PRIME_CMD
Definition: tok.h:153
DIVISION_CMD
Definition: tok.h:66
sleftv::rtyp
int rtyp
Definition: subexpr.h:90
Variable::name
char name() const
Definition: variable.cc:122
basePack
package basePack
Definition: ipid.cc:59
IS_RINGVAR
Definition: tok.h:101
MINBASE_CMD
Definition: tok.h:124
sLastPrinted
sleftv sLastPrinted
Definition: subexpr.cc:50
NULL
#define NULL
Definition: omList.c:9
VCOLMAX
Definition: tok.h:205
sleftv::CopyD
void * CopyD(int t)
Definition: subexpr.cc:702
NPARS_CMD
Definition: tok.h:139
iiARROW
BOOLEAN iiARROW(leftv r, char *a, char *s)
Definition: ipshell.cc:6412
sleftv::Copy
void Copy(leftv e)
Definition: subexpr.cc:683
l
int l
Definition: cfEzgcd.cc:93
IDNEXT
#define IDNEXT(a)
Definition: ipid.h:112
FINDUNI_CMD
Definition: tok.h:84
FGLMQUOT_CMD
Definition: tok.h:83
yydestruct
static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep)
Definition: grammar.cc:2049
TESTSETINT
#define TESTSETINT(a, i)
Definition: grammar.cc:177
BAREISS_CMD
Definition: tok.h:36
IMPORTFROM_CMD
Definition: tok.h:92
WRITE_CMD
Definition: tok.h:202
Warn
#define Warn
Definition: emacs.cc:76
yystos
static const yytype_uint8 yystos[]
Definition: grammar.cc:1505
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
sleftv_bin
omBin sleftv_bin
Definition: subexpr.cc:45
VDIM_CMD
Definition: tok.h:197
BT_if
Definition: fevoices.h:24
WAIT1ST_CMD
Definition: tok.h:198
p
int p
Definition: cfModGcd.cc:4019
YYFINAL
#define YYFINAL
Definition: grammar.cc:579
KBASE_CMD
Definition: tok.h:105
LIFT_CMD
Definition: tok.h:115
SLIM_GB_CMD
Definition: tok.h:176
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
exitBuffer
BOOLEAN exitBuffer(feBufferTypes typ)
Definition: fevoices.cc:225
POLY_CMD
Definition: grammar.cc:288
LAGSOLVE_CMD
Definition: tok.h:109
NOTEQUAL
Definition: grammar.cc:273
IDID
#define IDID(a)
Definition: ipid.h:116
RETURN
Definition: grammar.cc:346
CHINREM_CMD
Definition: tok.h:44
FGLM_CMD
Definition: tok.h:82
DEG_CMD
Definition: tok.h:59
iiParameter
BOOLEAN iiParameter(leftv p)
Definition: ipshell.cc:1279
BRACKET_CMD
Definition: tok.h:39
YYDPRINTF
#define YYDPRINTF(Args)
Definition: grammar.cc:1656
CHARSTR_CMD
Definition: tok.h:42
MINRES_CMD
Definition: tok.h:126
V_REDEFINE
#define V_REDEFINE
Definition: options.h:44
PrintLn
void PrintLn()
Definition: reporter.cc:309
intvec::length
int length() const
Definition: intvec.h:92
MINUSMINUS
Definition: grammar.cc:271
newBuffer
void newBuffer(char *s, feBufferTypes t, procinfo *pi, int lineno)
Definition: fevoices.cc:155
prompt_char
char prompt_char
Definition: febase.cc:38
LEADMONOM_CMD
Definition: tok.h:113
YYLAST
#define YYLAST
Definition: grammar.cc:581
STATUS_CMD
Definition: tok.h:180
rOrderName
rRingOrder_t rOrderName(char *ordername)
Definition: ring.cc:498
iiAssign
BOOLEAN iiAssign(leftv l, leftv r, BOOLEAN toplevel)
Definition: ipassign.cc:1791
LINK_CMD
Definition: tok.h:116
EXECUTE_CMD
Definition: tok.h:72
CMATRIX_CMD
Definition: tok.h:45
DBPRINT_CMD
Definition: tok.h:56
rSetHdl
void rSetHdl(idhdl h)
Definition: ipshell.cc:5049
YYACCEPT
#define YYACCEPT
Definition: grammar.cc:1554
sleftv::next
leftv next
Definition: subexpr.h:85
IDIDEAL
#define IDIDEAL(a)
Definition: ipid.h:127
WEIGHT_CMD
Definition: tok.h:201
TYPEOF_CMD
Definition: tok.h:190
PARDEG_CMD
Definition: tok.h:149
sdb_flags
int sdb_flags
Definition: sdb.cc:31
LIFTSTD_CMD
Definition: tok.h:114
VSHORTOUT
Definition: tok.h:210
singular_example
void singular_example(char *str)
Definition: misc_ip.cc:448
IMPART_CMD
Definition: tok.h:91
iiApply
BOOLEAN iiApply(leftv res, leftv a, int op, leftv proc)
Definition: ipshell.cc:6363
NAMEOF_CMD
Definition: tok.h:133
DOTDOT
Definition: grammar.cc:267