Macros | Enumerations | Functions | Variables
tok.h File Reference
#include <Singular/grammar.h>

Go to the source code of this file.

Macros

#define USE_IILOCALRING   1
 
#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, CLOSE_CMD, COLS_CMD,
  CONTENT_CMD, COUNT_CMD, CRING_CMD, DBPRINT_CMD,
  DEF_CMD, DEFINED_CMD, DELETE_CMD, DENOMINATOR_CMD,
  DET_CMD, DUMP_CMD, END_GRAMMAR, ENVELOPE_CMD,
  ERROR_CMD, EXECUTE_CMD, EXPORTTO_CMD, EXTGCD_CMD,
  FAC_CMD, FIND_CMD, FACSTD_CMD, FMD_CMD,
  FWALK_CMD, FGLM_CMD, FGLMQUOT_CMD, FINDUNI_CMD,
  GCD_CMD, GETDUMP_CMD, HIGHCORNER_CMD, HRES_CMD,
  IMPART_CMD, IMPORTFROM_CMD, INSERT_CMD, INT_CMD,
  INTDIV_CMD, INTERPOLATE_CMD, INTVEC_CMD, IS_RINGVAR,
  JANET_CMD, KERNEL_CMD, KILLATTR_CMD, KRES_CMD,
  LAGSOLVE_CMD, LINK_CMD, LIST_CMD, LOAD_CMD,
  LRES_CMD, LU_CMD, LUI_CMD, LUS_CMD,
  MEMORY_CMD, MONITOR_CMD, MPRES_CMD, MSTD_CMD,
  NAMEOF_CMD, NAMES_CMD, NEWSTRUCT_CMD, NCALGEBRA_CMD,
  NC_ALGEBRA_CMD, NEWTONPOLY_CMD, NPARS_CMD, NUMERATOR_CMD,
  NVARS_CMD, OPEN_CMD, OPPOSE_CMD, OPPOSITE_CMD,
  OPTION_CMD, ORDSTR_CMD, PACKAGE_CMD, PARSTR_CMD,
  PFAC_CMD, PRIME_CMD, PRINT_CMD, PRUNE_CMD,
  QRING_CMD, QRDS_CMD, RANDOM_CMD, RANK_CMD,
  READ_CMD, REPART_CMD, RESERVEDNAME_CMD, RESULTANT_CMD,
  RINGLIST_CMD, ROWS_CMD, SIMPLEX_CMD, SLIM_GB_CMD,
  SQR_FREE_CMD, STATUS_CMD, STRING_CMD, SYSTEM_CMD,
  TEST_CMD, TRANSPOSE_CMD, TRACE_CMD, TWOSTD_CMD,
  TYPEOF_CMD, UNIVARIATE_CMD, UNLOAD_CMD, URSOLVE_CMD,
  VANDER_CMD, VARIABLES_CMD, VARSTR_CMD, WAIT1ST_CMD,
  WAITALL_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

#define ANY_TYPE   UMINUS+3

Definition at line 34 of file tok.h.

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

Definition at line 33 of file tok.h.

#define COMP_OP   '<'

Definition at line 31 of file tok.h.

#define IDHDL   UMINUS+4

Definition at line 35 of file tok.h.

#define LOGIC_OP   '&'

Definition at line 29 of file tok.h.

#define MULDIV_OP   '/'

Definition at line 30 of file tok.h.

#define NONE   END_RING

Definition at line 170 of file tok.h.

#define UNKNOWN   0

Definition at line 171 of file tok.h.

#define USE_IILOCALRING   1

Definition at line 23 of file tok.h.

Enumeration Type Documentation

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 
CLOSE_CMD 
COLS_CMD 
CONTENT_CMD 
COUNT_CMD 
CRING_CMD 
DBPRINT_CMD 
DEF_CMD 
DEFINED_CMD 
DELETE_CMD 
DENOMINATOR_CMD 
DET_CMD 
DUMP_CMD 
END_GRAMMAR 
ENVELOPE_CMD 
ERROR_CMD 
EXECUTE_CMD 
EXPORTTO_CMD 
EXTGCD_CMD 
FAC_CMD 
FIND_CMD 
FACSTD_CMD 
FMD_CMD 
FWALK_CMD 
FGLM_CMD 
FGLMQUOT_CMD 
FINDUNI_CMD 
GCD_CMD 
GETDUMP_CMD 
HIGHCORNER_CMD 
HRES_CMD 
IMPART_CMD 
IMPORTFROM_CMD 
INSERT_CMD 
INT_CMD 
INTDIV_CMD 
INTERPOLATE_CMD 
INTVEC_CMD 
IS_RINGVAR 
JANET_CMD 
KERNEL_CMD 
KILLATTR_CMD 
KRES_CMD 
LAGSOLVE_CMD 
LINK_CMD 
LIST_CMD 
LOAD_CMD 
LRES_CMD 
LU_CMD 
LUI_CMD 
LUS_CMD 
MEMORY_CMD 
MONITOR_CMD 
MPRES_CMD 
MSTD_CMD 
NAMEOF_CMD 
NAMES_CMD 
NEWSTRUCT_CMD 
NCALGEBRA_CMD 
NC_ALGEBRA_CMD 
NEWTONPOLY_CMD 
NPARS_CMD 
NUMERATOR_CMD 
NVARS_CMD 
OPEN_CMD 
OPPOSE_CMD 
OPPOSITE_CMD 
OPTION_CMD 
ORDSTR_CMD 
PACKAGE_CMD 
PARSTR_CMD 
PFAC_CMD 
PRIME_CMD 
PRINT_CMD 
PRUNE_CMD 
QRING_CMD 
QRDS_CMD 
RANDOM_CMD 
RANK_CMD 
READ_CMD 
REPART_CMD 
RESERVEDNAME_CMD 
RESULTANT_CMD 
RINGLIST_CMD 
ROWS_CMD 
SIMPLEX_CMD 
SLIM_GB_CMD 
SQR_FREE_CMD 
STATUS_CMD 
STRING_CMD 
SYSTEM_CMD 
TEST_CMD 
TRANSPOSE_CMD 
TRACE_CMD 
TWOSTD_CMD 
TYPEOF_CMD 
UNIVARIATE_CMD 
UNLOAD_CMD 
URSOLVE_CMD 
VANDER_CMD 
VARIABLES_CMD 
VARSTR_CMD 
WAIT1ST_CMD 
WAITALL_CMD 
WRITE_CMD 
VECHO 
VCOLMAX 
VTIMER 
VRTIMER 
TRACE 
VOICE 
VSHORTOUT 
VPRINTLEVEL 
MAX_TOK 

Definition at line 37 of file tok.h.

37  {
38  ALIAS_CMD = UMINUS + 15,
39  ALIGN_CMD,
40  ATTRIB_CMD,
41  BAREISS_CMD,
42  BIGINT_CMD,
43  BRANCHTO_CMD,
44  BRACKET_CMD,
45  BREAKPOINT_CMD,
46  CHARACTERISTIC_CMD,
47  CHARSTR_CMD,
48  CHAR_SERIES_CMD,
49  CHINREM_CMD,
50  CMATRIX_CMD,
51  CNUMBER_CMD,
52  CLOSE_CMD,
53  COLS_CMD,
54  CONTENT_CMD,
55  COUNT_CMD,
56  CRING_CMD,
57  DBPRINT_CMD,
58  DEF_CMD,
59  DEFINED_CMD,
60  DELETE_CMD,
61  DENOMINATOR_CMD,
62  DET_CMD,
63  DUMP_CMD,
64  END_GRAMMAR,
65  ENVELOPE_CMD,
66  ERROR_CMD,
67  EXECUTE_CMD,
68  EXPORTTO_CMD,
69  EXTGCD_CMD,
70  FAC_CMD,
71  FIND_CMD,
72  FACSTD_CMD,
73  FMD_CMD,
74  FWALK_CMD,
75  FGLM_CMD,
76  FGLMQUOT_CMD,
77  FINDUNI_CMD,
78  GCD_CMD,
79  GETDUMP_CMD,
80  HIGHCORNER_CMD,
81  HRES_CMD,
82  IMPART_CMD,
83  IMPORTFROM_CMD,
84  INSERT_CMD,
85  INT_CMD,
86  INTDIV_CMD,
87  INTERPOLATE_CMD,
88  INTVEC_CMD,
89  IS_RINGVAR,
90  JANET_CMD,
91  KERNEL_CMD,
92  KILLATTR_CMD,
93  KRES_CMD,
94  LAGSOLVE_CMD,
95  LINK_CMD,
96  LIST_CMD,
97  LOAD_CMD,
98  LRES_CMD,
99  LU_CMD,
100  LUI_CMD,
101  LUS_CMD,
102  MEMORY_CMD,
103  MONITOR_CMD,
104  MPRES_CMD,
105  MSTD_CMD,
106  NAMEOF_CMD,
107  NAMES_CMD,
108  NEWSTRUCT_CMD,
109  NCALGEBRA_CMD,
110  NC_ALGEBRA_CMD,
111  NEWTONPOLY_CMD,
112  NPARS_CMD,
113  NUMERATOR_CMD,
114  NVARS_CMD,
115  OPEN_CMD,
116  OPPOSE_CMD,
117  OPPOSITE_CMD,
118  OPTION_CMD,
119  ORDSTR_CMD,
120  PACKAGE_CMD,
121  PARSTR_CMD,
122  PFAC_CMD,
123  PRIME_CMD,
124  PRINT_CMD,
125  PRUNE_CMD,
126  QRING_CMD,
127  QRDS_CMD,
128  RANDOM_CMD,
129  RANK_CMD,
130  READ_CMD,
131  REPART_CMD,
132  RESERVEDNAME_CMD,
133  RESULTANT_CMD,
134  RINGLIST_CMD,
135  ROWS_CMD,
136  SIMPLEX_CMD,
137  SLIM_GB_CMD,
138  SQR_FREE_CMD,
139  STATUS_CMD,
140  STRING_CMD,
141  SYSTEM_CMD,
142  TEST_CMD,
143  TRANSPOSE_CMD,
144  TRACE_CMD,
145  TWOSTD_CMD,
146  TYPEOF_CMD,
147  UNIVARIATE_CMD,
148  UNLOAD_CMD, /* unused*/
149  URSOLVE_CMD,
150  VANDER_CMD,
151  VARIABLES_CMD,
152  VARSTR_CMD,
153  WAIT1ST_CMD,
154  WAITALL_CMD,
155  WRITE_CMD,
156  /* start system var section: VECHO */
157  VECHO,
158  VCOLMAX,
159  VTIMER,
160  VRTIMER,
161  TRACE,
162  VOICE,
163  VSHORTOUT,
164  VPRINTLEVEL,
165  /* end system var section: VPRINTLEVEL */
166 
167  MAX_TOK /* must be the last, biggest token number */
168 };
FMD_CMD
Definition: tok.h:73
PRINT_CMD
Definition: tok.h:124
TRACE
Definition: tok.h:161
VECHO
Definition: tok.h:157
IMPART_CMD
Definition: tok.h:82
OPEN_CMD
Definition: tok.h:115
KRES_CMD
Definition: tok.h:93
FWALK_CMD
Definition: tok.h:74
QRDS_CMD
Definition: tok.h:127
INT_CMD
Definition: tok.h:85
IS_RINGVAR
Definition: tok.h:89
VCOLMAX
Definition: tok.h:158
NPARS_CMD
Definition: tok.h:112
BIGINT_CMD
Definition: tok.h:42
MAX_TOK
Definition: tok.h:167
READ_CMD
Definition: tok.h:130
FGLM_CMD
Definition: tok.h:75
LRES_CMD
Definition: tok.h:98
LUI_CMD
Definition: tok.h:100
ROWS_CMD
Definition: tok.h:135
DET_CMD
Definition: tok.h:62
LOAD_CMD
Definition: tok.h:97
KERNEL_CMD
Definition: tok.h:91
FAC_CMD
Definition: tok.h:70
EXTGCD_CMD
Definition: tok.h:69
PRUNE_CMD
Definition: tok.h:125
ATTRIB_CMD
Definition: tok.h:40
GCD_CMD
Definition: tok.h:78
VOICE
Definition: tok.h:162
CLOSE_CMD
Definition: tok.h:52
CRING_CMD
Definition: tok.h:56
FIND_CMD
Definition: tok.h:71
ERROR_CMD
Definition: tok.h:66
DEF_CMD
Definition: tok.h:58
JANET_CMD
Definition: tok.h:90
INSERT_CMD
Definition: tok.h:84
WRITE_CMD
Definition: tok.h:155
NVARS_CMD
Definition: tok.h:114
TRACE_CMD
Definition: tok.h:144
NAMES_CMD
Definition: tok.h:107
MSTD_CMD
Definition: tok.h:105
DUMP_CMD
Definition: tok.h:63
RANK_CMD
Definition: tok.h:129
FACSTD_CMD
Definition: tok.h:72
VRTIMER
Definition: tok.h:160
INTVEC_CMD
Definition: tok.h:88
LUS_CMD
Definition: tok.h:101
PRIME_CMD
Definition: tok.h:123
ALIAS_CMD
Definition: tok.h:38
VSHORTOUT
Definition: tok.h:163
LINK_CMD
Definition: tok.h:95
ALIGN_CMD
Definition: tok.h:39
COLS_CMD
Definition: tok.h:53
DELETE_CMD
Definition: tok.h:60
INTDIV_CMD
Definition: tok.h:86
HRES_CMD
Definition: tok.h:81
MPRES_CMD
Definition: tok.h:104
PFAC_CMD
Definition: tok.h:122
LIST_CMD
Definition: tok.h:96
LU_CMD
Definition: tok.h:99
TEST_CMD
Definition: tok.h:142
QRING_CMD
Definition: tok.h:126
VTIMER
Definition: tok.h:159
COUNT_CMD
Definition: tok.h:55

Function Documentation

int yyparse ( void  )

Definition at line 2168 of file grammar.cc.

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

Variable Documentation

char my_yylinebuf[80]

Definition at line 48 of file febase.cc.

int yylineno

Definition at line 45 of file febase.cc.

Generated on Mon Aug 3 2015 12:41:12 by   doxygen 1.8.9.1 for Singular a9b8ed0|M