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, RING_LIST_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 173 of file tok.h.

#define UNKNOWN   0

Definition at line 174 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 
RING_LIST_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,
42  BIGINT_CMD,
52  CLOSE_CMD,
53  COLS_CMD,
55  COUNT_CMD,
56  CRING_CMD,
58  DEF_CMD,
60  DELETE_CMD,
62  DET_CMD,
63  DUMP_CMD,
66  ERROR_CMD,
69  EXTGCD_CMD,
70  FAC_CMD,
71  FIND_CMD,
72  FACSTD_CMD,
73  FMD_CMD,
74  FWALK_CMD,
75  FGLM_CMD,
78  GCD_CMD,
81  HRES_CMD,
82  IMPART_CMD,
84  INSERT_CMD,
85  INT_CMD,
86  INTDIV_CMD,
88  INTVEC_CMD,
89  IS_RINGVAR,
90  JANET_CMD,
91  KERNEL_CMD,
93  KRES_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,
112  NPARS_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,
134  RINGLIST_CMD,
135  #ifdef SINGULAR_4_1
137  #endif
138  ROWS_CMD,
139  SIMPLEX_CMD,
140  SLIM_GB_CMD,
141  SQR_FREE_CMD,
142  STATUS_CMD,
143  STRING_CMD,
144  SYSTEM_CMD,
145  TEST_CMD,
147  TRACE_CMD,
148  TWOSTD_CMD,
149  TYPEOF_CMD,
151  UNLOAD_CMD, /* unused*/
152  URSOLVE_CMD,
153  VANDER_CMD,
155  VARSTR_CMD,
156  WAIT1ST_CMD,
157  WAITALL_CMD,
158  WRITE_CMD,
159  /* start system var section: VECHO */
160  VECHO,
161  VCOLMAX,
162  VTIMER,
163  VRTIMER,
164  TRACE,
165  VOICE,
166  VSHORTOUT,
167  VPRINTLEVEL,
168  /* end system var section: VPRINTLEVEL */
169 
170  MAX_TOK /* must be the last, biggest token number */
171 };
Definition: tok.h:73
Definition: tok.h:124
Definition: tok.h:164
Definition: tok.h:160
Definition: tok.h:82
Definition: tok.h:115
Definition: tok.h:93
Definition: tok.h:74
Definition: tok.h:127
Definition: tok.h:85
Definition: tok.h:89
Definition: tok.h:161
Definition: tok.h:112
Definition: tok.h:42
Definition: tok.h:170
Definition: tok.h:130
Definition: tok.h:75
Definition: tok.h:98
Definition: tok.h:100
Definition: tok.h:138
Definition: tok.h:62
Definition: tok.h:97
Definition: tok.h:91
Definition: tok.h:70
Definition: tok.h:69
Definition: tok.h:125
Definition: tok.h:40
Definition: tok.h:78
Definition: tok.h:165
Definition: tok.h:52
Definition: tok.h:56
Definition: tok.h:71
Definition: tok.h:66
Definition: tok.h:58
Definition: tok.h:90
Definition: tok.h:84
Definition: tok.h:158
Definition: tok.h:114
Definition: tok.h:147
Definition: tok.h:107
Definition: tok.h:105
Definition: tok.h:63
Definition: tok.h:129
Definition: tok.h:72
Definition: tok.h:163
Definition: tok.h:88
Definition: tok.h:101
Definition: tok.h:123
Definition: tok.h:38
Definition: tok.h:166
Definition: tok.h:95
Definition: tok.h:39
Definition: tok.h:53
Definition: tok.h:60
Definition: tok.h:86
Definition: tok.h:81
Definition: tok.h:104
Definition: tok.h:122
Definition: tok.h:96
Definition: tok.h:99
Definition: tok.h:145
Definition: tok.h:126
Definition: tok.h:162
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 366 "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();
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;
2457  ;}
2458  break;
2459 
2460  case 5:
2461 
2462 /* Line 1464 of yacc.c */
2463 #line 401 "grammar.y"
2464  {currentVoice->ifsw=0;;}
2465  break;
2466 
2467  case 6:
2468 
2469 /* Line 1464 of yacc.c */
2470 #line 403 "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 405 "grammar.y"
2478  {
2479  YYACCEPT;
2480  ;}
2481  break;
2482 
2483  case 8:
2484 
2485 /* Line 1464 of yacc.c */
2486 #line 409 "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 414 "grammar.y"
2497  {currentVoice->ifsw=0;;}
2498  break;
2499 
2500  case 10:
2501 
2502 /* Line 1464 of yacc.c */
2503 #line 416 "grammar.y"
2504  {
2505  #ifdef SIQ
2506  siq=0;
2507  #endif
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  {
2537  //PrintS("leaving yyparse\n");
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 474 "grammar.y"
2558  {if (currentVoice!=NULL) currentVoice->ifsw=0;;}
2559  break;
2560 
2561  case 19:
2562 
2563 /* Line 1464 of yacc.c */
2564 #line 477 "grammar.y"
2565  { omFree((ADDRESS)(yyvsp[(2) - (2)].name)); ;}
2566  break;
2567 
2568  case 29:
2569 
2570 /* Line 1464 of yacc.c */
2571 #line 492 "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 499 "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 504 "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 508 "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 512 "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 516 "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 520 "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 533 "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 561 "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 585 "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 591 "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 597 "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 601 "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 605 "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 609 "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 613 "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 617 "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 621 "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 625 "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 629 "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 633 "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 637 "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 641 "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 645 "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 649 "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 653 "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 657 "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 661 "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 665 "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 669 "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 673 "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 677 "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 683 "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 687 "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 691 "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 695 "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 699 "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 706 "grammar.y"
2965  {
2966  leftv v = &(yyvsp[(1) - (3)].lv);
2967  while (v->next!=NULL)
2968  {
2969  v=v->next;
2970  }
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 717 "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 723 "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 727 "grammar.y"
3000  { (yyval.lv) = (yyvsp[(1) - (1)].lv); ;}
3001  break;
3002 
3003  case 70:
3004 
3005 /* Line 1464 of yacc.c */
3006 #line 728 "grammar.y"
3007  { (yyval.lv) = (yyvsp[(2) - (3)].lv); ;}
3008  break;
3009 
3010  case 71:
3011 
3012 /* Line 1464 of yacc.c */
3013 #line 730 "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 734 "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 738 "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 742 "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 746 "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 750 "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 754 "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 758 "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 762 "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 766 "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 783 "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 789 "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 795 "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 807 "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 815 "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 823 "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 832 "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 836 "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 840 "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 844 "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 848 "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 852 "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 856 "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 860 "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 864 "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 868 "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 872 "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 876 "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 880 "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 892 "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 898 "grammar.y"
3321  { (yyval.lv) = (yyvsp[(1) - (2)].lv); ;}
3322  break;
3323 
3324  case 102:
3325 
3326 /* Line 1464 of yacc.c */
3327 #line 900 "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 920 "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 932 "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 937 "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 942 "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 946 "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 950 "grammar.y"
3400  {
3401  int r; TESTSETINT((yyvsp[(4) - (8)].lv),r);
3402  int c; TESTSETINT((yyvsp[(7) - (8)].lv),c);
3403  leftv v;
3404  idhdl h;
3405  if ((yyvsp[(1) - (8)].i) == MATRIX_CMD)
3406  {
3407  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&(currRing->idroot), TRUE)) YYERROR;
3408  v=&(yyval.lv);
3409  h=(idhdl)v->data;
3410  idDelete(&IDIDEAL(h));
3411  IDMATRIX(h) = mpNew(r,c);
3412  if (IDMATRIX(h)==NULL) YYERROR;
3413  }
3414  else if ((yyvsp[(1) - (8)].i) == INTMAT_CMD)
3415  {
3416  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
3417  YYERROR;
3418  v=&(yyval.lv);
3419  h=(idhdl)v->data;
3420  delete IDINTVEC(h);
3421  IDINTVEC(h) = new intvec(r,c,0);
3422  if (IDINTVEC(h)==NULL) YYERROR;
3423  }
3424  else /* BIGINTMAT_CMD */
3425  {
3426  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
3427  YYERROR;
3428  v=&(yyval.lv);
3429  h=(idhdl)v->data;
3430  delete IDBIMAT(h);
3431  IDBIMAT(h) = new bigintmat(r, c, coeffs_BIGINT);
3432  if (IDBIMAT(h)==NULL) YYERROR;
3433  }
3434  ;}
3435  break;
3436 
3437  case 110:
3438 
3439 /* Line 1464 of yacc.c */
3440 #line 986 "grammar.y"
3441  {
3442  if ((yyvsp[(1) - (2)].i) == MATRIX_CMD)
3443  {
3444  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3445  }
3446  else if ((yyvsp[(1) - (2)].i) == INTMAT_CMD)
3447  {
3448  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3449  YYERROR;
3450  leftv v=&(yyval.lv);
3451  idhdl h;
3452  do
3453  {
3454  h=(idhdl)v->data;
3455  delete IDINTVEC(h);
3456  IDINTVEC(h) = new intvec(1,1,0);
3457  v=v->next;
3458  } while (v!=NULL);
3459  }
3460  else /* BIGINTMAT_CMD */
3461  {
3462  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3463  YYERROR;
3464  }
3465  ;}
3466  break;
3467 
3468  case 111:
3469 
3470 /* Line 1464 of yacc.c */
3471 #line 1012 "grammar.y"
3472  {
3473  int t=(yyvsp[(1) - (3)].lv).Typ();
3474  sleftv r;
3475  memset(&r,0,sizeof(sleftv));
3476  if ((BEGIN_RING<t) && (t<END_RING))
3477  {
3478  if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&(currRing->idroot), TRUE))
3479  YYERROR;
3480  }
3481  else
3482  {
3483  if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&((yyvsp[(3) - (3)].lv).req_packhdl->idroot)))
3484  YYERROR;
3485  }
3486  leftv v=&(yyvsp[(1) - (3)].lv);
3487  while (v->next!=NULL) v=v->next;
3489  memcpy(v->next,&r,sizeof(sleftv));
3490  (yyval.lv)=(yyvsp[(1) - (3)].lv);
3491  ;}
3492  break;
3493 
3494  case 112:
3495 
3496 /* Line 1464 of yacc.c */
3497 #line 1033 "grammar.y"
3498  {
3499  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3500  YYERROR;
3501  ;}
3502  break;
3503 
3504  case 115:
3505 
3506 /* Line 1464 of yacc.c */
3507 #line 1046 "grammar.y"
3508  {
3509  leftv v = &(yyvsp[(2) - (5)].lv);
3510  while (v->next!=NULL)
3511  {
3512  v=v->next;
3513  }
3515  memcpy(v->next,&((yyvsp[(4) - (5)].lv)),sizeof(sleftv));
3516  (yyval.lv) = (yyvsp[(2) - (5)].lv);
3517  ;}
3518  break;
3519 
3520  case 116:
3521 
3522 /* Line 1464 of yacc.c */
3523 #line 1060 "grammar.y"
3524  {
3525  // let rInit take care of any errors
3526  (yyval.i)=rOrderName((yyvsp[(1) - (1)].name));
3527  ;}
3528  break;
3529 
3530  case 117:
3531 
3532 /* Line 1464 of yacc.c */
3533 #line 1068 "grammar.y"
3534  {
3535  memset(&(yyval.lv),0,sizeof((yyval.lv)));
3536  intvec *iv = new intvec(2);
3537  (*iv)[0] = 1;
3538  (*iv)[1] = (yyvsp[(1) - (1)].i);
3539  (yyval.lv).rtyp = INTVEC_CMD;
3540  (yyval.lv).data = (void *)iv;
3541  ;}
3542  break;
3543 
3544  case 118:
3545 
3546 /* Line 1464 of yacc.c */
3547 #line 1077 "grammar.y"
3548  {
3549  memset(&(yyval.lv),0,sizeof((yyval.lv)));
3550  leftv sl = &(yyvsp[(3) - (4)].lv);
3551  int slLength;
3552  {
3553  slLength = exprlist_length(sl);
3554  int l = 2 + slLength;
3555  intvec *iv = new intvec(l);
3556  (*iv)[0] = slLength;
3557  (*iv)[1] = (yyvsp[(1) - (4)].i);
3558 
3559  int i = 2;
3560  while ((i<l) && (sl!=NULL))
3561  {
3562  if (sl->Typ() == INT_CMD)
3563  {
3564  (*iv)[i++] = (int)((long)(sl->Data()));
3565  }
3566  else if ((sl->Typ() == INTVEC_CMD)
3567  ||(sl->Typ() == INTMAT_CMD))
3568  {
3569  intvec *ivv = (intvec *)(sl->Data());
3570  int ll = 0,l = ivv->length();
3571  for (; l>0; l--)
3572  {
3573  (*iv)[i++] = (*ivv)[ll++];
3574  }
3575  }
3576  else
3577  {
3578  delete iv;
3579  (yyvsp[(3) - (4)].lv).CleanUp();
3580  MYYERROR("wrong type in ordering");
3581  }
3582  sl = sl->next;
3583  }
3584  (yyval.lv).rtyp = INTVEC_CMD;
3585  (yyval.lv).data = (void *)iv;
3586  }
3587  (yyvsp[(3) - (4)].lv).CleanUp();
3588  ;}
3589  break;
3590 
3591  case 120:
3592 
3593 /* Line 1464 of yacc.c */
3594 #line 1123 "grammar.y"
3595  {
3596  (yyval.lv) = (yyvsp[(1) - (3)].lv);
3597  (yyval.lv).next = (sleftv *)omAllocBin(sleftv_bin);
3598  memcpy((yyval.lv).next,&(yyvsp[(3) - (3)].lv),sizeof(sleftv));
3599  ;}
3600  break;
3601 
3602  case 122:
3603 
3604 /* Line 1464 of yacc.c */
3605 #line 1133 "grammar.y"
3606  {
3607  (yyval.lv) = (yyvsp[(2) - (3)].lv);
3608  ;}
3609  break;
3610 
3611  case 123:
3612 
3613 /* Line 1464 of yacc.c */
3614 #line 1139 "grammar.y"
3615  {
3616  expected_parms = TRUE;
3617  ;}
3618  break;
3619 
3620  case 124:
3621 
3622 /* Line 1464 of yacc.c */
3623 #line 1146 "grammar.y"
3624  { (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3625  break;
3626 
3627  case 125:
3628 
3629 /* Line 1464 of yacc.c */
3630 #line 1148 "grammar.y"
3631  { (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3632  break;
3633 
3634  case 126:
3635 
3636 /* Line 1464 of yacc.c */
3637 #line 1150 "grammar.y"
3638  { (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3639  break;
3640 
3641  case 127:
3642 
3643 /* Line 1464 of yacc.c */
3644 #line 1159 "grammar.y"
3645  { if ((yyvsp[(1) - (2)].i) != '<') YYERROR;
3646  if((feFilePending=feFopen((yyvsp[(2) - (2)].name),"r",NULL,TRUE))==NULL) YYERROR; ;}
3647  break;
3648 
3649  case 128:
3650 
3651 /* Line 1464 of yacc.c */
3652 #line 1162 "grammar.y"
3653  { newFile((yyvsp[(2) - (4)].name),feFilePending); ;}
3654  break;
3655 
3656  case 129:
3657 
3658 /* Line 1464 of yacc.c */
3659 #line 1167 "grammar.y"
3660  {
3661  feHelp((yyvsp[(2) - (3)].name));
3662  omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3663  ;}
3664  break;
3665 
3666  case 130:
3667 
3668 /* Line 1464 of yacc.c */
3669 #line 1172 "grammar.y"
3670  {
3671  feHelp(NULL);
3672  ;}
3673  break;
3674 
3675  case 131:
3676 
3677 /* Line 1464 of yacc.c */
3678 #line 1179 "grammar.y"
3679  {
3680  singular_example((yyvsp[(2) - (3)].name));
3681  omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3682  ;}
3683  break;
3684 
3685  case 132:
3686 
3687 /* Line 1464 of yacc.c */
3688 #line 1187 "grammar.y"
3689  {
3690  if (basePack!=(yyvsp[(2) - (2)].lv).req_packhdl)
3691  {
3692  if(iiExport(&(yyvsp[(2) - (2)].lv),0,currPack)) YYERROR;
3693  }
3694  else
3695  if (iiExport(&(yyvsp[(2) - (2)].lv),0)) YYERROR;
3696  ;}
3697  break;
3698 
3699  case 133:
3700 
3701 /* Line 1464 of yacc.c */
3702 #line 1199 "grammar.y"
3703  {
3704  leftv v=&(yyvsp[(2) - (2)].lv);
3705  if (v->rtyp!=IDHDL)
3706  {
3707  if (v->name!=NULL)
3708  {
3709  Werror("`%s` is undefined in kill",v->name);
3710  }
3711  else WerrorS("kill what ?");
3712  }
3713  else
3714  {
3715  killhdl((idhdl)v->data,v->req_packhdl);
3716  }
3717  ;}
3718  break;
3719 
3720  case 134:
3721 
3722 /* Line 1464 of yacc.c */
3723 #line 1215 "grammar.y"
3724  {
3725  leftv v=&(yyvsp[(3) - (3)].lv);
3726  if (v->rtyp!=IDHDL)
3727  {
3728  if (v->name!=NULL)
3729  {
3730  Werror("`%s` is undefined in kill",v->name);
3731  }
3732  else WerrorS("kill what ?");
3733  }
3734  else
3735  {
3736  killhdl((idhdl)v->data,v->req_packhdl);
3737  }
3738  ;}
3739  break;
3740 
3741  case 135:
3742 
3743 /* Line 1464 of yacc.c */
3744 #line 1234 "grammar.y"
3745  {
3746  list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3747  ;}
3748  break;
3749 
3750  case 136:
3751 
3752 /* Line 1464 of yacc.c */
3753 #line 1238 "grammar.y"
3754  {
3755  list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3756  ;}
3757  break;
3758 
3759  case 137:
3760 
3761 /* Line 1464 of yacc.c */
3762 #line 1242 "grammar.y"
3763  {
3764  if ((yyvsp[(3) - (4)].i)==QRING_CMD) (yyvsp[(3) - (4)].i)=RING_CMD;
3765  list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3766  ;}
3767  break;
3768 
3769  case 138:
3770 
3771 /* Line 1464 of yacc.c */
3772 #line 1247 "grammar.y"
3773  {
3774  list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3775  ;}
3776  break;
3777 
3778  case 139:
3779 
3780 /* Line 1464 of yacc.c */
3781 #line 1251 "grammar.y"
3782  {
3783  list_cmd(RING_CMD,NULL,"// ",TRUE);
3784  ;}
3785  break;
3786 
3787  case 140:
3788 
3789 /* Line 1464 of yacc.c */
3790 #line 1255 "grammar.y"
3791  {
3792  list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3793  ;}
3794  break;
3795 
3796  case 141:
3797 
3798 /* Line 1464 of yacc.c */
3799 #line 1259 "grammar.y"
3800  {
3801  list_cmd(PROC_CMD,NULL,"// ",TRUE);
3802  ;}
3803  break;
3804 
3805  case 142:
3806 
3807 /* Line 1464 of yacc.c */
3808 #line 1263 "grammar.y"
3809  {
3810  list_cmd(0,(yyvsp[(3) - (4)].lv).Fullname(),"// ",TRUE);
3811  (yyvsp[(3) - (4)].lv).CleanUp();
3812  ;}
3813  break;
3814 
3815  case 143:
3816 
3817 /* Line 1464 of yacc.c */
3818 #line 1268 "grammar.y"
3819  {
3820  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3821  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3822  (yyvsp[(3) - (6)].lv).CleanUp();
3823  ;}
3824  break;
3825 
3826  case 144:
3827 
3828 /* Line 1464 of yacc.c */
3829 #line 1274 "grammar.y"
3830  {
3831  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3832  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3833  (yyvsp[(3) - (6)].lv).CleanUp();
3834  ;}
3835  break;
3836 
3837  case 145:
3838 
3839 /* Line 1464 of yacc.c */
3840 #line 1280 "grammar.y"
3841  {
3842  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3843  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3844  (yyvsp[(3) - (6)].lv).CleanUp();
3845  ;}
3846  break;
3847 
3848  case 146:
3849 
3850 /* Line 1464 of yacc.c */
3851 #line 1286 "grammar.y"
3852  {
3853  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3854  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3855  (yyvsp[(3) - (6)].lv).CleanUp();
3856  ;}
3857  break;
3858 
3859  case 147:
3860 
3861 /* Line 1464 of yacc.c */
3862 #line 1292 "grammar.y"
3863  {
3864  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3865  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3866  (yyvsp[(3) - (6)].lv).CleanUp();
3867  ;}
3868  break;
3869 
3870  case 148:
3871 
3872 /* Line 1464 of yacc.c */
3873 #line 1298 "grammar.y"
3874  {
3875  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3876  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3877  (yyvsp[(3) - (6)].lv).CleanUp();
3878  ;}
3879  break;
3880 
3881  case 149:
3882 
3883 /* Line 1464 of yacc.c */
3884 #line 1304 "grammar.y"
3885  {
3886  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3887  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3888  (yyvsp[(3) - (6)].lv).CleanUp();
3889  ;}
3890  break;
3891 
3892  case 150:
3893 
3894 /* Line 1464 of yacc.c */
3895 #line 1316 "grammar.y"
3896  {
3897  list_cmd(-1,NULL,"// ",TRUE);
3898  ;}
3899  break;
3900 
3901  case 151:
3902 
3903 /* Line 1464 of yacc.c */
3904 #line 1322 "grammar.y"
3905  { yyInRingConstruction = TRUE; ;}
3906  break;
3907 
3908  case 152:
3909 
3910 /* Line 1464 of yacc.c */
3911 #line 1331 "grammar.y"
3912  {
3913  const char *ring_name = (yyvsp[(2) - (8)].lv).name;
3914  ring b=
3915  rInit(&(yyvsp[(4) - (8)].lv), /* characteristik and list of parameters*/
3916  &(yyvsp[(6) - (8)].lv), /* names of ringvariables */
3917  &(yyvsp[(8) - (8)].lv)); /* ordering */
3918  idhdl newRingHdl=NULL;
3919 
3920  if (b!=NULL)
3921  {
3922  newRingHdl=enterid(ring_name, myynest, RING_CMD,
3923  &((yyvsp[(2) - (8)].lv).req_packhdl->idroot),FALSE);
3924  (yyvsp[(2) - (8)].lv).CleanUp();
3925  if (newRingHdl!=NULL)
3926  {
3927  IDRING(newRingHdl)=b;
3928  }
3929  else
3930  {
3931  rKill(b);
3932  }
3933  }
3935  if (newRingHdl==NULL)
3936  {
3937  MYYERROR("cannot make ring");
3938  }
3939  else
3940  {
3941  rSetHdl(newRingHdl);
3942  }
3943  ;}
3944  break;
3945 
3946  case 153:
3947 
3948 /* Line 1464 of yacc.c */
3949 #line 1364 "grammar.y"
3950  {
3951  const char *ring_name = (yyvsp[(2) - (2)].lv).name;
3952  if (!inerror) rDefault(ring_name);
3954  (yyvsp[(2) - (2)].lv).CleanUp();
3955  ;}
3956  break;
3957 
3958  case 154:
3959 
3960 /* Line 1464 of yacc.c */
3961 #line 1371 "grammar.y"
3962  {
3964  if (iiAssignCR(&(yyvsp[(2) - (4)].lv),&(yyvsp[(4) - (4)].lv))) YYERROR;
3965  ;}
3966  break;
3967 
3968  case 155:
3969 
3970 /* Line 1464 of yacc.c */
3971 #line 1379 "grammar.y"
3972  {
3973  if (((yyvsp[(1) - (2)].i)!=LIB_CMD)||(jjLOAD((yyvsp[(2) - (2)].name),TRUE))) YYERROR;
3974  ;}
3975  break;
3976 
3977  case 158:
3978 
3979 /* Line 1464 of yacc.c */
3980 #line 1388 "grammar.y"
3981  {
3982  if (((yyvsp[(1) - (2)].i)==KEEPRING_CMD) && (myynest==0))
3983  MYYERROR("only inside a proc allowed");
3984  const char * n=(yyvsp[(2) - (2)].lv).Name();
3985  if ((((yyvsp[(2) - (2)].lv).Typ()==RING_CMD)||((yyvsp[(2) - (2)].lv).Typ()==QRING_CMD))
3986  && ((yyvsp[(2) - (2)].lv).rtyp==IDHDL))
3987  {
3988  idhdl h=(idhdl)(yyvsp[(2) - (2)].lv).data;
3989  if ((yyvsp[(2) - (2)].lv).e!=NULL) h=rFindHdl((ring)(yyvsp[(2) - (2)].lv).Data(),NULL);
3990  //Print("setring %s lev %d (ptr:%x)\n",IDID(h),IDLEV(h),IDRING(h));
3991  if ((yyvsp[(1) - (2)].i)==KEEPRING_CMD)
3992  {
3993  if (h!=NULL)
3994  {
3995  if (IDLEV(h)!=0)
3996  {
3997  if (iiExport(&(yyvsp[(2) - (2)].lv),myynest-1)) YYERROR;
3998 #if 1
3999  idhdl p=IDRING(h)->idroot;
4000  idhdl root=p;
4001  int prevlev=myynest-1;
4002  while (p!=NULL)
4003  {
4004  if (IDLEV(p)==myynest)
4005  {
4006  idhdl old=root->get(IDID(p),prevlev);
4007  if (old!=NULL)
4008  {
4009  if (BVERBOSE(V_REDEFINE))
4010  Warn("redefining %s",IDID(p));
4011  killhdl2(old,&root,IDRING(h));
4012  IDRING(h)->idroot=root;
4013  }
4014  IDLEV(p)=prevlev;
4015  }
4016  p=IDNEXT(p);
4017  }
4018 #endif
4019  }
4020 #ifdef USE_IILOCALRING
4021  iiLocalRing[myynest-1]=IDRING(h);
4022 #endif
4023  procstack->cRing=IDRING(h);
4024  procstack->cRingHdl=h;
4025  }
4026  else
4027  {
4028  Werror("%s is no identifier",n);
4029  (yyvsp[(2) - (2)].lv).CleanUp();
4030  YYERROR;
4031  }
4032  }
4033  if (h!=NULL) rSetHdl(h);
4034  else
4035  {
4036  Werror("cannot find the name of the basering %s",n);
4037  (yyvsp[(2) - (2)].lv).CleanUp();
4038  YYERROR;
4039  }
4040  (yyvsp[(2) - (2)].lv).CleanUp();
4041  }
4042  else
4043  {
4044  Werror("%s is no name of a ring/qring",n);
4045  (yyvsp[(2) - (2)].lv).CleanUp();
4046  YYERROR;
4047  }
4048  ;}
4049  break;
4050 
4051  case 159:
4052 
4053 /* Line 1464 of yacc.c */
4054 #line 1460 "grammar.y"
4055  {
4056  type_cmd(&((yyvsp[(2) - (2)].lv)));
4057  ;}
4058  break;
4059 
4060  case 160:
4061 
4062 /* Line 1464 of yacc.c */
4063 #line 1464 "grammar.y"
4064  {
4065  //Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
4066  #ifdef SIQ
4067  if ((yyvsp[(1) - (1)].lv).rtyp!=COMMAND)
4068  {
4069  #endif
4070  if ((yyvsp[(1) - (1)].lv).Typ()==UNKNOWN)
4071  {
4072  if ((yyvsp[(1) - (1)].lv).name!=NULL)
4073  {
4074  Werror("`%s` is undefined",(yyvsp[(1) - (1)].lv).name);
4075  omFree((ADDRESS)(yyvsp[(1) - (1)].lv).name);
4076  }
4077  YYERROR;
4078  }
4079  #ifdef SIQ
4080  }
4081  #endif
4082  (yyvsp[(1) - (1)].lv).Print(&sLastPrinted);
4083  (yyvsp[(1) - (1)].lv).CleanUp(currRing);
4084  if (errorreported) YYERROR;
4085  ;}
4086  break;
4087 
4088  case 161:
4089 
4090 /* Line 1464 of yacc.c */
4091 #line 1493 "grammar.y"
4092  {
4093  int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4094  if (i!=0)
4095  {
4096  newBuffer( (yyvsp[(5) - (5)].name), BT_if);
4097  }
4098  else
4099  {
4100  omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4101  currentVoice->ifsw=1;
4102  }
4103  ;}
4104  break;
4105 
4106  case 162:
4107 
4108 /* Line 1464 of yacc.c */
4109 #line 1506 "grammar.y"
4110  {
4111  if (currentVoice->ifsw==1)
4112  {
4113  currentVoice->ifsw=0;
4114  newBuffer( (yyvsp[(2) - (2)].name), BT_else);
4115  }
4116  else
4117  {
4118  if (currentVoice->ifsw!=2)
4119  {
4120  Warn("`else` without `if` in level %d",myynest);
4121  }
4122  omFree((ADDRESS)(yyvsp[(2) - (2)].name));
4123  }
4124  currentVoice->ifsw=0;
4125  ;}
4126  break;
4127 
4128  case 163:
4129 
4130 /* Line 1464 of yacc.c */
4131 #line 1523 "grammar.y"
4132  {
4133  int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4134  if (i)
4135  {
4136  if (exitBuffer(BT_break)) YYERROR;
4137  }
4138  currentVoice->ifsw=0;
4139  ;}
4140  break;
4141 
4142  case 164:
4143 
4144 /* Line 1464 of yacc.c */
4145 #line 1532 "grammar.y"
4146  {
4147  if (exitBuffer(BT_break)) YYERROR;
4148  currentVoice->ifsw=0;
4149  ;}
4150  break;
4151 
4152  case 165:
4153 
4154 /* Line 1464 of yacc.c */
4155 #line 1537 "grammar.y"
4156  {
4157  if (contBuffer(BT_break)) YYERROR;
4158  currentVoice->ifsw=0;
4159  ;}
4160  break;
4161 
4162  case 166:
4163 
4164 /* Line 1464 of yacc.c */
4165 #line 1545 "grammar.y"
4166  {
4167  /* -> if(!$2) break; $3; continue;*/
4168  char * s = (char *)omAlloc( strlen((yyvsp[(2) - (3)].name)) + strlen((yyvsp[(3) - (3)].name)) + 36);
4169  sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,(yyvsp[(2) - (3)].name),(yyvsp[(3) - (3)].name));
4170  newBuffer(s,BT_break);
4171  omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4172  omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4173  ;}
4174  break;
4175 
4176  case 167:
4177 
4178 /* Line 1464 of yacc.c */
4179 #line 1557 "grammar.y"
4180  {
4181  /* $2 */
4182  /* if (!$3) break; $5; $4; continue; */
4183  char * s = (char *)omAlloc( strlen((yyvsp[(3) - (5)].name))+strlen((yyvsp[(4) - (5)].name))+strlen((yyvsp[(5) - (5)].name))+36);
4184  sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
4185  ,(yyvsp[(3) - (5)].name),(yyvsp[(5) - (5)].name),(yyvsp[(4) - (5)].name));
4186  omFree((ADDRESS)(yyvsp[(3) - (5)].name));
4187  omFree((ADDRESS)(yyvsp[(4) - (5)].name));
4188  omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4189  newBuffer(s,BT_break);
4190  s = (char *)omAlloc( strlen((yyvsp[(2) - (5)].name)) + 3);
4191  sprintf(s,"%s;\n",(yyvsp[(2) - (5)].name));
4192  omFree((ADDRESS)(yyvsp[(2) - (5)].name));
4193  newBuffer(s,BT_if);
4194  ;}
4195  break;
4196 
4197  case 168:
4198 
4199 /* Line 1464 of yacc.c */
4200 #line 1576 "grammar.y"
4201  {
4202  idhdl h = enterid((yyvsp[(2) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4203  if (h==NULL) {omFree((ADDRESS)(yyvsp[(2) - (3)].name));omFree((ADDRESS)(yyvsp[(3) - (3)].name)); YYERROR;}
4204  iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(2) - (3)].name), 0, 0);
4205  IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+31);;
4206  sprintf(IDPROC(h)->data.s.body,"parameter list #;\n%s;return();\n\n",(yyvsp[(3) - (3)].name));
4207  omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4208  omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4209  ;}
4210  break;
4211 
4212  case 169:
4213 
4214 /* Line 1464 of yacc.c */
4215 #line 1586 "grammar.y"
4216  {
4217  idhdl h = enterid((yyvsp[(1) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4218  if (h==NULL)
4219  {
4220  omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4221  omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4222  omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4223  YYERROR;
4224  }
4225  char *args=iiProcArgs((yyvsp[(2) - (3)].name),FALSE);
4226  omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4227  iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (3)].name), 0, 0);
4228  IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+strlen(args)+14);;
4229  sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(3) - (3)].name));
4230  omFree((ADDRESS)args);
4231  omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4232  omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4233  ;}
4234  break;
4235 
4236  case 170:
4237 
4238 /* Line 1464 of yacc.c */
4239 #line 1605 "grammar.y"
4240  {
4241  omFree((ADDRESS)(yyvsp[(3) - (4)].name));
4242  idhdl h = enterid((yyvsp[(1) - (4)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4243  if (h==NULL)
4244  {
4245  omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4246  omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4247  omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4248  YYERROR;
4249  }
4250  char *args=iiProcArgs((yyvsp[(2) - (4)].name),FALSE);
4251  omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4252  iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (4)].name), 0, 0);
4253  omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4254  IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(4) - (4)].name))+strlen(args)+14);;
4255  sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(4) - (4)].name));
4256  omFree((ADDRESS)args);
4257  omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4258  ;}
4259  break;
4260 
4261  case 171:
4262 
4263 /* Line 1464 of yacc.c */
4264 #line 1628 "grammar.y"
4265  {
4266  // decl. of type proc p(int i)
4267  if ((yyvsp[(1) - (2)].i)==PARAMETER) { if (iiParameter(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4268  else { if (iiAlias(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4269  ;}
4270  break;
4271 
4272  case 172:
4273 
4274 /* Line 1464 of yacc.c */
4275 #line 1634 "grammar.y"
4276  {
4277  // decl. of type proc p(i)
4278  sleftv tmp_expr;
4279  if ((yyvsp[(1) - (2)].i)==ALIAS_CMD) MYYERROR("alias requires a type");
4280  if ((iiDeclCommand(&tmp_expr,&(yyvsp[(2) - (2)].lv),myynest,DEF_CMD,&IDROOT))
4281  || (iiParameter(&tmp_expr)))
4282  YYERROR;
4283  ;}
4284  break;
4285 
4286  case 173:
4287 
4288 /* Line 1464 of yacc.c */
4289 #line 1646 "grammar.y"
4290  {
4291  iiRETURNEXPR.Copy(&(yyvsp[(3) - (4)].lv));
4292  (yyvsp[(3) - (4)].lv).CleanUp();
4293  if (exitBuffer(BT_proc)) YYERROR;
4294  ;}
4295  break;
4296 
4297  case 174:
4298 
4299 /* Line 1464 of yacc.c */
4300 #line 1652 "grammar.y"
4301  {
4302  if ((yyvsp[(1) - (3)].i)==RETURN)
4303  {
4304  iiRETURNEXPR.Init();
4306  if (exitBuffer(BT_proc)) YYERROR;
4307  }
4308  ;}
4309  break;
4310 
4311 
4312 
4313 /* Line 1464 of yacc.c */
4314 #line 4315 "grammar.cc"
4315  default: break;
4316  }
4317  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4318 
4319  YYPOPSTACK (yylen);
4320  yylen = 0;
4321  YY_STACK_PRINT (yyss, yyssp);
4322 
4323  *++yyvsp = yyval;
4324 
4325  /* Now `shift' the result of the reduction. Determine what state
4326  that goes to, based on the state we popped back to and the rule
4327  number reduced by. */
4328 
4329  yyn = yyr1[yyn];
4330 
4331  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4332  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4333  yystate = yytable[yystate];
4334  else
4335  yystate = yydefgoto[yyn - YYNTOKENS];
4336 
4337  goto yynewstate;
4338 
4339 
4340 /*------------------------------------.
4341 | yyerrlab -- here on detecting error |
4342 `------------------------------------*/
4343 yyerrlab:
4344  /* If not already recovering from an error, report this error. */
4345  if (!yyerrstatus)
4346  {
4347  ++yynerrs;
4348 #if ! YYERROR_VERBOSE
4349  yyerror (YY_("syntax error"));
4350 #else
4351  {
4352  YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
4353  if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
4354  {
4355  YYSIZE_T yyalloc = 2 * yysize;
4356  if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
4357  yyalloc = YYSTACK_ALLOC_MAXIMUM;
4358  if (yymsg != yymsgbuf)
4359  YYSTACK_FREE (yymsg);
4360  yymsg = (char *) YYSTACK_ALLOC (yyalloc);
4361  if (yymsg)
4362  yymsg_alloc = yyalloc;
4363  else
4364  {
4365  yymsg = yymsgbuf;
4366  yymsg_alloc = sizeof yymsgbuf;
4367  }
4368  }
4369 
4370  if (0 < yysize && yysize <= yymsg_alloc)
4371  {
4372  (void) yysyntax_error (yymsg, yystate, yychar);
4373  yyerror (yymsg);
4374  }
4375  else
4376  {
4377  yyerror (YY_("syntax error"));
4378  if (yysize != 0)
4379  goto yyexhaustedlab;
4380  }
4381  }
4382 #endif
4383  }
4384 
4385 
4386 
4387  if (yyerrstatus == 3)
4388  {
4389  /* If just tried and failed to reuse lookahead token after an
4390  error, discard it. */
4391 
4392  if (yychar <= YYEOF)
4393  {
4394  /* Return failure if at end of input. */
4395  if (yychar == YYEOF)
4396  YYABORT;
4397  }
4398  else
4399  {
4400  yydestruct ("Error: discarding",
4401  yytoken, &yylval);
4402  yychar = YYEMPTY;
4403  }
4404  }
4405 
4406  /* Else will try to reuse lookahead token after shifting the error
4407  token. */
4408  goto yyerrlab1;
4409 
4410 
4411 /*---------------------------------------------------.
4412 | yyerrorlab -- error raised explicitly by YYERROR. |
4413 `---------------------------------------------------*/
4414 yyerrorlab:
4415 
4416  /* Pacify compilers like GCC when the user code never invokes
4417  YYERROR and the label yyerrorlab therefore never appears in user
4418  code. */
4419  if (/*CONSTCOND*/ 0)
4420  goto yyerrorlab;
4421 
4422  /* Do not reclaim the symbols of the rule which action triggered
4423  this YYERROR. */
4424  YYPOPSTACK (yylen);
4425  yylen = 0;
4426  YY_STACK_PRINT (yyss, yyssp);
4427  yystate = *yyssp;
4428  goto yyerrlab1;
4429 
4430 
4431 /*-------------------------------------------------------------.
4432 | yyerrlab1 -- common code for both syntax error and YYERROR. |
4433 `-------------------------------------------------------------*/
4434 yyerrlab1:
4435  yyerrstatus = 3; /* Each real token shifted decrements this. */
4436 
4437  for (;;)
4438  {
4439  yyn = yypact[yystate];
4440  if (yyn != YYPACT_NINF)
4441  {
4442  yyn += YYTERROR;
4443  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4444  {
4445  yyn = yytable[yyn];
4446  if (0 < yyn)
4447  break;
4448  }
4449  }
4450 
4451  /* Pop the current state because it cannot handle the error token. */
4452  if (yyssp == yyss)
4453  YYABORT;
4454 
4455 
4456  yydestruct ("Error: popping",
4457  yystos[yystate], yyvsp);
4458  YYPOPSTACK (1);
4459  yystate = *yyssp;
4460  YY_STACK_PRINT (yyss, yyssp);
4461  }
4462 
4463  *++yyvsp = yylval;
4464 
4465 
4466  /* Shift the error token. */
4467  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4468 
4469  yystate = yyn;
4470  goto yynewstate;
4471 
4472 
4473 /*-------------------------------------.
4474 | yyacceptlab -- YYACCEPT comes here. |
4475 `-------------------------------------*/
4476 yyacceptlab:
4477  yyresult = 0;
4478  goto yyreturn;
4479 
4480 /*-----------------------------------.
4481 | yyabortlab -- YYABORT comes here. |
4482 `-----------------------------------*/
4483 yyabortlab:
4484  yyresult = 1;
4485  goto yyreturn;
4486 
4487 #if !defined(yyoverflow) || YYERROR_VERBOSE
4488 /*-------------------------------------------------.
4489 | yyexhaustedlab -- memory exhaustion comes here. |
4490 `-------------------------------------------------*/
4491 yyexhaustedlab:
4492  yyerror (YY_("memory exhausted"));
4493  yyresult = 2;
4494  /* Fall through. */
4495 #endif
4496 
4497 yyreturn:
4498  if (yychar != YYEMPTY)
4499  yydestruct ("Cleanup: discarding lookahead",
4500  yytoken, &yylval);
4501  /* Do not reclaim the symbols of the rule which action triggered
4502  this YYABORT or YYACCEPT. */
4503  YYPOPSTACK (yylen);
4504  YY_STACK_PRINT (yyss, yyssp);
4505  while (yyssp != yyss)
4506  {
4507  yydestruct ("Cleanup: popping",
4508  yystos[*yyssp], yyvsp);
4509  YYPOPSTACK (1);
4510  }
4511 #ifndef yyoverflow
4512  if (yyss != yyssa)
4513  YYSTACK_FREE (yyss);
4514 #endif
4515 #if YYERROR_VERBOSE
4516  if (yymsg != yymsgbuf)
4517  YYSTACK_FREE (yymsg);
4518 #endif
4519  /* Make sure YYID is used. */
4520  return YYID (yyresult);
4521 }
char * iiProcArgs(char *e, BOOLEAN withParenth)
Definition: iplib.cc:127
Definition: grammar.cc:273
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
BOOLEAN yyInRingConstruction
Definition: grammar.cc:173
const CanonicalForm int s
Definition: facAbsFact.cc:55
int iiTestConvert(int inputType, int outputType)
Definition: gentable.cc:292
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
void singular_example(char *str)
Definition: misc_ip.cc:438
#define YYFINAL
Definition: grammar.cc:627
#define yyerrok
Definition: grammar.cc:1608
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:599
void syMake(leftv v, const char *id, idhdl packhdl)
Definition: subexpr.cc:1474
int sdb_flags
Definition: sdb.cc:32
void PrintLn()
Definition: reporter.cc:327
#define Print
Definition: emacs.cc:83
Definition: tok.h:85
#define pAdd(p, q)
Definition: polys.h:174
#define idDelete(H)
delete an ideal
Definition: ideals.h:31
procinfo * iiInitSingularProcinfo(procinfov pi, const char *libname, const char *procname, int line, long pos, BOOLEAN pstatic)
Definition: iplib.cc:978
#define IDINTVEC(a)
Definition: ipid.h:127
#define IDID(a)
Definition: ipid.h:121
BOOLEAN iiExprArith1(leftv res, leftv a, int op)
Definition: iparith.cc:8330
#define FALSE
Definition: auxiliary.h:140
const int MAX_INT_LEN
Definition: mylimits.h:13
Definition: tok.h:42
return P p
Definition: myNF.cc:203
int exprlist_length(leftv v)
Definition: ipshell.cc:559
Matrices of numbers.
Definition: bigintmat.h:51
feBufferTypes Typ()
Definition: fevoices.cc:111
BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
Definition: iparith.cc:8542
#define YYACCEPT
Definition: grammar.cc:1613
#define YYSTACK_ALLOC
Definition: grammar.cc:539
#define YYTRANSLATE(YYX)
Definition: grammar.cc:644
char prompt_char
Definition: febase.cc:44
sleftv iiRETURNEXPR
Definition: iplib.cc:527
void writeTime(const char *v)
Definition: timer.cc:121
#define IDNEXT(a)
Definition: ipid.h:117
proclevel * procstack
Definition: ipid.cc:58
#define IDROOT
Definition: ipid.h:20
BOOLEAN siq
Definition: subexpr.cc:58
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: grammar.cc:1721
#define TRUE
Definition: auxiliary.h:144
int length() const
Definition: intvec.h:86
void type_cmd(leftv v)
Definition: ipshell.cc:251
BOOLEAN iiAssignCR(leftv r, leftv arg)
Definition: ipshell.cc:6376
#define IDIDEAL(a)
Definition: ipid.h:132
void Init()
Definition: subexpr.h:108
#define UNKNOWN
Definition: tok.h:174
void * ADDRESS
Definition: auxiliary.h:161
sleftv * leftv
Definition: structs.h:60
BOOLEAN iiExprArithM(leftv res, leftv a, int op)
Definition: iparith.cc:8630
#define IDBIMAT(a)
Definition: ipid.h:128
void WerrorS(const char *s)
Definition: feFopen.cc:24
int inerror
Definition: grammar.cc:176
#define YYNTOKENS
Definition: grammar.cc:632
int timerv
Definition: timer.cc:19
BOOLEAN jjLOAD(const char *s, BOOLEAN autoexport)
load lib/module given in v
Definition: iparith.cc:5286
coeffs coeffs_BIGINT
Definition: ipid.cc:54
int Typ()
Definition: subexpr.cc:969
#define omAlloc(size)
Definition: omAllocDecl.h:210
idhdl cRingHdl
Definition: ipid.h:60
BOOLEAN exitBuffer(feBufferTypes typ)
Definition: fevoices.cc:241
BOOLEAN iiExport(leftv v, int toLev)
Definition: ipshell.cc:1388
Definition: idrec.h:34
#define IDHDL
Definition: tok.h:35
idhdl get(const char *s, int lev)
Definition: ipid.cc:91
BOOLEAN iiParameter(leftv p)
Definition: ipshell.cc:1244
const char * currid
Definition: grammar.cc:172
void * data
Definition: subexpr.h:89
char ifsw
Definition: fevoices.h:76
#define YYSTYPE
Definition: stype.h:19
Definition: fevoices.h:24
BOOLEAN iiTestAssume(leftv a, leftv b)
Definition: ipshell.cc:6315
int myynest
Definition: febase.cc:46
#define YYPOPSTACK(N)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
void killhdl2(idhdl h, idhdl *ih, ring r)
Definition: ipid.cc:403
idhdl enterid(const char *s, int lev, int t, idhdl *root, BOOLEAN init, BOOLEAN search)
Definition: ipid.cc:259
#define YYTERROR
Definition: grammar.cc:1653
#define YYEMPTY
Definition: grammar.cc:1610
const ring r
Definition: syzextra.cc:208
#define YYSTACK_FREE
Definition: grammar.cc:540
static const yytype_uint8 yyr2[]
Definition: grammar.cc:905
int cmdtok
Definition: grammar.cc:175
Definition: intvec.h:16
const char * iiTwoOps(int t)
Definition: gentable.cc:252
void rKill(ring r)
Definition: ipshell.cc:5999
void list_cmd(int typ, const char *what, const char *prefix, BOOLEAN iterate, BOOLEAN fullname)
Definition: ipshell.cc:425
int j
Definition: myNF.cc:70
Definition: tok.h:58
procinfo * pi
Definition: fevoices.h:63
const char * name
Definition: subexpr.h:88
#define pSetCompP(a, i)
Definition: polys.h:274
#define omFree(addr)
Definition: omAllocDecl.h:261
BOOLEAN siCntrlc
Definition: cntrlc.cc:105
static const yytype_int16 yypact[]
Definition: grammar.cc:987
short int yytype_int16
Definition: grammar.cc:444
#define YYSTACK_ALLOC_MAXIMUM
Definition: grammar.cc:542
#define YYABORT
Definition: grammar.cc:1614
#define YY_REDUCE_PRINT(Rule)
Definition: grammar.cc:1854
BOOLEAN exitVoice()
Definition: fevoices.cc:346
idhdl currRingHdl
Definition: ipid.cc:65
void Copy(leftv e)
Definition: subexpr.cc:657
int rOrderName(char *ordername)
Definition: ring.cc:508
#define YY_STACK_PRINT(Bottom, Top)
Definition: grammar.cc:1816
ring rDefault(const coeffs cf, int N, char **n, int ord_size, int *ord, int *block0, int *block1, int **wvhdl)
Definition: ring.cc:113
idrec * idhdl
Definition: ring.h:18
FILE * feFopen(const char *path, const char *mode, char *where, short useWerror, short path_only)
Definition: feFopen.cc:47
omBin sleftv_bin
Definition: subexpr.cc:50
int i
Definition: cfEzgcd.cc:123
void startRTimer()
Definition: timer.cc:153
idhdl rFindHdl(ring r, idhdl n)
Definition: ipshell.cc:1573
static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep)
Definition: grammar.cc:2108
void iiDebug()
Definition: ipshell.cc:981
Definition: tok.h:88
static const yytype_int16 yypgoto[]
Definition: grammar.cc:1032
#define MYYERROR(a)
Definition: grammar.cc:186
#define IDLEV(a)
Definition: ipid.h:120
static const yytype_uint8 yydefact[]
Definition: grammar.cc:930
short errorreported
Definition: feFopen.cc:23
leftv next
Definition: subexpr.h:87
Voice * prev
Definition: fevoices.h:61
FILE * feFilePending
Definition: ipid.cc:56
#define BVERBOSE(a)
Definition: options.h:33
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:48
Definition: tok.h:38
int iiDeclCommand(leftv sy, leftv name, int lev, int t, idhdl *root, BOOLEAN isring, BOOLEAN init_b)
Definition: ipshell.cc:1119
#define TESTSETINT(a, i)
Definition: grammar.cc:178
#define IDPROC(a)
Definition: ipid.h:139
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
feBufferTypes
Definition: fevoices.h:16
#define YYLEX
Definition: grammar.cc:1704
ring * iiLocalRing
Definition: iplib.cc:525
char name(const Variable &v)
Definition: variable.h:95
#define YYLAST
Definition: grammar.cc:629
#define NULL
Definition: omList.c:10
package req_packhdl
Definition: subexpr.h:107
#define YYDPRINTF(Args)
Definition: grammar.cc:1715
#define YYTABLE_NINF
Definition: grammar.cc:1045
Voice * currentVoice
Definition: fevoices.cc:57
void killhdl(idhdl h, package proot)
Definition: ipid.cc:372
package basePack
Definition: ipid.cc:64
BOOLEAN iiConvert(int inputType, int outputType, int index, leftv input, leftv output, struct sConvertTypes *dConvertTypes)
Definition: ipconv.cc:358
BOOLEAN iiAlias(leftv p)
Definition: ipid.cc:745
void yyerror(const char *fmt)
Definition: grammar.cc:188
#define IDRING(a)
Definition: ipid.h:126
#define pDelete(p_ptr)
Definition: polys.h:157
package currPack
Definition: ipid.cc:63
#define YYINITDEPTH
Definition: grammar.cc:1873
ring cRing
Definition: ipid.h:61
int rtyp
Definition: subexpr.h:92
sleftv sLastPrinted
Definition: subexpr.cc:55
void CleanUp(ring r=currRing)
Definition: subexpr.cc:321
void * Data()
Definition: subexpr.cc:1111
#define YYSIZE_T
Definition: grammar.cc:455
void newBuffer(char *s, feBufferTypes t, procinfo *pi, int lineno)
Definition: fevoices.cc:171
#define YYMAXDEPTH
Definition: grammar.cc:167
BOOLEAN newFile(char *fname, FILE *f)
Definition: fevoices.cc:129
BOOLEAN iiARROW(leftv r, char *a, char *s)
Definition: ipshell.cc:6342
#define YY_(msgid)
Definition: grammar.cc:471
static const yytype_int16 yytable[]
Definition: grammar.cc:1046
static const yytype_int16 yydefgoto[]
Definition: grammar.cc:975
static const yytype_int16 yycheck[]
Definition: grammar.cc:1304
Definition: tok.h:126
ring rInit(sleftv *pn, sleftv *rv, sleftv *ord)
Definition: ipshell.cc:5461
int rtimerv
Definition: timer.cc:148
static const yytype_uint8 yyr1[]
Definition: grammar.cc:882
polyrec * poly
Definition: hilb.h:10
void rSetHdl(idhdl h)
Definition: ipshell.cc:4979
void startTimer()
Definition: timer.cc:82
static Poly * h
Definition: janet.cc:978
const poly b
Definition: syzextra.cc:213
BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
Definition: iparith.cc:8143
#define YYPACT_NINF
Definition: grammar.cc:986
#define NONE
Definition: tok.h:173
YYSTYPE yylval
BOOLEAN iiApply(leftv res, leftv a, int op, leftv proc)
Definition: ipshell.cc:6293
char trace_flag
Definition: subexpr.h:61
#define V_REDEFINE
Definition: options.h:43
void Werror(const char *fmt,...)
Definition: reporter.cc:199
#define YYID(n)
Definition: grammar.cc:484
void * CopyD(int t)
Definition: subexpr.cc:676
BOOLEAN expected_parms
Definition: grammar.cc:174
const char * lastreserved
Definition: ipshell.cc:86
#define YYEOF
Definition: grammar.cc:1611
int l
Definition: cfEzgcd.cc:94
void writeRTime(const char *v)
Definition: timer.cc:195
#define YYERROR
Definition: grammar.cc:1615
void feHelp(char *str)
Definition: fehelp.cc:103
#define IDMATRIX(a)
Definition: ipid.h:133
#define COMMAND
Definition: tok.h:33
utypes data
Definition: idrec.h:40
ListNode * next
Definition: janet.h:31
BOOLEAN iiAssign(leftv l, leftv r, BOOLEAN toplevel)
Definition: ipassign.cc:1782
#define Warn
Definition: emacs.cc:80
static const yytype_uint8 yystos[]
Definition: grammar.cc:1564
BOOLEAN contBuffer(feBufferTypes typ)
Definition: fevoices.cc:309
#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.