Changeset 5d442e in git
- Timestamp:
- Feb 4, 2013, 5:25:35 PM (10 years ago)
- Branches:
- (u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')
- Children:
- 3621e7317a4ff5f11cb74f268c348ff205ce8b0e
- Parents:
- 9bc6a43bf738fd99b4fb51230cb0c76f2ffee68d
- Location:
- Singular
- Files:
-
- 3 edited
Legend:
- Unmodified
- Added
- Removed
-
Singular/grammar.cc
r9bc6a43 r5d442e 1 /* A Bison parser, made by GNU Bison 2.4.3. */ 2 3 /* Skeleton implementation for Bison's Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 6 2009, 2010 Free Software Foundation, Inc. 7 8 This program is free software: you can redistribute it and/or modify 1 /* A Bison parser, made by GNU Bison 1.875d. */ 2 3 /* Skeleton parser for Yacc-like parsing with Bison, 4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 5 6 This program is free software; you can redistribute it and/or modify 9 7 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation , either version 3 of the License, or11 (at your option)any later version.12 8 the Free Software Foundation; either version 2, or (at your option) 9 any later version. 10 13 11 This program is distributed in the hope that it will be useful, 14 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 14 GNU General Public License for more details. 17 15 18 16 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 /* As a special exception, you may create a larger work that contains 22 part or all of the Bison parser skeleton and distribute that work 23 under terms of your choice, so long as that work isn't itself a 24 parser generator using the skeleton or a modified version thereof 25 as a parser skeleton. Alternatively, if you modify or redistribute 26 the parser skeleton itself, you may (at your option) remove this 27 special exception, which will cause the skeleton and the resulting 28 Bison output files to be licensed under the GNU General Public 29 License without this special exception. 30 31 This special exception was added by the Free Software Foundation in 32 version 2.2 of Bison. */ 33 34 /* C LALR(1) parser skeleton written by Richard Stallman, by 35 simplifying the original so-called "semantic" parser. */ 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 59 Temple Place - Suite 330, 19 Boston, MA 02111-1307, USA. */ 20 21 /* As a special exception, when this file is copied by Bison into a 22 Bison output file, you may use that output file without restriction. 23 This special exception was added by the Free Software Foundation 24 in version 1.24 of Bison. */ 25 26 /* Written by Richard Stallman by simplifying the original so called 27 ``semantic'' parser. */ 36 28 37 29 /* All symbols defined below should begin with yy or YY, to avoid … … 45 37 #define YYBISON 1 46 38 47 /* Bison version. */48 #define YYBISON_VERSION "2.4.3"49 50 39 /* Skeleton name. */ 51 40 #define YYSKELETON_NAME "yacc.c" … … 54 43 #define YYPURE 1 55 44 56 /* Push parsers. */57 #define YYPUSH 058 59 /* Pull parsers. */60 #define YYPULL 161 62 45 /* Using locations. */ 63 46 #define YYLSP_NEEDED 0 64 47 65 66 67 /* Copy the first part of user declarations. */68 69 /* Line 189 of yacc.c */70 #line 7 "grammar.y"71 72 73 #include <stdio.h>74 #include <stddef.h>75 #include <stdlib.h>76 #include <stdarg.h>77 #include <string.h>78 79 #include <kernel/mod2.h>80 #include <misc/mylimits.h>81 #include <omalloc/omalloc.h>82 #include <Singular/tok.h>83 #include <misc/options.h>84 #include <Singular/stype.h>85 #include <Singular/fehelp.h>86 #include <Singular/ipid.h>87 #include <misc/intvec.h>88 #include <kernel/febase.h>89 #include <polys/matpol.h>90 #include <polys/monomials/ring.h>91 #include <kernel/kstd1.h>92 #include <Singular/subexpr.h>93 #include <Singular/ipshell.h>94 #include <Singular/ipconv.h>95 #include <Singular/sdb.h>96 #include <kernel/ideals.h>97 #include <coeffs/numbers.h>98 #include <kernel/polys.h>99 #include <kernel/stairc.h>100 #include <kernel/timer.h>101 #include <Singular/cntrlc.h>102 #include <polys/monomials/maps.h>103 #include <kernel/syz.h>104 #include <Singular/lists.h>105 #include <kernel/longrat.h>106 #include <Singular/libparse.h>107 #include <coeffs/bigintmat.h>108 109 #if 0110 void debug_list(leftv v)111 {112 idhdl r=basePackHdl;113 idhdl h;114 BOOLEAN found=FALSE;115 const char *nn=v->name;116 h=IDROOT->get(nn,myynest);117 if (h!=NULL)118 {119 Print("Curr::%s, (%s)\n",nn,Tok2Cmdname((int)IDTYP(h)));120 found=TRUE;121 }122 else Print("`%s` not found in IDROOT\n",nn);123 while (r!=NULL)124 {125 if ((IDTYP(r)==PACKAGE_CMD)126 || (IDTYP(r)==RING_CMD)127 || (IDTYP(r)==QRING_CMD))128 {129 h=IDPACKAGE(r)->idroot->get(nn,myynest);130 if (h!=NULL)131 {132 Print("%s::%s, (%s)\n",r->id,nn,Tok2Cmdname((int)IDTYP(h)));133 found=TRUE;134 }135 else Print("%s::%s not found\n",r->id,nn);136 }137 if (r==basePackHdl) r=IDPACKAGE(r)->idroot;138 r=r->next;139 if (r==basePackHdl) break;140 }141 if (!found)142 {143 listall(TRUE);144 }145 }146 #endif147 148 /* From the bison docu:149 150 By defining the macro `YYMAXDEPTH', you can control how deep the151 parser stack can become before a stack overflow occurs. Define the152 macro with a value that is an integer. This value is the maximum number153 of tokens that can be shifted (and not reduced) before overflow. It154 must be a constant expression whose value is known at compile time.155 156 The stack space allowed is not necessarily allocated. If you157 specify a large value for `YYMAXDEPTH', the parser actually allocates a158 small stack at first, and then makes it bigger by stages as needed.159 This increasing allocation happens automatically and silently.160 Therefore, you do not need to make `YYMAXDEPTH' painfully small merely161 to save space for ordinary inputs that do not need much stack.162 163 The default value of `YYMAXDEPTH', if you do not define it, is 10000.164 */165 #define YYMAXDEPTH MAX_INT_VAL166 167 extern int yylineno;168 extern FILE* yyin;169 170 const char * currid;171 BOOLEAN yyInRingConstruction=FALSE;172 BOOLEAN expected_parms;173 int cmdtok;174 int inerror = 0;175 176 #define TESTSETINT(a,i) \177 if ((a).Typ() != INT_CMD) \178 { \179 WerrorS("no int expression"); \180 YYERROR; \181 } \182 (i) = (int)((long)(a).Data());(a).CleanUp()183 184 #define MYYERROR(a) { WerrorS(a); YYERROR; }185 186 void yyerror(const char * fmt)187 {188 189 BOOLEAN old_errorreported=errorreported;190 errorreported = TRUE;191 if (currid!=NULL)192 {193 killid(currid,&IDROOT);194 currid = NULL;195 }196 if(inerror==0)197 {198 {199 if ((strlen(fmt)>1)200 && (strncmp(fmt,"parse",5)!=0)201 && (strncmp(fmt,"syntax",6)!=0))202 WerrorS(fmt);203 Werror( "error occurred in or before %s line %d: `%s`"204 ,VoiceName(), yylineno, my_yylinebuf);205 }206 if (cmdtok!=0)207 {208 const char *s=Tok2Cmdname(cmdtok);209 if (expected_parms)210 {211 Werror("expected %s-expression. type \'help %s;\'",s,s);212 }213 else214 {215 Werror("wrong type declaration. type \'help %s;\'",s);216 }217 }218 if (!old_errorreported && (lastreserved!=NULL))219 {220 Werror("last reserved name was `%s`",lastreserved);221 }222 inerror=1;223 }224 if ((currentVoice!=NULL)225 && (currentVoice->prev!=NULL)226 && (myynest>0)227 #ifdef HAVE_SDB228 && ((sdb_flags &1)==0)229 #endif230 )231 {232 Werror("leaving %s",VoiceName());233 }234 #ifdef HAVE_FACTORY235 // libfac:236 #ifdef HAVE_LIBFAC237 extern int libfac_interruptflag;238 libfac_interruptflag=0;239 #endif // #ifdef HAVE_LIBFAC240 #endif241 }242 243 244 245 /* Line 189 of yacc.c */246 #line 247 "grammar.cc"247 248 /* Enabling traces. */249 #ifndef YYDEBUG250 # define YYDEBUG 1251 #endif252 253 /* Enabling verbose error messages. */254 #ifdef YYERROR_VERBOSE255 # undef YYERROR_VERBOSE256 # define YYERROR_VERBOSE 1257 #else258 # define YYERROR_VERBOSE 0259 #endif260 261 /* Enabling the token table. */262 #ifndef YYTOKEN_TABLE263 # define YYTOKEN_TABLE 0264 #endif265 48 266 49 … … 342 125 REGULARITY_CMD = 327, 343 126 RES_CMD = 328, 344 S IMPLIFY_CMD = 329,345 S ORTVEC_CMD = 330,346 S RES_CMD = 331,347 S TD_CMD = 332,348 S UBST_CMD = 333,349 S YZYGY_CMD = 334,350 VAR_CMD = 335,351 V DIM_CMD = 336,352 WEDGE_CMD = 337,353 WE IGHT_CMD = 338,354 VALTVARS= 339,355 V MAXDEG= 340,356 VMAX MULT= 341,357 V NOETHER= 342,358 V MINPOLY= 343,359 END_RING= 344,360 CMD_1= 345,361 CMD_ 2= 346,362 CMD_ 3= 347,363 CMD_ 12= 348,364 CMD_1 3= 349,365 CMD_ 23 = 350,366 CMD_ 123 = 351,367 CMD_ M= 352,368 ROOT_DECL= 353,369 ROOT_DECL _LIST= 354,370 R ING_DECL= 355,371 RING_DECL _LIST= 356,372 EXAMPLE_CMD= 357,373 EX PORT_CMD = 358,374 HELP_CMD = 359,375 KILL_CMD = 360,376 LIB_CMD = 361,377 LI STVAR_CMD = 362,378 SETRING_CMD = 363,379 TYPE_CMD = 364,380 STRINGTOK= 365,381 BLOCKTOK = 366,382 INT_CONST= 367,383 UNKNOWN_IDENT = 368,384 RINGVAR= 369,385 PROC_DEF= 370,386 BREAK_CMD= 371,387 CONTINUE_CMD = 372,388 ELSE_CMD = 373,389 E VAL= 374,390 QUOTE= 375,391 FOR_CMD= 376,392 IF_CMD = 377,393 SYS_BREAK= 378,394 WHILE_CMD= 379,395 RETURN= 380,396 PARAMETER= 381,397 SYSVAR = 382,398 UMINUS= 383,399 SBA_CMD= 384127 SBA_CMD = 329, 128 SIMPLIFY_CMD = 330, 129 SORTVEC_CMD = 331, 130 SRES_CMD = 332, 131 STD_CMD = 333, 132 SUBST_CMD = 334, 133 SYZYGY_CMD = 335, 134 VAR_CMD = 336, 135 VDIM_CMD = 337, 136 WEDGE_CMD = 338, 137 WEIGHT_CMD = 339, 138 VALTVARS = 340, 139 VMAXDEG = 341, 140 VMAXMULT = 342, 141 VNOETHER = 343, 142 VMINPOLY = 344, 143 END_RING = 345, 144 CMD_1 = 346, 145 CMD_2 = 347, 146 CMD_3 = 348, 147 CMD_12 = 349, 148 CMD_13 = 350, 149 CMD_23 = 351, 150 CMD_123 = 352, 151 CMD_M = 353, 152 ROOT_DECL = 354, 153 ROOT_DECL_LIST = 355, 154 RING_DECL = 356, 155 RING_DECL_LIST = 357, 156 EXAMPLE_CMD = 358, 157 EXPORT_CMD = 359, 158 HELP_CMD = 360, 159 KILL_CMD = 361, 160 LIB_CMD = 362, 161 LISTVAR_CMD = 363, 162 SETRING_CMD = 364, 163 TYPE_CMD = 365, 164 STRINGTOK = 366, 165 BLOCKTOK = 367, 166 INT_CONST = 368, 167 UNKNOWN_IDENT = 369, 168 RINGVAR = 370, 169 PROC_DEF = 371, 170 BREAK_CMD = 372, 171 CONTINUE_CMD = 373, 172 ELSE_CMD = 374, 173 EVAL = 375, 174 QUOTE = 376, 175 FOR_CMD = 377, 176 IF_CMD = 378, 177 SYS_BREAK = 379, 178 WHILE_CMD = 380, 179 RETURN = 381, 180 PARAMETER = 382, 181 SYSVAR = 383, 182 UMINUS = 384 400 183 }; 401 184 #endif 402 403 404 405 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 406 185 #define DOTDOT 258 186 #define EQUAL_EQUAL 259 187 #define GE 260 188 #define LE 261 189 #define MINUSMINUS 262 190 #define NOT 263 191 #define NOTEQUAL 264 192 #define PLUSPLUS 265 193 #define COLONCOLON 266 194 #define GRING_CMD 267 195 #define BIGINTMAT_CMD 268 196 #define INTMAT_CMD 269 197 #define PROC_CMD 270 198 #define RING_CMD 271 199 #define BEGIN_RING 272 200 #define IDEAL_CMD 273 201 #define MAP_CMD 274 202 #define MATRIX_CMD 275 203 #define MODUL_CMD 276 204 #define NUMBER_CMD 277 205 #define POLY_CMD 278 206 #define RESOLUTION_CMD 279 207 #define VECTOR_CMD 280 208 #define BETTI_CMD 281 209 #define COEFFS_CMD 282 210 #define COEF_CMD 283 211 #define CONTRACT_CMD 284 212 #define DEGREE_CMD 285 213 #define DEG_CMD 286 214 #define DIFF_CMD 287 215 #define DIM_CMD 288 216 #define DIVISION_CMD 289 217 #define ELIMINATION_CMD 290 218 #define E_CMD 291 219 #define FAREY_CMD 292 220 #define FETCH_CMD 293 221 #define FREEMODULE_CMD 294 222 #define KEEPRING_CMD 295 223 #define HILBERT_CMD 296 224 #define HOMOG_CMD 297 225 #define IMAP_CMD 298 226 #define INDEPSET_CMD 299 227 #define INTERRED_CMD 300 228 #define INTERSECT_CMD 301 229 #define JACOB_CMD 302 230 #define JET_CMD 303 231 #define KBASE_CMD 304 232 #define KOSZUL_CMD 305 233 #define LEADCOEF_CMD 306 234 #define LEADEXP_CMD 307 235 #define LEAD_CMD 308 236 #define LEADMONOM_CMD 309 237 #define LIFTSTD_CMD 310 238 #define LIFT_CMD 311 239 #define MAXID_CMD 312 240 #define MINBASE_CMD 313 241 #define MINOR_CMD 314 242 #define MINRES_CMD 315 243 #define MODULO_CMD 316 244 #define MONOM_CMD 317 245 #define MRES_CMD 318 246 #define MULTIPLICITY_CMD 319 247 #define ORD_CMD 320 248 #define PAR_CMD 321 249 #define PARDEG_CMD 322 250 #define PREIMAGE_CMD 323 251 #define QUOTIENT_CMD 324 252 #define QHWEIGHT_CMD 325 253 #define REDUCE_CMD 326 254 #define REGULARITY_CMD 327 255 #define RES_CMD 328 256 #define SBA_CMD 329 257 #define SIMPLIFY_CMD 330 258 #define SORTVEC_CMD 331 259 #define SRES_CMD 332 260 #define STD_CMD 333 261 #define SUBST_CMD 334 262 #define SYZYGY_CMD 335 263 #define VAR_CMD 336 264 #define VDIM_CMD 337 265 #define WEDGE_CMD 338 266 #define WEIGHT_CMD 339 267 #define VALTVARS 340 268 #define VMAXDEG 341 269 #define VMAXMULT 342 270 #define VNOETHER 343 271 #define VMINPOLY 344 272 #define END_RING 345 273 #define CMD_1 346 274 #define CMD_2 347 275 #define CMD_3 348 276 #define CMD_12 349 277 #define CMD_13 350 278 #define CMD_23 351 279 #define CMD_123 352 280 #define CMD_M 353 281 #define ROOT_DECL 354 282 #define ROOT_DECL_LIST 355 283 #define RING_DECL 356 284 #define RING_DECL_LIST 357 285 #define EXAMPLE_CMD 358 286 #define EXPORT_CMD 359 287 #define HELP_CMD 360 288 #define KILL_CMD 361 289 #define LIB_CMD 362 290 #define LISTVAR_CMD 363 291 #define SETRING_CMD 364 292 #define TYPE_CMD 365 293 #define STRINGTOK 366 294 #define BLOCKTOK 367 295 #define INT_CONST 368 296 #define UNKNOWN_IDENT 369 297 #define RINGVAR 370 298 #define PROC_DEF 371 299 #define BREAK_CMD 372 300 #define CONTINUE_CMD 373 301 #define ELSE_CMD 374 302 #define EVAL 375 303 #define QUOTE 376 304 #define FOR_CMD 377 305 #define IF_CMD 378 306 #define SYS_BREAK 379 307 #define WHILE_CMD 380 308 #define RETURN 381 309 #define PARAMETER 382 310 #define SYSVAR 383 311 #define UMINUS 384 312 313 314 315 316 /* Copy the first part of user declarations. */ 317 #line 7 "grammar.y" 318 319 320 #include <stdio.h> 321 #include <stddef.h> 322 #include <stdlib.h> 323 #include <stdarg.h> 324 #include <string.h> 325 326 #include <kernel/mod2.h> 327 #include <misc/mylimits.h> 328 #include <omalloc/omalloc.h> 329 #include <Singular/tok.h> 330 #include <misc/options.h> 331 #include <Singular/stype.h> 332 #include <Singular/fehelp.h> 333 #include <Singular/ipid.h> 334 #include <misc/intvec.h> 335 #include <kernel/febase.h> 336 #include <polys/matpol.h> 337 #include <polys/monomials/ring.h> 338 #include <kernel/kstd1.h> 339 #include <Singular/subexpr.h> 340 #include <Singular/ipshell.h> 341 #include <Singular/ipconv.h> 342 #include <Singular/sdb.h> 343 #include <kernel/ideals.h> 344 #include <coeffs/numbers.h> 345 #include <kernel/polys.h> 346 #include <kernel/stairc.h> 347 #include <kernel/timer.h> 348 #include <Singular/cntrlc.h> 349 #include <polys/monomials/maps.h> 350 #include <kernel/syz.h> 351 #include <Singular/lists.h> 352 #include <kernel/longrat.h> 353 #include <Singular/libparse.h> 354 #include <coeffs/bigintmat.h> 355 356 #if 0 357 void debug_list(leftv v) 358 { 359 idhdl r=basePackHdl; 360 idhdl h; 361 BOOLEAN found=FALSE; 362 const char *nn=v->name; 363 h=IDROOT->get(nn,myynest); 364 if (h!=NULL) 365 { 366 Print("Curr::%s, (%s)\n",nn,Tok2Cmdname((int)IDTYP(h))); 367 found=TRUE; 368 } 369 else Print("`%s` not found in IDROOT\n",nn); 370 while (r!=NULL) 371 { 372 if ((IDTYP(r)==PACKAGE_CMD) 373 || (IDTYP(r)==RING_CMD) 374 || (IDTYP(r)==QRING_CMD)) 375 { 376 h=IDPACKAGE(r)->idroot->get(nn,myynest); 377 if (h!=NULL) 378 { 379 Print("%s::%s, (%s)\n",r->id,nn,Tok2Cmdname((int)IDTYP(h))); 380 found=TRUE; 381 } 382 else Print("%s::%s not found\n",r->id,nn); 383 } 384 if (r==basePackHdl) r=IDPACKAGE(r)->idroot; 385 r=r->next; 386 if (r==basePackHdl) break; 387 } 388 if (!found) 389 { 390 listall(TRUE); 391 } 392 } 393 #endif 394 395 /* From the bison docu: 396 397 By defining the macro `YYMAXDEPTH', you can control how deep the 398 parser stack can become before a stack overflow occurs. Define the 399 macro with a value that is an integer. This value is the maximum number 400 of tokens that can be shifted (and not reduced) before overflow. It 401 must be a constant expression whose value is known at compile time. 402 403 The stack space allowed is not necessarily allocated. If you 404 specify a large value for `YYMAXDEPTH', the parser actually allocates a 405 small stack at first, and then makes it bigger by stages as needed. 406 This increasing allocation happens automatically and silently. 407 Therefore, you do not need to make `YYMAXDEPTH' painfully small merely 408 to save space for ordinary inputs that do not need much stack. 409 410 The default value of `YYMAXDEPTH', if you do not define it, is 10000. 411 */ 412 #define YYMAXDEPTH MAX_INT_VAL 413 414 extern int yylineno; 415 extern FILE* yyin; 416 417 const char * currid; 418 BOOLEAN yyInRingConstruction=FALSE; 419 BOOLEAN expected_parms; 420 int cmdtok; 421 int inerror = 0; 422 423 #define TESTSETINT(a,i) \ 424 if ((a).Typ() != INT_CMD) \ 425 { \ 426 WerrorS("no int expression"); \ 427 YYERROR; \ 428 } \ 429 (i) = (int)((long)(a).Data());(a).CleanUp() 430 431 #define MYYERROR(a) { WerrorS(a); YYERROR; } 432 433 void yyerror(const char * fmt) 434 { 435 436 BOOLEAN old_errorreported=errorreported; 437 errorreported = TRUE; 438 if (currid!=NULL) 439 { 440 killid(currid,&IDROOT); 441 currid = NULL; 442 } 443 if(inerror==0) 444 { 445 { 446 if ((strlen(fmt)>1) 447 && (strncmp(fmt,"parse",5)!=0) 448 && (strncmp(fmt,"syntax",6)!=0)) 449 WerrorS(fmt); 450 Werror( "error occurred in or before %s line %d: `%s`" 451 ,VoiceName(), yylineno, my_yylinebuf); 452 } 453 if (cmdtok!=0) 454 { 455 const char *s=Tok2Cmdname(cmdtok); 456 if (expected_parms) 457 { 458 Werror("expected %s-expression. type \'help %s;\'",s,s); 459 } 460 else 461 { 462 Werror("wrong type declaration. type \'help %s;\'",s); 463 } 464 } 465 if (!old_errorreported && (lastreserved!=NULL)) 466 { 467 Werror("last reserved name was `%s`",lastreserved); 468 } 469 inerror=1; 470 } 471 if ((currentVoice!=NULL) 472 && (currentVoice->prev!=NULL) 473 && (myynest>0) 474 #ifdef HAVE_SDB 475 && ((sdb_flags &1)==0) 476 #endif 477 ) 478 { 479 Werror("leaving %s",VoiceName()); 480 } 481 #ifdef HAVE_FACTORY 482 // libfac: 483 #ifdef HAVE_LIBFAC 484 extern int libfac_interruptflag; 485 libfac_interruptflag=0; 486 #endif // #ifdef HAVE_LIBFAC 487 #endif 488 } 489 490 491 492 /* Enabling traces. */ 493 #ifndef YYDEBUG 494 # define YYDEBUG 1 495 #endif 496 497 /* Enabling verbose error messages. */ 498 #ifdef YYERROR_VERBOSE 499 # undef YYERROR_VERBOSE 500 # define YYERROR_VERBOSE 1 501 #else 502 # define YYERROR_VERBOSE 0 503 #endif 504 505 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) 506 typedef int YYSTYPE; 407 507 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 408 508 # define YYSTYPE_IS_DECLARED 1 509 # define YYSTYPE_IS_TRIVIAL 1 409 510 #endif 410 511 411 512 513 412 514 /* Copy the second part of user declarations. */ 413 515 414 516 415 /* Line 264 of yacc.c */ 416 #line 416 "grammar.cc" 417 418 #ifdef short 419 # undef short 420 #endif 421 422 #ifdef YYTYPE_UINT8 423 typedef YYTYPE_UINT8 yytype_uint8; 424 #else 425 typedef unsigned char yytype_uint8; 426 #endif 427 428 #ifdef YYTYPE_INT8 429 typedef YYTYPE_INT8 yytype_int8; 430 #elif (defined __STDC__ || defined __C99__FUNC__ \ 431 || defined __cplusplus || defined _MSC_VER) 432 typedef signed char yytype_int8; 433 #else 434 typedef short int yytype_int8; 435 #endif 436 437 #ifdef YYTYPE_UINT16 438 typedef YYTYPE_UINT16 yytype_uint16; 439 #else 440 typedef unsigned short int yytype_uint16; 441 #endif 442 443 #ifdef YYTYPE_INT16 444 typedef YYTYPE_INT16 yytype_int16; 445 #else 446 typedef short int yytype_int16; 447 #endif 448 449 #ifndef YYSIZE_T 450 # ifdef __SIZE_TYPE__ 451 # define YYSIZE_T __SIZE_TYPE__ 452 # elif defined size_t 453 # define YYSIZE_T size_t 454 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 455 || defined __cplusplus || defined _MSC_VER) 456 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 457 # define YYSIZE_T size_t 458 # else 459 # define YYSIZE_T unsigned int 517 /* Line 214 of yacc.c. */ 518 #line 519 "grammar.cc" 519 520 #if ! defined (yyoverflow) || YYERROR_VERBOSE 521 522 # ifndef YYFREE 523 # define YYFREE free 460 524 # endif 461 #endif 462 463 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 464 465 #ifndef YY_ 466 # if defined YYENABLE_NLS && YYENABLE_NLS 467 # if ENABLE_NLS 468 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 469 # define YY_(msgid) dgettext ("bison-runtime", msgid) 470 # endif 525 # ifndef YYMALLOC 526 # define YYMALLOC malloc 471 527 # endif 472 # ifndef YY_473 # define YY_(msgid) msgid474 # endif475 #endif476 477 /* Suppress unused-variable warnings by "using" E. */478 #if ! defined lint || defined __GNUC__479 # define YYUSE(e) ((void) (e))480 #else481 # define YYUSE(e) /* empty */482 #endif483 484 /* Identity function, used to suppress warnings about constant conditions. */485 #ifndef lint486 # define YYID(n) (n)487 #else488 #if (defined __STDC__ || defined __C99__FUNC__ \489 || defined __cplusplus || defined _MSC_VER)490 static int491 YYID (int yyi)492 #else493 static int494 YYID (yyi)495 int yyi;496 #endif497 {498 return yyi;499 }500 #endif501 502 #if ! defined yyoverflow || YYERROR_VERBOSE503 528 504 529 /* The parser invokes alloca or malloc; define the necessary symbols. */ … … 506 531 # ifdef YYSTACK_USE_ALLOCA 507 532 # if YYSTACK_USE_ALLOCA 533 # define YYSTACK_ALLOC alloca 534 # endif 535 # else 536 # if defined (alloca) || defined (_ALLOCA_H) 537 # define YYSTACK_ALLOC alloca 538 # else 508 539 # ifdef __GNUC__ 509 540 # define YYSTACK_ALLOC __builtin_alloca 510 # elif defined __BUILTIN_VA_ARG_INCR511 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */512 # elif defined _AIX513 # define YYSTACK_ALLOC __alloca514 # elif defined _MSC_VER515 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */516 # define alloca _alloca517 # else518 # define YYSTACK_ALLOC alloca519 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \520 || defined __cplusplus || defined _MSC_VER)521 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */522 # ifndef _STDLIB_H523 # define _STDLIB_H 1524 # endif525 # endif526 541 # endif 527 542 # endif … … 529 544 530 545 # ifdef YYSTACK_ALLOC 531 /* Pacify GCC's `empty if-body' warning. */ 532 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 533 # ifndef YYSTACK_ALLOC_MAXIMUM 534 /* The OS might guarantee only one guard page at the bottom of the stack, 535 and a page size can be as small as 4096 bytes. So we cannot safely 536 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 537 to allow for a few compiler-allocated temporary stack slots. */ 538 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 546 /* Pacify GCC's `empty if-body' warning. */ 547 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 548 # else 549 # if defined (__STDC__) || defined (__cplusplus) 550 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 551 # define YYSIZE_T size_t 539 552 # endif 540 # else541 553 # define YYSTACK_ALLOC YYMALLOC 542 554 # define YYSTACK_FREE YYFREE 543 # ifndef YYSTACK_ALLOC_MAXIMUM544 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM545 # endif546 # if (defined __cplusplus && ! defined _STDLIB_H \547 && ! ((defined YYMALLOC || defined malloc) \548 && (defined YYFREE || defined free)))549 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */550 # ifndef _STDLIB_H551 # define _STDLIB_H 1552 # endif553 # endif554 # ifndef YYMALLOC555 # define YYMALLOC malloc556 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \557 || defined __cplusplus || defined _MSC_VER)558 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */559 # endif560 # endif561 # ifndef YYFREE562 # define YYFREE free563 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \564 || defined __cplusplus || defined _MSC_VER)565 void free (void *); /* INFRINGES ON USER NAME SPACE */566 # endif567 # endif568 555 # endif 569 #endif /* ! defined yyoverflow|| YYERROR_VERBOSE */570 571 572 #if (! defined yyoverflow\573 && (! defined __cplusplus\574 || (defined YYSTYPE_IS_TRIVIAL&& YYSTYPE_IS_TRIVIAL)))556 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ 557 558 559 #if (! defined (yyoverflow) \ 560 && (! defined (__cplusplus) \ 561 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) 575 562 576 563 /* A type that is properly aligned for any stack member. */ 577 564 union yyalloc 578 565 { 579 yytype_int16 yyss_alloc;580 YYSTYPE yyvs _alloc;581 };566 short int yyss; 567 YYSTYPE yyvs; 568 }; 582 569 583 570 /* The size of the maximum gap between one aligned stack and the next. */ … … 587 574 N elements. */ 588 575 # define YYSTACK_BYTES(N) \ 589 ((N) * (sizeof ( yytype_int16) + sizeof (YYSTYPE))\576 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \ 590 577 + YYSTACK_GAP_MAXIMUM) 591 578 … … 593 580 not overlap. */ 594 581 # ifndef YYCOPY 595 # if defined __GNUC__&& 1 < __GNUC__582 # if defined (__GNUC__) && 1 < __GNUC__ 596 583 # define YYCOPY(To, From, Count) \ 597 584 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) … … 600 587 do \ 601 588 { \ 602 YYSIZE_T yyi;\589 register YYSIZE_T yyi; \ 603 590 for (yyi = 0; yyi < (Count); yyi++) \ 604 591 (To)[yyi] = (From)[yyi]; \ 605 592 } \ 606 while ( YYID (0))593 while (0) 607 594 # endif 608 595 # endif … … 613 600 stack. Advance YYPTR to a properly aligned location for the next 614 601 stack. */ 615 # define YYSTACK_RELOCATE(Stack _alloc, Stack)\602 # define YYSTACK_RELOCATE(Stack) \ 616 603 do \ 617 604 { \ 618 605 YYSIZE_T yynewbytes; \ 619 YYCOPY (&yyptr->Stack _alloc, Stack, yysize);\620 Stack = &yyptr->Stack _alloc;\606 YYCOPY (&yyptr->Stack, Stack, yysize); \ 607 Stack = &yyptr->Stack; \ 621 608 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 622 609 yyptr += yynewbytes / sizeof (*yyptr); \ 623 610 } \ 624 while ( YYID (0))611 while (0) 625 612 626 613 #endif 627 614 628 /* YYFINAL -- State number of the termination state. */ 615 #if defined (__STDC__) || defined (__cplusplus) 616 typedef signed char yysigned_char; 617 #else 618 typedef short int yysigned_char; 619 #endif 620 621 /* YYFINAL -- State number of the termination state. */ 629 622 #define YYFINAL 2 630 623 /* YYLAST -- Last index in YYTABLE. */ 631 #define YYLAST 18 14632 633 /* YYNTOKENS -- Number of terminals. 634 #define YYNTOKENS 14 7635 /* YYNNTS -- Number of nonterminals. 624 #define YYLAST 1807 625 626 /* YYNTOKENS -- Number of terminals. */ 627 #define YYNTOKENS 148 628 /* YYNNTS -- Number of nonterminals. */ 636 629 #define YYNNTS 44 637 /* YYNRULES -- Number of rules. 630 /* YYNRULES -- Number of rules. */ 638 631 #define YYNRULES 164 639 /* YYNRULES -- Number of states. 632 /* YYNRULES -- Number of states. */ 640 633 #define YYNSTATES 355 641 634 642 635 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 643 636 #define YYUNDEFTOK 2 644 #define YYMAXUTOK 38 3645 646 #define YYTRANSLATE(YYX) \637 #define YYMAXUTOK 384 638 639 #define YYTRANSLATE(YYX) \ 647 640 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 648 641 649 642 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 650 static const yytype_uint8yytranslate[] =643 static const unsigned char yytranslate[] = 651 644 { 652 645 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 653 646 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 654 647 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 655 2, 2, 2, 2, 2, 2, 2, 2, 1 39, 2,656 14 3, 144, 141, 131, 137, 132, 145, 133, 2, 2,657 2, 2, 2, 2, 2, 2, 2, 2, 14 0, 138,658 1 29, 128, 130, 2, 2, 2, 2, 2, 2, 2,648 2, 2, 2, 2, 2, 2, 2, 2, 140, 2, 649 144, 145, 142, 132, 138, 133, 146, 134, 2, 2, 650 2, 2, 2, 2, 2, 2, 2, 2, 141, 139, 651 130, 129, 131, 2, 2, 2, 2, 2, 2, 2, 659 652 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 660 653 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 661 2, 13 4, 2, 135, 136, 2, 146, 2, 2, 2,654 2, 135, 2, 136, 137, 2, 147, 2, 2, 2, 662 655 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 663 656 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, … … 688 681 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 689 682 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 690 125, 126, 127, 1 42683 125, 126, 127, 128, 143 691 684 }; 692 685 … … 694 687 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 695 688 YYRHS. */ 696 static const yytype_uint16yyprhs[] =689 static const unsigned short int yyprhs[] = 697 690 { 698 691 0, 0, 3, 4, 7, 9, 12, 15, 17, 19, … … 715 708 }; 716 709 717 /* YYRHS -- A `-1'-separated list of the rules' RHS. 718 static const yytype_int16yyrhs[] =710 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 711 static const short int yyrhs[] = 719 712 { 720 14 8, 0, -1, -1, 148, 149, -1, 150, -1, 152,721 13 8, -1, 163, 138, -1, 190, -1, 123, -1, 138,722 -1, 1, 13 8, -1, 185, -1, 186, -1, 151, -1,723 18 7, -1, 188, -1, 172, -1, 174, -1, 175, -1,724 10 2, 111, -1, 153, -1, 176, -1, 177, -1, 178,725 -1, 1 89, -1, 180, -1, 181, -1, 183, -1, 184,726 -1, 16 1, 155, -1, 114, -1, 162, -1, 154, 11,727 15 4, -1, 154, 145, 154, -1, 154, 143, 144, -1,728 15 4, 143, 155, 144, -1, 134, 155, 135, -1, 112,729 -1, 12 7, -1, 164, -1, 15, 143, 156, 144, -1,730 15 5, 137, 156, -1, 156, -1, 160, -1, 154, -1,731 14 3, 155, 144, -1, 156, 134, 156, 137, 156, 135,732 -1, 15 6, 134, 156, 135, -1, 98, 143, 156, 144,733 -1, 99, 143, 155, 144, -1, 99, 143, 144, -1,734 10 0, 143, 156, 144, -1, 101, 143, 155, 144, -1,735 10 1, 143, 144, -1, 90, 143, 156, 144, -1, 91,736 14 3, 156, 137, 156, 144, -1, 92, 143, 156, 137,737 15 6, 137, 156, 144, -1, 95, 143, 156, 137, 156,738 14 4, -1, 95, 143, 156, 137, 156, 137, 156, 144,739 -1, 9 3, 143, 156, 144, -1, 94, 143, 156, 144,740 -1, 9 3, 143, 156, 137, 156, 144, -1, 96, 143,741 15 6, 144, -1, 96, 143, 156, 137, 156, 144, -1,742 9 4, 143, 156, 137, 156, 137, 156, 144, -1, 96,743 14 3, 156, 137, 156, 137, 156, 144, -1, 97, 143,744 14 4, -1, 97, 143, 155, 144, -1, 171, 143, 156,745 13 7, 156, 137, 156, 144, -1, 171, 143, 156, 144,746 -1, 16, 14 3, 165, 137, 165, 137, 169, 144, -1,747 16, 14 3, 156, 144, -1, 158, 156, 159, -1, 158,748 15 6, 128, 156, 159, -1, -1, 119, 143, 157, 156,749 14 4, -1, 120, 143, -1, 144, -1, 156, 10, -1,750 15 6, 7, -1, 156, 131, 156, -1, 156, 132, 156,751 -1, 15 6, 133, 156, -1, 156, 136, 156, -1, 156,752 1 29, 156, -1, 156, 139, 156, -1, 156, 9, 156,753 -1, 15 6, 4, 156, -1, 156, 3, 156, -1, 156,754 14 0, 156, -1, 8, 156, -1, 132, 156, -1, 163,755 17 0, -1, 155, 128, -1, 113, -1, 146, 156, 146,756 -1, 9 8, 154, -1, 99, 154, -1, 100, 154, -1,757 10 1, 154, -1, 171, 154, 134, 156, 135, 134, 156,758 13 5, -1, 171, 154, -1, 163, 137, 154, -1, 15,759 15 4, -1, 110, -1, 156, -1, 143, 156, 137, 155,760 14 4, -1, 113, -1, 166, -1, 166, 143, 155, 144,761 -1, 16 7, -1, 167, 137, 168, -1, 167, -1, 143,762 16 8, 144, -1, 128, -1, 20, -1, 14, -1, 13,763 -1, -1, 1 29, 164, 173, 138, -1, 104, 110, 138,764 -1, 10 4, 138, -1, 102, 110, 138, -1, 103, 155,765 -1, 10 5, 154, -1, 177, 137, 154, -1, 107, 143,766 9 8, 144, -1, 107, 143, 99, 144, -1, 107, 143,767 10 0, 144, -1, 107, 143, 101, 144, -1, 107, 143,768 16, 14 4, -1, 107, 143, 171, 144, -1, 107, 143,769 15, 14 4, -1, 107, 143, 154, 144, -1, 107, 143,770 15 4, 137, 98, 144, -1, 107, 143, 154, 137, 99,771 14 4, -1, 107, 143, 154, 137, 100, 144, -1, 107,772 14 3, 154, 137, 101, 144, -1, 107, 143, 154, 137,773 16, 14 4, -1, 107, 143, 154, 137, 171, 144, -1,774 10 7, 143, 154, 137, 15, 144, -1, 107, 143, 144,775 -1, 16, -1, 1 79, 154, 170, 165, 137, 165, 137,776 1 69, -1, 179, 154, -1, 127, 164, -1, 108, -1,777 40, -1, 18 2, 156, -1, 109, 156, -1, 155, -1,778 12 2, 143, 156, 144, 111, -1, 118, 111, -1, 122,779 14 3, 156, 144, 116, -1, 116, -1, 117, -1, 124,780 11 0, 111, -1, 121, 110, 110, 110, 111, -1, 15,781 16 2, 111, -1, 115, 110, 111, -1, 115, 110, 110,782 11 1, -1, 126, 163, -1, 126, 156, -1, 125, 143,783 15 5, 144, -1, 125, 143, 144, -1713 149, 0, -1, -1, 149, 150, -1, 151, -1, 153, 714 139, -1, 164, 139, -1, 191, -1, 124, -1, 139, 715 -1, 1, 139, -1, 186, -1, 187, -1, 152, -1, 716 188, -1, 189, -1, 173, -1, 175, -1, 176, -1, 717 103, 112, -1, 154, -1, 177, -1, 178, -1, 179, 718 -1, 190, -1, 181, -1, 182, -1, 184, -1, 185, 719 -1, 162, 156, -1, 115, -1, 163, -1, 155, 11, 720 155, -1, 155, 146, 155, -1, 155, 144, 145, -1, 721 155, 144, 156, 145, -1, 135, 156, 136, -1, 113, 722 -1, 128, -1, 165, -1, 15, 144, 157, 145, -1, 723 156, 138, 157, -1, 157, -1, 161, -1, 155, -1, 724 144, 156, 145, -1, 157, 135, 157, 138, 157, 136, 725 -1, 157, 135, 157, 136, -1, 99, 144, 157, 145, 726 -1, 100, 144, 156, 145, -1, 100, 144, 145, -1, 727 101, 144, 157, 145, -1, 102, 144, 156, 145, -1, 728 102, 144, 145, -1, 91, 144, 157, 145, -1, 92, 729 144, 157, 138, 157, 145, -1, 93, 144, 157, 138, 730 157, 138, 157, 145, -1, 96, 144, 157, 138, 157, 731 145, -1, 96, 144, 157, 138, 157, 138, 157, 145, 732 -1, 94, 144, 157, 145, -1, 95, 144, 157, 145, 733 -1, 94, 144, 157, 138, 157, 145, -1, 97, 144, 734 157, 145, -1, 97, 144, 157, 138, 157, 145, -1, 735 95, 144, 157, 138, 157, 138, 157, 145, -1, 97, 736 144, 157, 138, 157, 138, 157, 145, -1, 98, 144, 737 145, -1, 98, 144, 156, 145, -1, 172, 144, 157, 738 138, 157, 138, 157, 145, -1, 172, 144, 157, 145, 739 -1, 16, 144, 166, 138, 166, 138, 170, 145, -1, 740 16, 144, 157, 145, -1, 159, 157, 160, -1, 159, 741 157, 129, 157, 160, -1, -1, 120, 144, 158, 157, 742 145, -1, 121, 144, -1, 145, -1, 157, 10, -1, 743 157, 7, -1, 157, 132, 157, -1, 157, 133, 157, 744 -1, 157, 134, 157, -1, 157, 137, 157, -1, 157, 745 130, 157, -1, 157, 140, 157, -1, 157, 9, 157, 746 -1, 157, 4, 157, -1, 157, 3, 157, -1, 157, 747 141, 157, -1, 8, 157, -1, 133, 157, -1, 164, 748 171, -1, 156, 129, -1, 114, -1, 147, 157, 147, 749 -1, 99, 155, -1, 100, 155, -1, 101, 155, -1, 750 102, 155, -1, 172, 155, 135, 157, 136, 135, 157, 751 136, -1, 172, 155, -1, 164, 138, 155, -1, 15, 752 155, -1, 111, -1, 157, -1, 144, 157, 138, 156, 753 145, -1, 114, -1, 167, -1, 167, 144, 156, 145, 754 -1, 168, -1, 168, 138, 169, -1, 168, -1, 144, 755 169, 145, -1, 129, -1, 20, -1, 14, -1, 13, 756 -1, -1, 130, 165, 174, 139, -1, 105, 111, 139, 757 -1, 105, 139, -1, 103, 111, 139, -1, 104, 156, 758 -1, 106, 155, -1, 178, 138, 155, -1, 108, 144, 759 99, 145, -1, 108, 144, 100, 145, -1, 108, 144, 760 101, 145, -1, 108, 144, 102, 145, -1, 108, 144, 761 16, 145, -1, 108, 144, 172, 145, -1, 108, 144, 762 15, 145, -1, 108, 144, 155, 145, -1, 108, 144, 763 155, 138, 99, 145, -1, 108, 144, 155, 138, 100, 764 145, -1, 108, 144, 155, 138, 101, 145, -1, 108, 765 144, 155, 138, 102, 145, -1, 108, 144, 155, 138, 766 16, 145, -1, 108, 144, 155, 138, 172, 145, -1, 767 108, 144, 155, 138, 15, 145, -1, 108, 144, 145, 768 -1, 16, -1, 180, 155, 171, 166, 138, 166, 138, 769 170, -1, 180, 155, -1, 128, 165, -1, 109, -1, 770 40, -1, 183, 157, -1, 110, 157, -1, 156, -1, 771 123, 144, 157, 145, 112, -1, 119, 112, -1, 123, 772 144, 157, 145, 117, -1, 117, -1, 118, -1, 125, 773 111, 112, -1, 122, 111, 111, 111, 112, -1, 15, 774 163, 112, -1, 116, 111, 112, -1, 116, 111, 111, 775 112, -1, 127, 164, -1, 127, 157, -1, 126, 144, 776 156, 145, -1, 126, 144, 145, -1 784 777 }; 785 778 786 779 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 787 static const yytype_uint16yyrline[] =780 static const unsigned short int yyrline[] = 788 781 { 789 0, 36 3, 363, 365, 399, 400, 402, 404, 408, 413,790 41 5, 466, 467, 468, 469, 470, 471, 472, 473, 477,791 48 0, 481, 482, 483, 484, 485, 486, 487, 488, 491,792 49 8, 503, 507, 511, 515, 519, 532, 560, 584, 590,793 59 6, 603, 614, 620, 625, 626, 627, 631, 635, 639,794 64 3, 647, 651, 655, 659, 663, 667, 671, 675, 679,795 68 3, 687, 691, 695, 699, 703, 707, 711, 715, 719,796 72 3, 727, 731, 735, 753, 752, 770, 778, 787, 791,797 79 5, 799, 803, 807, 811, 815, 819, 823, 827, 831,798 83 5, 842, 849, 850, 869, 870, 882, 887, 892, 896,799 90 0, 940, 966, 987, 995, 999, 1000, 1014, 1022, 1031,800 107 6, 1077, 1086, 1087, 1093, 1099, 1101, 1103, 1113, 1112,801 112 0, 1125, 1132, 1140, 1152, 1168, 1187, 1191, 1195, 1200,802 120 4, 1208, 1212, 1216, 1221, 1227, 1233, 1239, 1245, 1251,803 125 7, 1269, 1276, 1280, 1317, 1327, 1340, 1340, 1343, 1415,804 141 9, 1448, 1461, 1478, 1487, 1492, 1500, 1512, 1531, 1542,805 15 62, 1586, 1592, 1604, 1611782 0, 364, 364, 366, 400, 401, 403, 405, 409, 414, 783 416, 467, 468, 469, 470, 471, 472, 473, 474, 478, 784 481, 482, 483, 484, 485, 486, 487, 488, 489, 492, 785 499, 504, 508, 512, 516, 520, 533, 561, 585, 591, 786 597, 604, 615, 621, 626, 627, 628, 632, 636, 640, 787 644, 648, 652, 656, 660, 664, 668, 672, 676, 680, 788 684, 688, 692, 696, 700, 704, 708, 712, 716, 720, 789 724, 728, 732, 736, 754, 753, 771, 779, 788, 792, 790 796, 800, 804, 808, 812, 816, 820, 824, 828, 832, 791 836, 843, 850, 851, 870, 871, 883, 888, 893, 897, 792 901, 941, 967, 988, 996, 1000, 1001, 1015, 1023, 1032, 793 1077, 1078, 1087, 1088, 1094, 1100, 1102, 1104, 1114, 1113, 794 1121, 1126, 1133, 1141, 1153, 1169, 1188, 1192, 1196, 1201, 795 1205, 1209, 1213, 1217, 1222, 1228, 1234, 1240, 1246, 1252, 796 1258, 1270, 1277, 1281, 1318, 1328, 1334, 1334, 1337, 1409, 797 1413, 1442, 1455, 1472, 1481, 1486, 1494, 1506, 1525, 1535, 798 1554, 1577, 1583, 1595, 1601 806 799 }; 807 800 #endif 808 801 809 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE810 /* YYTN AME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.811 First, the terminals, then, starting at YYNTOKENS, nonterminals. 802 #if YYDEBUG || YYERROR_VERBOSE 803 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 804 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 812 805 static const char *const yytname[] = 813 806 { … … 826 819 "MONOM_CMD", "MRES_CMD", "MULTIPLICITY_CMD", "ORD_CMD", "PAR_CMD", 827 820 "PARDEG_CMD", "PREIMAGE_CMD", "QUOTIENT_CMD", "QHWEIGHT_CMD", 828 "REDUCE_CMD", "REGULARITY_CMD", "RES_CMD", "SIMPLIFY_CMD", "SORTVEC_CMD", 829 "SRES_CMD", "STD_CMD", "SUBST_CMD", "SYZYGY_CMD", "VAR_CMD", "VDIM_CMD", 830 "WEDGE_CMD", "WEIGHT_CMD", "VALTVARS", "VMAXDEG", "VMAXMULT", "VNOETHER", 831 "VMINPOLY", "END_RING", "CMD_1", "CMD_2", "CMD_3", "CMD_12", "CMD_13", 832 "CMD_23", "CMD_123", "CMD_M", "ROOT_DECL", "ROOT_DECL_LIST", "RING_DECL", 833 "RING_DECL_LIST", "EXAMPLE_CMD", "EXPORT_CMD", "HELP_CMD", "KILL_CMD", 834 "LIB_CMD", "LISTVAR_CMD", "SETRING_CMD", "TYPE_CMD", "STRINGTOK", 835 "BLOCKTOK", "INT_CONST", "UNKNOWN_IDENT", "RINGVAR", "PROC_DEF", 836 "BREAK_CMD", "CONTINUE_CMD", "ELSE_CMD", "EVAL", "QUOTE", "FOR_CMD", 837 "IF_CMD", "SYS_BREAK", "WHILE_CMD", "RETURN", "PARAMETER", "SYSVAR", 838 "'='", "'<'", "'>'", "'+'", "'-'", "'/'", "'['", "']'", "'^'", "','", 839 "';'", "'&'", "':'", "'*'", "UMINUS", "'('", "')'", "'.'", "'`'", 840 "$accept", "lines", "pprompt", "flowctrl", "example_dummy", "command", 841 "assign", "elemexpr", "exprlist", "expr", "$@1", "quote_start", 842 "quote_end", "expr_arithmetic", "left_value", "extendedid", 843 "declare_ip_variable", "stringexpr", "rlist", "ordername", "orderelem", 844 "OrderingList", "ordering", "cmdeq", "mat_cmd", "filecmd", "$@2", 845 "helpcmd", "examplecmd", "exportcmd", "killcmd", "listcmd", "ringcmd1", 846 "ringcmd", "scriptcmd", "setrings", "setringcmd", "typecmd", "ifcmd", 847 "whilecmd", "forcmd", "proccmd", "parametercmd", "returncmd", 0 821 "REDUCE_CMD", "REGULARITY_CMD", "RES_CMD", "SBA_CMD", "SIMPLIFY_CMD", 822 "SORTVEC_CMD", "SRES_CMD", "STD_CMD", "SUBST_CMD", "SYZYGY_CMD", 823 "VAR_CMD", "VDIM_CMD", "WEDGE_CMD", "WEIGHT_CMD", "VALTVARS", "VMAXDEG", 824 "VMAXMULT", "VNOETHER", "VMINPOLY", "END_RING", "CMD_1", "CMD_2", 825 "CMD_3", "CMD_12", "CMD_13", "CMD_23", "CMD_123", "CMD_M", "ROOT_DECL", 826 "ROOT_DECL_LIST", "RING_DECL", "RING_DECL_LIST", "EXAMPLE_CMD", 827 "EXPORT_CMD", "HELP_CMD", "KILL_CMD", "LIB_CMD", "LISTVAR_CMD", 828 "SETRING_CMD", "TYPE_CMD", "STRINGTOK", "BLOCKTOK", "INT_CONST", 829 "UNKNOWN_IDENT", "RINGVAR", "PROC_DEF", "BREAK_CMD", "CONTINUE_CMD", 830 "ELSE_CMD", "EVAL", "QUOTE", "FOR_CMD", "IF_CMD", "SYS_BREAK", 831 "WHILE_CMD", "RETURN", "PARAMETER", "SYSVAR", "'='", "'<'", "'>'", "'+'", 832 "'-'", "'/'", "'['", "']'", "'^'", "','", "';'", "'&'", "':'", "'*'", 833 "UMINUS", "'('", "')'", "'.'", "'`'", "$accept", "lines", "pprompt", 834 "flowctrl", "example_dummy", "command", "assign", "elemexpr", "exprlist", 835 "expr", "@1", "quote_start", "quote_end", "expr_arithmetic", 836 "left_value", "extendedid", "declare_ip_variable", "stringexpr", "rlist", 837 "ordername", "orderelem", "OrderingList", "ordering", "cmdeq", "mat_cmd", 838 "filecmd", "@2", "helpcmd", "examplecmd", "exportcmd", "killcmd", 839 "listcmd", "ringcmd1", "ringcmd", "scriptcmd", "setrings", "setringcmd", 840 "typecmd", "ifcmd", "whilecmd", "forcmd", "proccmd", "parametercmd", 841 "returncmd", 0 848 842 }; 849 843 #endif … … 852 846 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 853 847 token YYLEX-NUM. */ 854 static const yytype_uint16yytoknum[] =848 static const unsigned short int yytoknum[] = 855 849 { 856 850 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, … … 866 860 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 867 861 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 868 375, 376, 377, 378, 379, 380, 381, 382, 61, 60,869 6 2, 43, 45, 47, 91, 93, 94, 44, 59, 38,870 58, 42, 383, 40, 41, 46, 96862 375, 376, 377, 378, 379, 380, 381, 382, 383, 61, 863 60, 62, 43, 45, 47, 91, 93, 94, 44, 59, 864 38, 58, 42, 384, 40, 41, 46, 96 871 865 }; 872 866 # endif 873 867 874 868 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 875 static const yytype_uint8yyr1[] =869 static const unsigned char yyr1[] = 876 870 { 877 0, 14 7, 148, 148, 149, 149, 149, 149, 149, 149,878 1 49, 150, 150, 150, 150, 150, 150, 150, 150, 151,879 15 2, 152, 152, 152, 152, 152, 152, 152, 152, 153,880 15 4, 154, 154, 154, 154, 154, 154, 154, 154, 154,881 15 4, 155, 155, 156, 156, 156, 156, 156, 156, 156,882 15 6, 156, 156, 156, 156, 156, 156, 156, 156, 156,883 15 6, 156, 156, 156, 156, 156, 156, 156, 156, 156,884 15 6, 156, 156, 156, 157, 156, 158, 159, 160, 160,885 16 0, 160, 160, 160, 160, 160, 160, 160, 160, 160,886 16 0, 160, 161, 161, 162, 162, 163, 163, 163, 163,887 16 3, 163, 163, 163, 164, 165, 165, 166, 167, 167,888 16 8, 168, 169, 169, 170, 171, 171, 171, 173, 172,889 17 4, 174, 175, 176, 177, 177, 178, 178, 178, 178,890 17 8, 178, 178, 178, 178, 178, 178, 178, 178, 178,891 17 8, 178, 179, 180, 180, 181, 182, 182, 183, 184,892 18 4, 185, 185, 185, 185, 185, 186, 187, 188, 188,893 18 8, 189, 189, 190, 190871 0, 148, 149, 149, 150, 150, 150, 150, 150, 150, 872 150, 151, 151, 151, 151, 151, 151, 151, 151, 152, 873 153, 153, 153, 153, 153, 153, 153, 153, 153, 154, 874 155, 155, 155, 155, 155, 155, 155, 155, 155, 155, 875 155, 156, 156, 157, 157, 157, 157, 157, 157, 157, 876 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 877 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 878 157, 157, 157, 157, 158, 157, 159, 160, 161, 161, 879 161, 161, 161, 161, 161, 161, 161, 161, 161, 161, 880 161, 161, 162, 162, 163, 163, 164, 164, 164, 164, 881 164, 164, 164, 164, 165, 166, 166, 167, 168, 168, 882 169, 169, 170, 170, 171, 172, 172, 172, 174, 173, 883 175, 175, 176, 177, 178, 178, 179, 179, 179, 179, 884 179, 179, 179, 179, 179, 179, 179, 179, 179, 179, 885 179, 179, 180, 181, 181, 182, 183, 183, 184, 185, 886 185, 186, 186, 186, 186, 186, 187, 188, 189, 189, 887 189, 190, 190, 191, 191 894 888 }; 895 889 896 890 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 897 static const yytype_uint8yyr2[] =891 static const unsigned char yyr2[] = 898 892 { 899 893 0, 2, 0, 2, 1, 2, 2, 1, 1, 1, … … 919 913 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 920 914 means the default is an error. */ 921 static const yytype_uint8yydefact[] =915 static const unsigned char yydefact[] = 922 916 { 923 917 2, 0, 1, 0, 0, 117, 116, 0, 142, 115, … … 959 953 }; 960 954 961 /* YYDEFGOTO[NTERM-NUM]. 962 static const yytype_int16yydefgoto[] =955 /* YYDEFGOTO[NTERM-NUM]. */ 956 static const short int yydefgoto[] = 963 957 { 964 958 -1, 1, 53, 54, 55, 56, 57, 58, 139, 60, … … 971 965 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 972 966 STATE-NUM. */ 973 #define YYPACT_NINF -31 9974 static const yytype_int16yypact[] =967 #define YYPACT_NINF -313 968 static const short int yypact[] = 975 969 { 976 -31 9, 253, -319, -134, 1202, -319, -319, 366, -129, -319,977 -31 9, -125, -121, -105, -100, -69, -63, -60, -52, 890,978 1 527, 1566, 1650, -54, 1202, -107, 1427, -50, -319, 1202,979 -31 9, -319, -319, -319, -80, -319, -319, -53, -49, -46,980 -12, -43, -319, -7, -39, 1260, -5, -5, 1202, 1202,981 -31 9, 1202, 1202, -319, -319, -319, -77, -319, 2, -113,982 15 89, 1202, -319, 1202, -319, -87, -319, 1660, -319, -319,983 -31 9, -319, -30, -319, 1427, -319, -319, 1202, -319, -319,984 -31 9, -319, -319, -319, -319, -319, -319, -35, -129, -31,985 -19, -18, -17, -319, 19, -15, 1202, 2, 23, 1317,986 1 202, 1202, 1202, 1202, 1202, 1202, 1202, 915, 1202, 2,987 9 72, 2, 1202, 2, 1030, 2, -28, -319, -8, 11,988 -31 9, 2, 1668, 1589, -33, -319, -319, -319, 30, 1202,989 46, 1087, 366, 1589, 22, -319, -319, 19, -82, -117,990 61, -31 9, 1427, 1145, 1427, -319, 1202, 1202, 1202, -319,991 1 202, -319, 1202, 1202, 1202, 1202, 1202, 1202, 1202, 1202,992 92, -8, -319, 1427, -319, -319, 1202, -2, 1427, 5,993 15 89, 443, -319, 1202, 464, 27, 478, 1337, 1359, 176,994 272, 1374, 291, -319, -98, 492, -319, -95, 523, -319,995 -9 0, -319, -319, -58, 16, 31, 32, 34, 40, -319,996 - 6, 45, 55, -319, 1202, 81, 537, -319, -319, -85,997 49, -319, -319, -319, 51, -319, -71, -319, 1589, 1613,998 77, 77, 403, 18, 18, 19, 827, 1, 1625, 18,999 1 202, -319, -319, 2, 326, 1202, 2, 1317, -319, 1386,1000 -31 9, 1317, -319, 1202, 1202, 1202, -319, 1202, -319, 1202,1001 1 202, -319, -319, -319, -319, -319, -319, -319, -319, -319,1002 -31 9, -319, -319, 633, -319, -319, -319, 581, 87, -99,1003 -31 9, -319, -319, -319, 1202, 630, 1202, -319, 1416, 1589,1004 62, 1202, 65, 675, 1431, 689, 1443, 385, 429, 59,1005 60, 68, 70, 71, 72, 74, -319, -319, -319, -319,1006 14 55, -319, 1475, 88, 1317, -65, -106, -319, 1202, -319,1007 1 202, 1202, -319, 1202, -319, -319, -319, -319, -319, -319,1008 -31 9, -319, -319, 1202, 1202, 90, -319, -319, 116, 91,1009 -31 9, 86, 719, 733, 747, 768, 782, 1524, -106, 96,1010 93, 1202, -319, -319, -319, -319, -319, -319, -319, -319,1011 1 16, -319, -62, -319, -319970 -313, 253, -313, -136, 1167, -313, -313, 849, -137, -313, 971 -313, -131, -126, -114, -103, -78, -70, -53, -45, 874, 972 1484, 1558, 1625, -33, 1167, -102, 674, -44, -313, 1167, 973 -313, -313, -313, -313, -54, -313, -313, -10, -39, -37, 974 13, -36, -313, 17, -34, 1224, 22, 22, 1167, 1167, 975 -313, 1167, 1167, -313, -313, -313, -27, -313, 1, -118, 976 1557, 1167, -313, 1167, -313, -124, -313, 1660, -313, -313, 977 -313, -313, -13, -313, 674, -313, -313, 1167, -313, -313, 978 -313, -313, -313, -313, -313, -313, -313, -18, -137, -15, 979 -9, -4, 16, -313, 62, 31, 1167, 1, 45, 1283, 980 1167, 1167, 1167, 1167, 1167, 1167, 1167, 826, 1167, 1, 981 935, 1, 1167, 1, 992, 1, -5, -313, 38, 39, 982 -313, 1, 1631, 1557, -26, -313, -313, -313, 73, 1167, 983 75, 1051, 849, 1557, 51, -313, -313, 62, -83, -121, 984 61, -313, 674, 1108, 674, -313, 1167, 1167, 1167, -313, 985 1167, -313, 1167, 1167, 1167, 1167, 1167, 1167, 1167, 1167, 986 80, 38, -313, 674, -313, -313, 1167, -3, 674, 20, 987 1557, 430, -313, 1167, 444, 52, 465, 1324, 1339, 94, 988 176, 1351, 272, -313, -99, 479, -313, -96, 493, -313, 989 -95, -313, -313, -51, 47, 55, 58, 66, 71, -313, 990 -7, 77, 106, -313, 1167, 95, 525, -313, -313, -91, 991 84, -313, -313, -313, 87, -313, -87, -313, 1557, 1581, 992 420, 420, 404, 70, 70, 62, 1303, 19, 18, 70, 993 1167, -313, -313, 1, 291, 1167, 1, 1283, -313, 1363, 994 -313, 1283, -313, 1167, 1167, 1167, -313, 1167, -313, 1167, 995 1167, -313, -313, -313, -313, -313, -313, -313, -313, -313, 996 -313, -313, -313, 634, -313, -313, -313, 539, 118, -56, 997 -313, -313, -313, -313, 1167, 583, 1167, -313, 1383, 1557, 998 98, 1167, 99, 632, 1398, 678, 1410, 326, 386, 93, 999 96, 97, 101, 102, 103, 104, -313, -313, -313, -313, 1000 1422, -313, 1442, 105, 1283, -86, -112, -313, 1167, -313, 1001 1167, 1167, -313, 1167, -313, -313, -313, -313, -313, -313, 1002 -313, -313, -313, 1167, 1167, 113, -313, -313, 129, 100, 1003 -313, 110, 692, 722, 736, 750, 771, 1502, -112, 119, 1004 125, 1167, -313, -313, -313, -313, -313, -313, -313, -313, 1005 129, -313, -63, -313, -313 1012 1006 }; 1013 1007 1014 1008 /* YYPGOTO[NTERM-NUM]. */ 1015 static const yytype_int16yypgoto[] =1009 static const short int yypgoto[] = 1016 1010 { 1017 -31 9, -319, -319, -319, -319, -319, -319, 14, -1, 15,1018 -31 9, -319, -70, -319, -319, 228, 193, 43, -235, -319,1019 -31 8, -111, -97, 73, 0, -319, -319, -319, -319, -319,1020 -31 9, -319, -319, -319, -319, -319, -319, -319, -319, -319,1021 -31 9, -319, -319, -3191011 -313, -313, -313, -313, -313, -313, -313, 14, -1, 15, 1012 -313, -313, 2, -313, -313, 264, 227, 49, -231, -313, 1013 -312, -76, -60, 114, 0, -313, -313, -313, -313, -313, 1014 -313, -313, -313, -313, -313, -313, -313, -313, -313, -313, 1015 -313, -313, -313, -313 1022 1016 }; 1023 1017 … … 1027 1021 If YYTABLE_NINF, syntax error. */ 1028 1022 #define YYTABLE_NINF -1 1029 static const yytype_int16yytable[] =1023 static const short int yytable[] = 1030 1024 { 1031 59, 67, 280, 119, 86, 142, 282, 327, 149, 142,1032 339, 151, 298, 142, 99, 145, 142, 299, 100, 94,1033 146, 97, 1 01, 118, 146, 149, 149, 212, 151, 151,1034 1 24, 120, 339, 109, 111, 113, 115, 328, 102, 146,1035 121, 1 62, 146, 103, 123, 67, 252, 146, 138, 254,1036 163, 164, 146, 211, 256, 146, 116, 117, 125, 270,1037 133, 141, 161, 137, 147, 148, 146, 140, 149, 325,1038 150, 151, 1 46, 272, 104, 146, 160, 202, 203, 326,1039 1 05, 167, 354, 106, 149, 96, 257, 151, 169, 135,1040 1 36, 107, 170, 122, 126, 147, 148, 127, 128, 149,1041 12 9, 150, 151, 130, 131, 30, 184, 168, 96, 187,1042 1 91, 171, 108, 190, 174, 176, 177, 178, 179, 180,1043 181, 182, 201, 185, 1 10, 112, 114, 188, 166, 146,1044 209, 263, 235, 162, 172, 156, 200, 143, 264, 144,1045 205, 143, 216, 144, 206, 143, 97, 144, 143, 192,1046 1 44, 155, 156, 156, 157, 157, 214, 207, 217, 163,1047 258, 218, 219, 220, 241, 221, 266, 222, 223, 224,1048 225, 226, 227, 228, 229, 259, 260, 233, 261, 147,1049 148, 234, 236, 149, 2 62, 150, 151, 271, 239, 265,1050 152, 268, 153, 154, 155, 156, 144, 157, 297, 304,1051 158, 159, 306, 315, 316, 301, 152, 213, 153, 154,1052 15 5, 156, 317, 157, 318, 319, 320, 159, 321, 267,1053 230, 152, 324, 153, 154, 155, 156, 338, 157, 327,1054 342, 158, 159, 350, 341, 98, 231, 351, 134, 353,1055 0, 349, 237, 0, 0, 275, 0, 0, 0, 0,1056 278, 0, 279, 2, 3, 0, 279,0, 283, 284,1025 59, 67, 327, 86, 142, 162, 280, 99, 142, 119, 1026 282, 145, 142, 100, 163, 164, 339, 146, 101, 94, 1027 146, 97, 148, 118, 212, 149, 149, 150, 151, 151, 1028 102, 142, 328, 109, 111, 113, 115, 120, 339, 146, 1029 121, 103, 146, 146, 123, 67, 252, 146, 138, 254, 1030 256, 146, 146, 211, 270, 146, 298, 124, 272, 326, 1031 133, 299, 161, 137, 147, 148, 104, 140, 149, 149, 1032 150, 151, 151, 325, 105, 146, 160, 149, 116, 117, 1033 151, 167, 354, 147, 148, 202, 203, 149, 169, 150, 1034 151, 106, 170, 96, 257, 135, 136, 147, 148, 107, 1035 122, 149, 125, 150, 151, 126, 184, 127, 129, 187, 1036 131, 171, 141, 190, 174, 176, 177, 178, 179, 180, 1037 181, 182, 201, 185, 128, 168, 96, 188, 130, 108, 1038 209, 263, 235, 30, 191, 110, 200, 143, 264, 144, 1039 112, 143, 216, 144, 206, 143, 97, 144, 152, 162, 1040 153, 154, 155, 156, 156, 157, 214, 172, 217, 159, 1041 114, 218, 219, 220, 143, 221, 144, 222, 223, 224, 1042 225, 226, 227, 228, 229, 166, 146, 233, 192, 147, 1043 148, 234, 236, 149, 205, 150, 151, 207, 239, 163, 1044 241, 152, 258, 153, 154, 155, 156, 156, 157, 157, 1045 259, 158, 159, 260, 155, 156, 268, 157, 213, 230, 1046 152, 261, 153, 154, 155, 156, 262, 157, 266, 267, 1047 158, 159, 265, 271, 152, 231, 153, 154, 155, 156, 1048 297, 157, 245, 144, 158, 159, 304, 306, 315, 246, 1049 324, 316, 317, 327, 341, 275, 318, 319, 320, 321, 1050 278, 338, 279, 2, 3, 342, 279, 350, 283, 284, 1057 1051 285, 4, 286, 295, 287, 288, 5, 6, 7, 8, 1058 0, 0, 0, 9, 0, 147, 148, 0, 0, 149,1059 305, 150, 151, 0, 0, 0, 0, 0, 0, 300,1052 351, 98, 134, 9, 353, 147, 148, 301, 349, 149, 1053 305, 150, 151, 237, 0, 0, 0, 0, 0, 300, 1060 1054 0, 302, 0, 10, 147, 148, 0, 0, 149, 0, 1061 150, 151, 0, 0, 0, 152, 0, 153, 154, 155,1062 15 6, 0, 157, 245, 0, 158, 159, 0, 0, 279,1063 246, 0, 0, 332, 0, 333, 334, 0, 335, 147,1055 150, 151, 0, 0, 0, 0, 152, 0, 153, 154, 1056 155, 156, 0, 157, 247, 0, 158, 159, 0, 279, 1057 0, 248, 0, 332, 0, 333, 334, 0, 335, 147, 1064 1058 148, 0, 0, 149, 0, 150, 151, 0, 336, 337, 1065 352, 0, 0, 11, 12, 13, 14, 15, 16, 17, 1066 18, 19, 20, 21, 22, 23, 24, 25, 26, 0, 1067 27, 28, 29, 30, 0, 31, 32, 33, 34, 35, 1068 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 1069 46, 87, 47, 0, 0, 48, 0, 49, 147, 148, 1070 0, 50, 149, 0, 150, 151, 51, 0, 0, 52, 1071 0, 152, 0, 153, 154, 155, 156, 0, 157, 247, 1072 149, 158, 159, 151, 0, 0, 248, 0, 0, 0, 1073 152, 0, 153, 154, 155, 156, 0, 157, 250, 0, 1074 158, 159, 147, 148, 0, 251, 149, 0, 150, 151, 1059 352, 0, 0, 0, 11, 12, 13, 14, 15, 16, 1060 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1061 0, 27, 28, 29, 30, 0, 31, 32, 33, 34, 1062 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 1063 45, 46, 0, 47, 0, 0, 48, 0, 49, 147, 1064 148, 0, 50, 149, 0, 150, 151, 51, 0, 0, 1065 52, 0, 152, 0, 153, 154, 155, 156, 0, 157, 1066 250, 149, 158, 159, 151, 0, 0, 251, 0, 0, 1067 0, 152, 0, 153, 154, 155, 156, 149, 157, 276, 1068 151, 158, 159, 147, 148, 0, 277, 149, 0, 150, 1069 151, 0, 0, 0, 0, 0, 0, 147, 148, 0, 1070 0, 149, 0, 150, 151, 0, 152, 0, 153, 154, 1071 155, 156, 0, 157, 311, 0, 158, 159, 147, 148, 1072 0, 312, 149, 0, 150, 151, 0, 0, 0, 0, 1073 0, 0, 147, 148, 0, 0, 149, 0, 150, 151, 1075 1074 0, 0, 0, 0, 0, 0, 147, 148, 0, 0, 1075 149, 0, 150, 151, 0, 0, 0, 0, 0, 0, 1076 0, 0, 0, 0, 0, 0, 152, 0, 153, 154, 1077 155, 156, 0, 157, 313, 0, 158, 159, 147, 148, 1078 0, 314, 149, 0, 150, 151, 153, 154, 155, 156, 1079 0, 157, 147, 148, 0, 159, 149, 0, 150, 151, 1080 152, 0, 153, 154, 155, 156, 0, 157, 0, 0, 1081 152, 159, 153, 154, 155, 156, 0, 157, 0, 0, 1082 158, 159, 0, 0, 152, 238, 153, 154, 155, 156, 1083 0, 157, 0, 0, 158, 159, 147, 148, 0, 240, 1076 1084 149, 0, 150, 151, 0, 152, 0, 153, 154, 155, 1077 156, 0, 157, 276, 0, 158, 159, 147, 148, 0, 1078 277, 149, 0, 150, 151, 0, 30, 0, 31, 32, 1079 33, 147, 148, 0, 0, 149, 0, 150, 151, 0, 1080 0, 0, 0, 93, 0, 147, 148, 0, 0, 149, 1081 49, 150, 151, 0, 0, 0, 0, 0, 0, 96, 1082 0, 0, 52, 0, 152, 0, 153, 154, 155, 156, 1083 0, 157, 311, 0, 158, 159, 147, 148, 0, 312, 1084 149, 0, 150, 151, 153, 154, 155, 156, 0, 157, 1085 147, 148, 0, 159, 149, 0, 150, 151, 0, 0, 1086 0, 0, 0, 0, 0, 0, 0, 0, 152, 0, 1087 153, 154, 155, 156, 0, 157, 313, 0, 158, 159, 1088 0, 0, 152, 314, 153, 154, 155, 156, 0, 157, 1089 0, 0, 158, 159, 147, 148, 0, 238, 149, 0, 1090 150, 151, 0, 152, 0, 153, 154, 155, 156, 0, 1091 157, 0, 0, 158, 159, 0, 0, 152, 240, 153, 1092 154, 155, 156, 0, 157, 0, 0, 158, 159, 0, 1093 0, 152, 242, 153, 154, 155, 156, 0, 157, 0, 1094 0, 158, 159, 147, 148, 0, 253, 149, 0, 150, 1095 151, 0, 0, 0, 0, 0, 5, 6, 289, 290, 1096 0, 0, 152, 9, 153, 154, 155, 156, 0, 157, 1097 0, 0, 158, 159, 0, 0, 152, 255, 153, 154, 1098 155, 156, 0, 157, 0, 0, 158, 159, 147, 148, 1099 0, 269, 149, 0, 150, 151, 0, 0, 0, 0, 1100 0, 0, 147, 148, 0, 0, 149, 0, 150, 151, 1101 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1102 152, 0, 153, 154, 155, 156, 0, 157, 0, 0, 1103 158, 159, 147, 148, 0, 296, 149, 0, 150, 151, 1104 0, 291, 292, 293, 294, 0, 147, 148, 0, 0, 1105 149, 0, 150, 151, 0, 0, 0, 0, 0, 0, 1106 147, 148, 0, 0, 149, 0, 150, 151, 0, 152, 1107 0, 153, 154, 155, 156, 0, 157, 0, 0, 158, 1108 159, 147, 148, 0, 231, 149, 0, 150, 151, 0, 1085 156, 0, 157, 0, 0, 158, 159, 0, 0, 152, 1086 242, 153, 154, 155, 156, 0, 157, 0, 0, 158, 1087 159, 0, 0, 152, 253, 153, 154, 155, 156, 0, 1088 157, 0, 0, 158, 159, 147, 148, 0, 255, 149, 1089 0, 150, 151, 0, 0, 0, 0, 5, 6, 289, 1090 290, 0, 0, 0, 9, 152, 0, 153, 154, 155, 1091 156, 0, 157, 0, 0, 158, 159, 0, 0, 152, 1092 269, 153, 154, 155, 156, 0, 157, 0, 0, 158, 1093 159, 147, 148, 0, 296, 149, 0, 150, 151, 87, 1109 1094 0, 0, 0, 0, 0, 147, 148, 0, 0, 149, 1110 1095 0, 150, 151, 0, 0, 0, 0, 0, 0, 0, 1111 0, 0, 0, 0, 152, 0, 153, 154, 155, 156, 1112 0, 157, 0, 0, 158, 159, 0, 0, 152, 307, 1096 0, 0, 0, 152, 0, 153, 154, 155, 156, 0, 1097 157, 0, 0, 158, 159, 147, 148, 0, 231, 149, 1098 0, 150, 151, 291, 292, 293, 294, 0, 0, 147, 1099 148, 0, 0, 149, 0, 150, 151, 0, 0, 0, 1100 0, 0, 0, 147, 148, 0, 0, 149, 0, 150, 1101 151, 0, 152, 0, 153, 154, 155, 156, 0, 157, 1102 0, 0, 158, 159, 147, 148, 0, 307, 149, 0, 1103 150, 151, 0, 0, 0, 30, 0, 31, 32, 33, 1104 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1105 0, 0, 93, 0, 0, 0, 0, 0, 152, 49, 1113 1106 153, 154, 155, 156, 0, 157, 0, 0, 158, 159, 1114 147, 148, 0, 309, 149, 0, 150, 151, 0, 0,1115 0, 0, 0, 0, 0, 0, 0, 0, 152, 0,1116 153, 154, 155, 156, 0, 157, 0, 0, 158, 159,1117 0, 0, 152, 343, 153, 154, 155, 156, 0, 157,1118 0, 0, 158, 159, 0, 0, 152, 344, 153, 154,1107 0, 52, 152, 309, 153, 154, 155, 156, 0, 157, 1108 0, 0, 158, 159, 4, 0, 0, 343, 0, 5, 1109 6, 87, 88, 0, 0, 0, 9, 0, 0, 0, 1110 0, 0, 152, 0, 153, 154, 155, 156, 0, 157, 1111 0, 0, 158, 159, 87, 0, 152, 344, 153, 154, 1119 1112 155, 156, 0, 157, 0, 0, 158, 159, 0, 0, 1120 0, 345, 0, 0, 0, 0, 0, 152, 0, 153, 1121 154, 155, 156, 0, 157, 87, 0, 158, 159, 0, 1122 0, 152, 346, 153, 154, 155, 156, 0, 157, 0, 1123 0, 158, 159, 4, 0, 0, 347, 0, 5, 6, 1124 87, 88, 0, 0, 0, 9, 0, 0, 0, 0, 1125 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1126 0, 0, 0, 0, 0, 0, 152, 0, 153, 154, 1127 155, 156, 273, 157, 274, 0, 158, 159, 0, 0, 1128 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1129 4, 0, 0, 0, 0, 5, 6, 87, 88, 0, 1130 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 1131 30, 0, 31, 32, 33, 11, 12, 13, 14, 15, 1132 16, 17, 18, 89, 90, 91, 92, 93, 0, 0, 1113 152, 345, 153, 154, 155, 156, 0, 157, 0, 87, 1114 158, 159, 0, 0, 0, 346, 0, 0, 0, 0, 1115 0, 152, 0, 153, 154, 155, 156, 0, 157, 0, 1116 0, 158, 159, 0, 0, 0, 347, 11, 12, 13, 1117 14, 15, 16, 17, 18, 89, 90, 91, 92, 0, 1118 0, 0, 0, 0, 0, 0, 0, 30, 0, 31, 1119 32, 33, 0, 4, 0, 0, 38, 39, 5, 6, 1120 87, 88, 0, 0, 93, 9, 0, 0, 0, 48, 1121 30, 49, 31, 32, 33, 0, 0, 0, 0, 0, 1122 51, 183, 0, 52, 0, 0, 0, 93, 0, 0, 1133 1123 0, 0, 0, 0, 49, 30, 0, 31, 32, 33, 1134 0, 0, 0, 108, 38, 39, 52, 0, 4, 0, 1135 0, 0, 93, 5, 6, 87, 88, 48, 0, 49, 1136 9, 0, 0, 0, 0, 0, 0, 0, 51, 183, 1137 0, 52, 11, 12, 13, 14, 15, 16, 17, 18, 1124 0, 0, 0, 96, 0, 0, 52, 0, 0, 0, 1125 4, 0, 93, 0, 0, 5, 6, 87, 88, 49, 1126 0, 0, 9, 0, 0, 0, 0, 0, 108, 0, 1127 0, 52, 0, 0, 0, 0, 11, 12, 13, 14, 1128 15, 16, 17, 18, 89, 90, 91, 92, 0, 0, 1129 0, 0, 0, 0, 0, 0, 30, 0, 31, 32, 1130 33, 0, 0, 0, 0, 38, 39, 0, 0, 4, 1131 0, 0, 0, 93, 5, 6, 87, 88, 48, 0, 1132 49, 9, 0, 0, 0, 0, 0, 0, 0, 51, 1133 186, 0, 52, 11, 12, 13, 14, 15, 16, 17, 1134 18, 89, 90, 91, 92, 0, 0, 0, 0, 0, 1135 0, 0, 0, 30, 0, 31, 32, 33, 0, 0, 1136 0, 0, 38, 39, 0, 0, 4, 0, 0, 0, 1137 93, 5, 6, 87, 88, 48, 0, 49, 9, 0, 1138 0, 0, 0, 0, 0, 0, 51, 189, 0, 52, 1139 0, 0, 11, 12, 13, 14, 15, 16, 17, 18, 1138 1140 89, 90, 91, 92, 0, 0, 0, 0, 0, 0, 1139 1141 0, 0, 30, 0, 31, 32, 33, 0, 0, 0, 1140 1142 0, 38, 39, 0, 0, 4, 0, 0, 0, 93, 1141 1143 5, 6, 87, 88, 48, 0, 49, 9, 0, 0, 1142 0, 0, 0, 0, 0, 51, 186, 0, 52, 0, 1143 11, 12, 13, 14, 15, 16, 17, 18, 89, 90, 1144 91, 92, 0, 0, 0, 0, 0, 0, 0, 0, 1145 30, 0, 31, 32, 33, 0, 0, 0, 0, 38, 1146 39, 0, 0, 4, 0, 0, 0, 93, 5, 6, 1147 87, 88, 48, 0, 49, 9, 0, 0, 0, 0, 1148 0, 0, 0, 51, 189, 0, 52, 11, 12, 13, 1149 14, 15, 16, 17, 18, 89, 90, 91, 92, 0, 1150 0, 0, 0, 0, 0, 0, 0, 30, 0, 31, 1151 32, 33, 0, 0, 0, 0, 38, 39, 0, 0, 1152 4, 0, 0, 0, 93, 5, 6, 87, 88, 48, 1153 0, 49, 9, 0, 0, 0, 0, 0, 0, 0, 1154 51, 208, 0, 52, 0, 11, 12, 13, 14, 15, 1155 16, 17, 18, 89, 90, 91, 92, 0, 0, 0, 1156 0, 0, 0, 0, 0, 30, 0, 31, 32, 33, 1157 0, 0, 0, 0, 38, 39, 0, 0, 4, 0, 1158 0, 0, 93, 5, 6, 132, 88, 48, 0, 49, 1159 9, 0, 0, 0, 0, 0, 0, 0, 51, 215, 1160 0, 52, 11, 12, 13, 14, 15, 16, 17, 18, 1161 89, 90, 91, 92, 0, 0, 0, 0, 0, 0, 1162 0, 0, 30, 0, 31, 32, 33, 0, 0, 0, 1163 0, 38, 39, 0, 0, 4, 0, 0, 0, 93, 1164 5, 6, 87, 88, 48, 0, 49, 9, 0, 0, 1165 147, 148, 0, 0, 149, 51, 150, 151, 52, 0, 1166 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1167 21, 22, 147, 148, 0, 0, 149, 0, 150, 151, 1168 30, 0, 31, 32, 33, 0, 0, 147, 148, 38, 1169 39, 149, 0, 150, 151, 0, 0, 93, 0, 147, 1170 148, 0, 48, 149, 49, 150, 151, 0, 0, 0, 1171 0, 0, 0, 51, 0, 0, 52, 11, 12, 13, 1172 14, 15, 16, 17, 18, 89, 90, 91, 92, 147, 1173 148, 0, 0, 149, 0, 150, 151, 30, 0, 31, 1174 32, 33, 0, 0, 147, 148, 38, 39, 149, 0, 1175 150, 151, 87, 0, 93, 0, 147, 148, 0, 48, 1176 149, 49, 150, 151, 0, 0, 0, 0, 147, 148, 1177 173, 0, 149, 52, 150, 151, 152, 0, 153, 154, 1178 155, 156, 0, 157, 243, 0, 158, 159, 147, 148, 1179 0, 0, 149, 0, 150, 151, 0, 0, 152, 0, 1180 153, 154, 155, 156, 0, 157, 244, 0, 158, 159, 1181 0, 0, 0, 152, 0, 153, 154, 155, 156, 0, 1182 157, 249, 0, 158, 159, 152, 0, 153, 154, 155, 1183 156, 0, 157, 281, 0, 158, 159, 147, 148, 0, 1184 0, 149, 0, 150, 151, 0, 0, 30, 0, 31, 1185 32, 33, 87, 0, 0, 152, 0, 153, 154, 155, 1186 156, 303, 157, 0, 93, 158, 159, 0, 0, 0, 1187 152, 49, 153, 154, 155, 156, 0, 157, 308, 0, 1188 158, 159, 152, 52, 153, 154, 155, 156, 0, 157, 1189 310, 87, 158, 159, 152, 0, 153, 154, 155, 156, 1190 322, 157, 147, 148, 158, 159, 149, 0, 150, 151, 1191 0, 0, 0, 0, 152, 0, 153, 154, 155, 156, 1192 0, 157, 323, 0, 158, 159, -1, 148, 0, 0, 1193 149, 0, 150, 151, 0, 0, 0, 0, 0, 148, 1194 0, 0, 149, 0, 150, 151, 0, 30, 0, 31, 1195 32, 33, 0, 0, 0, 0, 0, 0, 0, 0, 1196 0, 0, 0, 152, 93, 153, 154, 155, 156, 348, 1197 157, 49, 0, 158, 159, 87, 0, 0, 0, 0, 1198 110, 0, 0, 52, 0, 87, 30, 0, 31, 32, 1199 33, 5, 6, 193, 194, 0, 0, 0, 9, 0, 1200 0, 0, 0, 93, 0, 0, 0, 0, 0, 0, 1201 49, 0, 0, 0, 0, 0, 0, 0, 0, 112, 1202 0, 0, 52, 0, 0, 0, 0, 0, 152, 0, 1203 153, 154, 155, 156, 0, 157, 0, 0, 158, 159, 1144 0, 0, 0, 0, 0, 51, 208, 0, 52, 11, 1145 12, 13, 14, 15, 16, 17, 18, 89, 90, 91, 1146 92, 0, 0, 0, 0, 0, 0, 0, 0, 30, 1147 0, 31, 32, 33, 0, 0, 0, 0, 38, 39, 1148 0, 0, 4, 0, 0, 0, 93, 5, 6, 132, 1149 88, 48, 0, 49, 9, 0, 0, 0, 0, 0, 1150 0, 0, 51, 215, 0, 52, 0, 0, 11, 12, 1151 13, 14, 15, 16, 17, 18, 89, 90, 91, 92, 1152 0, 0, 0, 0, 0, 0, 0, 0, 30, 0, 1153 31, 32, 33, 0, 0, 0, 0, 38, 39, 0, 1154 0, 4, 0, 0, 0, 93, 5, 6, 87, 88, 1155 48, 0, 49, 9, 0, 0, 147, 148, 0, 0, 1156 149, 51, 150, 151, 52, 11, 12, 13, 14, 15, 1157 16, 17, 18, 19, 20, 21, 22, 147, 148, 0, 1158 0, 149, 0, 150, 151, 30, 0, 31, 32, 33, 1159 0, 0, 147, 148, 38, 39, 149, 0, 150, 151, 1160 0, 0, 93, 0, 147, 148, 0, 48, 149, 49, 1161 150, 151, 0, 0, 0, 0, 147, 148, 51, 0, 1162 149, 52, 150, 151, 11, 12, 13, 14, 15, 16, 1163 17, 18, 89, 90, 91, 92, 147, 148, 0, 0, 1164 149, 0, 150, 151, 30, 0, 31, 32, 33, 0, 1165 0, 147, 148, 38, 39, 149, 0, 150, 151, 0, 1166 0, 93, 0, 147, 148, 0, 48, 149, 49, 150, 1167 151, 0, 0, 0, 0, 147, 148, 173, 0, 149, 1168 52, 150, 151, 152, 0, 153, 154, 155, 156, 273, 1169 157, 274, 0, 158, 159, 147, 148, 0, 0, 149, 1170 0, 150, 151, 0, 152, 0, 153, 154, 155, 156, 1171 0, 157, 243, 0, 158, 159, 0, 0, 0, 152, 1172 0, 153, 154, 155, 156, 0, 157, 244, 0, 158, 1173 159, 152, 0, 153, 154, 155, 156, 0, 157, 249, 1174 0, 158, 159, 152, 0, 153, 154, 155, 156, 87, 1175 157, 281, 0, 158, 159, 147, 148, 0, 0, 149, 1176 0, 150, 151, 152, 0, 153, 154, 155, 156, 303, 1177 157, 0, 0, 158, 159, 0, 0, 0, 152, 0, 1178 153, 154, 155, 156, 0, 157, 308, 0, 158, 159, 1179 152, 0, 153, 154, 155, 156, 0, 157, 310, 0, 1180 158, 159, 152, 0, 153, 154, 155, 156, 322, 157, 1181 147, 148, 158, 159, 149, 0, 150, 151, 0, 0, 1182 0, 0, 152, 87, 153, 154, 155, 156, 0, 157, 1183 323, 0, 158, 159, -1, 148, 0, 0, 149, 0, 1184 150, 151, 0, 0, 0, 30, 0, 31, 32, 33, 1204 1185 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1205 0, 0, 152, 0, 153, 154, 155, 156, 0, 157, 1206 0, 0, 158, 159, 152, 0, 153, 154, 155, 156, 1207 30, 157, 31, 32, 33, 159, 195, 196, 197, 198, 1208 30, 0, 31, 32, 33, 0, 0, 93, 30, 0, 1209 31, 32, 33, 0, 49, 0, 0, 93, 0, 0, 1210 0, 0, 0, 114, 49, 93, 52, 0, 0, 0, 1211 0, 0, 49, 166, 0, 0, 52, 0, 0, 0, 1212 0, 0, 199, 0, 52 1186 0, 0, 93, 0, 0, 0, 0, 0, 0, 49, 1187 0, 0, 0, 0, 0, 0, 0, 0, 110, 0, 1188 0, 52, 152, 0, 153, 154, 155, 156, 348, 157, 1189 87, 0, 158, 159, 5, 6, 193, 194, 0, 0, 1190 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 1191 0, 0, 0, 0, 0, 0, 0, 0, 0, 30, 1192 0, 31, 32, 33, 0, 87, 0, 0, 0, 0, 1193 0, 0, 0, 0, 0, 0, 93, 152, 0, 153, 1194 154, 155, 156, 49, 157, 0, 0, 158, 159, 0, 1195 0, 0, 112, 0, 0, 52, 0, 0, 0, 0, 1196 0, 152, 0, 153, 154, 155, 156, 0, 157, 0, 1197 0, 158, 159, 0, 0, 0, 0, 0, 0, 0, 1198 195, 196, 197, 198, 0, 0, 30, 0, 31, 32, 1199 33, 0, 30, 0, 31, 32, 33, 0, 0, 0, 1200 0, 0, 0, 93, 0, 0, 0, 0, 0, 93, 1201 49, 0, 0, 0, 0, 0, 49, 0, 0, 114, 1202 0, 30, 52, 31, 32, 33, 199, 0, 52, 0, 1203 0, 0, 0, 0, 0, 0, 0, 0, 93, 0, 1204 0, 0, 0, 0, 0, 49, 0, 0, 0, 0, 1205 0, 0, 0, 0, 166, 0, 0, 52 1213 1206 }; 1214 1207 1215 static const yytype_int16yycheck[] =1208 static const short int yycheck[] = 1216 1209 { 1217 1, 1, 237, 110, 138, 11, 241, 113, 7,11,1218 328, 10, 111, 11, 143, 128, 11, 116, 143, 4,1219 13 7, 7, 143, 24, 137, 7, 7, 144, 10, 10,1220 1 10, 138, 350, 19, 20, 21, 22, 143, 143, 137,1221 26, 1 28, 137, 143, 29, 45, 144, 137, 49, 144,1222 1 37, 138, 137, 135, 144, 137, 110, 111, 111, 144,1223 45, 1 38, 63, 48, 3, 4, 137, 52, 7, 304,1224 9, 10, 137, 144, 143, 137, 61, 110, 111, 144,1225 143, 67, 144, 143, 7, 143, 144, 10, 74, 46,1226 47, 143, 77, 143, 143, 3, 4, 143, 110, 7,1227 14 3, 9, 10, 110, 143, 110, 107, 137, 143, 110,1228 1 38, 96, 143, 114, 99, 100, 101, 102, 103, 104,1229 105, 106, 122, 108, 1 43, 143, 143, 112, 143, 137,1230 131, 13 7, 134, 128, 111, 134, 122, 143, 144, 145,1231 1 10, 143, 143, 145, 129, 143, 132, 145, 143, 138,1232 1 45, 133, 134, 134, 136, 136, 142, 111, 144, 137,1233 144, 146, 147, 148, 1 37, 150, 111, 152, 153, 154,1234 155, 156, 157, 158, 159, 144, 1 44, 163, 144, 3,1235 4, 166, 168, 7, 1 44, 9, 10, 138, 173, 144,1236 1 29, 110, 131, 132, 133, 134, 145, 136, 111, 137,1237 1 39, 140, 137, 144, 144, 275, 129, 146, 131, 132,1238 13 3, 134, 144, 136, 144, 144, 144, 140, 144, 204,1239 1 28, 129, 134, 131, 132, 133, 134, 137, 136, 113,1240 1 44, 139, 140, 137, 143, 7, 144, 144, 45, 350,1241 -1, 338, 169, -1, -1, 230, -1, -1, -1, -1,1242 235, -1, 237, 0, 1, -1, 241, -1, 243, 244,1210 1, 1, 114, 139, 11, 129, 237, 144, 11, 111, 1211 241, 129, 11, 144, 138, 139, 328, 138, 144, 4, 1212 138, 7, 4, 24, 145, 7, 7, 9, 10, 10, 1213 144, 11, 144, 19, 20, 21, 22, 139, 350, 138, 1214 26, 144, 138, 138, 29, 45, 145, 138, 49, 145, 1215 145, 138, 138, 136, 145, 138, 112, 111, 145, 145, 1216 45, 117, 63, 48, 3, 4, 144, 52, 7, 7, 1217 9, 10, 10, 304, 144, 138, 61, 7, 111, 112, 1218 10, 67, 145, 3, 4, 111, 112, 7, 74, 9, 1219 10, 144, 77, 144, 145, 46, 47, 3, 4, 144, 1220 144, 7, 112, 9, 10, 144, 107, 144, 144, 110, 1221 144, 96, 139, 114, 99, 100, 101, 102, 103, 104, 1222 105, 106, 122, 108, 111, 138, 144, 112, 111, 144, 1223 131, 138, 135, 111, 139, 144, 122, 144, 145, 146, 1224 144, 144, 143, 146, 129, 144, 132, 146, 130, 129, 1225 132, 133, 134, 135, 135, 137, 142, 112, 144, 141, 1226 144, 146, 147, 148, 144, 150, 146, 152, 153, 154, 1227 155, 156, 157, 158, 159, 144, 138, 163, 139, 3, 1228 4, 166, 168, 7, 111, 9, 10, 112, 173, 138, 1229 138, 130, 145, 132, 133, 134, 135, 135, 137, 137, 1230 145, 140, 141, 145, 134, 135, 111, 137, 147, 129, 1231 130, 145, 132, 133, 134, 135, 145, 137, 112, 204, 1232 140, 141, 145, 139, 130, 145, 132, 133, 134, 135, 1233 112, 137, 138, 146, 140, 141, 138, 138, 145, 145, 1234 135, 145, 145, 114, 144, 230, 145, 145, 145, 145, 1235 235, 138, 237, 0, 1, 145, 241, 138, 243, 244, 1243 1236 245, 8, 247, 263, 249, 250, 13, 14, 15, 16, 1244 -1, -1, -1, 20, -1, 3, 4, -1, -1, 7,1245 281, 9, 10, -1, -1, -1, -1, -1, -1, 274,1237 145, 7, 45, 20, 350, 3, 4, 275, 338, 7, 1238 281, 9, 10, 169, -1, -1, -1, -1, -1, 274, 1246 1239 -1, 276, -1, 40, 3, 4, -1, -1, 7, -1, 1247 9, 10, -1, -1, -1, 129, -1, 131, 132, 133,1248 134, -1, 136, 137, -1, 139, 140, -1, -1, 304,1249 144, -1, -1, 308, -1, 310, 311, -1, 313, 3,1240 9, 10, -1, -1, -1, -1, 130, -1, 132, 133, 1241 134, 135, -1, 137, 138, -1, 140, 141, -1, 304, 1242 -1, 145, -1, 308, -1, 310, 311, -1, 313, 3, 1250 1243 4, -1, -1, 7, -1, 9, 10, -1, 323, 324, 1251 341, -1, -1, 90, 91, 92, 93, 94, 95, 96,1252 97, 98, 99, 100, 101, 102, 103, 104, 105, -1,1253 107, 108, 109, 110, -1, 112, 113, 114, 115, 116,1244 341, -1, -1, -1, 91, 92, 93, 94, 95, 96, 1245 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 1246 -1, 108, 109, 110, 111, -1, 113, 114, 115, 116, 1254 1247 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 1255 127, 15, 129, -1, -1, 132, -1, 134, 3, 4, 1256 -1, 138, 7, -1, 9, 10, 143, -1, -1, 146, 1257 -1, 129, -1, 131, 132, 133, 134, -1, 136, 137, 1258 7, 139, 140, 10, -1, -1, 144, -1, -1, -1, 1259 129, -1, 131, 132, 133, 134, -1, 136, 137, -1, 1260 139, 140, 3, 4, -1, 144, 7, -1, 9, 10, 1248 127, 128, -1, 130, -1, -1, 133, -1, 135, 3, 1249 4, -1, 139, 7, -1, 9, 10, 144, -1, -1, 1250 147, -1, 130, -1, 132, 133, 134, 135, -1, 137, 1251 138, 7, 140, 141, 10, -1, -1, 145, -1, -1, 1252 -1, 130, -1, 132, 133, 134, 135, 7, 137, 138, 1253 10, 140, 141, 3, 4, -1, 145, 7, -1, 9, 1254 10, -1, -1, -1, -1, -1, -1, 3, 4, -1, 1255 -1, 7, -1, 9, 10, -1, 130, -1, 132, 133, 1256 134, 135, -1, 137, 138, -1, 140, 141, 3, 4, 1257 -1, 145, 7, -1, 9, 10, -1, -1, -1, -1, 1258 -1, -1, 3, 4, -1, -1, 7, -1, 9, 10, 1261 1259 -1, -1, -1, -1, -1, -1, 3, 4, -1, -1, 1262 7, -1, 9, 10, -1, 129, -1, 131, 132, 133,1263 134, -1, 136, 137, -1, 139, 140, 3, 4, -1,1264 144, 7, -1, 9, 10, -1, 110, -1, 112, 113,1265 114, 3, 4, -1, -1, 7, -1, 9, 10, -1,1266 -1, -1, -1, 127, -1, 3, 4, -1, -1, 7,1267 134, 9, 10, -1, -1, -1, -1, -1, -1, 143,1268 -1, -1, 146, -1, 129, -1, 131, 132, 133, 134,1269 -1, 136, 137, -1, 139, 140, 3, 4, -1, 144,1270 7, -1, 9, 10, 131, 132, 133, 134, -1, 136,1271 3, 4, -1, 140, 7, -1, 9, 10, -1, -1,1272 -1, -1, -1, -1, -1, -1, -1, -1, 129, -1,1273 131, 132, 133, 134, -1, 136, 137, -1, 139, 140,1274 -1, -1, 129, 144, 131, 132, 133, 134, -1, 136,1275 -1, -1, 139, 140, 3, 4, -1, 144, 7, -1,1276 9, 10, -1, 129, -1, 131, 132, 133, 134, -1,1277 136, -1, -1, 139, 140, -1, -1, 129, 144, 131,1278 132, 133, 134, -1, 136, -1, -1, 139, 140, -1,1279 -1, 129, 144, 131, 132, 133, 134, -1, 136, -1,1280 -1, 139, 140, 3, 4, -1, 144, 7, -1, 9,1281 10, -1, -1, -1, -1, -1, 13, 14, 15, 16,1282 -1, -1, 129, 20, 131, 132, 133, 134, -1, 136,1283 -1, -1, 139, 140, -1, -1, 129, 144, 131, 132,1284 133, 134, -1, 136, -1, -1, 139, 140, 3, 4,1285 -1, 144, 7, -1, 9, 10, -1, -1, -1, -1,1286 -1, -1, 3, 4, -1, -1, 7, -1, 9, 10,1287 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,1288 129, -1, 131, 132, 133, 134, -1, 136, -1, -1,1289 139, 140, 3, 4, -1, 144, 7, -1, 9, 10,1290 -1, 98, 99, 100, 101, -1, 3, 4, -1, -1,1291 1260 7, -1, 9, 10, -1, -1, -1, -1, -1, -1, 1292 3, 4, -1, -1, 7, -1, 9, 10, -1, 129, 1293 -1, 131, 132, 133, 134, -1, 136, -1, -1, 139, 1294 140, 3, 4, -1, 144, 7, -1, 9, 10, -1, 1261 -1, -1, -1, -1, -1, -1, 130, -1, 132, 133, 1262 134, 135, -1, 137, 138, -1, 140, 141, 3, 4, 1263 -1, 145, 7, -1, 9, 10, 132, 133, 134, 135, 1264 -1, 137, 3, 4, -1, 141, 7, -1, 9, 10, 1265 130, -1, 132, 133, 134, 135, -1, 137, -1, -1, 1266 130, 141, 132, 133, 134, 135, -1, 137, -1, -1, 1267 140, 141, -1, -1, 130, 145, 132, 133, 134, 135, 1268 -1, 137, -1, -1, 140, 141, 3, 4, -1, 145, 1269 7, -1, 9, 10, -1, 130, -1, 132, 133, 134, 1270 135, -1, 137, -1, -1, 140, 141, -1, -1, 130, 1271 145, 132, 133, 134, 135, -1, 137, -1, -1, 140, 1272 141, -1, -1, 130, 145, 132, 133, 134, 135, -1, 1273 137, -1, -1, 140, 141, 3, 4, -1, 145, 7, 1274 -1, 9, 10, -1, -1, -1, -1, 13, 14, 15, 1275 16, -1, -1, -1, 20, 130, -1, 132, 133, 134, 1276 135, -1, 137, -1, -1, 140, 141, -1, -1, 130, 1277 145, 132, 133, 134, 135, -1, 137, -1, -1, 140, 1278 141, 3, 4, -1, 145, 7, -1, 9, 10, 15, 1295 1279 -1, -1, -1, -1, -1, 3, 4, -1, -1, 7, 1296 1280 -1, 9, 10, -1, -1, -1, -1, -1, -1, -1, 1297 -1, -1, -1, -1, 129, -1, 131, 132, 133, 134, 1298 -1, 136, -1, -1, 139, 140, -1, -1, 129, 144, 1299 131, 132, 133, 134, -1, 136, -1, -1, 139, 140, 1300 3, 4, -1, 144, 7, -1, 9, 10, -1, -1, 1301 -1, -1, -1, -1, -1, -1, -1, -1, 129, -1, 1302 131, 132, 133, 134, -1, 136, -1, -1, 139, 140, 1303 -1, -1, 129, 144, 131, 132, 133, 134, -1, 136, 1304 -1, -1, 139, 140, -1, -1, 129, 144, 131, 132, 1305 133, 134, -1, 136, -1, -1, 139, 140, -1, -1, 1306 -1, 144, -1, -1, -1, -1, -1, 129, -1, 131, 1307 132, 133, 134, -1, 136, 15, -1, 139, 140, -1, 1308 -1, 129, 144, 131, 132, 133, 134, -1, 136, -1, 1309 -1, 139, 140, 8, -1, -1, 144, -1, 13, 14, 1310 15, 16, -1, -1, -1, 20, -1, -1, -1, -1, 1281 -1, -1, -1, 130, -1, 132, 133, 134, 135, -1, 1282 137, -1, -1, 140, 141, 3, 4, -1, 145, 7, 1283 -1, 9, 10, 99, 100, 101, 102, -1, -1, 3, 1284 4, -1, -1, 7, -1, 9, 10, -1, -1, -1, 1285 -1, -1, -1, 3, 4, -1, -1, 7, -1, 9, 1286 10, -1, 130, -1, 132, 133, 134, 135, -1, 137, 1287 -1, -1, 140, 141, 3, 4, -1, 145, 7, -1, 1288 9, 10, -1, -1, -1, 111, -1, 113, 114, 115, 1311 1289 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1312 -1, -1, -1, -1, -1, -1, 129, -1, 131, 132, 1313 133, 134, 135, 136, 137, -1, 139, 140, -1, -1, 1290 -1, -1, 128, -1, -1, -1, -1, -1, 130, 135, 1291 132, 133, 134, 135, -1, 137, -1, -1, 140, 141, 1292 -1, 147, 130, 145, 132, 133, 134, 135, -1, 137, 1293 -1, -1, 140, 141, 8, -1, -1, 145, -1, 13, 1294 14, 15, 16, -1, -1, -1, 20, -1, -1, -1, 1295 -1, -1, 130, -1, 132, 133, 134, 135, -1, 137, 1296 -1, -1, 140, 141, 15, -1, 130, 145, 132, 133, 1297 134, 135, -1, 137, -1, -1, 140, 141, -1, -1, 1298 130, 145, 132, 133, 134, 135, -1, 137, -1, 15, 1299 140, 141, -1, -1, -1, 145, -1, -1, -1, -1, 1300 -1, 130, -1, 132, 133, 134, 135, -1, 137, -1, 1301 -1, 140, 141, -1, -1, -1, 145, 91, 92, 93, 1302 94, 95, 96, 97, 98, 99, 100, 101, 102, -1, 1303 -1, -1, -1, -1, -1, -1, -1, 111, -1, 113, 1304 114, 115, -1, 8, -1, -1, 120, 121, 13, 14, 1305 15, 16, -1, -1, 128, 20, -1, -1, -1, 133, 1306 111, 135, 113, 114, 115, -1, -1, -1, -1, -1, 1307 144, 145, -1, 147, -1, -1, -1, 128, -1, -1, 1308 -1, -1, -1, -1, 135, 111, -1, 113, 114, 115, 1309 -1, -1, -1, 144, -1, -1, 147, -1, -1, -1, 1310 8, -1, 128, -1, -1, 13, 14, 15, 16, 135, 1311 -1, -1, 20, -1, -1, -1, -1, -1, 144, -1, 1312 -1, 147, -1, -1, -1, -1, 91, 92, 93, 94, 1313 95, 96, 97, 98, 99, 100, 101, 102, -1, -1, 1314 -1, -1, -1, -1, -1, -1, 111, -1, 113, 114, 1315 115, -1, -1, -1, -1, 120, 121, -1, -1, 8, 1316 -1, -1, -1, 128, 13, 14, 15, 16, 133, -1, 1317 135, 20, -1, -1, -1, -1, -1, -1, -1, 144, 1318 145, -1, 147, 91, 92, 93, 94, 95, 96, 97, 1319 98, 99, 100, 101, 102, -1, -1, -1, -1, -1, 1320 -1, -1, -1, 111, -1, 113, 114, 115, -1, -1, 1321 -1, -1, 120, 121, -1, -1, 8, -1, -1, -1, 1322 128, 13, 14, 15, 16, 133, -1, 135, 20, -1, 1323 -1, -1, -1, -1, -1, -1, 144, 145, -1, 147, 1324 -1, -1, 91, 92, 93, 94, 95, 96, 97, 98, 1325 99, 100, 101, 102, -1, -1, -1, -1, -1, -1, 1326 -1, -1, 111, -1, 113, 114, 115, -1, -1, -1, 1327 -1, 120, 121, -1, -1, 8, -1, -1, -1, 128, 1328 13, 14, 15, 16, 133, -1, 135, 20, -1, -1, 1329 -1, -1, -1, -1, -1, 144, 145, -1, 147, 91, 1330 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 1331 102, -1, -1, -1, -1, -1, -1, -1, -1, 111, 1332 -1, 113, 114, 115, -1, -1, -1, -1, 120, 121, 1333 -1, -1, 8, -1, -1, -1, 128, 13, 14, 15, 1334 16, 133, -1, 135, 20, -1, -1, -1, -1, -1, 1335 -1, -1, 144, 145, -1, 147, -1, -1, 91, 92, 1336 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 1337 -1, -1, -1, -1, -1, -1, -1, -1, 111, -1, 1338 113, 114, 115, -1, -1, -1, -1, 120, 121, -1, 1339 -1, 8, -1, -1, -1, 128, 13, 14, 15, 16, 1340 133, -1, 135, 20, -1, -1, 3, 4, -1, -1, 1341 7, 144, 9, 10, 147, 91, 92, 93, 94, 95, 1342 96, 97, 98, 99, 100, 101, 102, 3, 4, -1, 1343 -1, 7, -1, 9, 10, 111, -1, 113, 114, 115, 1344 -1, -1, 3, 4, 120, 121, 7, -1, 9, 10, 1345 -1, -1, 128, -1, 3, 4, -1, 133, 7, 135, 1346 9, 10, -1, -1, -1, -1, 3, 4, 144, -1, 1347 7, 147, 9, 10, 91, 92, 93, 94, 95, 96, 1348 97, 98, 99, 100, 101, 102, 3, 4, -1, -1, 1349 7, -1, 9, 10, 111, -1, 113, 114, 115, -1, 1350 -1, 3, 4, 120, 121, 7, -1, 9, 10, -1, 1351 -1, 128, -1, 3, 4, -1, 133, 7, 135, 9, 1352 10, -1, -1, -1, -1, 3, 4, 144, -1, 7, 1353 147, 9, 10, 130, -1, 132, 133, 134, 135, 136, 1354 137, 138, -1, 140, 141, 3, 4, -1, -1, 7, 1355 -1, 9, 10, -1, 130, -1, 132, 133, 134, 135, 1356 -1, 137, 138, -1, 140, 141, -1, -1, -1, 130, 1357 -1, 132, 133, 134, 135, -1, 137, 138, -1, 140, 1358 141, 130, -1, 132, 133, 134, 135, -1, 137, 138, 1359 -1, 140, 141, 130, -1, 132, 133, 134, 135, 15, 1360 137, 138, -1, 140, 141, 3, 4, -1, -1, 7, 1361 -1, 9, 10, 130, -1, 132, 133, 134, 135, 136, 1362 137, -1, -1, 140, 141, -1, -1, -1, 130, -1, 1363 132, 133, 134, 135, -1, 137, 138, -1, 140, 141, 1364 130, -1, 132, 133, 134, 135, -1, 137, 138, -1, 1365 140, 141, 130, -1, 132, 133, 134, 135, 136, 137, 1366 3, 4, 140, 141, 7, -1, 9, 10, -1, -1, 1367 -1, -1, 130, 15, 132, 133, 134, 135, -1, 137, 1368 138, -1, 140, 141, 3, 4, -1, -1, 7, -1, 1369 9, 10, -1, -1, -1, 111, -1, 113, 114, 115, 1314 1370 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1315 8, -1, -1, -1, -1, 13, 14, 15, 16, -1, 1316 -1, -1, 20, -1, -1, -1, -1, -1, -1, -1, 1317 110, -1, 112, 113, 114, 90, 91, 92, 93, 94, 1318 95, 96, 97, 98, 99, 100, 101, 127, -1, -1, 1319 -1, -1, -1, -1, 134, 110, -1, 112, 113, 114, 1320 -1, -1, -1, 143, 119, 120, 146, -1, 8, -1, 1321 -1, -1, 127, 13, 14, 15, 16, 132, -1, 134, 1322 20, -1, -1, -1, -1, -1, -1, -1, 143, 144, 1323 -1, 146, 90, 91, 92, 93, 94, 95, 96, 97, 1324 98, 99, 100, 101, -1, -1, -1, -1, -1, -1, 1325 -1, -1, 110, -1, 112, 113, 114, -1, -1, -1, 1326 -1, 119, 120, -1, -1, 8, -1, -1, -1, 127, 1327 13, 14, 15, 16, 132, -1, 134, 20, -1, -1, 1328 -1, -1, -1, -1, -1, 143, 144, -1, 146, -1, 1329 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 1330 100, 101, -1, -1, -1, -1, -1, -1, -1, -1, 1331 110, -1, 112, 113, 114, -1, -1, -1, -1, 119, 1332 120, -1, -1, 8, -1, -1, -1, 127, 13, 14, 1333 15, 16, 132, -1, 134, 20, -1, -1, -1, -1, 1334 -1, -1, -1, 143, 144, -1, 146, 90, 91, 92, 1335 93, 94, 95, 96, 97, 98, 99, 100, 101, -1, 1336 -1, -1, -1, -1, -1, -1, -1, 110, -1, 112, 1337 113, 114, -1, -1, -1, -1, 119, 120, -1, -1, 1338 8, -1, -1, -1, 127, 13, 14, 15, 16, 132, 1339 -1, 134, 20, -1, -1, -1, -1, -1, -1, -1, 1340 143, 144, -1, 146, -1, 90, 91, 92, 93, 94, 1341 95, 96, 97, 98, 99, 100, 101, -1, -1, -1, 1342 -1, -1, -1, -1, -1, 110, -1, 112, 113, 114, 1343 -1, -1, -1, -1, 119, 120, -1, -1, 8, -1, 1344 -1, -1, 127, 13, 14, 15, 16, 132, -1, 134, 1345 20, -1, -1, -1, -1, -1, -1, -1, 143, 144, 1346 -1, 146, 90, 91, 92, 93, 94, 95, 96, 97, 1347 98, 99, 100, 101, -1, -1, -1, -1, -1, -1, 1348 -1, -1, 110, -1, 112, 113, 114, -1, -1, -1, 1349 -1, 119, 120, -1, -1, 8, -1, -1, -1, 127, 1350 13, 14, 15, 16, 132, -1, 134, 20, -1, -1, 1351 3, 4, -1, -1, 7, 143, 9, 10, 146, -1, 1352 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 1353 100, 101, 3, 4, -1, -1, 7, -1, 9, 10, 1354 110, -1, 112, 113, 114, -1, -1, 3, 4, 119, 1355 120, 7, -1, 9, 10, -1, -1, 127, -1, 3, 1356 4, -1, 132, 7, 134, 9, 10, -1, -1, -1, 1357 -1, -1, -1, 143, -1, -1, 146, 90, 91, 92, 1358 93, 94, 95, 96, 97, 98, 99, 100, 101, 3, 1359 4, -1, -1, 7, -1, 9, 10, 110, -1, 112, 1360 113, 114, -1, -1, 3, 4, 119, 120, 7, -1, 1361 9, 10, 15, -1, 127, -1, 3, 4, -1, 132, 1362 7, 134, 9, 10, -1, -1, -1, -1, 3, 4, 1363 143, -1, 7, 146, 9, 10, 129, -1, 131, 132, 1364 133, 134, -1, 136, 137, -1, 139, 140, 3, 4, 1365 -1, -1, 7, -1, 9, 10, -1, -1, 129, -1, 1366 131, 132, 133, 134, -1, 136, 137, -1, 139, 140, 1367 -1, -1, -1, 129, -1, 131, 132, 133, 134, -1, 1368 136, 137, -1, 139, 140, 129, -1, 131, 132, 133, 1369 134, -1, 136, 137, -1, 139, 140, 3, 4, -1, 1370 -1, 7, -1, 9, 10, -1, -1, 110, -1, 112, 1371 113, 114, 15, -1, -1, 129, -1, 131, 132, 133, 1372 134, 135, 136, -1, 127, 139, 140, -1, -1, -1, 1373 129, 134, 131, 132, 133, 134, -1, 136, 137, -1, 1374 139, 140, 129, 146, 131, 132, 133, 134, -1, 136, 1375 137, 15, 139, 140, 129, -1, 131, 132, 133, 134, 1376 135, 136, 3, 4, 139, 140, 7, -1, 9, 10, 1377 -1, -1, -1, -1, 129, -1, 131, 132, 133, 134, 1378 -1, 136, 137, -1, 139, 140, 3, 4, -1, -1, 1379 7, -1, 9, 10, -1, -1, -1, -1, -1, 4, 1380 -1, -1, 7, -1, 9, 10, -1, 110, -1, 112, 1381 113, 114, -1, -1, -1, -1, -1, -1, -1, -1, 1382 -1, -1, -1, 129, 127, 131, 132, 133, 134, 135, 1383 136, 134, -1, 139, 140, 15, -1, -1, -1, -1, 1384 143, -1, -1, 146, -1, 15, 110, -1, 112, 113, 1385 114, 13, 14, 15, 16, -1, -1, -1, 20, -1, 1386 -1, -1, -1, 127, -1, -1, -1, -1, -1, -1, 1387 134, -1, -1, -1, -1, -1, -1, -1, -1, 143, 1388 -1, -1, 146, -1, -1, -1, -1, -1, 129, -1, 1389 131, 132, 133, 134, -1, 136, -1, -1, 139, 140, 1390 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1391 -1, -1, 129, -1, 131, 132, 133, 134, -1, 136, 1392 -1, -1, 139, 140, 129, -1, 131, 132, 133, 134, 1393 110, 136, 112, 113, 114, 140, 98, 99, 100, 101, 1394 110, -1, 112, 113, 114, -1, -1, 127, 110, -1, 1395 112, 113, 114, -1, 134, -1, -1, 127, -1, -1, 1396 -1, -1, -1, 143, 134, 127, 146, -1, -1, -1, 1397 -1, -1, 134, 143, -1, -1, 146, -1, -1, -1, 1398 -1, -1, 144, -1, 146 1371 -1, -1, 128, -1, -1, -1, -1, -1, -1, 135, 1372 -1, -1, -1, -1, -1, -1, -1, -1, 144, -1, 1373 -1, 147, 130, -1, 132, 133, 134, 135, 136, 137, 1374 15, -1, 140, 141, 13, 14, 15, 16, -1, -1, 1375 -1, 20, -1, -1, -1, -1, -1, -1, -1, -1, 1376 -1, -1, -1, -1, -1, -1, -1, -1, -1, 111, 1377 -1, 113, 114, 115, -1, 15, -1, -1, -1, -1, 1378 -1, -1, -1, -1, -1, -1, 128, 130, -1, 132, 1379 133, 134, 135, 135, 137, -1, -1, 140, 141, -1, 1380 -1, -1, 144, -1, -1, 147, -1, -1, -1, -1, 1381 -1, 130, -1, 132, 133, 134, 135, -1, 137, -1, 1382 -1, 140, 141, -1, -1, -1, -1, -1, -1, -1, 1383 99, 100, 101, 102, -1, -1, 111, -1, 113, 114, 1384 115, -1, 111, -1, 113, 114, 115, -1, -1, -1, 1385 -1, -1, -1, 128, -1, -1, -1, -1, -1, 128, 1386 135, -1, -1, -1, -1, -1, 135, -1, -1, 144, 1387 -1, 111, 147, 113, 114, 115, 145, -1, 147, -1, 1388 -1, -1, -1, -1, -1, -1, -1, -1, 128, -1, 1389 -1, -1, -1, -1, -1, 135, -1, -1, -1, -1, 1390 -1, -1, -1, -1, 144, -1, -1, 147 1399 1391 }; 1400 1392 1401 1393 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1402 1394 symbol of state STATE-NUM. */ 1403 static const yytype_uint8yystos[] =1395 static const unsigned char yystos[] = 1404 1396 { 1405 0, 14 8, 0, 1, 8, 13, 14, 15, 16, 20,1406 40, 9 0, 91, 92, 93, 94, 95, 96, 97, 98,1407 99, 100, 101, 102, 103, 104, 105, 107, 108, 109,1408 11 0, 112, 113, 114, 115, 116, 117, 118, 119, 120,1409 12 1, 122, 123, 124, 125, 126, 127, 129, 132, 134,1410 13 8, 143, 146, 149, 150, 151, 152, 153, 154, 155,1411 15 6, 158, 160, 161, 162, 163, 164, 171, 172, 174,1412 17 5, 176, 177, 178, 179, 180, 181, 182, 183, 184,1413 18 5, 186, 187, 188, 189, 190, 138, 15, 16, 98,1414 99, 100, 101, 127, 156, 171, 143, 154, 162, 143,1415 14 3, 143, 143, 143, 143, 143, 143, 143, 143, 154,1416 14 3, 154, 143, 154, 143, 154, 110, 111, 155, 110,1417 13 8, 154, 143, 156, 110, 111, 143, 143, 110, 143,1418 11 0, 143, 15, 156, 163, 164, 164, 156, 155, 155,1419 15 6, 138, 11, 143, 145, 128, 137, 3, 4, 7,1420 9, 10, 1 29, 131, 132, 133, 134, 136, 139, 140,1421 15 6, 155, 128, 137, 138, 170, 143, 154, 137, 154,1422 15 6, 156, 111, 143, 156, 165, 156, 156, 156, 156,1423 15 6, 156, 156, 144, 155, 156, 144, 155, 156, 144,1424 15 5, 138, 138, 15, 16, 98, 99, 100, 101, 144,1425 15 4, 171, 110, 111, 157, 110, 156, 111, 144, 155,1426 17 3, 135, 144, 146, 154, 144, 155, 154, 156, 156,1427 15 6, 156, 156, 156, 156, 156, 156, 156, 156, 156,1428 12 8, 144, 159, 154, 156, 134, 154, 170, 144, 156,1429 14 4, 137, 144, 137, 137, 137, 144, 137, 144, 137,1430 13 7, 144, 144, 144, 144, 144, 144, 144, 144, 144,1431 14 4, 144, 144, 137, 144, 144, 111, 156, 110, 144,1432 14 4, 138, 144, 135, 137, 156, 137, 144, 156, 156,1433 16 5, 137, 165, 156, 156, 156, 156, 156, 156, 15,1434 16, 9 8, 99, 100, 101, 171, 144, 111, 111, 116,1435 15 6, 159, 156, 135, 137, 155, 137, 144, 137, 144,1436 13 7, 137, 144, 137, 144, 144, 144, 144, 144, 144,1437 14 4, 144, 135, 137, 134, 165, 144, 113, 143, 166,1438 16 7, 169, 156, 156, 156, 156, 156, 156, 137, 167,1439 16 8, 143, 144, 144, 144, 144, 144, 144, 135, 169,1440 13 7, 144, 155, 168, 1441397 0, 149, 0, 1, 8, 13, 14, 15, 16, 20, 1398 40, 91, 92, 93, 94, 95, 96, 97, 98, 99, 1399 100, 101, 102, 103, 104, 105, 106, 108, 109, 110, 1400 111, 113, 114, 115, 116, 117, 118, 119, 120, 121, 1401 122, 123, 124, 125, 126, 127, 128, 130, 133, 135, 1402 139, 144, 147, 150, 151, 152, 153, 154, 155, 156, 1403 157, 159, 161, 162, 163, 164, 165, 172, 173, 175, 1404 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 1405 186, 187, 188, 189, 190, 191, 139, 15, 16, 99, 1406 100, 101, 102, 128, 157, 172, 144, 155, 163, 144, 1407 144, 144, 144, 144, 144, 144, 144, 144, 144, 155, 1408 144, 155, 144, 155, 144, 155, 111, 112, 156, 111, 1409 139, 155, 144, 157, 111, 112, 144, 144, 111, 144, 1410 111, 144, 15, 157, 164, 165, 165, 157, 156, 156, 1411 157, 139, 11, 144, 146, 129, 138, 3, 4, 7, 1412 9, 10, 130, 132, 133, 134, 135, 137, 140, 141, 1413 157, 156, 129, 138, 139, 171, 144, 155, 138, 155, 1414 157, 157, 112, 144, 157, 166, 157, 157, 157, 157, 1415 157, 157, 157, 145, 156, 157, 145, 156, 157, 145, 1416 156, 139, 139, 15, 16, 99, 100, 101, 102, 145, 1417 155, 172, 111, 112, 158, 111, 157, 112, 145, 156, 1418 174, 136, 145, 147, 155, 145, 156, 155, 157, 157, 1419 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 1420 129, 145, 160, 155, 157, 135, 155, 171, 145, 157, 1421 145, 138, 145, 138, 138, 138, 145, 138, 145, 138, 1422 138, 145, 145, 145, 145, 145, 145, 145, 145, 145, 1423 145, 145, 145, 138, 145, 145, 112, 157, 111, 145, 1424 145, 139, 145, 136, 138, 157, 138, 145, 157, 157, 1425 166, 138, 166, 157, 157, 157, 157, 157, 157, 15, 1426 16, 99, 100, 101, 102, 172, 145, 112, 112, 117, 1427 157, 160, 157, 136, 138, 156, 138, 145, 138, 145, 1428 138, 138, 145, 138, 145, 145, 145, 145, 145, 145, 1429 145, 145, 136, 138, 135, 166, 145, 114, 144, 167, 1430 168, 170, 157, 157, 157, 157, 157, 157, 138, 168, 1431 169, 144, 145, 145, 145, 145, 145, 145, 136, 170, 1432 138, 145, 156, 169, 145 1441 1433 }; 1434 1435 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) 1436 # define YYSIZE_T __SIZE_TYPE__ 1437 #endif 1438 #if ! defined (YYSIZE_T) && defined (size_t) 1439 # define YYSIZE_T size_t 1440 #endif 1441 #if ! defined (YYSIZE_T) 1442 # if defined (__STDC__) || defined (__cplusplus) 1443 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 1444 # define YYSIZE_T size_t 1445 # endif 1446 #endif 1447 #if ! defined (YYSIZE_T) 1448 # define YYSIZE_T unsigned int 1449 #endif 1442 1450 1443 1451 #define yyerrok (yyerrstatus = 0) … … 1453 1461 /* Like YYERROR except do call yyerror. This remains here temporarily 1454 1462 to ease the transition to the new meaning of YYERROR, for GCC. 1455 Once GCC version 2 has supplanted version 1, this can go. However, 1456 YYFAIL appears to be in use. Nevertheless, it is formally deprecated 1457 in Bison 2.4.2's NEWS entry, where a plan to phase it out is 1458 discussed. */ 1463 Once GCC version 2 has supplanted version 1, this can go. */ 1459 1464 1460 1465 #define YYFAIL goto yyerrlab 1461 #if defined YYFAIL1462 /* This is here to suppress warnings from the GCC cpp's1463 -Wunused-macros. Normally we don't worry about that warning, but1464 some users do, and we want to make it easy for users to remove1465 YYFAIL uses, which will produce warnings from Bison 2.5. */1466 #endif1467 1466 1468 1467 #define YYRECOVERING() (!!yyerrstatus) … … 1475 1474 yylval = (Value); \ 1476 1475 yytoken = YYTRANSLATE (yychar); \ 1477 YYPOPSTACK (1); \1476 YYPOPSTACK; \ 1478 1477 goto yybackup; \ 1479 1478 } \ 1480 1479 else \ 1481 { \1482 yyerror ( YY_("syntax error: cannot back up"));\1480 { \ 1481 yyerror ("syntax error: cannot back up");\ 1483 1482 YYERROR; \ 1484 1483 } \ 1485 while (YYID (0)) 1486 1484 while (0) 1487 1485 1488 1486 #define YYTERROR 1 1489 1487 #define YYERRCODE 256 1490 1488 1491 1492 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 1493 If N is 0, then set CURRENT to the empty location which ends 1494 the previous symbol: RHS[0] (always defined). */ 1495 1496 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 1489 /* YYLLOC_DEFAULT -- Compute the default location (before the actions 1490 are run). */ 1491 1497 1492 #ifndef YYLLOC_DEFAULT 1498 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 1499 do \ 1500 if (YYID (N)) \ 1501 { \ 1502 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 1503 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 1504 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 1505 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 1506 } \ 1507 else \ 1508 { \ 1509 (Current).first_line = (Current).last_line = \ 1510 YYRHSLOC (Rhs, 0).last_line; \ 1511 (Current).first_column = (Current).last_column = \ 1512 YYRHSLOC (Rhs, 0).last_column; \ 1513 } \ 1514 while (YYID (0)) 1493 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 1494 ((Current).first_line = (Rhs)[1].first_line, \ 1495 (Current).first_column = (Rhs)[1].first_column, \ 1496 (Current).last_line = (Rhs)[N].last_line, \ 1497 (Current).last_column = (Rhs)[N].last_column) 1515 1498 #endif 1516 1517 1518 /* YY_LOCATION_PRINT -- Print the location on the stream.1519 This macro was not mandated originally: define only if we know1520 we won't break user code: when these are the locations we know. */1521 1522 #ifndef YY_LOCATION_PRINT1523 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL1524 # define YY_LOCATION_PRINT(File, Loc) \1525 fprintf (File, "%d.%d-%d.%d", \1526 (Loc).first_line, (Loc).first_column, \1527 (Loc).last_line, (Loc).last_column)1528 # else1529 # define YY_LOCATION_PRINT(File, Loc) do {} while (0)1530 # endif1531 #endif1532 1533 1499 1534 1500 /* YYLEX -- calling `yylex' with the right arguments. */ … … 1552 1518 if (yydebug) \ 1553 1519 YYFPRINTF Args; \ 1554 } while (YYID (0)) 1555 1556 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1557 do { \ 1558 if (yydebug) \ 1559 { \ 1560 YYFPRINTF (stderr, "%s ", Title); \ 1561 yy_symbol_print (stderr, \ 1562 Type, Value); \ 1563 YYFPRINTF (stderr, "\n"); \ 1564 } \ 1565 } while (YYID (0)) 1566 1567 1568 /*--------------------------------. 1569 | Print this symbol on YYOUTPUT. | 1570 `--------------------------------*/ 1571 1572 /*ARGSUSED*/ 1573 #if (defined __STDC__ || defined __C99__FUNC__ \ 1574 || defined __cplusplus || defined _MSC_VER) 1575 static void 1576 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1577 #else 1578 static void 1579 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 1580 FILE *yyoutput; 1581 int yytype; 1582 YYSTYPE const * const yyvaluep; 1583 #endif 1584 { 1585 if (!yyvaluep) 1586 return; 1587 # ifdef YYPRINT 1588 if (yytype < YYNTOKENS) 1589 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1590 # else 1591 YYUSE (yyoutput); 1592 # endif 1593 switch (yytype) 1594 { 1595 default: 1596 break; 1597 } 1598 } 1599 1600 1601 /*--------------------------------. 1602 | Print this symbol on YYOUTPUT. | 1603 `--------------------------------*/ 1604 1605 #if (defined __STDC__ || defined __C99__FUNC__ \ 1606 || defined __cplusplus || defined _MSC_VER) 1607 static void 1608 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1609 #else 1610 static void 1611 yy_symbol_print (yyoutput, yytype, yyvaluep) 1612 FILE *yyoutput; 1613 int yytype; 1614 YYSTYPE const * const yyvaluep; 1615 #endif 1616 { 1617 if (yytype < YYNTOKENS) 1618 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1619 else 1620 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1621 1622 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 1623 YYFPRINTF (yyoutput, ")"); 1624 } 1520 } while (0) 1521 1522 # define YYDSYMPRINT(Args) \ 1523 do { \ 1524 if (yydebug) \ 1525 yysymprint Args; \ 1526 } while (0) 1527 1528 # define YYDSYMPRINTF(Title, Token, Value, Location) \ 1529 do { \ 1530 if (yydebug) \ 1531 { \ 1532 YYFPRINTF (stderr, "%s ", Title); \ 1533 yysymprint (stderr, \ 1534 Token, Value); \ 1535 YYFPRINTF (stderr, "\n"); \ 1536 } \ 1537 } while (0) 1625 1538 1626 1539 /*------------------------------------------------------------------. … … 1629 1542 `------------------------------------------------------------------*/ 1630 1543 1631 #if (defined __STDC__ || defined __C99__FUNC__ \ 1632 || defined __cplusplus || defined _MSC_VER) 1544 #if defined (__STDC__) || defined (__cplusplus) 1633 1545 static void 1634 yy_stack_print ( yytype_int16 *yybottom, yytype_int16 *yytop)1546 yy_stack_print (short int *bottom, short int *top) 1635 1547 #else 1636 1548 static void 1637 yy_stack_print ( yybottom, yytop)1638 yytype_int16 *yybottom;1639 yytype_int16 *yytop;1549 yy_stack_print (bottom, top) 1550 short int *bottom; 1551 short int *top; 1640 1552 #endif 1641 1553 { 1642 1554 YYFPRINTF (stderr, "Stack now"); 1643 for (; yybottom <= yytop; yybottom++) 1644 { 1645 int yybot = *yybottom; 1646 YYFPRINTF (stderr, " %d", yybot); 1647 } 1555 for (/* Nothing. */; bottom <= top; ++bottom) 1556 YYFPRINTF (stderr, " %d", *bottom); 1648 1557 YYFPRINTF (stderr, "\n"); 1649 1558 } … … 1653 1562 if (yydebug) \ 1654 1563 yy_stack_print ((Bottom), (Top)); \ 1655 } while ( YYID (0))1564 } while (0) 1656 1565 1657 1566 … … 1660 1569 `------------------------------------------------*/ 1661 1570 1662 #if (defined __STDC__ || defined __C99__FUNC__ \ 1663 || defined __cplusplus || defined _MSC_VER) 1571 #if defined (__STDC__) || defined (__cplusplus) 1664 1572 static void 1665 yy_reduce_print ( YYSTYPE *yyvsp,int yyrule)1573 yy_reduce_print (int yyrule) 1666 1574 #else 1667 1575 static void 1668 yy_reduce_print (yyvsp, yyrule) 1669 YYSTYPE *yyvsp; 1576 yy_reduce_print (yyrule) 1670 1577 int yyrule; 1671 1578 #endif 1672 1579 { 1673 int yynrhs = yyr2[yyrule];1674 1580 int yyi; 1675 unsigned long int yylno = yyrline[yyrule]; 1676 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1677 yyrule - 1, yylno); 1678 /* The symbols being reduced. */ 1679 for (yyi = 0; yyi < yynrhs; yyi++) 1680 { 1681 YYFPRINTF (stderr, " $%d = ", yyi + 1); 1682 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1683 &(yyvsp[(yyi + 1) - (yynrhs)]) 1684 ); 1685 YYFPRINTF (stderr, "\n"); 1686 } 1581 unsigned int yylno = yyrline[yyrule]; 1582 YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", 1583 yyrule - 1, yylno); 1584 /* Print the symbols being reduced, and their result. */ 1585 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) 1586 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); 1587 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); 1687 1588 } 1688 1589 … … 1690 1591 do { \ 1691 1592 if (yydebug) \ 1692 yy_reduce_print ( yyvsp, Rule);\1693 } while ( YYID (0))1593 yy_reduce_print (Rule); \ 1594 } while (0) 1694 1595 1695 1596 /* Nonzero means print parse trace. It is left uninitialized so that … … 1698 1599 #else /* !YYDEBUG */ 1699 1600 # define YYDPRINTF(Args) 1700 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1601 # define YYDSYMPRINT(Args) 1602 # define YYDSYMPRINTF(Title, Token, Value, Location) 1701 1603 # define YY_STACK_PRINT(Bottom, Top) 1702 1604 # define YY_REDUCE_PRINT(Rule) … … 1713 1615 1714 1616 Do not make this value too large; the results are undefined if 1715 YYSTACK_ALLOC_MAXIMUM< YYSTACK_BYTES (YYMAXDEPTH)1617 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) 1716 1618 evaluated with infinite-precision integer arithmetic. */ 1619 1620 #if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 1621 # undef YYMAXDEPTH 1622 #endif 1717 1623 1718 1624 #ifndef YYMAXDEPTH … … 1726 1632 1727 1633 # ifndef yystrlen 1728 # if defined __GLIBC__ && defined _STRING_H1634 # if defined (__GLIBC__) && defined (_STRING_H) 1729 1635 # define yystrlen strlen 1730 1636 # else 1731 1637 /* Return the length of YYSTR. */ 1732 #if (defined __STDC__ || defined __C99__FUNC__ \1733 || defined __cplusplus || defined _MSC_VER)1734 1638 static YYSIZE_T 1639 # if defined (__STDC__) || defined (__cplusplus) 1735 1640 yystrlen (const char *yystr) 1736 #else 1737 static YYSIZE_T 1641 # else 1738 1642 yystrlen (yystr) 1739 const char *yystr;1740 # endif1643 const char *yystr; 1644 # endif 1741 1645 { 1742 YYSIZE_T yylen; 1743 for (yylen = 0; yystr[yylen]; yylen++) 1646 register const char *yys = yystr; 1647 1648 while (*yys++ != '\0') 1744 1649 continue; 1745 return yylen; 1650 1651 return yys - yystr - 1; 1746 1652 } 1747 1653 # endif … … 1749 1655 1750 1656 # ifndef yystpcpy 1751 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE1657 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) 1752 1658 # define yystpcpy stpcpy 1753 1659 # else 1754 1660 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1755 1661 YYDEST. */ 1756 #if (defined __STDC__ || defined __C99__FUNC__ \1757 || defined __cplusplus || defined _MSC_VER)1758 1662 static char * 1663 # if defined (__STDC__) || defined (__cplusplus) 1759 1664 yystpcpy (char *yydest, const char *yysrc) 1760 #else 1761 static char * 1665 # else 1762 1666 yystpcpy (yydest, yysrc) 1763 char *yydest;1764 const char *yysrc;1765 # endif1667 char *yydest; 1668 const char *yysrc; 1669 # endif 1766 1670 { 1767 char *yyd = yydest;1768 const char *yys = yysrc;1671 register char *yyd = yydest; 1672 register const char *yys = yysrc; 1769 1673 1770 1674 while ((*yyd++ = *yys++) != '\0') … … 1776 1680 # endif 1777 1681 1778 # ifndef yytnamerr 1779 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1780 quotes and backslashes, so that it's suitable for yyerror. The 1781 heuristic is that double-quoting is unnecessary unless the string 1782 contains an apostrophe, a comma, or backslash (other than 1783 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1784 null, do not copy; instead, return the length of what the result 1785 would have been. */ 1786 static YYSIZE_T 1787 yytnamerr (char *yyres, const char *yystr) 1788 { 1789 if (*yystr == '"') 1790 { 1791 YYSIZE_T yyn = 0; 1792 char const *yyp = yystr; 1793 1794 for (;;) 1795 switch (*++yyp) 1796 { 1797 case '\'': 1798 case ',': 1799 goto do_not_strip_quotes; 1800 1801 case '\\': 1802 if (*++yyp != '\\') 1803 goto do_not_strip_quotes; 1804 /* Fall through. */ 1805 default: 1806 if (yyres) 1807 yyres[yyn] = *yyp; 1808 yyn++; 1809 break; 1810 1811 case '"': 1812 if (yyres) 1813 yyres[yyn] = '\0'; 1814 return yyn; 1815 } 1816 do_not_strip_quotes: ; 1817 } 1818 1819 if (! yyres) 1820 return yystrlen (yystr); 1821 1822 return yystpcpy (yyres, yystr) - yyres; 1823 } 1824 # endif 1825 1826 /* Copy into YYRESULT an error message about the unexpected token 1827 YYCHAR while in state YYSTATE. Return the number of bytes copied, 1828 including the terminating null byte. If YYRESULT is null, do not 1829 copy anything; just return the number of bytes that would be 1830 copied. As a special case, return 0 if an ordinary "syntax error" 1831 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 1832 size calculation. */ 1833 static YYSIZE_T 1834 yysyntax_error (char *yyresult, int yystate, int yychar) 1835 { 1836 int yyn = yypact[yystate]; 1837 1838 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 1839 return 0; 1840 else 1841 { 1842 int yytype = YYTRANSLATE (yychar); 1843 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 1844 YYSIZE_T yysize = yysize0; 1845 YYSIZE_T yysize1; 1846 int yysize_overflow = 0; 1847 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1848 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1849 int yyx; 1850 1851 # if 0 1852 /* This is so xgettext sees the translatable formats that are 1853 constructed on the fly. */ 1854 YY_("syntax error, unexpected %s"); 1855 YY_("syntax error, unexpected %s, expecting %s"); 1856 YY_("syntax error, unexpected %s, expecting %s or %s"); 1857 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 1858 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 1859 # endif 1860 char *yyfmt; 1861 char const *yyf; 1862 static char const yyunexpected[] = "syntax error, unexpected %s"; 1863 static char const yyexpecting[] = ", expecting %s"; 1864 static char const yyor[] = " or %s"; 1865 char yyformat[sizeof yyunexpected 1866 + sizeof yyexpecting - 1 1867 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 1868 * (sizeof yyor - 1))]; 1869 char const *yyprefix = yyexpecting; 1870 1871 /* Start YYX at -YYN if negative to avoid negative indexes in 1872 YYCHECK. */ 1873 int yyxbegin = yyn < 0 ? -yyn : 0; 1874 1875 /* Stay within bounds of both yycheck and yytname. */ 1876 int yychecklim = YYLAST - yyn + 1; 1877 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1878 int yycount = 1; 1879 1880 yyarg[0] = yytname[yytype]; 1881 yyfmt = yystpcpy (yyformat, yyunexpected); 1882 1883 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1884 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1885 { 1886 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1887 { 1888 yycount = 1; 1889 yysize = yysize0; 1890 yyformat[sizeof yyunexpected - 1] = '\0'; 1891 break; 1892 } 1893 yyarg[yycount++] = yytname[yyx]; 1894 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1895 yysize_overflow |= (yysize1 < yysize); 1896 yysize = yysize1; 1897 yyfmt = yystpcpy (yyfmt, yyprefix); 1898 yyprefix = yyor; 1899 } 1900 1901 yyf = YY_(yyformat); 1902 yysize1 = yysize + yystrlen (yyf); 1903 yysize_overflow |= (yysize1 < yysize); 1904 yysize = yysize1; 1905 1906 if (yysize_overflow) 1907 return YYSIZE_MAXIMUM; 1908 1909 if (yyresult) 1910 { 1911 /* Avoid sprintf, as that infringes on the user's name space. 1912 Don't have undefined behavior even if the translation 1913 produced a string with the wrong number of "%s"s. */ 1914 char *yyp = yyresult; 1915 int yyi = 0; 1916 while ((*yyp = *yyf) != '\0') 1917 { 1918 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 1919 { 1920 yyp += yytnamerr (yyp, yyarg[yyi++]); 1921 yyf += 2; 1922 } 1923 else 1924 { 1925 yyp++; 1926 yyf++; 1927 } 1928 } 1929 } 1930 return yysize; 1931 } 1932 } 1933 #endif /* YYERROR_VERBOSE */ 1934 1935 1936 1937 /*-----------------------------------------------. 1938 | Release the memory associated to this symbol. | 1939 `-----------------------------------------------*/ 1940 1941 /*ARGSUSED*/ 1942 #if (defined __STDC__ || defined __C99__FUNC__ \ 1943 || defined __cplusplus || defined _MSC_VER) 1682 #endif /* !YYERROR_VERBOSE */ 1683 1684 1685 1686 1687 #if YYDEBUG 1688 /*--------------------------------. 1689 | Print this symbol on YYOUTPUT. | 1690 `--------------------------------*/ 1691 1692 #if defined (__STDC__) || defined (__cplusplus) 1944 1693 static void 1945 yy destruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)1694 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) 1946 1695 #else 1947 1696 static void 1948 yy destruct (yymsg, yytype, yyvaluep)1949 const char *yymsg;1697 yysymprint (yyoutput, yytype, yyvaluep) 1698 FILE *yyoutput; 1950 1699 int yytype; 1951 1700 YYSTYPE *yyvaluep; 1952 1701 #endif 1953 1702 { 1954 YYUSE (yyvaluep); 1955 1956 if (!yymsg) 1957 yymsg = "Deleting"; 1958 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1703 /* Pacify ``unused variable'' warnings. */ 1704 (void) yyvaluep; 1705 1706 if (yytype < YYNTOKENS) 1707 { 1708 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1709 # ifdef YYPRINT 1710 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1711 # endif 1712 } 1713 else 1714 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1959 1715 1960 1716 switch (yytype) 1961 1717 { 1962 1963 1718 default: 1964 break; 1719 break; 1720 } 1721 YYFPRINTF (yyoutput, ")"); 1722 } 1723 1724 #endif /* ! YYDEBUG */ 1725 /*-----------------------------------------------. 1726 | Release the memory associated to this symbol. | 1727 `-----------------------------------------------*/ 1728 1729 #if defined (__STDC__) || defined (__cplusplus) 1730 static void 1731 yydestruct (int yytype, YYSTYPE *yyvaluep) 1732 #else 1733 static void 1734 yydestruct (yytype, yyvaluep) 1735 int yytype; 1736 YYSTYPE *yyvaluep; 1737 #endif 1738 { 1739 /* Pacify ``unused variable'' warnings. */ 1740 (void) yyvaluep; 1741 1742 switch (yytype) 1743 { 1744 1745 default: 1746 break; 1965 1747 } 1966 1748 } 1967 1749 1750 1751 1968 1752 /* Prevent warnings from -Wmissing-prototypes. */ 1753 1969 1754 #ifdef YYPARSE_PARAM 1970 # if defined __STDC__ || defined __cplusplus1755 # if defined (__STDC__) || defined (__cplusplus) 1971 1756 int yyparse (void *YYPARSE_PARAM); 1972 # else1757 # else 1973 1758 int yyparse (); 1974 # endif1759 # endif 1975 1760 #else /* ! YYPARSE_PARAM */ 1976 #if defined __STDC__ || defined __cplusplus1761 #if defined (__STDC__) || defined (__cplusplus) 1977 1762 int yyparse (void); 1978 1763 #else … … 1985 1770 1986 1771 1987 /*-------------------------. 1988 | yyparse or yypush_parse. | 1989 `-------------------------*/ 1772 1773 /*----------. 1774 | yyparse. | 1775 `----------*/ 1990 1776 1991 1777 #ifdef YYPARSE_PARAM 1992 #if (defined __STDC__ || defined __C99__FUNC__ \ 1993 || defined __cplusplus || defined _MSC_VER) 1994 int 1995 yyparse (void *YYPARSE_PARAM) 1996 #else 1997 int 1998 yyparse (YYPARSE_PARAM) 1999 void *YYPARSE_PARAM; 2000 #endif 1778 # if defined (__STDC__) || defined (__cplusplus) 1779 int yyparse (void *YYPARSE_PARAM) 1780 # else 1781 int yyparse (YYPARSE_PARAM) 1782 void *YYPARSE_PARAM; 1783 # endif 2001 1784 #else /* ! YYPARSE_PARAM */ 2002 #if (defined __STDC__ || defined __C99__FUNC__ \ 2003 || defined __cplusplus || defined _MSC_VER) 1785 #if defined (__STDC__) || defined (__cplusplus) 2004 1786 int 2005 1787 yyparse (void) … … 2011 1793 #endif 2012 1794 { 2013 /* The lookahead symbol. */1795 /* The lookahead symbol. */ 2014 1796 int yychar; 2015 1797 … … 2017 1799 YYSTYPE yylval; 2018 1800 2019 /* Number of syntax errors so far. */ 2020 int yynerrs; 2021 2022 int yystate; 2023 /* Number of tokens to shift before error messages enabled. */ 2024 int yyerrstatus; 2025 2026 /* The stacks and their tools: 2027 `yyss': related to states. 2028 `yyvs': related to semantic values. 2029 2030 Refer to the stacks thru separate pointers, to allow yyoverflow 2031 to reallocate them elsewhere. */ 2032 2033 /* The state stack. */ 2034 yytype_int16 yyssa[YYINITDEPTH]; 2035 yytype_int16 *yyss; 2036 yytype_int16 *yyssp; 2037 2038 /* The semantic value stack. */ 2039 YYSTYPE yyvsa[YYINITDEPTH]; 2040 YYSTYPE *yyvs; 2041 YYSTYPE *yyvsp; 2042 2043 YYSIZE_T yystacksize; 2044 2045 int yyn; 1801 /* Number of syntax errors so far. */ 1802 int yynerrs; 1803 1804 register int yystate; 1805 register int yyn; 2046 1806 int yyresult; 1807 /* Number of tokens to shift before error messages enabled. */ 1808 int yyerrstatus; 2047 1809 /* Lookahead token as an internal (translated) token number. */ 2048 int yytoken; 1810 int yytoken = 0; 1811 1812 /* Three stacks and their tools: 1813 `yyss': related to states, 1814 `yyvs': related to semantic values, 1815 `yyls': related to locations. 1816 1817 Refer to the stacks thru separate pointers, to allow yyoverflow 1818 to reallocate them elsewhere. */ 1819 1820 /* The state stack. */ 1821 short int yyssa[YYINITDEPTH]; 1822 short int *yyss = yyssa; 1823 register short int *yyssp; 1824 1825 /* The semantic value stack. */ 1826 YYSTYPE yyvsa[YYINITDEPTH]; 1827 YYSTYPE *yyvs = yyvsa; 1828 register YYSTYPE *yyvsp; 1829 1830 1831 1832 #define YYPOPSTACK (yyvsp--, yyssp--) 1833 1834 YYSIZE_T yystacksize = YYINITDEPTH; 1835 2049 1836 /* The variables used to return semantic value and location from the 2050 1837 action routines. */ 2051 1838 YYSTYPE yyval; 2052 1839 2053 #if YYERROR_VERBOSE 2054 /* Buffer for error messages, and its allocated size. */ 2055 char yymsgbuf[128]; 2056 char *yymsg = yymsgbuf; 2057 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 2058 #endif 2059 2060 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 2061 2062 /* The number of symbols on the RHS of the reduced rule. 2063 Keep to zero when no symbol should be popped. */ 2064 int yylen = 0; 2065 2066 yytoken = 0; 2067 yyss = yyssa; 2068 yyvs = yyvsa; 2069 yystacksize = YYINITDEPTH; 1840 1841 /* When reducing, the number of symbols on the RHS of the reduced 1842 rule. */ 1843 int yylen; 2070 1844 2071 1845 YYDPRINTF ((stderr, "Starting parse\n")); … … 2074 1848 yyerrstatus = 0; 2075 1849 yynerrs = 0; 2076 yychar = YYEMPTY; 1850 yychar = YYEMPTY; /* Cause a token to be read. */ 2077 1851 2078 1852 /* Initialize stack pointers. … … 2080 1854 so that they stay on the same level as the state stack. 2081 1855 The wasted elements are never initialized. */ 1856 2082 1857 yyssp = yyss; 2083 1858 yyvsp = yyvs; 1859 2084 1860 2085 1861 goto yysetstate; … … 2090 1866 yynewstate: 2091 1867 /* In all cases, when you get here, the value and location stacks 2092 have just been pushed. So pushing a state here evens the stacks. */ 1868 have just been pushed. so pushing a state here evens the stacks. 1869 */ 2093 1870 yyssp++; 2094 1871 … … 2103 1880 #ifdef yyoverflow 2104 1881 { 2105 /* Give user a chance to reallocate the stack. 1882 /* Give user a chance to reallocate the stack. Use copies of 2106 1883 these so that the &'s don't force the real ones into 2107 1884 memory. */ 2108 1885 YYSTYPE *yyvs1 = yyvs; 2109 yytype_int16 *yyss1 = yyss; 1886 short int *yyss1 = yyss; 1887 2110 1888 2111 1889 /* Each stack pointer address is followed by the size of the … … 2113 1891 conditional around just the two extra args, but that might 2114 1892 be undefined if yyoverflow is a macro. */ 2115 yyoverflow ( YY_("memory exhausted"),1893 yyoverflow ("parser stack overflow", 2116 1894 &yyss1, yysize * sizeof (*yyssp), 2117 1895 &yyvs1, yysize * sizeof (*yyvsp), 1896 2118 1897 &yystacksize); 2119 1898 … … 2123 1902 #else /* no yyoverflow */ 2124 1903 # ifndef YYSTACK_RELOCATE 2125 goto yy exhaustedlab;1904 goto yyoverflowlab; 2126 1905 # else 2127 1906 /* Extend the stack our own way. */ 2128 1907 if (YYMAXDEPTH <= yystacksize) 2129 goto yy exhaustedlab;1908 goto yyoverflowlab; 2130 1909 yystacksize *= 2; 2131 1910 if (YYMAXDEPTH < yystacksize) … … 2133 1912 2134 1913 { 2135 yytype_int16*yyss1 = yyss;1914 short int *yyss1 = yyss; 2136 1915 union yyalloc *yyptr = 2137 1916 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 2138 1917 if (! yyptr) 2139 goto yyexhaustedlab; 2140 YYSTACK_RELOCATE (yyss_alloc, yyss); 2141 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1918 goto yyoverflowlab; 1919 YYSTACK_RELOCATE (yyss); 1920 YYSTACK_RELOCATE (yyvs); 1921 2142 1922 # undef YYSTACK_RELOCATE 2143 1923 if (yyss1 != yyssa) … … 2150 1930 yyvsp = yyvs + yysize - 1; 2151 1931 1932 2152 1933 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 2153 1934 (unsigned long int) yystacksize)); … … 2158 1939 2159 1940 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 2160 2161 if (yystate == YYFINAL)2162 YYACCEPT;2163 1941 2164 1942 goto yybackup; … … 2169 1947 yybackup: 2170 1948 2171 /* Do appropriate processing given the current state. Read a 2172 lookahead token if we need one and don't already have one. */ 1949 /* Do appropriate processing given the current state. */ 1950 /* Read a lookahead token if we need one and don't already have one. */ 1951 /* yyresume: */ 2173 1952 2174 1953 /* First try to decide what to do without reference to lookahead token. */ 1954 2175 1955 yyn = yypact[yystate]; 2176 1956 if (yyn == YYPACT_NINF) … … 2194 1974 { 2195 1975 yytoken = YYTRANSLATE (yychar); 2196 YY _SYMBOL_PRINT("Next token is", yytoken, &yylval, &yylloc);1976 YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); 2197 1977 } 2198 1978 … … 2211 1991 } 2212 1992 1993 if (yyn == YYFINAL) 1994 YYACCEPT; 1995 1996 /* Shift the lookahead token. */ 1997 YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); 1998 1999 /* Discard the token being shifted unless it is eof. */ 2000 if (yychar != YYEOF) 2001 yychar = YYEMPTY; 2002 2003 *++yyvsp = yylval; 2004 2005 2213 2006 /* Count tokens shifted since error; after three, turn off error 2214 2007 status. */ … … 2216 2009 yyerrstatus--; 2217 2010 2218 /* Shift the lookahead token. */2219 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);2220 2221 /* Discard the shifted token. */2222 yychar = YYEMPTY;2223 2224 2011 yystate = yyn; 2225 *++yyvsp = yylval;2226 2227 2012 goto yynewstate; 2228 2013 … … 2260 2045 { 2261 2046 case 3: 2262 2263 /* Line 1464 of yacc.c */ 2264 #line 366 "grammar.y" 2047 #line 367 "grammar.y" 2265 2048 { 2266 2049 if (timerv) … … 2296 2079 2297 2080 case 5: 2298 2299 /* Line 1464 of yacc.c */ 2300 #line 401 "grammar.y" 2081 #line 402 "grammar.y" 2301 2082 {currentVoice->ifsw=0;;} 2302 2083 break; 2303 2084 2304 2085 case 6: 2305 2306 /* Line 1464 of yacc.c */ 2307 #line 403 "grammar.y" 2308 { (yyvsp[(1) - (2)].lv).CleanUp(); currentVoice->ifsw=0;;} 2086 #line 404 "grammar.y" 2087 { yyvsp[-1].lv.CleanUp(); currentVoice->ifsw=0;;} 2309 2088 break; 2310 2089 2311 2090 case 7: 2312 2313 /* Line 1464 of yacc.c */ 2314 #line 405 "grammar.y" 2091 #line 406 "grammar.y" 2315 2092 { 2316 2093 YYACCEPT; … … 2319 2096 2320 2097 case 8: 2321 2322 /* Line 1464 of yacc.c */ 2323 #line 409 "grammar.y" 2098 #line 410 "grammar.y" 2324 2099 { 2325 2100 currentVoice->ifsw=0; … … 2329 2104 2330 2105 case 9: 2331 2332 /* Line 1464 of yacc.c */ 2333 #line 414 "grammar.y" 2106 #line 415 "grammar.y" 2334 2107 {currentVoice->ifsw=0;;} 2335 2108 break; 2336 2109 2337 2110 case 10: 2338 2339 /* Line 1464 of yacc.c */ 2340 #line 416 "grammar.y" 2111 #line 417 "grammar.y" 2341 2112 { 2342 2113 #ifdef SIQ … … 2348 2119 { 2349 2120 /* bison failed here*/ 2350 if ((inerror!=3) && ( (yyvsp[(1) - (2)].i)<UMINUS) && ((yyvsp[(1) - (2)].i)>' '))2121 if ((inerror!=3) && (yyvsp[-1].i<UMINUS) && (yyvsp[-1].i>' ')) 2351 2122 { 2352 2123 // 1: yyerror called … … 2354 2125 // 3: error rule put token+\n 2355 2126 inerror=3; 2356 Print(" error at token `%s`\n",iiTwoOps( (yyvsp[(1) - (2)].i)));2127 Print(" error at token `%s`\n",iiTwoOps(yyvsp[-1].i)); 2357 2128 } 2358 2129 /**/ … … 2390 2161 2391 2162 case 18: 2392 2393 /* Line 1464 of yacc.c */ 2394 #line 474 "grammar.y" 2163 #line 475 "grammar.y" 2395 2164 {if (currentVoice!=NULL) currentVoice->ifsw=0;;} 2396 2165 break; 2397 2166 2398 2167 case 19: 2399 2400 /* Line 1464 of yacc.c */ 2401 #line 477 "grammar.y" 2402 { omFree((ADDRESS)(yyvsp[(2) - (2)].name)); ;} 2168 #line 478 "grammar.y" 2169 { omFree((ADDRESS)yyvsp[0].name); ;} 2403 2170 break; 2404 2171 2405 2172 case 29: 2406 2407 /* Line 1464 of yacc.c */ 2408 #line 492 "grammar.y" 2409 { 2410 if(iiAssign(&(yyvsp[(1) - (2)].lv),&(yyvsp[(2) - (2)].lv))) YYERROR; 2173 #line 493 "grammar.y" 2174 { 2175 if(iiAssign(&yyvsp[-1].lv,&yyvsp[0].lv)) YYERROR; 2411 2176 ;} 2412 2177 break; 2413 2178 2414 2179 case 30: 2415 2416 /* Line 1464 of yacc.c */ 2417 #line 499 "grammar.y" 2180 #line 500 "grammar.y" 2418 2181 { 2419 2182 if (currRing==NULL) MYYERROR("no ring active"); 2420 syMake(& (yyval.lv),omStrDup((yyvsp[(1) - (1)].name)));2183 syMake(&yyval.lv,omStrDup(yyvsp[0].name)); 2421 2184 ;} 2422 2185 break; 2423 2186 2424 2187 case 31: 2425 2426 /* Line 1464 of yacc.c */ 2427 #line 504 "grammar.y" 2428 { 2429 syMake(&(yyval.lv),(yyvsp[(1) - (1)].name)); 2188 #line 505 "grammar.y" 2189 { 2190 syMake(&yyval.lv,yyvsp[0].name); 2430 2191 ;} 2431 2192 break; 2432 2193 2433 2194 case 32: 2434 2435 /* Line 1464 of yacc.c */ 2436 #line 508 "grammar.y" 2437 { 2438 if(iiExprArith2(&(yyval.lv), &(yyvsp[(1) - (3)].lv), COLONCOLON, &(yyvsp[(3) - (3)].lv))) YYERROR; 2195 #line 509 "grammar.y" 2196 { 2197 if(iiExprArith2(&yyval.lv, &yyvsp[-2].lv, COLONCOLON, &yyvsp[0].lv)) YYERROR; 2439 2198 ;} 2440 2199 break; 2441 2200 2442 2201 case 33: 2443 2444 /* Line 1464 of yacc.c */ 2445 #line 512 "grammar.y" 2446 { 2447 if(iiExprArith2(&(yyval.lv), &(yyvsp[(1) - (3)].lv), '.', &(yyvsp[(3) - (3)].lv))) YYERROR; 2202 #line 513 "grammar.y" 2203 { 2204 if(iiExprArith2(&yyval.lv, &yyvsp[-2].lv, '.', &yyvsp[0].lv)) YYERROR; 2448 2205 ;} 2449 2206 break; 2450 2207 2451 2208 case 34: 2452 2453 /* Line 1464 of yacc.c */ 2454 #line 516 "grammar.y" 2455 { 2456 if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'(')) YYERROR; 2209 #line 517 "grammar.y" 2210 { 2211 if(iiExprArith1(&yyval.lv,&yyvsp[-2].lv,'(')) YYERROR; 2457 2212 ;} 2458 2213 break; 2459 2214 2460 2215 case 35: 2461 2462 /* Line 1464 of yacc.c */ 2463 #line 520 "grammar.y" 2464 { 2465 if ((yyvsp[(1) - (4)].lv).rtyp==UNKNOWN) 2216 #line 521 "grammar.y" 2217 { 2218 if (yyvsp[-3].lv.rtyp==UNKNOWN) 2466 2219 { // for x(i)(j) 2467 if(iiExprArith2(& (yyval.lv),&(yyvsp[(1) - (4)].lv),'(',&(yyvsp[(3) - (4)].lv))) YYERROR;2220 if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,'(',&yyvsp[-1].lv)) YYERROR; 2468 2221 } 2469 2222 else 2470 2223 { 2471 (yyvsp[(1) - (4)].lv).next=(leftv)omAllocBin(sleftv_bin);2472 memcpy( (yyvsp[(1) - (4)].lv).next,&(yyvsp[(3) - (4)].lv),sizeof(sleftv));2473 if(iiExprArithM(& (yyval.lv),&(yyvsp[(1) - (4)].lv),'(')) YYERROR;2224 yyvsp[-3].lv.next=(leftv)omAllocBin(sleftv_bin); 2225 memcpy(yyvsp[-3].lv.next,&yyvsp[-1].lv,sizeof(sleftv)); 2226 if(iiExprArithM(&yyval.lv,&yyvsp[-3].lv,'(')) YYERROR; 2474 2227 } 2475 2228 ;} … … 2477 2230 2478 2231 case 36: 2479 2480 /* Line 1464 of yacc.c */ 2481 #line 533 "grammar.y" 2232 #line 534 "grammar.y" 2482 2233 { 2483 2234 if (currRingHdl==NULL) MYYERROR("no ring active"); 2484 2235 int j = 0; 2485 memset(& (yyval.lv),0,sizeof(sleftv));2486 (yyval.lv).rtyp=VECTOR_CMD;2487 leftv v = & (yyvsp[(2) - (3)].lv);2236 memset(&yyval.lv,0,sizeof(sleftv)); 2237 yyval.lv.rtyp=VECTOR_CMD; 2238 leftv v = &yyvsp[-1].lv; 2488 2239 while (v!=NULL) 2489 2240 { … … 2494 2245 if((i==0) || (iiConvert(t /*v->Typ()*/,POLY_CMD,i,v,&tmp))) 2495 2246 { 2496 pDelete((poly *)& (yyval.lv).data);2497 (yyvsp[(2) - (3)].lv).CleanUp();2247 pDelete((poly *)&yyval.lv.data); 2248 yyvsp[-1].lv.CleanUp(); 2498 2249 MYYERROR("expected '[poly,...'"); 2499 2250 } 2500 2251 poly p = (poly)tmp.CopyD(POLY_CMD); 2501 2252 pSetCompP(p,++j); 2502 (yyval.lv).data = (void *)pAdd((poly)(yyval.lv).data,p);2253 yyval.lv.data = (void *)pAdd((poly)yyval.lv.data,p); 2503 2254 v->next=tmp.next;tmp.next=NULL; 2504 2255 tmp.CleanUp(); 2505 2256 v=v->next; 2506 2257 } 2507 (yyvsp[(2) - (3)].lv).CleanUp();2258 yyvsp[-1].lv.CleanUp(); 2508 2259 ;} 2509 2260 break; 2510 2261 2511 2262 case 37: 2512 2513 /* Line 1464 of yacc.c */ 2514 #line 561 "grammar.y" 2515 { 2516 memset(&(yyval.lv),0,sizeof((yyval.lv))); 2517 int i = atoi((yyvsp[(1) - (1)].name)); 2263 #line 562 "grammar.y" 2264 { 2265 memset(&yyval.lv,0,sizeof(yyval.lv)); 2266 int i = atoi(yyvsp[0].name); 2518 2267 /*remember not to omFree($1) 2519 2268 *because it is a part of the scanner buffer*/ 2520 (yyval.lv).rtyp = INT_CMD;2521 (yyval.lv).data = (void *)(long)i;2269 yyval.lv.rtyp = INT_CMD; 2270 yyval.lv.data = (void *)(long)i; 2522 2271 2523 2272 /* check: out of range input */ 2524 int l = strlen( (yyvsp[(1) - (1)].name))+2;2273 int l = strlen(yyvsp[0].name)+2; 2525 2274 number n; 2526 2275 if (l >= MAX_INT_LEN) … … 2528 2277 char tmp[MAX_INT_LEN+5]; 2529 2278 sprintf(tmp,"%d",i); 2530 if (strcmp(tmp, (yyvsp[(1) - (1)].name))!=0)2279 if (strcmp(tmp,yyvsp[0].name)!=0) 2531 2280 { 2532 n_Read( (yyvsp[(1) - (1)].name),&n,coeffs_BIGINT);2533 (yyval.lv).rtyp=BIGINT_CMD;2534 (yyval.lv).data = n;2281 n_Read(yyvsp[0].name,&n,coeffs_BIGINT); 2282 yyval.lv.rtyp=BIGINT_CMD; 2283 yyval.lv.data = n; 2535 2284 } 2536 2285 } … … 2539 2288 2540 2289 case 38: 2541 2542 /* Line 1464 of yacc.c */ 2543 #line 585 "grammar.y" 2544 { 2545 memset(&(yyval.lv),0,sizeof((yyval.lv))); 2546 (yyval.lv).rtyp = (yyvsp[(1) - (1)].i); 2547 (yyval.lv).data = (yyval.lv).Data(); 2290 #line 586 "grammar.y" 2291 { 2292 memset(&yyval.lv,0,sizeof(yyval.lv)); 2293 yyval.lv.rtyp = yyvsp[0].i; 2294 yyval.lv.data = yyval.lv.Data(); 2548 2295 ;} 2549 2296 break; 2550 2297 2551 2298 case 39: 2552 2553 /* Line 1464 of yacc.c */ 2554 #line 591 "grammar.y" 2555 { 2556 memset(&(yyval.lv),0,sizeof((yyval.lv))); 2557 (yyval.lv).rtyp = STRING_CMD; 2558 (yyval.lv).data = (yyvsp[(1) - (1)].name); 2299 #line 592 "grammar.y" 2300 { 2301 memset(&yyval.lv,0,sizeof(yyval.lv)); 2302 yyval.lv.rtyp = STRING_CMD; 2303 yyval.lv.data = yyvsp[0].name; 2559 2304 ;} 2560 2305 break; 2561 2306 2562 2307 case 40: 2563 2564 /* Line 1464 of yacc.c */ 2565 #line 597 "grammar.y" 2566 { 2567 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR; 2308 #line 598 "grammar.y" 2309 { 2310 if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR; 2568 2311 ;} 2569 2312 break; 2570 2313 2571 2314 case 41: 2572 2573 /* Line 1464 of yacc.c */ 2574 #line 604 "grammar.y" 2575 { 2576 leftv v = &(yyvsp[(1) - (3)].lv); 2315 #line 605 "grammar.y" 2316 { 2317 leftv v = &yyvsp[-2].lv; 2577 2318 while (v->next!=NULL) 2578 2319 { … … 2580 2321 } 2581 2322 v->next = (leftv)omAllocBin(sleftv_bin); 2582 memcpy(v->next,&( (yyvsp[(3) - (3)].lv)),sizeof(sleftv));2583 (yyval.lv) = (yyvsp[(1) - (3)].lv);2323 memcpy(v->next,&(yyvsp[0].lv),sizeof(sleftv)); 2324 yyval.lv = yyvsp[-2].lv; 2584 2325 ;} 2585 2326 break; 2586 2327 2587 2328 case 42: 2588 2589 /* Line 1464 of yacc.c */ 2590 #line 615 "grammar.y" 2591 { 2592 (yyval.lv) = (yyvsp[(1) - (1)].lv); 2329 #line 616 "grammar.y" 2330 { 2331 yyval.lv = yyvsp[0].lv; 2593 2332 ;} 2594 2333 break; 2595 2334 2596 2335 case 43: 2597 2598 /* Line 1464 of yacc.c */ 2599 #line 621 "grammar.y" 2336 #line 622 "grammar.y" 2600 2337 { 2601 2338 /*if ($1.typ == eunknown) YYERROR;*/ 2602 (yyval.lv) = (yyvsp[(1) - (1)].lv);2339 yyval.lv = yyvsp[0].lv; 2603 2340 ;} 2604 2341 break; 2605 2342 2606 2343 case 44: 2607 2608 /* Line 1464 of yacc.c */ 2609 #line 625 "grammar.y" 2610 { (yyval.lv) = (yyvsp[(1) - (1)].lv); ;} 2344 #line 626 "grammar.y" 2345 { yyval.lv = yyvsp[0].lv; ;} 2611 2346 break; 2612 2347 2613 2348 case 45: 2614 2615 /* Line 1464 of yacc.c */ 2616 #line 626 "grammar.y" 2617 { (yyval.lv) = (yyvsp[(2) - (3)].lv); ;} 2349 #line 627 "grammar.y" 2350 { yyval.lv = yyvsp[-1].lv; ;} 2618 2351 break; 2619 2352 2620 2353 case 46: 2621 2622 /* Line 1464 of yacc.c */ 2623 #line 628 "grammar.y" 2624 { 2625 if(iiExprArith3(&(yyval.lv),'[',&(yyvsp[(1) - (6)].lv),&(yyvsp[(3) - (6)].lv),&(yyvsp[(5) - (6)].lv))) YYERROR; 2354 #line 629 "grammar.y" 2355 { 2356 if(iiExprArith3(&yyval.lv,'[',&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR; 2626 2357 ;} 2627 2358 break; 2628 2359 2629 2360 case 47: 2630 2631 /* Line 1464 of yacc.c */ 2632 #line 632 "grammar.y" 2633 { 2634 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'[',&(yyvsp[(3) - (4)].lv))) YYERROR; 2361 #line 633 "grammar.y" 2362 { 2363 if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,'[',&yyvsp[-1].lv)) YYERROR; 2635 2364 ;} 2636 2365 break; 2637 2366 2638 2367 case 48: 2639 2640 /* Line 1464 of yacc.c */ 2641 #line 636 "grammar.y" 2642 { 2643 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR; 2368 #line 637 "grammar.y" 2369 { 2370 if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR; 2644 2371 ;} 2645 2372 break; 2646 2373 2647 2374 case 49: 2648 2649 /* Line 1464 of yacc.c */ 2650 #line 640 "grammar.y" 2651 { 2652 if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR; 2375 #line 641 "grammar.y" 2376 { 2377 if(iiExprArithM(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR; 2653 2378 ;} 2654 2379 break; 2655 2380 2656 2381 case 50: 2657 2658 /* Line 1464 of yacc.c */ 2659 #line 644 "grammar.y" 2660 { 2661 if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR; 2382 #line 645 "grammar.y" 2383 { 2384 if(iiExprArithM(&yyval.lv,NULL,yyvsp[-2].i)) YYERROR; 2662 2385 ;} 2663 2386 break; 2664 2387 2665 2388 case 51: 2666 2667 /* Line 1464 of yacc.c */ 2668 #line 648 "grammar.y" 2669 { 2670 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR; 2389 #line 649 "grammar.y" 2390 { 2391 if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR; 2671 2392 ;} 2672 2393 break; 2673 2394 2674 2395 case 52: 2675 2676 /* Line 1464 of yacc.c */ 2677 #line 652 "grammar.y" 2678 { 2679 if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR; 2396 #line 653 "grammar.y" 2397 { 2398 if(iiExprArithM(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR; 2680 2399 ;} 2681 2400 break; 2682 2401 2683 2402 case 53: 2684 2685 /* Line 1464 of yacc.c */ 2686 #line 656 "grammar.y" 2687 { 2688 if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR; 2403 #line 657 "grammar.y" 2404 { 2405 if(iiExprArithM(&yyval.lv,NULL,yyvsp[-2].i)) YYERROR; 2689 2406 ;} 2690 2407 break; 2691 2408 2692 2409 case 54: 2693 2694 /* Line 1464 of yacc.c */ 2695 #line 660 "grammar.y" 2696 { 2697 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR; 2410 #line 661 "grammar.y" 2411 { 2412 if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR; 2698 2413 ;} 2699 2414 break; 2700 2415 2701 2416 case 55: 2702 2703 /* Line 1464 of yacc.c */ 2704 #line 664 "grammar.y" 2705 { 2706 if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR; 2417 #line 665 "grammar.y" 2418 { 2419 if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,yyvsp[-5].i,&yyvsp[-1].lv,TRUE)) YYERROR; 2707 2420 ;} 2708 2421 break; 2709 2422 2710 2423 case 56: 2711 2712 /* Line 1464 of yacc.c */ 2713 #line 668 "grammar.y" 2714 { 2715 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR; 2424 #line 669 "grammar.y" 2425 { 2426 if(iiExprArith3(&yyval.lv,yyvsp[-7].i,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR; 2716 2427 ;} 2717 2428 break; 2718 2429 2719 2430 case 57: 2720 2721 /* Line 1464 of yacc.c */ 2722 #line 672 "grammar.y" 2723 { 2724 if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR; 2431 #line 673 "grammar.y" 2432 { 2433 if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,yyvsp[-5].i,&yyvsp[-1].lv,TRUE)) YYERROR; 2725 2434 ;} 2726 2435 break; 2727 2436 2728 2437 case 58: 2729 2730 /* Line 1464 of yacc.c */ 2731 #line 676 "grammar.y" 2732 { 2733 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR; 2438 #line 677 "grammar.y" 2439 { 2440 if(iiExprArith3(&yyval.lv,yyvsp[-7].i,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR; 2734 2441 ;} 2735 2442 break; 2736 2443 2737 2444 case 59: 2738 2739 /* Line 1464 of yacc.c */ 2740 #line 680 "grammar.y" 2741 { 2742 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR; 2445 #line 681 "grammar.y" 2446 { 2447 if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR; 2743 2448 ;} 2744 2449 break; 2745 2450 2746 2451 case 60: 2747 2748 /* Line 1464 of yacc.c */ 2749 #line 684 "grammar.y" 2750 { 2751 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR; 2452 #line 685 "grammar.y" 2453 { 2454 if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR; 2752 2455 ;} 2753 2456 break; 2754 2457 2755 2458 case 61: 2756 2757 /* Line 1464 of yacc.c */ 2758 #line 688 "grammar.y" 2759 { 2760 if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR; 2459 #line 689 "grammar.y" 2460 { 2461 if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,yyvsp[-5].i,&yyvsp[-1].lv,TRUE)) YYERROR; 2761 2462 ;} 2762 2463 break; 2763 2464 2764 2465 case 62: 2765 2766 /* Line 1464 of yacc.c */ 2767 #line 692 "grammar.y" 2768 { 2769 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR; 2466 #line 693 "grammar.y" 2467 { 2468 if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR; 2770 2469 ;} 2771 2470 break; 2772 2471 2773 2472 case 63: 2774 2775 /* Line 1464 of yacc.c */ 2776 #line 696 "grammar.y" 2777 { 2778 if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR; 2473 #line 697 "grammar.y" 2474 { 2475 if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,yyvsp[-5].i,&yyvsp[-1].lv,TRUE)) YYERROR; 2779 2476 ;} 2780 2477 break; 2781 2478 2782 2479 case 64: 2783 2784 /* Line 1464 of yacc.c */ 2785 #line 700 "grammar.y" 2786 { 2787 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR; 2480 #line 701 "grammar.y" 2481 { 2482 if(iiExprArith3(&yyval.lv,yyvsp[-7].i,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR; 2788 2483 ;} 2789 2484 break; 2790 2485 2791 2486 case 65: 2792 2793 /* Line 1464 of yacc.c */ 2794 #line 704 "grammar.y" 2795 { 2796 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR; 2487 #line 705 "grammar.y" 2488 { 2489 if(iiExprArith3(&yyval.lv,yyvsp[-7].i,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR; 2797 2490 ;} 2798 2491 break; 2799 2492 2800 2493 case 66: 2801 2802 /* Line 1464 of yacc.c */ 2803 #line 708 "grammar.y" 2804 { 2805 if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR; 2494 #line 709 "grammar.y" 2495 { 2496 if(iiExprArithM(&yyval.lv,NULL,yyvsp[-2].i)) YYERROR; 2806 2497 ;} 2807 2498 break; 2808 2499 2809 2500 case 67: 2810 2811 /* Line 1464 of yacc.c */ 2812 #line 712 "grammar.y" 2813 { 2814 if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR; 2501 #line 713 "grammar.y" 2502 { 2503 if(iiExprArithM(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR; 2815 2504 ;} 2816 2505 break; 2817 2506 2818 2507 case 68: 2819 2820 /* Line 1464 of yacc.c */ 2821 #line 716 "grammar.y" 2822 { 2823 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR; 2508 #line 717 "grammar.y" 2509 { 2510 if(iiExprArith3(&yyval.lv,yyvsp[-7].i,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR; 2824 2511 ;} 2825 2512 break; 2826 2513 2827 2514 case 69: 2828 2829 /* Line 1464 of yacc.c */ 2830 #line 720 "grammar.y" 2831 { 2832 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR; 2515 #line 721 "grammar.y" 2516 { 2517 if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR; 2833 2518 ;} 2834 2519 break; 2835 2520 2836 2521 case 70: 2837 2838 /* Line 1464 of yacc.c */ 2839 #line 724 "grammar.y" 2840 { 2841 if(iiExprArith3(&(yyval.lv),RING_CMD,&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR; 2522 #line 725 "grammar.y" 2523 { 2524 if(iiExprArith3(&yyval.lv,RING_CMD,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR; 2842 2525 ;} 2843 2526 break; 2844 2527 2845 2528 case 71: 2846 2847 /* Line 1464 of yacc.c */ 2848 #line 728 "grammar.y" 2849 { 2850 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),RING_CMD)) YYERROR; 2529 #line 729 "grammar.y" 2530 { 2531 if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,RING_CMD)) YYERROR; 2851 2532 ;} 2852 2533 break; 2853 2534 2854 2535 case 72: 2855 2856 /* Line 1464 of yacc.c */ 2857 #line 732 "grammar.y" 2858 { 2859 (yyval.lv)=(yyvsp[(2) - (3)].lv); 2536 #line 733 "grammar.y" 2537 { 2538 yyval.lv=yyvsp[-1].lv; 2860 2539 ;} 2861 2540 break; 2862 2541 2863 2542 case 73: 2864 2865 /* Line 1464 of yacc.c */ 2866 #line 736 "grammar.y" 2543 #line 737 "grammar.y" 2867 2544 { 2868 2545 #ifdef SIQ 2869 2546 siq++; 2870 2547 if (siq>0) 2871 { if (iiExprArith2(& (yyval.lv),&(yyvsp[(2) - (5)].lv),'=',&(yyvsp[(4) - (5)].lv))) YYERROR; }2548 { if (iiExprArith2(&yyval.lv,&yyvsp[-3].lv,'=',&yyvsp[-1].lv)) YYERROR; } 2872 2549 else 2873 2550 #endif 2874 2551 { 2875 memset(& (yyval.lv),0,sizeof((yyval.lv)));2876 (yyval.lv).rtyp=NONE;2877 if (iiAssign(& (yyvsp[(2) - (5)].lv),&(yyvsp[(4) - (5)].lv))) YYERROR;2552 memset(&yyval.lv,0,sizeof(yyval.lv)); 2553 yyval.lv.rtyp=NONE; 2554 if (iiAssign(&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR; 2878 2555 } 2879 2556 #ifdef SIQ … … 2884 2561 2885 2562 case 74: 2886 2887 /* Line 1464 of yacc.c */ 2888 #line 753 "grammar.y" 2563 #line 754 "grammar.y" 2889 2564 { 2890 2565 #ifdef SIQ … … 2895 2570 2896 2571 case 75: 2897 2898 /* Line 1464 of yacc.c */ 2899 #line 759 "grammar.y" 2572 #line 760 "grammar.y" 2900 2573 { 2901 2574 #ifdef SIQ 2902 if (siq<=0) (yyvsp[(4) - (5)].lv).Eval();2575 if (siq<=0) yyvsp[-1].lv.Eval(); 2903 2576 #endif 2904 (yyval.lv)=(yyvsp[(4) - (5)].lv);2577 yyval.lv=yyvsp[-1].lv; 2905 2578 #ifdef SIQ 2906 2579 siq++; … … 2910 2583 2911 2584 case 76: 2912 2913 /* Line 1464 of yacc.c */ 2914 #line 771 "grammar.y" 2585 #line 772 "grammar.y" 2915 2586 { 2916 2587 #ifdef SIQ … … 2921 2592 2922 2593 case 77: 2923 2924 /* Line 1464 of yacc.c */ 2925 #line 779 "grammar.y" 2594 #line 780 "grammar.y" 2926 2595 { 2927 2596 #ifdef SIQ … … 2932 2601 2933 2602 case 78: 2934 2935 /* Line 1464 of yacc.c */ 2936 #line 788 "grammar.y" 2937 { 2938 if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (2)].lv),PLUSPLUS)) YYERROR; 2603 #line 789 "grammar.y" 2604 { 2605 if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,PLUSPLUS)) YYERROR; 2939 2606 ;} 2940 2607 break; 2941 2608 2942 2609 case 79: 2943 2944 /* Line 1464 of yacc.c */ 2945 #line 792 "grammar.y" 2946 { 2947 if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (2)].lv),MINUSMINUS)) YYERROR; 2610 #line 793 "grammar.y" 2611 { 2612 if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,MINUSMINUS)) YYERROR; 2948 2613 ;} 2949 2614 break; 2950 2615 2951 2616 case 80: 2952 2953 /* Line 1464 of yacc.c */ 2954 #line 796 "grammar.y" 2955 { 2956 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'+',&(yyvsp[(3) - (3)].lv))) YYERROR; 2617 #line 797 "grammar.y" 2618 { 2619 if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,'+',&yyvsp[0].lv)) YYERROR; 2957 2620 ;} 2958 2621 break; 2959 2622 2960 2623 case 81: 2961 2962 /* Line 1464 of yacc.c */ 2963 #line 800 "grammar.y" 2964 { 2965 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'-',&(yyvsp[(3) - (3)].lv))) YYERROR; 2624 #line 801 "grammar.y" 2625 { 2626 if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,'-',&yyvsp[0].lv)) YYERROR; 2966 2627 ;} 2967 2628 break; 2968 2629 2969 2630 case 82: 2970 2971 /* Line 1464 of yacc.c */ 2972 #line 804 "grammar.y" 2973 { 2974 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR; 2631 #line 805 "grammar.y" 2632 { 2633 if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,yyvsp[-1].i,&yyvsp[0].lv)) YYERROR; 2975 2634 ;} 2976 2635 break; 2977 2636 2978 2637 case 83: 2979 2980 /* Line 1464 of yacc.c */ 2981 #line 808 "grammar.y" 2982 { 2983 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'^',&(yyvsp[(3) - (3)].lv))) YYERROR; 2638 #line 809 "grammar.y" 2639 { 2640 if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,'^',&yyvsp[0].lv)) YYERROR; 2984 2641 ;} 2985 2642 break; 2986 2643 2987 2644 case 84: 2988 2989 /* Line 1464 of yacc.c */ 2990 #line 812 "grammar.y" 2991 { 2992 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR; 2645 #line 813 "grammar.y" 2646 { 2647 if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,yyvsp[-1].i,&yyvsp[0].lv)) YYERROR; 2993 2648 ;} 2994 2649 break; 2995 2650 2996 2651 case 85: 2997 2998 /* Line 1464 of yacc.c */ 2999 #line 816 "grammar.y" 3000 { 3001 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR; 2652 #line 817 "grammar.y" 2653 { 2654 if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,yyvsp[-1].i,&yyvsp[0].lv)) YYERROR; 3002 2655 ;} 3003 2656 break; 3004 2657 3005 2658 case 86: 3006 3007 /* Line 1464 of yacc.c */ 3008 #line 820 "grammar.y" 3009 { 3010 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),NOTEQUAL,&(yyvsp[(3) - (3)].lv))) YYERROR; 2659 #line 821 "grammar.y" 2660 { 2661 if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,NOTEQUAL,&yyvsp[0].lv)) YYERROR; 3011 2662 ;} 3012 2663 break; 3013 2664 3014 2665 case 87: 3015 3016 /* Line 1464 of yacc.c */ 3017 #line 824 "grammar.y" 3018 { 3019 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),EQUAL_EQUAL,&(yyvsp[(3) - (3)].lv))) YYERROR; 2666 #line 825 "grammar.y" 2667 { 2668 if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,EQUAL_EQUAL,&yyvsp[0].lv)) YYERROR; 3020 2669 ;} 3021 2670 break; 3022 2671 3023 2672 case 88: 3024 3025 /* Line 1464 of yacc.c */ 3026 #line 828 "grammar.y" 3027 { 3028 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),DOTDOT,&(yyvsp[(3) - (3)].lv))) YYERROR; 2673 #line 829 "grammar.y" 2674 { 2675 if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,DOTDOT,&yyvsp[0].lv)) YYERROR; 3029 2676 ;} 3030 2677 break; 3031 2678 3032 2679 case 89: 3033 3034 /* Line 1464 of yacc.c */ 3035 #line 832 "grammar.y" 3036 { 3037 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),':',&(yyvsp[(3) - (3)].lv))) YYERROR; 2680 #line 833 "grammar.y" 2681 { 2682 if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,':',&yyvsp[0].lv)) YYERROR; 3038 2683 ;} 3039 2684 break; 3040 2685 3041 2686 case 90: 3042 3043 /* Line 1464 of yacc.c */ 3044 #line 836 "grammar.y" 3045 { 3046 memset(&(yyval.lv),0,sizeof((yyval.lv))); 3047 int i; TESTSETINT((yyvsp[(2) - (2)].lv),i); 3048 (yyval.lv).rtyp = INT_CMD; 3049 (yyval.lv).data = (void *)(long)(i == 0 ? 1 : 0); 2687 #line 837 "grammar.y" 2688 { 2689 memset(&yyval.lv,0,sizeof(yyval.lv)); 2690 int i; TESTSETINT(yyvsp[0].lv,i); 2691 yyval.lv.rtyp = INT_CMD; 2692 yyval.lv.data = (void *)(long)(i == 0 ? 1 : 0); 3050 2693 ;} 3051 2694 break; 3052 2695 3053 2696 case 91: 3054 3055 /* Line 1464 of yacc.c */ 3056 #line 843 "grammar.y" 3057 { 3058 if(iiExprArith1(&(yyval.lv),&(yyvsp[(2) - (2)].lv),'-')) YYERROR; 2697 #line 844 "grammar.y" 2698 { 2699 if(iiExprArith1(&yyval.lv,&yyvsp[0].lv,'-')) YYERROR; 3059 2700 ;} 3060 2701 break; 3061 2702 3062 2703 case 92: 3063 3064 /* Line 1464 of yacc.c */ 3065 #line 849 "grammar.y" 3066 { (yyval.lv) = (yyvsp[(1) - (2)].lv); ;} 2704 #line 850 "grammar.y" 2705 { yyval.lv = yyvsp[-1].lv; ;} 3067 2706 break; 3068 2707 3069 2708 case 93: 3070 3071 /* Line 1464 of yacc.c */ 3072 #line 851 "grammar.y" 3073 { 3074 if ((yyvsp[(1) - (2)].lv).rtyp==0) 3075 { 3076 Werror("`%s` is undefined",(yyvsp[(1) - (2)].lv).Fullname()); 2709 #line 852 "grammar.y" 2710 { 2711 if (yyvsp[-1].lv.rtyp==0) 2712 { 2713 Werror("`%s` is undefined",yyvsp[-1].lv.Fullname()); 3077 2714 YYERROR; 3078 2715 } 3079 else if (( (yyvsp[(1) - (2)].lv).rtyp==MODUL_CMD)2716 else if ((yyvsp[-1].lv.rtyp==MODUL_CMD) 3080 2717 // matrix m; m[2]=... 3081 && ( (yyvsp[(1) - (2)].lv).e!=NULL) && ((yyvsp[(1) - (2)].lv).e->next==NULL))2718 && (yyvsp[-1].lv.e!=NULL) && (yyvsp[-1].lv.e->next==NULL)) 3082 2719 { 3083 2720 MYYERROR("matrix must have 2 indices"); 3084 2721 } 3085 (yyval.lv) = (yyvsp[(1) - (2)].lv);2722 yyval.lv = yyvsp[-1].lv; 3086 2723 ;} 3087 2724 break; 3088 2725 3089 2726 case 95: 3090 3091 /* Line 1464 of yacc.c */ 3092 #line 871 "grammar.y" 3093 { 3094 if ((yyvsp[(2) - (3)].lv).Typ()!=STRING_CMD) 2727 #line 872 "grammar.y" 2728 { 2729 if (yyvsp[-1].lv.Typ()!=STRING_CMD) 3095 2730 { 3096 2731 MYYERROR("string expression expected"); 3097 2732 } 3098 (yyval.name) = (char *)(yyvsp[(2) - (3)].lv).CopyD(STRING_CMD);3099 (yyvsp[(2) - (3)].lv).CleanUp();2733 yyval.name = (char *)yyvsp[-1].lv.CopyD(STRING_CMD); 2734 yyvsp[-1].lv.CleanUp(); 3100 2735 ;} 3101 2736 break; 3102 2737 3103 2738 case 96: 3104 3105 /* Line 1464 of yacc.c */ 3106 #line 883 "grammar.y" 3107 { 3108 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot))) 2739 #line 884 "grammar.y" 2740 { 2741 if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot))) 3109 2742 YYERROR; 3110 2743 ;} … … 3112 2745 3113 2746 case 97: 3114 3115 /* Line 1464 of yacc.c */ 3116 #line 888 "grammar.y" 3117 { 3118 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot))) 2747 #line 889 "grammar.y" 2748 { 2749 if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot))) 3119 2750 YYERROR; 3120 2751 ;} … … 3122 2753 3123 2754 case 98: 3124 3125 /* Line 1464 of yacc.c */ 3126 #line 893 "grammar.y" 3127 { 3128 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR; 2755 #line 894 "grammar.y" 2756 { 2757 if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(currRing->idroot), TRUE)) YYERROR; 3129 2758 ;} 3130 2759 break; 3131 2760 3132 2761 case 99: 3133 3134 /* Line 1464 of yacc.c */ 3135 #line 897 "grammar.y" 3136 { 3137 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR; 2762 #line 898 "grammar.y" 2763 { 2764 if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(currRing->idroot), TRUE)) YYERROR; 3138 2765 ;} 3139 2766 break; 3140 2767 3141 2768 case 100: 3142 3143 /* Line 1464 of yacc.c */ 3144 #line 901 "grammar.y" 3145 { 3146 int r; TESTSETINT((yyvsp[(4) - (8)].lv),r); 3147 int c; TESTSETINT((yyvsp[(7) - (8)].lv),c); 2769 #line 902 "grammar.y" 2770 { 2771 int r; TESTSETINT(yyvsp[-4].lv,r); 2772 int c; TESTSETINT(yyvsp[-1].lv,c); 3148 2773 if (r < 1) 3149 2774 MYYERROR("rows must be greater than 0"); … … 3152 2777 leftv v; 3153 2778 idhdl h; 3154 if ( (yyvsp[(1) - (8)].i)== MATRIX_CMD)3155 { 3156 if (iiDeclCommand(& (yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&(currRing->idroot), TRUE)) YYERROR;3157 v=& (yyval.lv);2779 if (yyvsp[-7].i == MATRIX_CMD) 2780 { 2781 if (iiDeclCommand(&yyval.lv,&yyvsp[-6].lv,myynest,yyvsp[-7].i,&(currRing->idroot), TRUE)) YYERROR; 2782 v=&yyval.lv; 3158 2783 h=(idhdl)v->data; 3159 2784 idDelete(&IDIDEAL(h)); … … 3161 2786 if (IDMATRIX(h)==NULL) YYERROR; 3162 2787 } 3163 else if ( (yyvsp[(1) - (8)].i)== INTMAT_CMD)3164 { 3165 if (iiDeclCommand(& (yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))2788 else if (yyvsp[-7].i == INTMAT_CMD) 2789 { 2790 if (iiDeclCommand(&yyval.lv,&yyvsp[-6].lv,myynest,yyvsp[-7].i,&(yyvsp[-6].lv.req_packhdl->idroot))) 3166 2791 YYERROR; 3167 v=& (yyval.lv);2792 v=&yyval.lv; 3168 2793 h=(idhdl)v->data; 3169 2794 delete IDINTVEC(h); … … 3173 2798 else /* BIGINTMAT_CMD */ 3174 2799 { 3175 if (iiDeclCommand(& (yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))2800 if (iiDeclCommand(&yyval.lv,&yyvsp[-6].lv,myynest,yyvsp[-7].i,&(yyvsp[-6].lv.req_packhdl->idroot))) 3176 2801 YYERROR; 3177 v=& (yyval.lv);2802 v=&yyval.lv; 3178 2803 h=(idhdl)v->data; 3179 2804 delete IDBIMAT(h); … … 3185 2810 3186 2811 case 101: 3187 3188 /* Line 1464 of yacc.c */ 3189 #line 941 "grammar.y" 3190 { 3191 if ((yyvsp[(1) - (2)].i) == MATRIX_CMD) 3192 { 3193 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR; 3194 } 3195 else if ((yyvsp[(1) - (2)].i) == INTMAT_CMD) 3196 { 3197 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot))) 2812 #line 942 "grammar.y" 2813 { 2814 if (yyvsp[-1].i == MATRIX_CMD) 2815 { 2816 if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(currRing->idroot), TRUE)) YYERROR; 2817 } 2818 else if (yyvsp[-1].i == INTMAT_CMD) 2819 { 2820 if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot))) 3198 2821 YYERROR; 3199 leftv v=& (yyval.lv);2822 leftv v=&yyval.lv; 3200 2823 idhdl h; 3201 2824 do … … 3209 2832 else /* BIGINTMAT_CMD */ 3210 2833 { 3211 if (iiDeclCommand(& (yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))2834 if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot))) 3212 2835 YYERROR; 3213 2836 } … … 3216 2839 3217 2840 case 102: 3218 3219 /* Line 1464 of yacc.c */ 3220 #line 967 "grammar.y" 3221 { 3222 int t=(yyvsp[(1) - (3)].lv).Typ(); 2841 #line 968 "grammar.y" 2842 { 2843 int t=yyvsp[-2].lv.Typ(); 3223 2844 sleftv r; 3224 2845 memset(&r,0,sizeof(sleftv)); 3225 2846 if ((BEGIN_RING<t) && (t<END_RING)) 3226 2847 { 3227 if (iiDeclCommand(&r,& (yyvsp[(3) - (3)].lv),myynest,t,&(currRing->idroot), TRUE))2848 if (iiDeclCommand(&r,&yyvsp[0].lv,myynest,t,&(currRing->idroot), TRUE)) 3228 2849 YYERROR; 3229 2850 } 3230 2851 else 3231 2852 { 3232 if (iiDeclCommand(&r,& (yyvsp[(3) - (3)].lv),myynest,t,&((yyvsp[(3) - (3)].lv).req_packhdl->idroot)))2853 if (iiDeclCommand(&r,&yyvsp[0].lv,myynest,t,&(yyvsp[0].lv.req_packhdl->idroot))) 3233 2854 YYERROR; 3234 2855 } 3235 leftv v=& (yyvsp[(1) - (3)].lv);2856 leftv v=&yyvsp[-2].lv; 3236 2857 while (v->next!=NULL) v=v->next; 3237 2858 v->next=(leftv)omAllocBin(sleftv_bin); 3238 2859 memcpy(v->next,&r,sizeof(sleftv)); 3239 (yyval.lv)=(yyvsp[(1) - (3)].lv);2860 yyval.lv=yyvsp[-2].lv; 3240 2861 ;} 3241 2862 break; 3242 2863 3243 2864 case 103: 3244 3245 /* Line 1464 of yacc.c */ 3246 #line 988 "grammar.y" 3247 { 3248 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot))) 2865 #line 989 "grammar.y" 2866 { 2867 if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot))) 3249 2868 YYERROR; 3250 2869 ;} … … 3252 2871 3253 2872 case 106: 3254 3255 /* Line 1464 of yacc.c */ 3256 #line 1001 "grammar.y" 3257 { 3258 leftv v = &(yyvsp[(2) - (5)].lv); 2873 #line 1002 "grammar.y" 2874 { 2875 leftv v = &yyvsp[-3].lv; 3259 2876 while (v->next!=NULL) 3260 2877 { … … 3262 2879 } 3263 2880 v->next = (leftv)omAllocBin(sleftv_bin); 3264 memcpy(v->next,&( (yyvsp[(4) - (5)].lv)),sizeof(sleftv));3265 (yyval.lv) = (yyvsp[(2) - (5)].lv);2881 memcpy(v->next,&(yyvsp[-1].lv),sizeof(sleftv)); 2882 yyval.lv = yyvsp[-3].lv; 3266 2883 ;} 3267 2884 break; 3268 2885 3269 2886 case 107: 3270 3271 /* Line 1464 of yacc.c */ 3272 #line 1015 "grammar.y" 2887 #line 1016 "grammar.y" 3273 2888 { 3274 2889 // let rInit take care of any errors 3275 (yyval.i)=rOrderName((yyvsp[(1) - (1)].name));2890 yyval.i=rOrderName(yyvsp[0].name); 3276 2891 ;} 3277 2892 break; 3278 2893 3279 2894 case 108: 3280 3281 /* Line 1464 of yacc.c */ 3282 #line 1023 "grammar.y" 3283 { 3284 memset(&(yyval.lv),0,sizeof((yyval.lv))); 2895 #line 1024 "grammar.y" 2896 { 2897 memset(&yyval.lv,0,sizeof(yyval.lv)); 3285 2898 intvec *iv = new intvec(2); 3286 2899 (*iv)[0] = 1; 3287 (*iv)[1] = (yyvsp[(1) - (1)].i);3288 (yyval.lv).rtyp = INTVEC_CMD;3289 (yyval.lv).data = (void *)iv;2900 (*iv)[1] = yyvsp[0].i; 2901 yyval.lv.rtyp = INTVEC_CMD; 2902 yyval.lv.data = (void *)iv; 3290 2903 ;} 3291 2904 break; 3292 2905 3293 2906 case 109: 3294 3295 /* Line 1464 of yacc.c */ 3296 #line 1032 "grammar.y" 3297 { 3298 memset(&(yyval.lv),0,sizeof((yyval.lv))); 3299 leftv sl = &(yyvsp[(3) - (4)].lv); 2907 #line 1033 "grammar.y" 2908 { 2909 memset(&yyval.lv,0,sizeof(yyval.lv)); 2910 leftv sl = &yyvsp[-1].lv; 3300 2911 int slLength; 3301 2912 { … … 3304 2915 intvec *iv = new intvec(l); 3305 2916 (*iv)[0] = slLength; 3306 (*iv)[1] = (yyvsp[(1) - (4)].i);2917 (*iv)[1] = yyvsp[-3].i; 3307 2918 3308 2919 int i = 2; … … 3326 2937 { 3327 2938 delete iv; 3328 (yyvsp[(3) - (4)].lv).CleanUp();2939 yyvsp[-1].lv.CleanUp(); 3329 2940 MYYERROR("wrong type in ordering"); 3330 2941 } 3331 2942 sl = sl->next; 3332 2943 } 3333 (yyval.lv).rtyp = INTVEC_CMD;3334 (yyval.lv).data = (void *)iv;3335 } 3336 (yyvsp[(3) - (4)].lv).CleanUp();2944 yyval.lv.rtyp = INTVEC_CMD; 2945 yyval.lv.data = (void *)iv; 2946 } 2947 yyvsp[-1].lv.CleanUp(); 3337 2948 ;} 3338 2949 break; 3339 2950 3340 2951 case 111: 3341 3342 /* Line 1464 of yacc.c */ 3343 #line 1078 "grammar.y" 3344 { 3345 (yyval.lv) = (yyvsp[(1) - (3)].lv); 3346 (yyval.lv).next = (sleftv *)omAllocBin(sleftv_bin); 3347 memcpy((yyval.lv).next,&(yyvsp[(3) - (3)].lv),sizeof(sleftv)); 2952 #line 1079 "grammar.y" 2953 { 2954 yyval.lv = yyvsp[-2].lv; 2955 yyval.lv.next = (sleftv *)omAllocBin(sleftv_bin); 2956 memcpy(yyval.lv.next,&yyvsp[0].lv,sizeof(sleftv)); 3348 2957 ;} 3349 2958 break; 3350 2959 3351 2960 case 113: 3352 3353 /* Line 1464 of yacc.c */ 3354 #line 1088 "grammar.y" 3355 { 3356 (yyval.lv) = (yyvsp[(2) - (3)].lv); 2961 #line 1089 "grammar.y" 2962 { 2963 yyval.lv = yyvsp[-1].lv; 3357 2964 ;} 3358 2965 break; 3359 2966 3360 2967 case 114: 3361 3362 /* Line 1464 of yacc.c */ 3363 #line 1094 "grammar.y" 2968 #line 1095 "grammar.y" 3364 2969 { 3365 2970 expected_parms = TRUE; … … 3368 2973 3369 2974 case 115: 3370 3371 /* Line 1464 of yacc.c */ 3372 #line 1100 "grammar.y" 3373 { (yyval.i) = (yyvsp[(1) - (1)].i); ;} 2975 #line 1101 "grammar.y" 2976 { yyval.i = yyvsp[0].i; ;} 3374 2977 break; 3375 2978 3376 2979 case 116: 3377 3378 /* Line 1464 of yacc.c */ 3379 #line 1102 "grammar.y" 3380 { (yyval.i) = (yyvsp[(1) - (1)].i); ;} 2980 #line 1103 "grammar.y" 2981 { yyval.i = yyvsp[0].i; ;} 3381 2982 break; 3382 2983 3383 2984 case 117: 3384 3385 /* Line 1464 of yacc.c */ 3386 #line 1104 "grammar.y" 3387 { (yyval.i) = (yyvsp[(1) - (1)].i); ;} 2985 #line 1105 "grammar.y" 2986 { yyval.i = yyvsp[0].i; ;} 3388 2987 break; 3389 2988 3390 2989 case 118: 3391 3392 /* Line 1464 of yacc.c */ 3393 #line 1113 "grammar.y" 3394 { if ((yyvsp[(1) - (2)].i) != '<') YYERROR; 3395 if((feFilePending=feFopen((yyvsp[(2) - (2)].name),"r",NULL,TRUE))==NULL) YYERROR; ;} 2990 #line 1114 "grammar.y" 2991 { if (yyvsp[-1].i != '<') YYERROR; 2992 if((feFilePending=feFopen(yyvsp[0].name,"r",NULL,TRUE))==NULL) YYERROR; ;} 3396 2993 break; 3397 2994 3398 2995 case 119: 3399 3400 /* Line 1464 of yacc.c */ 3401 #line 1116 "grammar.y" 3402 { newFile((yyvsp[(2) - (4)].name),feFilePending); ;} 2996 #line 1117 "grammar.y" 2997 { newFile(yyvsp[-2].name,feFilePending); ;} 3403 2998 break; 3404 2999 3405 3000 case 120: 3406 3407 /* Line 1464 of yacc.c */ 3408 #line 1121 "grammar.y" 3409 { 3410 feHelp((yyvsp[(2) - (3)].name)); 3411 omFree((ADDRESS)(yyvsp[(2) - (3)].name)); 3001 #line 1122 "grammar.y" 3002 { 3003 feHelp(yyvsp[-1].name); 3004 omFree((ADDRESS)yyvsp[-1].name); 3412 3005 ;} 3413 3006 break; 3414 3007 3415 3008 case 121: 3416 3417 /* Line 1464 of yacc.c */ 3418 #line 1126 "grammar.y" 3009 #line 1127 "grammar.y" 3419 3010 { 3420 3011 feHelp(NULL); … … 3423 3014 3424 3015 case 122: 3425 3426 /* Line 1464 of yacc.c */ 3427 #line 1133 "grammar.y" 3428 { 3429 singular_example((yyvsp[(2) - (3)].name)); 3430 omFree((ADDRESS)(yyvsp[(2) - (3)].name)); 3016 #line 1134 "grammar.y" 3017 { 3018 singular_example(yyvsp[-1].name); 3019 omFree((ADDRESS)yyvsp[-1].name); 3431 3020 ;} 3432 3021 break; 3433 3022 3434 3023 case 123: 3435 3436 /* Line 1464 of yacc.c */ 3437 #line 1141 "grammar.y" 3438 { 3439 if (basePack!=(yyvsp[(2) - (2)].lv).req_packhdl) 3024 #line 1142 "grammar.y" 3025 { 3026 if (basePack!=yyvsp[0].lv.req_packhdl) 3440 3027 { 3441 if(iiExport(& (yyvsp[(2) - (2)].lv),0,currPackHdl)) YYERROR;3028 if(iiExport(&yyvsp[0].lv,0,currPackHdl)) YYERROR; 3442 3029 } 3443 3030 else 3444 if (iiExport(& (yyvsp[(2) - (2)].lv),0)) YYERROR;3031 if (iiExport(&yyvsp[0].lv,0)) YYERROR; 3445 3032 ;} 3446 3033 break; 3447 3034 3448 3035 case 124: 3449 3450 /* Line 1464 of yacc.c */ 3451 #line 1153 "grammar.y" 3452 { 3453 leftv v=&(yyvsp[(2) - (2)].lv); 3036 #line 1154 "grammar.y" 3037 { 3038 leftv v=&yyvsp[0].lv; 3454 3039 if (v->rtyp!=IDHDL) 3455 3040 { … … 3468 3053 3469 3054 case 125: 3470 3471 /* Line 1464 of yacc.c */ 3472 #line 1169 "grammar.y" 3473 { 3474 leftv v=&(yyvsp[(3) - (3)].lv); 3055 #line 1170 "grammar.y" 3056 { 3057 leftv v=&yyvsp[0].lv; 3475 3058 if (v->rtyp!=IDHDL) 3476 3059 { … … 3489 3072 3490 3073 case 126: 3491 3492 /* Line 1464 of yacc.c */ 3493 #line 1188 "grammar.y" 3494 { 3495 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE); 3074 #line 1189 "grammar.y" 3075 { 3076 list_cmd(yyvsp[-1].i,NULL,"// ",TRUE); 3496 3077 ;} 3497 3078 break; 3498 3079 3499 3080 case 127: 3500 3501 /* Line 1464 of yacc.c */ 3502 #line 1192 "grammar.y" 3503 { 3504 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE); 3081 #line 1193 "grammar.y" 3082 { 3083 list_cmd(yyvsp[-1].i,NULL,"// ",TRUE); 3505 3084 ;} 3506 3085 break; 3507 3086 3508 3087 case 128: 3509 3510 /* Line 1464 of yacc.c */ 3511 #line 1196 "grammar.y" 3512 { 3513 if ((yyvsp[(3) - (4)].i)==QRING_CMD) (yyvsp[(3) - (4)].i)=RING_CMD; 3514 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE); 3088 #line 1197 "grammar.y" 3089 { 3090 if (yyvsp[-1].i==QRING_CMD) yyvsp[-1].i=RING_CMD; 3091 list_cmd(yyvsp[-1].i,NULL,"// ",TRUE); 3515 3092 ;} 3516 3093 break; 3517 3094 3518 3095 case 129: 3519 3520 /* Line 1464 of yacc.c */ 3521 #line 1201 "grammar.y" 3522 { 3523 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE); 3096 #line 1202 "grammar.y" 3097 { 3098 list_cmd(yyvsp[-1].i,NULL,"// ",TRUE); 3524 3099 ;} 3525 3100 break; 3526 3101 3527 3102 case 130: 3528 3529 /* Line 1464 of yacc.c */ 3530 #line 1205 "grammar.y" 3103 #line 1206 "grammar.y" 3531 3104 { 3532 3105 list_cmd(RING_CMD,NULL,"// ",TRUE); … … 3535 3108 3536 3109 case 131: 3537 3538 /* Line 1464 of yacc.c */ 3539 #line 1209 "grammar.y" 3540 { 3541 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE); 3110 #line 1210 "grammar.y" 3111 { 3112 list_cmd(yyvsp[-1].i,NULL,"// ",TRUE); 3542 3113 ;} 3543 3114 break; 3544 3115 3545 3116 case 132: 3546 3547 /* Line 1464 of yacc.c */ 3548 #line 1213 "grammar.y" 3117 #line 1214 "grammar.y" 3549 3118 { 3550 3119 list_cmd(PROC_CMD,NULL,"// ",TRUE); … … 3553 3122 3554 3123 case 133: 3555 3556 /* Line 1464 of yacc.c */ 3557 #line 1217 "grammar.y" 3558 { 3559 list_cmd(0,(yyvsp[(3) - (4)].lv).Fullname(),"// ",TRUE); 3560 (yyvsp[(3) - (4)].lv).CleanUp(); 3124 #line 1218 "grammar.y" 3125 { 3126 list_cmd(0,yyvsp[-1].lv.Fullname(),"// ",TRUE); 3127 yyvsp[-1].lv.CleanUp(); 3561 3128 ;} 3562 3129 break; 3563 3130 3564 3131 case 134: 3565 3566 /* Line 1464 of yacc.c */ 3567 #line 1222 "grammar.y" 3568 { 3569 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD) 3570 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE); 3571 (yyvsp[(3) - (6)].lv).CleanUp(); 3132 #line 1223 "grammar.y" 3133 { 3134 if(yyvsp[-3].lv.Typ() == PACKAGE_CMD) 3135 list_cmd(yyvsp[-1].i,NULL,"// ",TRUE); 3136 yyvsp[-3].lv.CleanUp(); 3572 3137 ;} 3573 3138 break; 3574 3139 3575 3140 case 135: 3576 3577 /* Line 1464 of yacc.c */ 3578 #line 1228 "grammar.y" 3579 { 3580 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD) 3581 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE); 3582 (yyvsp[(3) - (6)].lv).CleanUp(); 3141 #line 1229 "grammar.y" 3142 { 3143 if(yyvsp[-3].lv.Typ() == PACKAGE_CMD) 3144 list_cmd(yyvsp[-1].i,NULL,"// ",TRUE); 3145 yyvsp[-3].lv.CleanUp(); 3583 3146 ;} 3584 3147 break; 3585 3148 3586 3149 case 136: 3587 3588 /* Line 1464 of yacc.c */ 3589 #line 1234 "grammar.y" 3590 { 3591 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD) 3592 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE); 3593 (yyvsp[(3) - (6)].lv).CleanUp(); 3150 #line 1235 "grammar.y" 3151 { 3152 if(yyvsp[-3].lv.Typ() == PACKAGE_CMD) 3153 list_cmd(yyvsp[-1].i,NULL,"// ",TRUE); 3154 yyvsp[-3].lv.CleanUp(); 3594 3155 ;} 3595 3156 break; 3596 3157 3597 3158 case 137: 3598 3599 /* Line 1464 of yacc.c */ 3600 #line 1240 "grammar.y" 3601 { 3602 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD) 3603 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE); 3604 (yyvsp[(3) - (6)].lv).CleanUp(); 3159 #line 1241 "grammar.y" 3160 { 3161 if(yyvsp[-3].lv.Typ() == PACKAGE_CMD) 3162 list_cmd(yyvsp[-1].i,NULL,"// ",TRUE); 3163 yyvsp[-3].lv.CleanUp(); 3605 3164 ;} 3606 3165 break; 3607 3166 3608 3167 case 138: 3609 3610 /* Line 1464 of yacc.c */ 3611 #line 1246 "grammar.y" 3612 { 3613 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD) 3614 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE); 3615 (yyvsp[(3) - (6)].lv).CleanUp(); 3168 #line 1247 "grammar.y" 3169 { 3170 if(yyvsp[-3].lv.Typ() == PACKAGE_CMD) 3171 list_cmd(yyvsp[-1].i,NULL,"// ",TRUE); 3172 yyvsp[-3].lv.CleanUp(); 3616 3173 ;} 3617 3174 break; 3618 3175 3619 3176 case 139: 3620 3621 /* Line 1464 of yacc.c */ 3622 #line 1252 "grammar.y" 3623 { 3624 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD) 3625 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE); 3626 (yyvsp[(3) - (6)].lv).CleanUp(); 3177 #line 1253 "grammar.y" 3178 { 3179 if(yyvsp[-3].lv.Typ() == PACKAGE_CMD) 3180 list_cmd(yyvsp[-1].i,NULL,"// ",TRUE); 3181 yyvsp[-3].lv.CleanUp(); 3627 3182 ;} 3628 3183 break; 3629 3184 3630 3185 case 140: 3631 3632 /* Line 1464 of yacc.c */ 3633 #line 1258 "grammar.y" 3634 { 3635 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD) 3636 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE); 3637 (yyvsp[(3) - (6)].lv).CleanUp(); 3186 #line 1259 "grammar.y" 3187 { 3188 if(yyvsp[-3].lv.Typ() == PACKAGE_CMD) 3189 list_cmd(yyvsp[-1].i,NULL,"// ",TRUE); 3190 yyvsp[-3].lv.CleanUp(); 3638 3191 ;} 3639 3192 break; 3640 3193 3641 3194 case 141: 3642 3643 /* Line 1464 of yacc.c */ 3644 #line 1270 "grammar.y" 3195 #line 1271 "grammar.y" 3645 3196 { 3646 3197 list_cmd(-1,NULL,"// ",TRUE); … … 3649 3200 3650 3201 case 142: 3651 3652 /* Line 1464 of yacc.c */ 3653 #line 1276 "grammar.y" 3202 #line 1277 "grammar.y" 3654 3203 { yyInRingConstruction = TRUE; ;} 3655 3204 break; 3656 3205 3657 3206 case 143: 3658 3659 /* Line 1464 of yacc.c */ 3660 #line 1285 "grammar.y" 3661 { 3662 const char *ring_name = (yyvsp[(2) - (8)].lv).name; 3207 #line 1286 "grammar.y" 3208 { 3209 const char *ring_name = yyvsp[-6].lv.name; 3663 3210 ring b= 3664 rInit(& (yyvsp[(4) - (8)].lv), /* characteristik and list of parameters*/3665 & (yyvsp[(6) - (8)].lv), /* names of ringvariables */3666 & (yyvsp[(8) - (8)].lv)); /* ordering */3211 rInit(&yyvsp[-4].lv, /* characteristik and list of parameters*/ 3212 &yyvsp[-2].lv, /* names of ringvariables */ 3213 &yyvsp[0].lv); /* ordering */ 3667 3214 idhdl newRingHdl=NULL; 3668 3215 … … 3670 3217 { 3671 3218 newRingHdl=enterid(ring_name, myynest, RING_CMD, 3672 &( (yyvsp[(2) - (8)].lv).req_packhdl->idroot),FALSE);3673 (yyvsp[(2) - (8)].lv).CleanUp();3219 &(yyvsp[-6].lv.req_packhdl->idroot),FALSE); 3220 yyvsp[-6].lv.CleanUp(); 3674 3221 if (newRingHdl!=NULL) 3675 3222 { … … 3694 3241 3695 3242 case 144: 3696 3697 /* Line 1464 of yacc.c */ 3698 #line 1318 "grammar.y" 3699 { 3700 const char *ring_name = (yyvsp[(2) - (2)].lv).name; 3243 #line 1319 "grammar.y" 3244 { 3245 const char *ring_name = yyvsp[0].lv.name; 3701 3246 if (!inerror) rDefault(ring_name); 3702 3247 yyInRingConstruction = FALSE; 3703 (yyvsp[(2) - (2)].lv).CleanUp();3248 yyvsp[0].lv.CleanUp(); 3704 3249 ;} 3705 3250 break; 3706 3251 3707 3252 case 145: 3708 3709 /* Line 1464 of yacc.c */ 3710 #line 1328 "grammar.y" 3711 { 3712 if (((yyvsp[(1) - (2)].i)!=LIB_CMD)||(iiLibCmd((yyvsp[(2) - (2)].name),TRUE,TRUE,TRUE))) 3713 //if ($1==LIB_CMD) 3714 //{ 3715 // sleftv tmp; 3716 // if(iiExprArith1(&tmp,&$2,LIB_CMD)) YYERROR; 3717 //} 3718 //else 3719 YYERROR; 3253 #line 1329 "grammar.y" 3254 { 3255 if ((yyvsp[-1].i!=LIB_CMD)||(jjLOAD(yyvsp[0].name,TRUE))) YYERROR; 3720 3256 ;} 3721 3257 break; 3722 3258 3723 3259 case 148: 3724 3725 /* Line 1464 of yacc.c */ 3726 #line 1344 "grammar.y" 3727 { 3728 if (((yyvsp[(1) - (2)].i)==KEEPRING_CMD) && (myynest==0)) 3260 #line 1338 "grammar.y" 3261 { 3262 if ((yyvsp[-1].i==KEEPRING_CMD) && (myynest==0)) 3729 3263 MYYERROR("only inside a proc allowed"); 3730 const char * n= (yyvsp[(2) - (2)].lv).Name();3731 if ((( (yyvsp[(2) - (2)].lv).Typ()==RING_CMD)||((yyvsp[(2) - (2)].lv).Typ()==QRING_CMD))3732 && ( (yyvsp[(2) - (2)].lv).rtyp==IDHDL))3733 { 3734 idhdl h=(idhdl) (yyvsp[(2) - (2)].lv).data;3735 if ( (yyvsp[(2) - (2)].lv).e!=NULL) h=rFindHdl((ring)(yyvsp[(2) - (2)].lv).Data(),NULL, NULL);3264 const char * n=yyvsp[0].lv.Name(); 3265 if (((yyvsp[0].lv.Typ()==RING_CMD)||(yyvsp[0].lv.Typ()==QRING_CMD)) 3266 && (yyvsp[0].lv.rtyp==IDHDL)) 3267 { 3268 idhdl h=(idhdl)yyvsp[0].lv.data; 3269 if (yyvsp[0].lv.e!=NULL) h=rFindHdl((ring)yyvsp[0].lv.Data(),NULL, NULL); 3736 3270 //Print("setring %s lev %d (ptr:%x)\n",IDID(h),IDLEV(h),IDRING(h)); 3737 if ( (yyvsp[(1) - (2)].i)==KEEPRING_CMD)3271 if (yyvsp[-1].i==KEEPRING_CMD) 3738 3272 { 3739 3273 if (h!=NULL) … … 3741 3275 if (IDLEV(h)!=0) 3742 3276 { 3743 if (iiExport(& (yyvsp[(2) - (2)].lv),myynest-1)) YYERROR;3277 if (iiExport(&yyvsp[0].lv,myynest-1)) YYERROR; 3744 3278 #if 1 3745 3279 idhdl p=IDRING(h)->idroot; … … 3773 3307 { 3774 3308 Werror("%s is no identifier",n); 3775 (yyvsp[(2) - (2)].lv).CleanUp();3309 yyvsp[0].lv.CleanUp(); 3776 3310 YYERROR; 3777 3311 } … … 3781 3315 { 3782 3316 Werror("cannot find the name of the basering %s",n); 3783 (yyvsp[(2) - (2)].lv).CleanUp();3317 yyvsp[0].lv.CleanUp(); 3784 3318 YYERROR; 3785 3319 } 3786 (yyvsp[(2) - (2)].lv).CleanUp();3320 yyvsp[0].lv.CleanUp(); 3787 3321 } 3788 3322 else 3789 3323 { 3790 3324 Werror("%s is no name of a ring/qring",n); 3791 (yyvsp[(2) - (2)].lv).CleanUp();3325 yyvsp[0].lv.CleanUp(); 3792 3326 YYERROR; 3793 3327 } … … 3796 3330 3797 3331 case 149: 3798 3799 /* Line 1464 of yacc.c */ 3800 #line 1416 "grammar.y" 3801 { 3802 type_cmd(&((yyvsp[(2) - (2)].lv))); 3332 #line 1410 "grammar.y" 3333 { 3334 type_cmd(&(yyvsp[0].lv)); 3803 3335 ;} 3804 3336 break; 3805 3337 3806 3338 case 150: 3807 3808 /* Line 1464 of yacc.c */ 3809 #line 1420 "grammar.y" 3339 #line 1414 "grammar.y" 3810 3340 { 3811 3341 //Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp); 3812 3342 #ifdef SIQ 3813 if ( (yyvsp[(1) - (1)].lv).rtyp!=COMMAND)3343 if (yyvsp[0].lv.rtyp!=COMMAND) 3814 3344 { 3815 3345 #endif 3816 if ( (yyvsp[(1) - (1)].lv).Typ()==UNKNOWN)3346 if (yyvsp[0].lv.Typ()==UNKNOWN) 3817 3347 { 3818 if ( (yyvsp[(1) - (1)].lv).name!=NULL)3348 if (yyvsp[0].lv.name!=NULL) 3819 3349 { 3820 Werror("`%s` is undefined", (yyvsp[(1) - (1)].lv).name);3821 omFree((ADDRESS) (yyvsp[(1) - (1)].lv).name);3350 Werror("`%s` is undefined",yyvsp[0].lv.name); 3351 omFree((ADDRESS)yyvsp[0].lv.name); 3822 3352 } 3823 3353 YYERROR; … … 3826 3356 } 3827 3357 #endif 3828 (yyvsp[(1) - (1)].lv).Print(&sLastPrinted);3829 (yyvsp[(1) - (1)].lv).CleanUp(currRing);3358 yyvsp[0].lv.Print(&sLastPrinted); 3359 yyvsp[0].lv.CleanUp(currRing); 3830 3360 if (errorreported) YYERROR; 3831 3361 ;} … … 3833 3363 3834 3364 case 151: 3835 3836 /* Line 1464 of yacc.c */ 3837 #line 1449 "grammar.y" 3838 { 3839 int i; TESTSETINT((yyvsp[(3) - (5)].lv),i); 3365 #line 1443 "grammar.y" 3366 { 3367 int i; TESTSETINT(yyvsp[-2].lv,i); 3840 3368 if (i!=0) 3841 3369 { 3842 newBuffer( (yyvsp[(5) - (5)].name), BT_if);3370 newBuffer( yyvsp[0].name, BT_if); 3843 3371 } 3844 3372 else 3845 3373 { 3846 omFree((ADDRESS) (yyvsp[(5) - (5)].name));3374 omFree((ADDRESS)yyvsp[0].name); 3847 3375 currentVoice->ifsw=1; 3848 3376 } … … 3851 3379 3852 3380 case 152: 3853 3854 /* Line 1464 of yacc.c */ 3855 #line 1462 "grammar.y" 3381 #line 1456 "grammar.y" 3856 3382 { 3857 3383 if (currentVoice->ifsw==1) 3858 3384 { 3859 3385 currentVoice->ifsw=0; 3860 newBuffer( (yyvsp[(2) - (2)].name), BT_else);3386 newBuffer( yyvsp[0].name, BT_else); 3861 3387 } 3862 3388 else … … 3866 3392 Warn("`else` without `if` in level %d",myynest); 3867 3393 } 3868 omFree((ADDRESS) (yyvsp[(2) - (2)].name));3394 omFree((ADDRESS)yyvsp[0].name); 3869 3395 } 3870 3396 currentVoice->ifsw=0; … … 3873 3399 3874 3400 case 153: 3875 3876 /* Line 1464 of yacc.c */ 3877 #line 1479 "grammar.y" 3878 { 3879 int i; TESTSETINT((yyvsp[(3) - (5)].lv),i); 3401 #line 1473 "grammar.y" 3402 { 3403 int i; TESTSETINT(yyvsp[-2].lv,i); 3880 3404 if (i) 3881 3405 { … … 3887 3411 3888 3412 case 154: 3889 3890 /* Line 1464 of yacc.c */ 3891 #line 1488 "grammar.y" 3413 #line 1482 "grammar.y" 3892 3414 { 3893 3415 if (exitBuffer(BT_break)) YYERROR; … … 3897 3419 3898 3420 case 155: 3899 3900 /* Line 1464 of yacc.c */ 3901 #line 1493 "grammar.y" 3421 #line 1487 "grammar.y" 3902 3422 { 3903 3423 if (contBuffer(BT_break)) YYERROR; … … 3907 3427 3908 3428 case 156: 3909 3910 /* Line 1464 of yacc.c */ 3911 #line 1501 "grammar.y" 3429 #line 1495 "grammar.y" 3912 3430 { 3913 3431 /* -> if(!$2) break; $3; continue;*/ 3914 char * s = (char *)omAlloc( strlen( (yyvsp[(2) - (3)].name)) + strlen((yyvsp[(3) - (3)].name)) + 36);3915 sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " , (yyvsp[(2) - (3)].name),(yyvsp[(3) - (3)].name));3432 char * s = (char *)omAlloc( strlen(yyvsp[-1].name) + strlen(yyvsp[0].name) + 36); 3433 sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,yyvsp[-1].name,yyvsp[0].name); 3916 3434 newBuffer(s,BT_break); 3917 omFree((ADDRESS) (yyvsp[(2) - (3)].name));3918 omFree((ADDRESS) (yyvsp[(3) - (3)].name));3435 omFree((ADDRESS)yyvsp[-1].name); 3436 omFree((ADDRESS)yyvsp[0].name); 3919 3437 ;} 3920 3438 break; 3921 3439 3922 3440 case 157: 3923 3924 /* Line 1464 of yacc.c */ 3925 #line 1513 "grammar.y" 3441 #line 1507 "grammar.y" 3926 3442 { 3927 3443 /* $2 */ 3928 3444 /* if (!$3) break; $5; $4; continue; */ 3929 char * s = (char *)omAlloc( strlen( (yyvsp[(3) - (5)].name))+strlen((yyvsp[(4) - (5)].name))+strlen((yyvsp[(5) - (5)].name))+36);3445 char * s = (char *)omAlloc( strlen(yyvsp[-2].name)+strlen(yyvsp[-1].name)+strlen(yyvsp[0].name)+36); 3930 3446 sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n " 3931 , (yyvsp[(3) - (5)].name),(yyvsp[(5) - (5)].name),(yyvsp[(4) - (5)].name));3932 omFree((ADDRESS) (yyvsp[(3) - (5)].name));3933 omFree((ADDRESS) (yyvsp[(4) - (5)].name));3934 omFree((ADDRESS) </(yyvsp[(5) - (5)].name));