From a4675d851bf79aaa20591828f64446e32a5d2801 Mon Sep 17 00:00:00 2001 From: markhummel Date: Tue, 20 Sep 2005 15:46:05 +0000 Subject: [PATCH] bumping revision to 2.8.4 --- ChangeLog | 1 + configure.in | 2 +- src/parse.cc | 6584 ++++++++++++++++++++++++++--------------------- src/parse.h | 387 ++- src/sdfcpars.cc | 1779 +++++++------ src/sdfcpars.h | 246 +- src/sdfparse.cc | 3038 ++++++++++++---------- src/sdfparse.h | 288 ++- 8 files changed, 7043 insertions(+), 5282 deletions(-) diff --git a/ChangeLog b/ChangeLog index 45e7f61..9934d4b 100644 --- a/ChangeLog +++ b/ChangeLog @@ -49,3 +49,4 @@ * fixed parsers so they work with older versions of bision * fixed vfscanf configuration check + * changed revision number to 2.8.4 diff --git a/configure.in b/configure.in index cf8c9b3..743ba4b 100644 --- a/configure.in +++ b/configure.in @@ -1,5 +1,5 @@ AC_PREREQ(2.59) -AC_INIT(veriwell,2.8.3) +AC_INIT(veriwell,2.8.4) AC_CONFIG_AUX_DIR(config) AC_CONFIG_HEADER([config.h]) diff --git a/src/parse.cc b/src/parse.cc index 9e2165d..b7bcb06 100644 --- a/src/parse.cc +++ b/src/parse.cc @@ -1,120 +1,287 @@ -/* A Bison parser, made from /home/mdh/sourceforge/veriwell/src/parse.yy - by GNU bison 1.35. */ - -#define YYBISON 1 /* Identify Bison output. */ - -# define LOWEST 257 -# define IF 258 -# define ELSE 259 -# define OROR 260 -# define ANDAND 261 -# define ANDANDAND 262 -# define XNOR 263 -# define LOGICAL_EQUALITY 264 -# define LOGICAL_INEQUALITY 265 -# define CASE_EQUALITY 266 -# define CASE_INEQUALITY 267 -# define LT 268 -# define LE 269 -# define GT 270 -# define GE 271 -# define LEFT_SHIFT 272 -# define RIGHT_SHIFT 273 -# define REDUCTION_NOR 274 -# define REDUCTION_NAND 275 -# define UNARY 276 -# define IDENTIFIER 277 -# define HIERARCHY_IDENTIFIER 278 -# define STARARROW 279 -# define EQUALARROW 280 -# define SPECPARAM 281 -# define SETUP 282 -# define HOLD 283 -# define PERIOD 284 -# define WIDTH 285 -# define SKEW 286 -# define RECOVERY 287 -# define SETUPHOLD 288 -# define NOCHANGE 289 -# define MODULE 290 -# define MACROMODULE 291 -# define ENDMODULE 292 -# define SPECIFY 293 -# define ENDSPECIFY 294 -# define PRIMITIVE 295 -# define ENDPRIMITIVE 296 -# define TABLE 297 -# define ENDTABLE 298 -# define TASK 299 -# define ENDTASK 300 -# define FUNCTION 301 -# define ENDFUNCTION 302 -# define PARAMETER 303 -# define INPUT 304 -# define OUTPUT 305 -# define INOUT 306 -# define NETTYPE 307 -# define TRIREG 308 -# define SCALARED 309 -# define VECTORED 310 -# define REG 311 -# define TIME 312 -# define INTEGER 313 -# define REAL 314 -# define EVENT 315 -# define ASSIGN 316 -# define DEFPARAM 317 -# define STRENGTH0 318 -# define STRENGTH1 319 -# define SUPPLY0 320 -# define SUPPLY1 321 -# define LOGIC 322 -# define BUFFER 323 -# define BUFIF 324 -# define CMOS 325 -# define PULL 326 -# define TRAN 327 -# define INITIAL 328 -# define ALWAYS 329 -# define CASE 330 -# define CASEZ 331 -# define CASEX 332 -# define ENDCASE 333 -# define FOREVER 334 -# define REPEAT 335 -# define WHILE 336 -# define FOR 337 -# define WAIT_ 338 -# define ARROW_ 339 -# define DISABLE 340 -# define DEASSIGN 341 -# define FORCE 342 -# define RELEASE 343 -# define DEFAULT 344 -# define BEGIN 345 -# define END 346 -# define FORK 347 -# define JOIN 348 -# define SYSTEM_IDENTIFIER 349 -# define STRING 350 -# define NUMBER 351 -# define BASE_NUMBER 352 -# define POSEDGE 353 -# define NEGEDGE 354 -# define OR 355 -# define SMALL 356 -# define MEDIUM 357 -# define LARGE 358 -# define EDGE 359 -# define DOUBLE_DIGIT 360 -# define UDP_CHAR 361 -# define UDP_ONE 362 -# define UDP_ZERO 363 -# define UDP_X 364 -# define UDP_B 365 -# define UDP_HOOK 366 -# define EOF_ 367 +/* A Bison parser, made by GNU Bison 2.0. */ +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Written by Richard Stallman by simplifying the original so called + ``semantic'' parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 1 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + LOWEST = 258, + IF = 259, + ELSE = 260, + OROR = 261, + ANDAND = 262, + ANDANDAND = 263, + XNOR = 264, + CASE_INEQUALITY = 265, + CASE_EQUALITY = 266, + LOGICAL_INEQUALITY = 267, + LOGICAL_EQUALITY = 268, + GE = 269, + GT = 270, + LE = 271, + LT = 272, + RIGHT_SHIFT = 273, + LEFT_SHIFT = 274, + REDUCTION_NOR = 275, + REDUCTION_NAND = 276, + UNARY = 277, + IDENTIFIER = 278, + HIERARCHY_IDENTIFIER = 279, + STARARROW = 280, + EQUALARROW = 281, + SPECPARAM = 282, + SETUP = 283, + HOLD = 284, + PERIOD = 285, + WIDTH = 286, + SKEW = 287, + RECOVERY = 288, + SETUPHOLD = 289, + NOCHANGE = 290, + MODULE = 291, + MACROMODULE = 292, + ENDMODULE = 293, + SPECIFY = 294, + ENDSPECIFY = 295, + PRIMITIVE = 296, + ENDPRIMITIVE = 297, + TABLE = 298, + ENDTABLE = 299, + TASK = 300, + ENDTASK = 301, + FUNCTION = 302, + ENDFUNCTION = 303, + PARAMETER = 304, + INPUT = 305, + OUTPUT = 306, + INOUT = 307, + NETTYPE = 308, + TRIREG = 309, + SCALARED = 310, + VECTORED = 311, + REG = 312, + TIME = 313, + INTEGER = 314, + REAL = 315, + EVENT = 316, + ASSIGN = 317, + DEFPARAM = 318, + STRENGTH0 = 319, + STRENGTH1 = 320, + SUPPLY0 = 321, + SUPPLY1 = 322, + LOGIC = 323, + BUFFER = 324, + BUFIF = 325, + CMOS = 326, + PULL = 327, + TRAN = 328, + INITIAL = 329, + ALWAYS = 330, + CASE = 331, + CASEZ = 332, + CASEX = 333, + ENDCASE = 334, + FOREVER = 335, + REPEAT = 336, + WHILE = 337, + FOR = 338, + WAIT_ = 339, + ARROW_ = 340, + DISABLE = 341, + DEASSIGN = 342, + FORCE = 343, + RELEASE = 344, + DEFAULT = 345, + BEGIN = 346, + END = 347, + FORK = 348, + JOIN = 349, + SYSTEM_IDENTIFIER = 350, + STRING = 351, + NUMBER = 352, + BASE_NUMBER = 353, + POSEDGE = 354, + NEGEDGE = 355, + OR = 356, + SMALL = 357, + MEDIUM = 358, + LARGE = 359, + EDGE = 360, + DOUBLE_DIGIT = 361, + UDP_CHAR = 362, + UDP_ONE = 363, + UDP_ZERO = 364, + UDP_X = 365, + UDP_B = 366, + UDP_HOOK = 367, + EOF_ = 368 + }; +#endif +#define LOWEST 258 +#define IF 259 +#define ELSE 260 +#define OROR 261 +#define ANDAND 262 +#define ANDANDAND 263 +#define XNOR 264 +#define CASE_INEQUALITY 265 +#define CASE_EQUALITY 266 +#define LOGICAL_INEQUALITY 267 +#define LOGICAL_EQUALITY 268 +#define GE 269 +#define GT 270 +#define LE 271 +#define LT 272 +#define RIGHT_SHIFT 273 +#define LEFT_SHIFT 274 +#define REDUCTION_NOR 275 +#define REDUCTION_NAND 276 +#define UNARY 277 +#define IDENTIFIER 278 +#define HIERARCHY_IDENTIFIER 279 +#define STARARROW 280 +#define EQUALARROW 281 +#define SPECPARAM 282 +#define SETUP 283 +#define HOLD 284 +#define PERIOD 285 +#define WIDTH 286 +#define SKEW 287 +#define RECOVERY 288 +#define SETUPHOLD 289 +#define NOCHANGE 290 +#define MODULE 291 +#define MACROMODULE 292 +#define ENDMODULE 293 +#define SPECIFY 294 +#define ENDSPECIFY 295 +#define PRIMITIVE 296 +#define ENDPRIMITIVE 297 +#define TABLE 298 +#define ENDTABLE 299 +#define TASK 300 +#define ENDTASK 301 +#define FUNCTION 302 +#define ENDFUNCTION 303 +#define PARAMETER 304 +#define INPUT 305 +#define OUTPUT 306 +#define INOUT 307 +#define NETTYPE 308 +#define TRIREG 309 +#define SCALARED 310 +#define VECTORED 311 +#define REG 312 +#define TIME 313 +#define INTEGER 314 +#define REAL 315 +#define EVENT 316 +#define ASSIGN 317 +#define DEFPARAM 318 +#define STRENGTH0 319 +#define STRENGTH1 320 +#define SUPPLY0 321 +#define SUPPLY1 322 +#define LOGIC 323 +#define BUFFER 324 +#define BUFIF 325 +#define CMOS 326 +#define PULL 327 +#define TRAN 328 +#define INITIAL 329 +#define ALWAYS 330 +#define CASE 331 +#define CASEZ 332 +#define CASEX 333 +#define ENDCASE 334 +#define FOREVER 335 +#define REPEAT 336 +#define WHILE 337 +#define FOR 338 +#define WAIT_ 339 +#define ARROW_ 340 +#define DISABLE 341 +#define DEASSIGN 342 +#define FORCE 343 +#define RELEASE 344 +#define DEFAULT 345 +#define BEGIN 346 +#define END 347 +#define FORK 348 +#define JOIN 349 +#define SYSTEM_IDENTIFIER 350 +#define STRING 351 +#define NUMBER 352 +#define BASE_NUMBER 353 +#define POSEDGE 354 +#define NEGEDGE 355 +#define OR 356 +#define SMALL 357 +#define MEDIUM 358 +#define LARGE 359 +#define EDGE 360 +#define DOUBLE_DIGIT 361 +#define UDP_CHAR 362 +#define UDP_ONE 363 +#define UDP_ZERO 364 +#define UDP_X 365 +#define UDP_B 366 +#define UDP_HOOK 367 +#define EOF_ 368 + + + + +/* Copy the first part of user declarations. */ #line 22 "parse.yy" #define yyparse prog_parse @@ -225,9 +392,23 @@ void init_parse() } + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) #line 133 "parse.yy" -#ifndef YYSTYPE -typedef union { +typedef union YYSTYPE { tree ttype; /* pointer to a tree node */ int integer; /* used for integers */ // inst ctype; /* pointer to an instruction node (code) */ @@ -238,25 +419,142 @@ typedef union { enum tree_type ntype; /* for nets (same as gtype, buy more readable) */ char double_digit[2]; /* structure for parsing edges */ char c; /* char used in udp parsing */ -} yystype; -# define YYSTYPE yystype +} YYSTYPE; +/* Line 190 of yacc.c. */ +#line 425 "parse.cc" +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 #endif -#ifndef YYDEBUG -# define YYDEBUG 0 -#endif -#define YYFINAL 998 -#define YYFLAG -32768 -#define YYNTBASE 138 +/* Copy the second part of user declarations. */ + + +/* Line 213 of yacc.c. */ +#line 437 "parse.cc" + +#if ! defined (yyoverflow) || YYERROR_VERBOSE + +# ifndef YYFREE +# define YYFREE free +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# endif + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# else +# define YYSTACK_ALLOC alloca +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# endif +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short int yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined (__GNUC__) && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif -/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */ -#define YYTRANSLATE(x) ((unsigned)(x) <= 367 ? yytranslate[x] : 349) +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short int yysigned_char; +#endif -/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */ -static const short yytranslate[] = +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 74 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 2571 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 138 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 212 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 519 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 998 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 368 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -283,1444 +581,1437 @@ static const short yytranslate[] = 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 3, 4, 5, - 8, 9, 10, 13, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127 + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 8, 9, 10, 13, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127 }; #if YYDEBUG -static const short yyprhs[] = +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned short int yyprhs[] = { - 0, 0, 2, 5, 7, 9, 11, 14, 16, 18, - 19, 20, 21, 31, 32, 35, 38, 42, 43, 45, - 49, 51, 55, 57, 63, 65, 69, 70, 72, 76, - 78, 83, 90, 92, 94, 96, 98, 100, 102, 104, - 106, 108, 110, 112, 114, 116, 117, 118, 119, 131, - 132, 135, 138, 140, 142, 146, 147, 153, 154, 159, - 161, 164, 167, 168, 171, 173, 175, 177, 179, 181, - 183, 188, 190, 192, 194, 196, 198, 199, 207, 208, - 217, 218, 220, 222, 224, 225, 228, 230, 232, 234, - 235, 241, 243, 247, 249, 253, 257, 261, 265, 266, - 271, 276, 281, 286, 289, 292, 295, 297, 301, 303, - 306, 310, 314, 317, 320, 323, 325, 327, 328, 333, - 338, 343, 347, 348, 354, 356, 358, 360, 362, 365, - 368, 369, 370, 376, 380, 382, 386, 388, 391, 395, - 399, 400, 405, 407, 411, 413, 416, 420, 424, 425, - 430, 434, 438, 444, 446, 450, 452, 455, 459, 463, - 465, 472, 474, 478, 480, 484, 485, 489, 493, 497, - 498, 500, 506, 512, 514, 516, 518, 520, 521, 523, - 529, 530, 534, 536, 538, 540, 542, 544, 546, 548, - 549, 553, 554, 559, 561, 565, 570, 574, 575, 581, - 582, 585, 590, 595, 602, 611, 613, 617, 619, 623, - 625, 628, 632, 636, 638, 642, 644, 647, 651, 655, - 660, 664, 666, 668, 670, 674, 676, 680, 682, 683, - 685, 689, 695, 700, 701, 705, 706, 710, 712, 714, - 717, 718, 726, 727, 728, 737, 738, 742, 743, 750, - 751, 758, 759, 770, 771, 775, 776, 780, 781, 788, - 789, 796, 797, 803, 804, 811, 812, 819, 820, 827, - 828, 833, 835, 837, 839, 841, 842, 847, 848, 855, - 856, 861, 862, 869, 870, 875, 876, 879, 881, 883, - 885, 886, 891, 893, 896, 898, 901, 905, 909, 912, - 914, 918, 920, 924, 926, 930, 931, 933, 934, 939, - 940, 948, 949, 954, 955, 963, 964, 967, 970, 971, - 974, 977, 978, 981, 983, 985, 988, 994, 997, 998, - 1005, 1007, 1009, 1011, 1016, 1023, 1024, 1028, 1031, 1032, - 1035, 1038, 1040, 1042, 1044, 1045, 1050, 1056, 1066, 1077, - 1088, 1100, 1106, 1113, 1115, 1119, 1121, 1125, 1129, 1131, - 1135, 1137, 1141, 1145, 1147, 1152, 1159, 1161, 1166, 1173, - 1175, 1181, 1189, 1203, 1205, 1207, 1209, 1211, 1213, 1215, - 1217, 1219, 1221, 1222, 1227, 1238, 1249, 1258, 1266, 1277, - 1288, 1299, 1312, 1324, 1325, 1328, 1330, 1333, 1338, 1341, - 1346, 1347, 1349, 1351, 1352, 1358, 1360, 1362, 1363, 1369, - 1371, 1375, 1377, 1379, 1383, 1386, 1390, 1394, 1398, 1402, - 1404, 1406, 1408, 1410, 1415, 1422, 1426, 1428, 1430, 1434, - 1438, 1440, 1443, 1447, 1451, 1455, 1457, 1459, 1461, 1467, - 1473, 1475, 1478, 1481, 1484, 1487, 1490, 1493, 1496, 1499, - 1502, 1505, 1509, 1513, 1517, 1518, 1523, 1524, 1529, 1533, - 1537, 1538, 1543, 1544, 1549, 1553, 1557, 1561, 1565, 1569, - 1573, 1577, 1581, 1585, 1589, 1593, 1597, 1603, 1605, 1607, - 1609, 1611, 1616, 1623, 1625, 1627, 1631, 1635, 1639, 1646, - 1651, 1656, 1658, 1660, 1662, 1664, 1666, 1667, 1669, 1672, - 1675, 1680, 1682, 1686, 1692, 1695, 1698, 1703, 1704, 1708, - 1709, 1715, 1717, 1720, 1723, 1727, 1729, 1731, 1733 + 0, 0, 3, 5, 8, 10, 12, 14, 17, 19, + 21, 22, 23, 24, 34, 35, 38, 41, 45, 46, + 48, 52, 54, 58, 60, 66, 68, 72, 73, 75, + 79, 81, 86, 93, 95, 97, 99, 101, 103, 105, + 107, 109, 111, 113, 115, 117, 119, 120, 121, 122, + 134, 135, 138, 141, 143, 145, 149, 150, 156, 157, + 162, 164, 167, 170, 171, 174, 176, 178, 180, 182, + 184, 186, 191, 193, 195, 197, 199, 201, 202, 210, + 211, 220, 221, 223, 225, 227, 228, 231, 233, 235, + 237, 238, 244, 246, 250, 252, 256, 260, 264, 268, + 269, 274, 279, 284, 289, 292, 295, 298, 300, 304, + 306, 309, 313, 317, 320, 323, 326, 328, 330, 331, + 336, 341, 346, 350, 351, 357, 359, 361, 363, 365, + 368, 371, 372, 373, 379, 383, 385, 389, 391, 394, + 398, 402, 403, 408, 410, 414, 416, 419, 423, 427, + 428, 433, 437, 441, 447, 449, 453, 455, 458, 462, + 466, 468, 475, 477, 481, 483, 487, 488, 492, 496, + 500, 501, 503, 509, 515, 517, 519, 521, 523, 524, + 526, 532, 533, 537, 539, 541, 543, 545, 547, 549, + 551, 552, 556, 557, 562, 564, 568, 573, 577, 578, + 584, 585, 588, 593, 598, 605, 614, 616, 620, 622, + 626, 628, 631, 635, 639, 641, 645, 647, 650, 654, + 658, 663, 667, 669, 671, 673, 677, 679, 683, 685, + 686, 688, 692, 698, 703, 704, 708, 709, 713, 715, + 717, 720, 721, 729, 730, 731, 740, 741, 745, 746, + 753, 754, 761, 762, 773, 774, 778, 779, 783, 784, + 791, 792, 799, 800, 806, 807, 814, 815, 822, 823, + 830, 831, 836, 838, 840, 842, 844, 845, 850, 851, + 858, 859, 864, 865, 872, 873, 878, 879, 882, 884, + 886, 888, 889, 894, 896, 899, 901, 904, 908, 912, + 915, 917, 921, 923, 927, 929, 933, 934, 936, 937, + 942, 943, 951, 952, 957, 958, 966, 967, 970, 973, + 974, 977, 980, 981, 984, 986, 988, 991, 997, 1000, + 1001, 1008, 1010, 1012, 1014, 1019, 1026, 1027, 1031, 1034, + 1035, 1038, 1041, 1043, 1045, 1047, 1048, 1053, 1059, 1069, + 1080, 1091, 1103, 1109, 1116, 1118, 1122, 1124, 1128, 1132, + 1134, 1138, 1140, 1144, 1148, 1150, 1155, 1162, 1164, 1169, + 1176, 1178, 1184, 1192, 1206, 1208, 1210, 1212, 1214, 1216, + 1218, 1220, 1222, 1224, 1225, 1230, 1241, 1252, 1261, 1269, + 1280, 1291, 1302, 1315, 1327, 1328, 1331, 1333, 1336, 1341, + 1344, 1349, 1350, 1352, 1354, 1355, 1361, 1363, 1365, 1366, + 1372, 1374, 1378, 1380, 1382, 1386, 1389, 1393, 1397, 1401, + 1405, 1407, 1409, 1411, 1413, 1418, 1425, 1429, 1431, 1433, + 1437, 1441, 1443, 1446, 1450, 1454, 1458, 1460, 1462, 1464, + 1470, 1476, 1478, 1481, 1484, 1487, 1490, 1493, 1496, 1499, + 1502, 1505, 1508, 1512, 1516, 1520, 1521, 1526, 1527, 1532, + 1536, 1540, 1541, 1546, 1547, 1552, 1556, 1560, 1564, 1568, + 1572, 1576, 1580, 1584, 1588, 1592, 1596, 1600, 1606, 1608, + 1610, 1612, 1614, 1619, 1626, 1628, 1630, 1634, 1638, 1642, + 1649, 1654, 1659, 1661, 1663, 1665, 1667, 1669, 1670, 1672, + 1675, 1678, 1683, 1685, 1689, 1695, 1698, 1701, 1706, 1707, + 1711, 1712, 1718, 1720, 1723, 1726, 1730, 1732, 1734, 1736 }; -static const short yyrhs[] = + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const short int yyrhs[] = { - 241, 0, 139, 127, 0, 1, 0, 127, 0, 140, - 0, 139, 140, 0, 141, 0, 153, 0, 0, 0, - 0, 50, 142, 337, 143, 146, 348, 144, 145, 52, - 0, 0, 145, 152, 0, 145, 1, 0, 30, 147, - 346, 0, 0, 148, 0, 147, 128, 148, 0, 1, - 0, 147, 128, 1, 0, 149, 0, 129, 37, 30, - 149, 346, 0, 151, 0, 130, 150, 131, 0, 0, - 151, 0, 150, 128, 151, 0, 37, 0, 37, 31, - 325, 132, 0, 37, 31, 325, 7, 325, 132, 0, - 175, 0, 181, 0, 188, 0, 180, 0, 216, 0, - 224, 0, 203, 0, 194, 0, 287, 0, 236, 0, - 238, 0, 168, 0, 170, 0, 0, 0, 0, 55, - 154, 37, 155, 146, 348, 156, 157, 160, 161, 56, - 0, 0, 157, 158, 0, 157, 1, 0, 181, 0, - 159, 0, 71, 37, 348, 0, 0, 88, 37, 133, - 320, 348, 0, 0, 57, 162, 163, 58, 0, 164, - 0, 163, 164, 0, 165, 348, 0, 0, 165, 166, - 0, 121, 0, 126, 0, 123, 0, 122, 0, 125, - 0, 124, 0, 30, 167, 167, 346, 0, 124, 0, - 123, 0, 122, 0, 125, 0, 126, 0, 0, 59, - 37, 348, 169, 173, 240, 60, 0, 0, 61, 172, - 37, 348, 171, 173, 240, 62, 0, 0, 215, 0, - 73, 0, 74, 0, 0, 173, 174, 0, 175, 0, - 181, 0, 180, 0, 0, 63, 214, 176, 177, 348, - 0, 178, 0, 177, 128, 178, 0, 1, 0, 177, - 1, 178, 0, 177, 128, 1, 0, 37, 133, 325, - 0, 37, 133, 327, 0, 0, 184, 179, 205, 348, - 0, 186, 179, 207, 348, 0, 185, 179, 208, 348, - 0, 182, 179, 183, 348, 0, 64, 214, 0, 65, - 214, 0, 66, 214, 0, 37, 0, 183, 128, 37, - 0, 1, 0, 183, 1, 0, 183, 1, 37, 0, - 183, 128, 1, 0, 71, 214, 0, 73, 214, 0, - 72, 214, 0, 74, 0, 75, 0, 0, 189, 187, - 208, 348, 0, 190, 179, 208, 348, 0, 189, 187, - 197, 348, 0, 192, 193, 338, 0, 0, 68, 191, - 209, 193, 338, 0, 67, 0, 80, 0, 81, 0, - 215, 0, 69, 215, 0, 70, 215, 0, 0, 0, - 196, 179, 195, 200, 348, 0, 76, 210, 338, 0, - 198, 0, 197, 128, 198, 0, 1, 0, 197, 1, - 0, 197, 1, 198, 0, 197, 128, 1, 0, 0, - 37, 133, 199, 328, 0, 201, 0, 200, 128, 201, - 0, 1, 0, 200, 1, 0, 200, 1, 201, 0, - 200, 128, 1, 0, 0, 285, 133, 202, 328, 0, - 77, 204, 348, 0, 336, 133, 325, 0, 204, 128, - 336, 133, 325, 0, 206, 0, 205, 128, 206, 0, - 1, 0, 205, 1, 0, 205, 1, 206, 0, 205, - 128, 1, 0, 37, 0, 37, 31, 325, 7, 325, - 132, 0, 37, 0, 207, 128, 37, 0, 37, 0, - 208, 128, 37, 0, 0, 30, 116, 346, 0, 30, - 117, 346, 0, 30, 118, 346, 0, 0, 211, 0, - 30, 212, 128, 213, 346, 0, 30, 213, 128, 212, - 346, 0, 78, 0, 80, 0, 79, 0, 81, 0, - 0, 215, 0, 31, 325, 7, 325, 347, 0, 0, - 218, 217, 219, 0, 82, 0, 115, 0, 83, 0, - 84, 0, 85, 0, 86, 0, 87, 0, 0, 220, - 222, 348, 0, 0, 339, 221, 222, 348, 0, 223, - 0, 222, 128, 223, 0, 37, 30, 228, 346, 0, - 30, 228, 346, 0, 0, 37, 226, 225, 229, 348, - 0, 0, 134, 325, 0, 134, 30, 227, 135, 0, - 134, 30, 326, 135, 0, 134, 30, 326, 128, 326, - 135, 0, 134, 30, 326, 128, 326, 128, 326, 135, - 0, 325, 0, 227, 128, 325, 0, 328, 0, 228, - 128, 328, 0, 1, 0, 228, 1, 0, 228, 1, - 328, 0, 228, 128, 1, 0, 230, 0, 229, 128, - 230, 0, 1, 0, 229, 1, 0, 229, 1, 230, - 0, 229, 128, 1, 0, 37, 30, 231, 346, 0, - 30, 231, 346, 0, 232, 0, 234, 0, 233, 0, - 232, 128, 233, 0, 1, 0, 232, 128, 1, 0, - 328, 0, 0, 235, 0, 234, 128, 235, 0, 129, - 37, 30, 328, 346, 0, 129, 37, 30, 346, 0, - 0, 88, 237, 241, 0, 0, 89, 239, 241, 0, - 241, 0, 348, 0, 265, 348, 0, 0, 4, 242, - 30, 328, 346, 240, 263, 0, 0, 0, 243, 264, - 244, 30, 328, 346, 267, 93, 0, 0, 94, 245, - 241, 0, 0, 95, 246, 30, 328, 346, 241, 0, - 0, 96, 247, 30, 328, 346, 241, 0, 0, 97, - 248, 30, 265, 348, 328, 348, 265, 346, 241, 0, - 0, 341, 249, 240, 0, 0, 342, 250, 240, 0, - 0, 285, 133, 251, 341, 328, 348, 0, 0, 285, - 133, 252, 342, 328, 348, 0, 0, 285, 20, 253, - 328, 348, 0, 0, 285, 20, 254, 341, 328, 348, - 0, 0, 285, 20, 255, 342, 328, 348, 0, 0, - 98, 256, 30, 324, 346, 240, 0, 0, 99, 257, - 336, 348, 0, 272, 0, 275, 0, 282, 0, 283, - 0, 0, 100, 258, 336, 348, 0, 0, 76, 259, - 285, 133, 328, 348, 0, 0, 101, 260, 285, 348, - 0, 0, 102, 261, 285, 133, 328, 348, 0, 0, - 103, 262, 285, 348, 0, 0, 5, 240, 0, 90, - 0, 91, 0, 92, 0, 0, 285, 133, 266, 328, - 0, 268, 0, 267, 268, 0, 1, 0, 267, 1, - 0, 269, 7, 240, 0, 104, 7, 240, 0, 104, - 240, 0, 328, 0, 269, 128, 328, 0, 1, 0, - 269, 128, 1, 0, 271, 0, 270, 128, 271, 0, - 0, 328, 0, 0, 105, 273, 278, 106, 0, 0, - 105, 7, 37, 274, 280, 278, 106, 0, 0, 107, - 276, 279, 108, 0, 0, 107, 7, 37, 277, 280, - 279, 108, 0, 0, 278, 241, 0, 278, 1, 0, - 0, 279, 241, 0, 279, 1, 0, 0, 280, 281, - 0, 175, 0, 180, 0, 336, 348, 0, 336, 30, - 269, 346, 348, 0, 109, 348, 0, 0, 109, 284, - 30, 270, 346, 348, 0, 286, 0, 322, 0, 336, - 0, 336, 31, 328, 132, 0, 336, 31, 328, 7, - 328, 132, 0, 0, 53, 288, 289, 0, 290, 54, - 0, 0, 290, 291, 0, 290, 1, 0, 292, 0, - 294, 0, 308, 0, 0, 41, 293, 177, 348, 0, - 307, 295, 133, 300, 348, 0, 30, 296, 303, 30, - 297, 7, 305, 346, 346, 0, 30, 306, 296, 303, - 30, 297, 7, 305, 346, 346, 0, 30, 296, 303, - 30, 297, 302, 7, 305, 346, 346, 0, 30, 306, - 296, 303, 30, 297, 302, 7, 305, 346, 346, 0, - 30, 296, 303, 297, 346, 0, 30, 296, 302, 303, - 297, 346, 0, 298, 0, 296, 128, 298, 0, 1, - 0, 296, 1, 298, 0, 296, 128, 1, 0, 299, - 0, 297, 128, 299, 0, 1, 0, 297, 1, 299, - 0, 297, 128, 1, 0, 37, 0, 37, 31, 325, - 347, 0, 37, 31, 325, 7, 325, 347, 0, 37, - 0, 37, 31, 325, 347, 0, 37, 31, 325, 7, - 325, 347, 0, 301, 0, 30, 301, 128, 301, 346, - 0, 30, 301, 128, 301, 128, 301, 346, 0, 30, - 301, 128, 301, 128, 301, 128, 301, 128, 301, 128, - 301, 346, 0, 326, 0, 25, 0, 26, 0, 39, - 0, 40, 0, 328, 0, 328, 0, 113, 0, 114, - 0, 0, 4, 30, 304, 346, 0, 42, 30, 311, - 128, 311, 128, 328, 309, 346, 348, 0, 43, 30, - 311, 128, 311, 128, 328, 309, 346, 348, 0, 44, - 30, 312, 128, 328, 309, 346, 348, 0, 45, 30, - 312, 128, 328, 346, 348, 0, 45, 30, 312, 128, - 328, 128, 328, 309, 346, 348, 0, 46, 30, 311, - 128, 311, 128, 328, 309, 346, 348, 0, 47, 30, - 312, 128, 311, 128, 328, 309, 346, 348, 0, 48, - 30, 311, 128, 311, 128, 328, 128, 328, 309, 346, - 348, 0, 49, 30, 312, 128, 311, 128, 328, 128, - 328, 346, 348, 0, 0, 128, 310, 0, 37, 0, - 313, 321, 0, 313, 321, 10, 318, 0, 315, 321, - 0, 315, 321, 10, 318, 0, 0, 113, 0, 114, - 0, 0, 119, 31, 314, 317, 347, 0, 113, 0, - 114, 0, 0, 119, 31, 316, 317, 347, 0, 120, - 0, 120, 128, 317, 0, 1, 0, 319, 0, 30, - 318, 135, 0, 33, 319, 0, 319, 15, 320, 0, - 319, 17, 320, 0, 319, 18, 320, 0, 319, 16, - 320, 0, 37, 0, 112, 0, 111, 0, 336, 0, - 336, 31, 328, 132, 0, 336, 31, 325, 7, 325, - 132, 0, 130, 323, 131, 0, 286, 0, 322, 0, - 323, 128, 286, 0, 323, 128, 322, 0, 1, 0, - 323, 1, 0, 323, 1, 286, 0, 323, 1, 322, - 0, 323, 128, 1, 0, 328, 0, 328, 0, 328, - 0, 328, 7, 328, 7, 328, 0, 328, 7, 328, - 7, 328, 0, 333, 0, 25, 333, 0, 26, 333, - 0, 32, 333, 0, 33, 333, 0, 14, 333, 0, - 35, 333, 0, 11, 333, 0, 34, 333, 0, 12, - 333, 0, 13, 333, 0, 328, 25, 328, 0, 328, - 26, 328, 0, 328, 27, 328, 0, 0, 328, 28, - 329, 328, 0, 0, 328, 29, 330, 328, 0, 328, - 15, 328, 0, 328, 16, 328, 0, 0, 328, 17, - 331, 328, 0, 0, 328, 18, 332, 328, 0, 328, - 9, 328, 0, 328, 8, 328, 0, 328, 19, 328, - 0, 328, 20, 328, 0, 328, 21, 328, 0, 328, - 22, 328, 0, 328, 14, 328, 0, 328, 11, 328, - 0, 328, 12, 328, 0, 328, 13, 328, 0, 328, - 23, 328, 0, 328, 24, 328, 0, 328, 6, 328, - 7, 328, 0, 110, 0, 111, 0, 112, 0, 336, - 0, 336, 31, 328, 132, 0, 336, 31, 325, 7, - 325, 132, 0, 334, 0, 335, 0, 30, 326, 346, - 0, 30, 1, 346, 0, 130, 269, 131, 0, 130, - 325, 130, 269, 131, 131, 0, 336, 30, 270, 346, - 0, 109, 30, 270, 346, 0, 109, 0, 38, 0, - 37, 0, 37, 0, 115, 0, 0, 339, 0, 134, - 111, 0, 134, 336, 0, 134, 30, 340, 346, 0, - 326, 0, 326, 128, 326, 0, 326, 128, 326, 128, - 326, 0, 134, 111, 0, 134, 336, 0, 134, 30, - 326, 346, 0, 0, 136, 343, 336, 0, 0, 136, - 30, 344, 345, 346, 0, 328, 0, 113, 328, 0, - 114, 328, 0, 345, 115, 345, 0, 135, 0, 132, - 0, 1, 0, 137, 0 + 139, 0, -1, 242, -1, 140, 127, -1, 1, -1, + 127, -1, 141, -1, 140, 141, -1, 142, -1, 154, + -1, -1, -1, -1, 50, 143, 338, 144, 147, 349, + 145, 146, 52, -1, -1, 146, 153, -1, 146, 1, + -1, 30, 148, 347, -1, -1, 149, -1, 148, 128, + 149, -1, 1, -1, 148, 128, 1, -1, 150, -1, + 129, 37, 30, 150, 347, -1, 152, -1, 130, 151, + 131, -1, -1, 152, -1, 151, 128, 152, -1, 37, + -1, 37, 31, 326, 132, -1, 37, 31, 326, 7, + 326, 132, -1, 176, -1, 182, -1, 189, -1, 181, + -1, 217, -1, 225, -1, 204, -1, 195, -1, 288, + -1, 237, -1, 239, -1, 169, -1, 171, -1, -1, + -1, -1, 55, 155, 37, 156, 147, 349, 157, 158, + 161, 162, 56, -1, -1, 158, 159, -1, 158, 1, + -1, 182, -1, 160, -1, 71, 37, 349, -1, -1, + 88, 37, 133, 321, 349, -1, -1, 57, 163, 164, + 58, -1, 165, -1, 164, 165, -1, 166, 349, -1, + -1, 166, 167, -1, 121, -1, 126, -1, 123, -1, + 122, -1, 125, -1, 124, -1, 30, 168, 168, 347, + -1, 124, -1, 123, -1, 122, -1, 125, -1, 126, + -1, -1, 59, 37, 349, 170, 174, 241, 60, -1, + -1, 61, 173, 37, 349, 172, 174, 241, 62, -1, + -1, 216, -1, 73, -1, 74, -1, -1, 174, 175, + -1, 176, -1, 182, -1, 181, -1, -1, 63, 215, + 177, 178, 349, -1, 179, -1, 178, 128, 179, -1, + 1, -1, 178, 1, 179, -1, 178, 128, 1, -1, + 37, 133, 326, -1, 37, 133, 328, -1, -1, 185, + 180, 206, 349, -1, 187, 180, 208, 349, -1, 186, + 180, 209, 349, -1, 183, 180, 184, 349, -1, 64, + 215, -1, 65, 215, -1, 66, 215, -1, 37, -1, + 184, 128, 37, -1, 1, -1, 184, 1, -1, 184, + 1, 37, -1, 184, 128, 1, -1, 71, 215, -1, + 73, 215, -1, 72, 215, -1, 74, -1, 75, -1, + -1, 190, 188, 209, 349, -1, 191, 180, 209, 349, + -1, 190, 188, 198, 349, -1, 193, 194, 339, -1, + -1, 68, 192, 210, 194, 339, -1, 67, -1, 80, + -1, 81, -1, 216, -1, 69, 216, -1, 70, 216, + -1, -1, -1, 197, 180, 196, 201, 349, -1, 76, + 211, 339, -1, 199, -1, 198, 128, 199, -1, 1, + -1, 198, 1, -1, 198, 1, 199, -1, 198, 128, + 1, -1, -1, 37, 133, 200, 329, -1, 202, -1, + 201, 128, 202, -1, 1, -1, 201, 1, -1, 201, + 1, 202, -1, 201, 128, 1, -1, -1, 286, 133, + 203, 329, -1, 77, 205, 349, -1, 337, 133, 326, + -1, 205, 128, 337, 133, 326, -1, 207, -1, 206, + 128, 207, -1, 1, -1, 206, 1, -1, 206, 1, + 207, -1, 206, 128, 1, -1, 37, -1, 37, 31, + 326, 7, 326, 132, -1, 37, -1, 208, 128, 37, + -1, 37, -1, 209, 128, 37, -1, -1, 30, 116, + 347, -1, 30, 117, 347, -1, 30, 118, 347, -1, + -1, 212, -1, 30, 213, 128, 214, 347, -1, 30, + 214, 128, 213, 347, -1, 78, -1, 80, -1, 79, + -1, 81, -1, -1, 216, -1, 31, 326, 7, 326, + 348, -1, -1, 219, 218, 220, -1, 82, -1, 115, + -1, 83, -1, 84, -1, 85, -1, 86, -1, 87, + -1, -1, 221, 223, 349, -1, -1, 340, 222, 223, + 349, -1, 224, -1, 223, 128, 224, -1, 37, 30, + 229, 347, -1, 30, 229, 347, -1, -1, 37, 227, + 226, 230, 349, -1, -1, 134, 326, -1, 134, 30, + 228, 135, -1, 134, 30, 327, 135, -1, 134, 30, + 327, 128, 327, 135, -1, 134, 30, 327, 128, 327, + 128, 327, 135, -1, 326, -1, 228, 128, 326, -1, + 329, -1, 229, 128, 329, -1, 1, -1, 229, 1, + -1, 229, 1, 329, -1, 229, 128, 1, -1, 231, + -1, 230, 128, 231, -1, 1, -1, 230, 1, -1, + 230, 1, 231, -1, 230, 128, 1, -1, 37, 30, + 232, 347, -1, 30, 232, 347, -1, 233, -1, 235, + -1, 234, -1, 233, 128, 234, -1, 1, -1, 233, + 128, 1, -1, 329, -1, -1, 236, -1, 235, 128, + 236, -1, 129, 37, 30, 329, 347, -1, 129, 37, + 30, 347, -1, -1, 88, 238, 242, -1, -1, 89, + 240, 242, -1, 242, -1, 349, -1, 266, 349, -1, + -1, 4, 243, 30, 329, 347, 241, 264, -1, -1, + -1, 244, 265, 245, 30, 329, 347, 268, 93, -1, + -1, 94, 246, 242, -1, -1, 95, 247, 30, 329, + 347, 242, -1, -1, 96, 248, 30, 329, 347, 242, + -1, -1, 97, 249, 30, 266, 349, 329, 349, 266, + 347, 242, -1, -1, 342, 250, 241, -1, -1, 343, + 251, 241, -1, -1, 286, 133, 252, 342, 329, 349, + -1, -1, 286, 133, 253, 343, 329, 349, -1, -1, + 286, 21, 254, 329, 349, -1, -1, 286, 21, 255, + 342, 329, 349, -1, -1, 286, 21, 256, 343, 329, + 349, -1, -1, 98, 257, 30, 325, 347, 241, -1, + -1, 99, 258, 337, 349, -1, 273, -1, 276, -1, + 283, -1, 284, -1, -1, 100, 259, 337, 349, -1, + -1, 76, 260, 286, 133, 329, 349, -1, -1, 101, + 261, 286, 349, -1, -1, 102, 262, 286, 133, 329, + 349, -1, -1, 103, 263, 286, 349, -1, -1, 5, + 241, -1, 90, -1, 91, -1, 92, -1, -1, 286, + 133, 267, 329, -1, 269, -1, 268, 269, -1, 1, + -1, 268, 1, -1, 270, 7, 241, -1, 104, 7, + 241, -1, 104, 241, -1, 329, -1, 270, 128, 329, + -1, 1, -1, 270, 128, 1, -1, 272, -1, 271, + 128, 272, -1, -1, 329, -1, -1, 105, 274, 279, + 106, -1, -1, 105, 7, 37, 275, 281, 279, 106, + -1, -1, 107, 277, 280, 108, -1, -1, 107, 7, + 37, 278, 281, 280, 108, -1, -1, 279, 242, -1, + 279, 1, -1, -1, 280, 242, -1, 280, 1, -1, + -1, 281, 282, -1, 176, -1, 181, -1, 337, 349, + -1, 337, 30, 270, 347, 349, -1, 109, 349, -1, + -1, 109, 285, 30, 271, 347, 349, -1, 287, -1, + 323, -1, 337, -1, 337, 31, 329, 132, -1, 337, + 31, 329, 7, 329, 132, -1, -1, 53, 289, 290, + -1, 291, 54, -1, -1, 291, 292, -1, 291, 1, + -1, 293, -1, 295, -1, 309, -1, -1, 41, 294, + 178, 349, -1, 308, 296, 133, 301, 349, -1, 30, + 297, 304, 30, 298, 7, 306, 347, 347, -1, 30, + 307, 297, 304, 30, 298, 7, 306, 347, 347, -1, + 30, 297, 304, 30, 298, 303, 7, 306, 347, 347, + -1, 30, 307, 297, 304, 30, 298, 303, 7, 306, + 347, 347, -1, 30, 297, 304, 298, 347, -1, 30, + 297, 303, 304, 298, 347, -1, 299, -1, 297, 128, + 299, -1, 1, -1, 297, 1, 299, -1, 297, 128, + 1, -1, 300, -1, 298, 128, 300, -1, 1, -1, + 298, 1, 300, -1, 298, 128, 1, -1, 37, -1, + 37, 31, 326, 348, -1, 37, 31, 326, 7, 326, + 348, -1, 37, -1, 37, 31, 326, 348, -1, 37, + 31, 326, 7, 326, 348, -1, 302, -1, 30, 302, + 128, 302, 347, -1, 30, 302, 128, 302, 128, 302, + 347, -1, 30, 302, 128, 302, 128, 302, 128, 302, + 128, 302, 128, 302, 347, -1, 327, -1, 25, -1, + 26, -1, 39, -1, 40, -1, 329, -1, 329, -1, + 113, -1, 114, -1, -1, 4, 30, 305, 347, -1, + 42, 30, 312, 128, 312, 128, 329, 310, 347, 349, + -1, 43, 30, 312, 128, 312, 128, 329, 310, 347, + 349, -1, 44, 30, 313, 128, 329, 310, 347, 349, + -1, 45, 30, 313, 128, 329, 347, 349, -1, 45, + 30, 313, 128, 329, 128, 329, 310, 347, 349, -1, + 46, 30, 312, 128, 312, 128, 329, 310, 347, 349, + -1, 47, 30, 313, 128, 312, 128, 329, 310, 347, + 349, -1, 48, 30, 312, 128, 312, 128, 329, 128, + 329, 310, 347, 349, -1, 49, 30, 313, 128, 312, + 128, 329, 128, 329, 347, 349, -1, -1, 128, 311, + -1, 37, -1, 314, 322, -1, 314, 322, 10, 319, + -1, 316, 322, -1, 316, 322, 10, 319, -1, -1, + 113, -1, 114, -1, -1, 119, 31, 315, 318, 348, + -1, 113, -1, 114, -1, -1, 119, 31, 317, 318, + 348, -1, 120, -1, 120, 128, 318, -1, 1, -1, + 320, -1, 30, 319, 135, -1, 33, 320, -1, 320, + 18, 321, -1, 320, 16, 321, -1, 320, 15, 321, + -1, 320, 17, 321, -1, 37, -1, 112, -1, 111, + -1, 337, -1, 337, 31, 329, 132, -1, 337, 31, + 326, 7, 326, 132, -1, 130, 324, 131, -1, 287, + -1, 323, -1, 324, 128, 287, -1, 324, 128, 323, + -1, 1, -1, 324, 1, -1, 324, 1, 287, -1, + 324, 1, 323, -1, 324, 128, 1, -1, 329, -1, + 329, -1, 329, -1, 329, 7, 329, 7, 329, -1, + 329, 7, 329, 7, 329, -1, 334, -1, 25, 334, + -1, 26, 334, -1, 32, 334, -1, 33, 334, -1, + 14, 334, -1, 35, 334, -1, 11, 334, -1, 34, + 334, -1, 12, 334, -1, 13, 334, -1, 329, 25, + 329, -1, 329, 26, 329, -1, 329, 27, 329, -1, + -1, 329, 28, 330, 329, -1, -1, 329, 29, 331, + 329, -1, 329, 18, 329, -1, 329, 17, 329, -1, + -1, 329, 16, 332, 329, -1, -1, 329, 15, 333, + 329, -1, 329, 9, 329, -1, 329, 8, 329, -1, + 329, 22, 329, -1, 329, 21, 329, -1, 329, 20, + 329, -1, 329, 19, 329, -1, 329, 14, 329, -1, + 329, 11, 329, -1, 329, 12, 329, -1, 329, 13, + 329, -1, 329, 24, 329, -1, 329, 23, 329, -1, + 329, 6, 329, 7, 329, -1, 110, -1, 111, -1, + 112, -1, 337, -1, 337, 31, 329, 132, -1, 337, + 31, 326, 7, 326, 132, -1, 335, -1, 336, -1, + 30, 327, 347, -1, 30, 1, 347, -1, 130, 270, + 131, -1, 130, 326, 130, 270, 131, 131, -1, 337, + 30, 271, 347, -1, 109, 30, 271, 347, -1, 109, + -1, 38, -1, 37, -1, 37, -1, 115, -1, -1, + 340, -1, 134, 111, -1, 134, 337, -1, 134, 30, + 341, 347, -1, 327, -1, 327, 128, 327, -1, 327, + 128, 327, 128, 327, -1, 134, 111, -1, 134, 337, + -1, 134, 30, 327, 347, -1, -1, 136, 344, 337, + -1, -1, 136, 30, 345, 346, 347, -1, 329, -1, + 113, 329, -1, 114, 329, -1, 346, 115, 346, -1, + 135, -1, 132, -1, 1, -1, 137, -1 }; -#endif - -#if YYDEBUG -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const short yyrline[] = +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned short int yyrline[] = { - 0, 426, 435, 436, 445, 454, 455, 467, 468, 472, - 472, 472, 472, 500, 501, 503, 507, 509, 514, 515, - 519, 525, 529, 535, 540, 541, 545, 550, 552, 557, - 559, 564, 572, 574, 576, 578, 580, 581, 583, 585, - 587, 589, 593, 597, 599, 614, 614, 614, 614, 636, - 638, 640, 644, 645, 649, 662, 664, 682, 682, 694, - 695, 701, 709, 711, 715, 720, 725, 730, 735, 740, - 745, 760, 761, 762, 763, 764, 768, 768, 788, 788, - 807, 809, 811, 813, 818, 820, 824, 825, 826, 834, - 834, 843, 844, 848, 849, 851, 855, 858, 864, 869, - 872, 875, 882, 890, 897, 905, 917, 919, 923, 924, - 925, 927, 931, 933, 938, 945, 950, 956, 961, 967, - 968, 977, 984, 984, 993, 994, 996, 1008, 1009, 1014, - 1019, 1024, 1024, 1034, 1041, 1043, 1047, 1048, 1049, 1051, - 1055, 1055, 1065, 1067, 1071, 1072, 1073, 1075, 1079, 1079, - 1085, 1090, 1095, 1104, 1105, 1109, 1110, 1111, 1113, 1117, - 1119, 1126, 1128, 1133, 1135, 1140, 1142, 1144, 1146, 1151, - 1153, 1161, 1163, 1168, 1169, 1173, 1174, 1187, 1189, 1193, - 1209, 1209, 1220, 1222, 1224, 1226, 1228, 1230, 1232, 1246, - 1246, 1251, 1251, 1257, 1258, 1262, 1268, 1279, 1279, 1315, - 1317, 1319, 1321, 1323, 1327, 1335, 1337, 1364, 1366, 1369, - 1370, 1371, 1373, 1383, 1384, 1386, 1387, 1388, 1390, 1394, - 1402, 1412, 1413, 1417, 1418, 1422, 1423, 1427, 1429, 1434, - 1435, 1440, 1443, 1450, 1450, 1458, 1458, 1464, 1465, 1470, - 1473, 1473, 1477, 1477, 1477, 1487, 1487, 1493, 1493, 1502, - 1502, 1508, 1508, 1518, 1518, 1526, 1526, 1535, 1535, 1546, - 1546, 1556, 1556, 1567, 1567, 1578, 1578, 1594, 1594, 1602, - 1602, 1610, 1611, 1612, 1613, 1614, 1614, 1620, 1620, 1626, - 1626, 1631, 1631, 1640, 1640, 1652, 1654, 1659, 1661, 1663, - 1675, 1675, 1682, 1683, 1687, 1688, 1692, 1695, 1700, 1708, - 1710, 1712, 1713, 1717, 1724, 1733, 1735, 1739, 1739, 1746, - 1746, 1770, 1770, 1778, 1778, 1801, 1803, 1807, 1811, 1813, - 1817, 1821, 1823, 1827, 1828, 1832, 1838, 1846, 1848, 1848, - 1857, 1859, 1864, 1866, 1869, 1879, 1879, 1888, 1893, 1895, - 1900, 1903, 1904, 1905, 1923, 1923, 1932, 1943, 1951, 1959, - 1967, 1975, 1981, 1989, 1990, 1994, 1995, 1997, 2000, 2001, - 2005, 2006, 2008, 2011, 2015, 2019, 2025, 2029, 2033, 2039, - 2040, 2044, 2051, 2064, 2070, 2074, 2080, 2084, 2090, 2095, - 2098, 2102, 2108, 2112, 2119, 2124, 2129, 2134, 2139, 2144, - 2149, 2154, 2159, 2166, 2170, 2176, 2179, 2183, 2190, 2194, - 2201, 2206, 2211, 2216, 2216, 2228, 2233, 2238, 2238, 2250, - 2255, 2260, 2266, 2267, 2269, 2271, 2273, 2275, 2277, 2281, - 2285, 2289, 2296, 2301, 2306, 2319, 2327, 2329, 2331, 2333, - 2335, 2336, 2337, 2338, 2339, 2343, 2347, 2358, 2359, 2369, - 2379, 2380, 2382, 2384, 2386, 2388, 2390, 2392, 2394, 2396, - 2398, 2400, 2402, 2404, 2406, 2406, 2410, 2410, 2414, 2416, - 2418, 2418, 2422, 2422, 2426, 2428, 2430, 2432, 2434, 2436, - 2438, 2440, 2442, 2444, 2446, 2448, 2450, 2452, 2472, 2473, - 2474, 2476, 2478, 2480, 2481, 2482, 2484, 2517, 2522, 2531, - 2536, 2540, 2551, 2560, 2564, 2565, 2584, 2586, 2590, 2594, - 2599, 2608, 2612, 2616, 2623, 2625, 2627, 2632, 2632, 2644, - 2644, 2651, 2658, 2661, 2664, 2673, 2678, 2680, 2685 + 0, 426, 426, 435, 436, 445, 454, 455, 467, 468, + 473, 478, 487, 472, 499, 501, 503, 507, 510, 514, + 515, 519, 525, 529, 535, 540, 541, 546, 550, 552, + 557, 559, 564, 572, 574, 576, 578, 580, 581, 583, + 585, 587, 589, 593, 597, 599, 615, 620, 627, 614, + 637, 638, 640, 644, 645, 649, 663, 664, 683, 682, + 694, 695, 701, 710, 711, 715, 720, 725, 730, 735, + 740, 745, 760, 761, 762, 763, 764, 769, 768, 789, + 788, 808, 809, 811, 813, 819, 820, 824, 825, 826, + 835, 834, 843, 844, 848, 849, 851, 855, 858, 865, + 869, 872, 875, 882, 890, 897, 905, 917, 919, 923, + 924, 925, 927, 931, 933, 938, 945, 950, 957, 961, + 967, 968, 977, 985, 984, 993, 994, 996, 1008, 1009, + 1014, 1020, 1025, 1024, 1034, 1041, 1043, 1047, 1048, 1049, + 1051, 1055, 1055, 1065, 1067, 1071, 1072, 1073, 1075, 1079, + 1079, 1085, 1090, 1095, 1104, 1105, 1109, 1110, 1111, 1113, + 1117, 1119, 1126, 1128, 1133, 1135, 1141, 1142, 1144, 1146, + 1152, 1153, 1161, 1163, 1168, 1169, 1173, 1174, 1188, 1189, + 1193, 1210, 1209, 1220, 1222, 1224, 1226, 1228, 1230, 1232, + 1246, 1246, 1252, 1251, 1257, 1258, 1262, 1268, 1280, 1279, + 1316, 1317, 1319, 1321, 1323, 1327, 1335, 1337, 1364, 1366, + 1369, 1370, 1371, 1373, 1383, 1384, 1386, 1387, 1388, 1390, + 1394, 1402, 1412, 1413, 1417, 1418, 1422, 1423, 1427, 1430, + 1434, 1435, 1440, 1443, 1451, 1450, 1458, 1458, 1464, 1465, + 1470, 1473, 1473, 1477, 1479, 1477, 1488, 1487, 1494, 1493, + 1503, 1502, 1508, 1508, 1519, 1518, 1527, 1526, 1536, 1535, + 1547, 1546, 1557, 1556, 1568, 1567, 1579, 1578, 1595, 1594, + 1603, 1602, 1610, 1611, 1612, 1613, 1614, 1614, 1621, 1620, + 1627, 1626, 1631, 1631, 1640, 1640, 1652, 1654, 1659, 1661, + 1663, 1675, 1675, 1682, 1683, 1687, 1688, 1692, 1695, 1700, + 1708, 1710, 1712, 1713, 1717, 1724, 1734, 1735, 1740, 1739, + 1747, 1746, 1771, 1770, 1779, 1778, 1802, 1803, 1807, 1812, + 1813, 1817, 1822, 1823, 1827, 1828, 1832, 1838, 1846, 1849, + 1848, 1857, 1859, 1864, 1866, 1869, 1880, 1879, 1888, 1894, + 1895, 1900, 1903, 1904, 1905, 1924, 1923, 1932, 1943, 1951, + 1959, 1967, 1975, 1981, 1989, 1990, 1994, 1995, 1997, 2000, + 2001, 2005, 2006, 2008, 2011, 2015, 2019, 2025, 2029, 2033, + 2039, 2040, 2044, 2051, 2064, 2070, 2074, 2080, 2084, 2090, + 2095, 2098, 2102, 2109, 2112, 2119, 2124, 2129, 2134, 2139, + 2144, 2149, 2154, 2159, 2167, 2170, 2176, 2179, 2183, 2190, + 2194, 2202, 2206, 2211, 2217, 2216, 2228, 2233, 2239, 2238, + 2250, 2255, 2260, 2266, 2267, 2269, 2271, 2273, 2275, 2277, + 2281, 2285, 2289, 2296, 2301, 2306, 2319, 2327, 2329, 2331, + 2333, 2335, 2336, 2337, 2338, 2339, 2343, 2347, 2358, 2359, + 2369, 2379, 2380, 2382, 2384, 2386, 2388, 2390, 2392, 2394, + 2396, 2398, 2400, 2402, 2404, 2407, 2406, 2411, 2410, 2414, + 2416, 2419, 2418, 2423, 2422, 2426, 2428, 2430, 2432, 2434, + 2436, 2438, 2440, 2442, 2444, 2446, 2448, 2450, 2452, 2472, + 2473, 2474, 2476, 2478, 2480, 2481, 2482, 2484, 2517, 2522, + 2531, 2536, 2540, 2551, 2560, 2564, 2565, 2585, 2586, 2590, + 2594, 2599, 2608, 2612, 2616, 2623, 2625, 2627, 2632, 2632, + 2644, 2644, 2651, 2658, 2661, 2664, 2673, 2678, 2680, 2685 }; #endif - -#if (YYDEBUG) || defined YYERROR_VERBOSE - -/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */ +#if YYDEBUG || YYERROR_VERBOSE +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ static const char *const yytname[] = { - "$", "error", "$undefined.", "LOWEST", "IF", "ELSE", "'?'", "':'", "OROR", - "ANDAND", "ANDANDAND", "'|'", "'^'", "XNOR", "'&'", "LOGICAL_EQUALITY", - "LOGICAL_INEQUALITY", "CASE_EQUALITY", "CASE_INEQUALITY", "LT", "LE", - "GT", "GE", "LEFT_SHIFT", "RIGHT_SHIFT", "'+'", "'-'", "'*'", "'/'", - "'%'", "'('", "'['", "'!'", "'~'", "REDUCTION_NOR", "REDUCTION_NAND", - "UNARY", "IDENTIFIER", "HIERARCHY_IDENTIFIER", "STARARROW", - "EQUALARROW", "SPECPARAM", "SETUP", "HOLD", "PERIOD", "WIDTH", "SKEW", - "RECOVERY", "SETUPHOLD", "NOCHANGE", "MODULE", "MACROMODULE", - "ENDMODULE", "SPECIFY", "ENDSPECIFY", "PRIMITIVE", "ENDPRIMITIVE", - "TABLE", "ENDTABLE", "TASK", "ENDTASK", "FUNCTION", "ENDFUNCTION", - "PARAMETER", "INPUT", "OUTPUT", "INOUT", "NETTYPE", "TRIREG", - "SCALARED", "VECTORED", "REG", "TIME", "INTEGER", "REAL", "EVENT", - "ASSIGN", "DEFPARAM", "STRENGTH0", "STRENGTH1", "SUPPLY0", "SUPPLY1", - "LOGIC", "BUFFER", "BUFIF", "CMOS", "PULL", "TRAN", "INITIAL", "ALWAYS", - "CASE", "CASEZ", "CASEX", "ENDCASE", "FOREVER", "REPEAT", "WHILE", - "FOR", "WAIT_", "ARROW_", "DISABLE", "DEASSIGN", "FORCE", "RELEASE", - "DEFAULT", "BEGIN", "END", "FORK", "JOIN", "SYSTEM_IDENTIFIER", - "STRING", "NUMBER", "BASE_NUMBER", "POSEDGE", "NEGEDGE", "OR", "SMALL", - "MEDIUM", "LARGE", "EDGE", "DOUBLE_DIGIT", "UDP_CHAR", "UDP_ONE", - "UDP_ZERO", "UDP_X", "UDP_B", "UDP_HOOK", "EOF_", "','", "'.'", "'{'", - "'}'", "']'", "'='", "'#'", "')'", "'@'", "';'", "source_text", - "description_list", "description", "module", "@1", "@2", "@3", - "module_item_list", "list_of_ports_o", "port_clist", "port", - "port_expression_o", "port_reference_clist", "port_reference", - "module_item", "UDP", "@4", "@5", "@6", "UDP_declarations", - "UDP_declaration", "UDP_reg_statement", "UDP_initial_statement", - "UDP_table_definition", "@7", "table_entry_list", "table_entry", - "table_digit_list", "table_digit", "table_digit1", "task", "@8", - "function", "@9", "function_type", "tf_declaration_list", - "tf_declaration", "parameter_declaration", "@10", - "list_of_param_assignments", "param_assignment", "setspec", - "static_declaration", "port_declaration", "port_spec", - "port_decl_identifiers", "reg_spec", "real_spec", "event_spec", - "setnetspec", "net_declaration", "net_spec", "trireg_spec", "@11", - "nettype", "expandrange_o", "continuous_assign", "@12", "assign_spec", - "list_of_net_assignments", "net_assignment", "@13", - "list_of_assignments", "cont_assignment", "@14", "parameter_override", - "list_of_param_overrides", "reg_decl_identifiers", - "reg_decl_identifier", "non_reg_decl_identifiers", "decl_identifiers", - "charge_strength_o", "drive_strength_o", "drive_strength", "strength0", - "strength1", "xrange", "range", "gate_declaration", "@15", "gatetype", - "gate_description", "@16", "@17", "gate_instance_clist", - "gate_instance", "UDP_or_module_instantiation", "@18", - "xparameter_value_assignment", "constant_expression_clist", - "terminal_clist", "module_instance_clist", "module_instance", - "list_of_module_connections_o", "module_port_connection_clist", - "module_port_connection", "named_port_connection_clist", - "named_port_connection", "initial_statement", "@19", "always_statement", - "@20", "statement_or_null", "statement", "@21", "@22", "@23", "@24", - "@25", "@26", "@27", "@28", "@29", "@30", "@31", "@32", "@33", "@34", - "@35", "@36", "@37", "@38", "@39", "@40", "@41", "elsepart", "case", - "assignment", "@42", "case_item_plist", "case_expr", "expression_clist", - "xexpression_clist", "xexpression", "seq_block", "@43", "@44", - "par_block", "@45", "@46", "statement_list", "statement_tree_list", - "block_declaration_list", "block_declaration", "task_enable", - "system_task_enable", "@47", "lvalue", "lval_normal", "specify_block", - "@48", "specify_stuff", "specify_items", "specify_item", - "specparam_declaration", "@49", "path_declaration", "path_description", - "list_of_path_inputs", "list_of_path_outputs", - "specify_input_terminal_descriptor", - "specify_output_terminal_descriptor", "path_delay_value", - "path_delay_expression", "polarity_operator", "path_operator", - "conditional_port_expression", "data_source_expression", - "edge_identifier", "specify_if_clause", "system_timing_check", - "notify_clause", "notify_register", "timing_check_event", - "controlled_timing_check_event", "timing_check_event_control", "@50", - "timing_check_event_control_no_empty", "@51", "edge_list", - "timing_check_condition", "scalar_expression", "scalar_constant", - "timing_input_terminal_descriptor", "lval_concat", "lval_clist", - "conditional_expression", "constant_expression", "mintypmax_expression", - "mintypmax_expression_triplet", "expression", "@52", "@53", "@54", - "@55", "primary", "concatenation", "function_call", "identifier", - "IDENTIFIER_or_OR", "delay_o", "delay", "mintypmax_clist", - "delay_control", "event_control", "@56", "@57", "event_expression", - "rp", "rb", "sc", 0 + "$end", "error", "$undefined", "LOWEST", "IF", "ELSE", "'?'", "':'", + "OROR", "ANDAND", "ANDANDAND", "'|'", "'^'", "XNOR", "'&'", + "CASE_INEQUALITY", "CASE_EQUALITY", "LOGICAL_INEQUALITY", + "LOGICAL_EQUALITY", "GE", "GT", "LE", "LT", "RIGHT_SHIFT", "LEFT_SHIFT", + "'+'", "'-'", "'*'", "'/'", "'%'", "'('", "'['", "'!'", "'~'", + "REDUCTION_NOR", "REDUCTION_NAND", "UNARY", "IDENTIFIER", + "HIERARCHY_IDENTIFIER", "STARARROW", "EQUALARROW", "SPECPARAM", "SETUP", + "HOLD", "PERIOD", "WIDTH", "SKEW", "RECOVERY", "SETUPHOLD", "NOCHANGE", + "MODULE", "MACROMODULE", "ENDMODULE", "SPECIFY", "ENDSPECIFY", + "PRIMITIVE", "ENDPRIMITIVE", "TABLE", "ENDTABLE", "TASK", "ENDTASK", + "FUNCTION", "ENDFUNCTION", "PARAMETER", "INPUT", "OUTPUT", "INOUT", + "NETTYPE", "TRIREG", "SCALARED", "VECTORED", "REG", "TIME", "INTEGER", + "REAL", "EVENT", "ASSIGN", "DEFPARAM", "STRENGTH0", "STRENGTH1", + "SUPPLY0", "SUPPLY1", "LOGIC", "BUFFER", "BUFIF", "CMOS", "PULL", "TRAN", + "INITIAL", "ALWAYS", "CASE", "CASEZ", "CASEX", "ENDCASE", "FOREVER", + "REPEAT", "WHILE", "FOR", "WAIT_", "ARROW_", "DISABLE", "DEASSIGN", + "FORCE", "RELEASE", "DEFAULT", "BEGIN", "END", "FORK", "JOIN", + "SYSTEM_IDENTIFIER", "STRING", "NUMBER", "BASE_NUMBER", "POSEDGE", + "NEGEDGE", "OR", "SMALL", "MEDIUM", "LARGE", "EDGE", "DOUBLE_DIGIT", + "UDP_CHAR", "UDP_ONE", "UDP_ZERO", "UDP_X", "UDP_B", "UDP_HOOK", "EOF_", + "','", "'.'", "'{'", "'}'", "']'", "'='", "'#'", "')'", "'@'", "';'", + "$accept", "source_text", "description_list", "description", "module", + "@1", "@2", "@3", "module_item_list", "list_of_ports_o", "port_clist", + "port", "port_expression_o", "port_reference_clist", "port_reference", + "module_item", "UDP", "@4", "@5", "@6", "UDP_declarations", + "UDP_declaration", "UDP_reg_statement", "UDP_initial_statement", + "UDP_table_definition", "@7", "table_entry_list", "table_entry", + "table_digit_list", "table_digit", "table_digit1", "task", "@8", + "function", "@9", "function_type", "tf_declaration_list", + "tf_declaration", "parameter_declaration", "@10", + "list_of_param_assignments", "param_assignment", "setspec", + "static_declaration", "port_declaration", "port_spec", + "port_decl_identifiers", "reg_spec", "real_spec", "event_spec", + "setnetspec", "net_declaration", "net_spec", "trireg_spec", "@11", + "nettype", "expandrange_o", "continuous_assign", "@12", "assign_spec", + "list_of_net_assignments", "net_assignment", "@13", + "list_of_assignments", "cont_assignment", "@14", "parameter_override", + "list_of_param_overrides", "reg_decl_identifiers", "reg_decl_identifier", + "non_reg_decl_identifiers", "decl_identifiers", "charge_strength_o", + "drive_strength_o", "drive_strength", "strength0", "strength1", "xrange", + "range", "gate_declaration", "@15", "gatetype", "gate_description", + "@16", "@17", "gate_instance_clist", "gate_instance", + "UDP_or_module_instantiation", "@18", "xparameter_value_assignment", + "constant_expression_clist", "terminal_clist", "module_instance_clist", + "module_instance", "list_of_module_connections_o", + "module_port_connection_clist", "module_port_connection", + "named_port_connection_clist", "named_port_connection", + "initial_statement", "@19", "always_statement", "@20", + "statement_or_null", "statement", "@21", "@22", "@23", "@24", "@25", + "@26", "@27", "@28", "@29", "@30", "@31", "@32", "@33", "@34", "@35", + "@36", "@37", "@38", "@39", "@40", "@41", "elsepart", "case", + "assignment", "@42", "case_item_plist", "case_expr", "expression_clist", + "xexpression_clist", "xexpression", "seq_block", "@43", "@44", + "par_block", "@45", "@46", "statement_list", "statement_tree_list", + "block_declaration_list", "block_declaration", "task_enable", + "system_task_enable", "@47", "lvalue", "lval_normal", "specify_block", + "@48", "specify_stuff", "specify_items", "specify_item", + "specparam_declaration", "@49", "path_declaration", "path_description", + "list_of_path_inputs", "list_of_path_outputs", + "specify_input_terminal_descriptor", + "specify_output_terminal_descriptor", "path_delay_value", + "path_delay_expression", "polarity_operator", "path_operator", + "conditional_port_expression", "data_source_expression", + "edge_identifier", "specify_if_clause", "system_timing_check", + "notify_clause", "notify_register", "timing_check_event", + "controlled_timing_check_event", "timing_check_event_control", "@50", + "timing_check_event_control_no_empty", "@51", "edge_list", + "timing_check_condition", "scalar_expression", "scalar_constant", + "timing_input_terminal_descriptor", "lval_concat", "lval_clist", + "conditional_expression", "constant_expression", "mintypmax_expression", + "mintypmax_expression_triplet", "expression", "@52", "@53", "@54", "@55", + "primary", "concatenation", "function_call", "identifier", + "IDENTIFIER_or_OR", "delay_o", "delay", "mintypmax_clist", + "delay_control", "event_control", "@56", "@57", "event_expression", "rp", + "rb", "sc", 0 }; #endif -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const short yyr1[] = +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const unsigned short int yytoknum[] = { - 0, 138, 138, 138, 138, 139, 139, 140, 140, 142, - 143, 144, 141, 145, 145, 145, 146, 146, 147, 147, - 147, 147, 148, 148, 149, 149, 149, 150, 150, 151, - 151, 151, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 154, 155, 156, 153, 157, - 157, 157, 158, 158, 159, 160, 160, 162, 161, 163, - 163, 164, 165, 165, 166, 166, 166, 166, 166, 166, - 166, 167, 167, 167, 167, 167, 169, 168, 171, 170, - 172, 172, 172, 172, 173, 173, 174, 174, 174, 176, - 175, 177, 177, 177, 177, 177, 178, 178, 179, 180, - 180, 180, 181, 182, 182, 182, 183, 183, 183, 183, - 183, 183, 184, 184, 184, 185, 186, 187, 188, 188, - 188, 189, 191, 190, 192, 192, 192, 193, 193, 193, - 193, 195, 194, 196, 197, 197, 197, 197, 197, 197, - 199, 198, 200, 200, 200, 200, 200, 200, 202, 201, - 203, 204, 204, 205, 205, 205, 205, 205, 205, 206, - 206, 207, 207, 208, 208, 209, 209, 209, 209, 210, - 210, 211, 211, 212, 212, 213, 213, 214, 214, 215, - 217, 216, 218, 218, 218, 218, 218, 218, 218, 220, - 219, 221, 219, 222, 222, 223, 223, 225, 224, 226, - 226, 226, 226, 226, 226, 227, 227, 228, 228, 228, - 228, 228, 228, 229, 229, 229, 229, 229, 229, 230, - 230, 231, 231, 232, 232, 232, 232, 233, 233, 234, - 234, 235, 235, 237, 236, 239, 238, 240, 240, 241, - 242, 241, 243, 244, 241, 245, 241, 246, 241, 247, - 241, 248, 241, 249, 241, 250, 241, 251, 241, 252, - 241, 253, 241, 254, 241, 255, 241, 256, 241, 257, - 241, 241, 241, 241, 241, 258, 241, 259, 241, 260, - 241, 261, 241, 262, 241, 263, 263, 264, 264, 264, - 266, 265, 267, 267, 267, 267, 268, 268, 268, 269, - 269, 269, 269, 270, 270, 271, 271, 273, 272, 274, - 272, 276, 275, 277, 275, 278, 278, 278, 279, 279, - 279, 280, 280, 281, 281, 282, 282, 283, 284, 283, - 285, 285, 286, 286, 286, 288, 287, 289, 290, 290, - 290, 291, 291, 291, 293, 292, 294, 295, 295, 295, - 295, 295, 295, 296, 296, 296, 296, 296, 297, 297, - 297, 297, 297, 298, 298, 298, 299, 299, 299, 300, - 300, 300, 300, 301, 302, 302, 303, 303, 304, 305, - 306, 306, 307, 307, 308, 308, 308, 308, 308, 308, - 308, 308, 308, 309, 309, 310, 311, 311, 312, 312, - 313, 313, 313, 314, 313, 315, 315, 316, 315, 317, - 317, 317, 318, 318, 318, 318, 318, 318, 318, 319, - 320, 320, 321, 321, 321, 322, 323, 323, 323, 323, - 323, 323, 323, 323, 323, 324, 325, 326, 326, 327, - 328, 328, 328, 328, 328, 328, 328, 328, 328, 328, - 328, 328, 328, 328, 329, 328, 330, 328, 328, 328, - 331, 328, 332, 328, 328, 328, 328, 328, 328, 328, - 328, 328, 328, 328, 328, 328, 328, 328, 333, 333, - 333, 333, 333, 333, 333, 333, 333, 334, 334, 335, - 335, 335, 336, 336, 337, 337, 338, 338, 339, 339, - 339, 340, 340, 340, 341, 341, 341, 343, 342, 344, - 342, 345, 345, 345, 345, 346, 347, 347, 348 + 0, 256, 257, 258, 259, 260, 63, 58, 261, 262, + 263, 124, 94, 264, 38, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 43, 45, 42, 47, 37, + 40, 91, 33, 126, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 362, 363, 364, 365, 366, 367, 368, 44, 46, + 123, 125, 93, 61, 35, 41, 64, 59 }; +# endif -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const short yyr2[] = +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned short int yyr1[] = { - 0, 1, 2, 1, 1, 1, 2, 1, 1, 0, - 0, 0, 9, 0, 2, 2, 3, 0, 1, 3, - 1, 3, 1, 5, 1, 3, 0, 1, 3, 1, - 4, 6, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 0, 0, 0, 11, 0, - 2, 2, 1, 1, 3, 0, 5, 0, 4, 1, - 2, 2, 0, 2, 1, 1, 1, 1, 1, 1, - 4, 1, 1, 1, 1, 1, 0, 7, 0, 8, - 0, 1, 1, 1, 0, 2, 1, 1, 1, 0, - 5, 1, 3, 1, 3, 3, 3, 3, 0, 4, - 4, 4, 4, 2, 2, 2, 1, 3, 1, 2, - 3, 3, 2, 2, 2, 1, 1, 0, 4, 4, - 4, 3, 0, 5, 1, 1, 1, 1, 2, 2, - 0, 0, 5, 3, 1, 3, 1, 2, 3, 3, - 0, 4, 1, 3, 1, 2, 3, 3, 0, 4, - 3, 3, 5, 1, 3, 1, 2, 3, 3, 1, - 6, 1, 3, 1, 3, 0, 3, 3, 3, 0, - 1, 5, 5, 1, 1, 1, 1, 0, 1, 5, - 0, 3, 1, 1, 1, 1, 1, 1, 1, 0, - 3, 0, 4, 1, 3, 4, 3, 0, 5, 0, - 2, 4, 4, 6, 8, 1, 3, 1, 3, 1, - 2, 3, 3, 1, 3, 1, 2, 3, 3, 4, - 3, 1, 1, 1, 3, 1, 3, 1, 0, 1, - 3, 5, 4, 0, 3, 0, 3, 1, 1, 2, - 0, 7, 0, 0, 8, 0, 3, 0, 6, 0, - 6, 0, 10, 0, 3, 0, 3, 0, 6, 0, - 6, 0, 5, 0, 6, 0, 6, 0, 6, 0, - 4, 1, 1, 1, 1, 0, 4, 0, 6, 0, - 4, 0, 6, 0, 4, 0, 2, 1, 1, 1, - 0, 4, 1, 2, 1, 2, 3, 3, 2, 1, - 3, 1, 3, 1, 3, 0, 1, 0, 4, 0, - 7, 0, 4, 0, 7, 0, 2, 2, 0, 2, - 2, 0, 2, 1, 1, 2, 5, 2, 0, 6, - 1, 1, 1, 4, 6, 0, 3, 2, 0, 2, - 2, 1, 1, 1, 0, 4, 5, 9, 10, 10, - 11, 5, 6, 1, 3, 1, 3, 3, 1, 3, - 1, 3, 3, 1, 4, 6, 1, 4, 6, 1, - 5, 7, 13, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 0, 4, 10, 10, 8, 7, 10, 10, - 10, 12, 11, 0, 2, 1, 2, 4, 2, 4, - 0, 1, 1, 0, 5, 1, 1, 0, 5, 1, - 3, 1, 1, 3, 2, 3, 3, 3, 3, 1, - 1, 1, 1, 4, 6, 3, 1, 1, 3, 3, - 1, 2, 3, 3, 3, 1, 1, 1, 5, 5, - 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 3, 3, 3, 0, 4, 0, 4, 3, 3, - 0, 4, 0, 4, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 5, 1, 1, 1, - 1, 4, 6, 1, 1, 3, 3, 3, 6, 4, - 4, 1, 1, 1, 1, 1, 0, 1, 2, 2, - 4, 1, 3, 5, 2, 2, 4, 0, 3, 0, - 5, 1, 2, 2, 3, 1, 1, 1, 1 + 0, 138, 139, 139, 139, 139, 140, 140, 141, 141, + 143, 144, 145, 142, 146, 146, 146, 147, 147, 148, + 148, 148, 148, 149, 149, 150, 150, 150, 151, 151, + 152, 152, 152, 153, 153, 153, 153, 153, 153, 153, + 153, 153, 153, 153, 153, 153, 155, 156, 157, 154, + 158, 158, 158, 159, 159, 160, 161, 161, 163, 162, + 164, 164, 165, 166, 166, 167, 167, 167, 167, 167, + 167, 167, 168, 168, 168, 168, 168, 170, 169, 172, + 171, 173, 173, 173, 173, 174, 174, 175, 175, 175, + 177, 176, 178, 178, 178, 178, 178, 179, 179, 180, + 181, 181, 181, 182, 183, 183, 183, 184, 184, 184, + 184, 184, 184, 185, 185, 185, 186, 187, 188, 189, + 189, 189, 190, 192, 191, 193, 193, 193, 194, 194, + 194, 194, 196, 195, 197, 198, 198, 198, 198, 198, + 198, 200, 199, 201, 201, 201, 201, 201, 201, 203, + 202, 204, 205, 205, 206, 206, 206, 206, 206, 206, + 207, 207, 208, 208, 209, 209, 210, 210, 210, 210, + 211, 211, 212, 212, 213, 213, 214, 214, 215, 215, + 216, 218, 217, 219, 219, 219, 219, 219, 219, 219, + 221, 220, 222, 220, 223, 223, 224, 224, 226, 225, + 227, 227, 227, 227, 227, 227, 228, 228, 229, 229, + 229, 229, 229, 229, 230, 230, 230, 230, 230, 230, + 231, 231, 232, 232, 233, 233, 233, 233, 234, 234, + 235, 235, 236, 236, 238, 237, 240, 239, 241, 241, + 242, 243, 242, 244, 245, 242, 246, 242, 247, 242, + 248, 242, 249, 242, 250, 242, 251, 242, 252, 242, + 253, 242, 254, 242, 255, 242, 256, 242, 257, 242, + 258, 242, 242, 242, 242, 242, 259, 242, 260, 242, + 261, 242, 262, 242, 263, 242, 264, 264, 265, 265, + 265, 267, 266, 268, 268, 268, 268, 269, 269, 269, + 270, 270, 270, 270, 271, 271, 272, 272, 274, 273, + 275, 273, 277, 276, 278, 276, 279, 279, 279, 280, + 280, 280, 281, 281, 282, 282, 283, 283, 284, 285, + 284, 286, 286, 287, 287, 287, 289, 288, 290, 291, + 291, 291, 292, 292, 292, 294, 293, 295, 296, 296, + 296, 296, 296, 296, 297, 297, 297, 297, 297, 298, + 298, 298, 298, 298, 299, 299, 299, 300, 300, 300, + 301, 301, 301, 301, 302, 303, 303, 304, 304, 305, + 306, 307, 307, 308, 308, 309, 309, 309, 309, 309, + 309, 309, 309, 309, 310, 310, 311, 312, 312, 313, + 313, 314, 314, 314, 315, 314, 316, 316, 317, 316, + 318, 318, 318, 319, 319, 319, 319, 319, 319, 319, + 320, 321, 321, 322, 322, 322, 323, 324, 324, 324, + 324, 324, 324, 324, 324, 324, 325, 326, 327, 327, + 328, 329, 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 330, 329, 331, 329, 329, + 329, 332, 329, 333, 329, 329, 329, 329, 329, 329, + 329, 329, 329, 329, 329, 329, 329, 329, 329, 334, + 334, 334, 334, 334, 334, 334, 334, 334, 335, 335, + 336, 336, 336, 337, 337, 338, 338, 339, 339, 340, + 340, 340, 341, 341, 341, 342, 342, 342, 344, 343, + 345, 343, 346, 346, 346, 346, 347, 348, 348, 349 }; -/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE - doesn't specify something else to do. Zero means the default is an - error. */ -static const short yydefact[] = +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const unsigned char yyr2[] = { - 0, 3, 240, 493, 492, 9, 45, 277, 245, 247, - 249, 251, 267, 269, 275, 279, 281, 283, 307, 311, - 328, 4, 0, 0, 507, 0, 5, 7, 8, 1, - 0, 0, 271, 272, 273, 274, 0, 330, 331, 332, - 253, 255, 0, 0, 0, 0, 242, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 315, 0, 318, - 518, 0, 327, 430, 426, 427, 0, 332, 0, 504, - 505, 509, 0, 2, 6, 287, 288, 289, 243, 239, - 261, 290, 0, 0, 325, 242, 242, 0, 494, 495, - 10, 46, 0, 246, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 309, 0, 313, 0, 305, 431, 0, - 425, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 491, 477, 478, 479, 0, 0, 437, 440, - 483, 484, 480, 0, 508, 0, 0, 0, 0, 0, - 0, 0, 301, 0, 299, 0, 254, 237, 238, 256, - 0, 17, 17, 0, 0, 0, 0, 0, 0, 435, - 270, 276, 280, 0, 284, 321, 317, 308, 316, 321, - 320, 312, 319, 0, 303, 306, 432, 433, 434, 428, - 429, 447, 449, 450, 445, 441, 442, 0, 0, 443, - 444, 448, 446, 305, 0, 0, 299, 515, 506, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 460, - 462, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 454, 456, 305, 0, 0, 0, 511, 0, 0, 0, - 0, 0, 0, 0, 291, 0, 0, 0, 333, 242, - 0, 0, 0, 0, 242, 242, 0, 290, 242, 0, - 315, 318, 305, 0, 486, 485, 0, 487, 0, 0, - 0, 465, 464, 471, 472, 473, 470, 458, 459, 0, - 0, 466, 467, 468, 469, 474, 475, 451, 452, 453, - 0, 0, 0, 0, 436, 512, 513, 0, 510, 0, - 262, 0, 0, 0, 0, 302, 300, 326, 0, 285, - 20, 29, 0, 0, 0, 18, 22, 24, 11, 47, - 278, 248, 250, 0, 268, 282, 177, 177, 177, 177, - 115, 116, 323, 324, 98, 98, 98, 0, 322, 0, - 304, 329, 490, 0, 0, 0, 461, 463, 455, 457, - 489, 0, 481, 514, 0, 264, 266, 258, 260, 334, - 242, 241, 0, 0, 0, 27, 0, 16, 13, 49, - 0, 0, 89, 178, 112, 114, 113, 0, 0, 0, - 310, 314, 0, 476, 438, 0, 436, 294, 242, 0, - 292, 0, 286, 0, 26, 0, 25, 21, 19, 0, - 0, 0, 0, 0, 155, 159, 0, 153, 163, 0, - 161, 0, 488, 482, 242, 298, 295, 244, 293, 242, - 0, 30, 0, 28, 15, 199, 12, 335, 0, 80, - 177, 177, 177, 124, 122, 169, 0, 125, 126, 182, - 184, 185, 186, 187, 188, 233, 235, 183, 14, 43, - 44, 32, 35, 33, 98, 34, 117, 98, 130, 39, - 98, 38, 36, 180, 37, 41, 42, 40, 51, 0, - 0, 50, 53, 0, 52, 242, 0, 93, 0, 0, - 91, 0, 156, 0, 99, 0, 101, 0, 100, 297, - 296, 0, 23, 0, 197, 338, 0, 82, 83, 0, - 81, 103, 104, 105, 165, 0, 496, 170, 0, 0, - 242, 242, 0, 0, 0, 0, 0, 496, 127, 131, - 189, 0, 0, 57, 0, 252, 0, 0, 0, 0, - 90, 0, 157, 158, 154, 164, 162, 31, 0, 200, - 0, 336, 0, 76, 0, 0, 130, 173, 175, 174, - 176, 0, 0, 0, 133, 497, 0, 150, 0, 234, - 236, 108, 106, 0, 136, 163, 0, 134, 0, 0, - 128, 129, 121, 0, 181, 0, 191, 54, 0, 62, - 48, 517, 516, 179, 96, 97, 436, 94, 95, 92, - 0, 0, 205, 0, 436, 215, 0, 0, 0, 213, - 340, 0, 344, 0, 0, 0, 0, 0, 0, 0, - 0, 337, 339, 341, 342, 0, 343, 84, 78, 0, - 0, 0, 496, 0, 0, 0, 498, 499, 0, 151, - 109, 0, 102, 140, 137, 0, 120, 118, 119, 144, - 0, 142, 0, 0, 0, 0, 193, 0, 421, 420, - 0, 62, 59, 0, 0, 0, 0, 201, 0, 515, - 225, 0, 0, 221, 223, 222, 229, 227, 0, 216, - 0, 198, 0, 0, 400, 400, 0, 0, 400, 0, - 400, 0, 0, 0, 242, 84, 166, 167, 168, 123, - 0, 0, 501, 0, 0, 110, 111, 107, 0, 0, - 138, 139, 135, 145, 0, 132, 148, 209, 0, 207, - 0, 0, 190, 0, 56, 58, 60, 0, 64, 67, - 66, 69, 68, 65, 63, 61, 0, 160, 206, 0, - 0, 220, 0, 0, 0, 217, 218, 214, 0, 378, - 0, 401, 402, 0, 0, 0, 0, 405, 406, 0, - 0, 0, 0, 0, 0, 0, 0, 355, 363, 380, - 381, 0, 353, 0, 0, 85, 86, 88, 87, 0, - 242, 171, 172, 0, 500, 152, 141, 146, 147, 143, - 0, 210, 0, 196, 0, 194, 192, 73, 72, 71, - 74, 75, 0, 0, 0, 203, 0, 226, 224, 230, - 219, 383, 345, 403, 400, 396, 422, 400, 407, 0, - 398, 0, 400, 400, 400, 400, 0, 0, 374, 375, - 376, 377, 0, 0, 0, 0, 0, 0, 369, 373, - 77, 0, 502, 149, 211, 212, 208, 195, 0, 439, - 0, 0, 232, 0, 0, 0, 0, 0, 0, 393, - 0, 0, 0, 0, 0, 0, 0, 356, 357, 354, - 0, 360, 0, 366, 0, 358, 0, 0, 373, 346, - 79, 0, 70, 204, 231, 411, 409, 0, 0, 0, - 0, 419, 397, 412, 0, 436, 0, 0, 0, 0, - 399, 0, 0, 0, 0, 0, 0, 0, 364, 0, - 0, 0, 0, 0, 351, 0, 0, 503, 0, 404, - 393, 0, 414, 0, 0, 0, 0, 0, 423, 393, - 408, 395, 394, 0, 393, 387, 393, 393, 0, 0, - 0, 352, 0, 0, 0, 361, 362, 359, 0, 0, - 410, 0, 413, 415, 418, 416, 417, 0, 0, 386, - 0, 0, 0, 0, 0, 365, 0, 379, 0, 0, - 367, 0, 0, 0, 370, 0, 424, 0, 0, 0, - 0, 393, 0, 0, 0, 0, 0, 0, 0, 384, - 385, 388, 389, 390, 0, 0, 347, 0, 368, 0, - 0, 0, 371, 0, 392, 349, 348, 0, 0, 391, - 350, 0, 0, 0, 0, 372, 0, 0, 0 + 0, 2, 1, 2, 1, 1, 1, 2, 1, 1, + 0, 0, 0, 9, 0, 2, 2, 3, 0, 1, + 3, 1, 3, 1, 5, 1, 3, 0, 1, 3, + 1, 4, 6, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 0, 0, 0, 11, + 0, 2, 2, 1, 1, 3, 0, 5, 0, 4, + 1, 2, 2, 0, 2, 1, 1, 1, 1, 1, + 1, 4, 1, 1, 1, 1, 1, 0, 7, 0, + 8, 0, 1, 1, 1, 0, 2, 1, 1, 1, + 0, 5, 1, 3, 1, 3, 3, 3, 3, 0, + 4, 4, 4, 4, 2, 2, 2, 1, 3, 1, + 2, 3, 3, 2, 2, 2, 1, 1, 0, 4, + 4, 4, 3, 0, 5, 1, 1, 1, 1, 2, + 2, 0, 0, 5, 3, 1, 3, 1, 2, 3, + 3, 0, 4, 1, 3, 1, 2, 3, 3, 0, + 4, 3, 3, 5, 1, 3, 1, 2, 3, 3, + 1, 6, 1, 3, 1, 3, 0, 3, 3, 3, + 0, 1, 5, 5, 1, 1, 1, 1, 0, 1, + 5, 0, 3, 1, 1, 1, 1, 1, 1, 1, + 0, 3, 0, 4, 1, 3, 4, 3, 0, 5, + 0, 2, 4, 4, 6, 8, 1, 3, 1, 3, + 1, 2, 3, 3, 1, 3, 1, 2, 3, 3, + 4, 3, 1, 1, 1, 3, 1, 3, 1, 0, + 1, 3, 5, 4, 0, 3, 0, 3, 1, 1, + 2, 0, 7, 0, 0, 8, 0, 3, 0, 6, + 0, 6, 0, 10, 0, 3, 0, 3, 0, 6, + 0, 6, 0, 5, 0, 6, 0, 6, 0, 6, + 0, 4, 1, 1, 1, 1, 0, 4, 0, 6, + 0, 4, 0, 6, 0, 4, 0, 2, 1, 1, + 1, 0, 4, 1, 2, 1, 2, 3, 3, 2, + 1, 3, 1, 3, 1, 3, 0, 1, 0, 4, + 0, 7, 0, 4, 0, 7, 0, 2, 2, 0, + 2, 2, 0, 2, 1, 1, 2, 5, 2, 0, + 6, 1, 1, 1, 4, 6, 0, 3, 2, 0, + 2, 2, 1, 1, 1, 0, 4, 5, 9, 10, + 10, 11, 5, 6, 1, 3, 1, 3, 3, 1, + 3, 1, 3, 3, 1, 4, 6, 1, 4, 6, + 1, 5, 7, 13, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 0, 4, 10, 10, 8, 7, 10, + 10, 10, 12, 11, 0, 2, 1, 2, 4, 2, + 4, 0, 1, 1, 0, 5, 1, 1, 0, 5, + 1, 3, 1, 1, 3, 2, 3, 3, 3, 3, + 1, 1, 1, 1, 4, 6, 3, 1, 1, 3, + 3, 1, 2, 3, 3, 3, 1, 1, 1, 5, + 5, 1, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 3, 3, 3, 0, 4, 0, 4, 3, + 3, 0, 4, 0, 4, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 5, 1, 1, + 1, 1, 4, 6, 1, 1, 3, 3, 3, 6, + 4, 4, 1, 1, 1, 1, 1, 0, 1, 2, + 2, 4, 1, 3, 5, 2, 2, 4, 0, 3, + 0, 5, 1, 2, 2, 3, 1, 1, 1, 1 }; -static const short yydefgoto[] = +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const unsigned short int yydefact[] = { - 996, 25, 26, 27, 43, 151, 358, 389, 241, 304, - 305, 306, 354, 307, 438, 28, 44, 152, 359, 390, - 461, 462, 463, 514, 569, 641, 642, 643, 714, 782, - 439, 607, 440, 675, 489, 674, 755, 322, 393, 469, - 470, 367, 323, 758, 444, 553, 324, 325, 326, 503, - 445, 446, 447, 494, 448, 507, 449, 563, 450, 556, - 557, 688, 630, 631, 770, 451, 498, 396, 397, 401, - 399, 536, 496, 497, 541, 542, 362, 363, 452, 510, - 453, 564, 565, 637, 635, 636, 454, 530, 484, 581, - 698, 588, 589, 652, 653, 654, 655, 656, 455, 500, - 456, 501, 146, 147, 42, 30, 135, 46, 47, 48, - 49, 85, 86, 139, 140, 136, 137, 138, 50, 51, - 52, 45, 53, 54, 55, 351, 78, 31, 141, 379, - 380, 381, 173, 174, 32, 57, 165, 33, 59, 169, - 104, 106, 250, 328, 34, 35, 61, 36, 37, 457, - 485, 531, 532, 602, 603, 663, 604, 673, 751, 854, - 752, 855, 817, 818, 813, 814, 728, 946, 753, 605, - 606, 879, 912, 734, 740, 735, 833, 741, 838, 867, - 872, 873, 640, 795, 38, 66, 158, 195, 819, 575, - 376, 280, 281, 269, 270, 129, 130, 131, 132, 90, - 544, 545, 683, 40, 41, 72, 133, 227, 255, 573, - 148 + 0, 4, 241, 494, 493, 10, 46, 278, 246, 248, + 250, 252, 268, 270, 276, 280, 282, 284, 308, 312, + 329, 5, 0, 0, 508, 0, 0, 6, 8, 9, + 2, 0, 0, 272, 273, 274, 275, 0, 331, 332, + 333, 254, 256, 0, 0, 0, 0, 243, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 316, 0, + 319, 519, 0, 328, 431, 427, 428, 0, 333, 0, + 505, 506, 510, 0, 1, 3, 7, 288, 289, 290, + 244, 240, 262, 291, 0, 0, 326, 243, 243, 0, + 495, 496, 11, 47, 0, 247, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 310, 0, 314, 0, 306, + 432, 0, 426, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 492, 478, 479, 480, 0, 0, + 438, 441, 484, 485, 481, 0, 509, 0, 0, 0, + 0, 0, 0, 0, 302, 0, 300, 0, 255, 238, + 239, 257, 0, 18, 18, 0, 0, 0, 0, 0, + 0, 436, 271, 277, 281, 0, 285, 322, 318, 309, + 317, 322, 321, 313, 320, 0, 304, 307, 433, 434, + 435, 429, 430, 448, 450, 451, 446, 442, 443, 0, + 0, 444, 445, 449, 447, 306, 0, 0, 300, 516, + 507, 0, 0, 0, 0, 0, 0, 0, 0, 463, + 461, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 455, 457, 306, 0, 0, 0, 512, 0, + 0, 0, 0, 0, 0, 0, 292, 0, 0, 0, + 334, 243, 0, 0, 0, 0, 243, 243, 0, 291, + 243, 0, 316, 319, 306, 0, 487, 486, 0, 488, + 0, 0, 0, 466, 465, 472, 473, 474, 471, 0, + 0, 460, 459, 470, 469, 468, 467, 476, 475, 452, + 453, 454, 0, 0, 0, 0, 437, 513, 514, 0, + 511, 0, 263, 0, 0, 0, 0, 303, 301, 327, + 0, 286, 21, 30, 0, 0, 0, 19, 23, 25, + 12, 48, 279, 249, 251, 0, 269, 283, 178, 178, + 178, 178, 116, 117, 324, 325, 99, 99, 99, 0, + 323, 0, 305, 330, 491, 0, 0, 0, 464, 462, + 456, 458, 490, 0, 482, 515, 0, 265, 267, 259, + 261, 335, 243, 242, 0, 0, 0, 28, 0, 17, + 14, 50, 0, 0, 90, 179, 113, 115, 114, 0, + 0, 0, 311, 315, 0, 477, 439, 0, 437, 295, + 243, 0, 293, 0, 287, 0, 27, 0, 26, 22, + 20, 0, 0, 0, 0, 0, 156, 160, 0, 154, + 164, 0, 162, 0, 489, 483, 243, 299, 296, 245, + 294, 243, 0, 31, 0, 29, 16, 200, 13, 336, + 0, 81, 178, 178, 178, 125, 123, 170, 0, 126, + 127, 183, 185, 186, 187, 188, 189, 234, 236, 184, + 15, 44, 45, 33, 36, 34, 99, 35, 118, 99, + 131, 40, 99, 39, 37, 181, 38, 42, 43, 41, + 52, 0, 0, 51, 54, 0, 53, 243, 0, 94, + 0, 0, 92, 0, 157, 0, 100, 0, 102, 0, + 101, 298, 297, 0, 24, 0, 198, 339, 0, 83, + 84, 0, 82, 104, 105, 106, 166, 0, 497, 171, + 0, 0, 243, 243, 0, 0, 0, 0, 0, 497, + 128, 132, 190, 0, 0, 58, 0, 253, 0, 0, + 0, 0, 91, 0, 158, 159, 155, 165, 163, 32, + 0, 201, 0, 337, 0, 77, 0, 0, 131, 174, + 176, 175, 177, 0, 0, 0, 134, 498, 0, 151, + 0, 235, 237, 109, 107, 0, 137, 164, 0, 135, + 0, 0, 129, 130, 122, 0, 182, 0, 192, 55, + 0, 63, 49, 518, 517, 180, 97, 98, 437, 95, + 96, 93, 0, 0, 206, 0, 437, 216, 0, 0, + 0, 214, 341, 0, 345, 0, 0, 0, 0, 0, + 0, 0, 0, 338, 340, 342, 343, 0, 344, 85, + 79, 0, 0, 0, 497, 0, 0, 0, 499, 500, + 0, 152, 110, 0, 103, 141, 138, 0, 121, 119, + 120, 145, 0, 143, 0, 0, 0, 0, 194, 0, + 422, 421, 0, 63, 60, 0, 0, 0, 0, 202, + 0, 516, 226, 0, 0, 222, 224, 223, 230, 228, + 0, 217, 0, 199, 0, 0, 401, 401, 0, 0, + 401, 0, 401, 0, 0, 0, 243, 85, 167, 168, + 169, 124, 0, 0, 502, 0, 0, 111, 112, 108, + 0, 0, 139, 140, 136, 146, 0, 133, 149, 210, + 0, 208, 0, 0, 191, 0, 57, 59, 61, 0, + 65, 68, 67, 70, 69, 66, 64, 62, 0, 161, + 207, 0, 0, 221, 0, 0, 0, 218, 219, 215, + 0, 379, 0, 402, 403, 0, 0, 0, 0, 406, + 407, 0, 0, 0, 0, 0, 0, 0, 0, 356, + 364, 381, 382, 0, 354, 0, 0, 86, 87, 89, + 88, 0, 243, 172, 173, 0, 501, 153, 142, 147, + 148, 144, 0, 211, 0, 197, 0, 195, 193, 74, + 73, 72, 75, 76, 0, 0, 0, 204, 0, 227, + 225, 231, 220, 384, 346, 404, 401, 397, 423, 401, + 408, 0, 399, 0, 401, 401, 401, 401, 0, 0, + 375, 376, 377, 378, 0, 0, 0, 0, 0, 0, + 370, 374, 78, 0, 503, 150, 212, 213, 209, 196, + 0, 440, 0, 0, 233, 0, 0, 0, 0, 0, + 0, 394, 0, 0, 0, 0, 0, 0, 0, 357, + 358, 355, 0, 361, 0, 367, 0, 359, 0, 0, + 374, 347, 80, 0, 71, 205, 232, 412, 410, 0, + 0, 0, 0, 420, 398, 413, 0, 437, 0, 0, + 0, 0, 400, 0, 0, 0, 0, 0, 0, 0, + 365, 0, 0, 0, 0, 0, 352, 0, 0, 504, + 0, 405, 394, 0, 415, 0, 0, 0, 0, 0, + 424, 394, 409, 396, 395, 0, 394, 388, 394, 394, + 0, 0, 0, 353, 0, 0, 0, 362, 363, 360, + 0, 0, 411, 0, 414, 418, 417, 419, 416, 0, + 0, 387, 0, 0, 0, 0, 0, 366, 0, 380, + 0, 0, 368, 0, 0, 0, 371, 0, 425, 0, + 0, 0, 0, 394, 0, 0, 0, 0, 0, 0, + 0, 385, 386, 389, 390, 391, 0, 0, 348, 0, + 369, 0, 0, 0, 372, 0, 393, 350, 349, 0, + 0, 392, 351, 0, 0, 0, 0, 373 }; -static const short yypact[] = +/* YYDEFGOTO[NTERM-NUM]. */ +static const short int yydefgoto[] = { - 685,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 34, 46, - -52,-32768, 76, 232, 68, 49,-32768,-32768,-32768,-32768, - 500, -52,-32768,-32768,-32768,-32768, 14,-32768,-32768, 5, - -32768,-32768, 151, -8, 37, 90, 1425, 209, 237, 275, - 354, 322, 322, 90, 90, 90, 355,-32768, 363,-32768, - -32768, 380,-32768,-32768,-32768,-32768, 83, 89, 2201,-32768, - -32768,-32768, 322,-32768,-32768,-32768,-32768,-32768,-32768,-32768, - 326, 433, 1670, 2201,-32768, 1375, 1375, 2201,-32768,-32768, - -32768,-32768, 273,-32768, 2201, 2201, 90, 2201, -52, -52, - -52, 285, -52,-32768, 912,-32768, 1049, 2201, 90, 85, - -32768, 447, 447, 447, 447, 447, 447, 1719, 447, 447, - 447, 447, 482,-32768,-32768,-32768, 1670, 304, 2415,-32768, - -32768,-32768, 405, 2173,-32768, 487, 2201, 393, 399, 393, - 399, 2201,-32768, 117, 2537, 1883,-32768,-32768,-32768,-32768, - 1602, 510, 510, 2201, 1602, 1602, -52, 443, 304, 2537, - -32768,-32768,-32768, 2201,-32768,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768, 150,-32768, 2537,-32768,-32768,-32768,-32768, - -32768,-32768,-32768,-32768,-32768,-32768,-32768, 304, 304,-32768, - -32768,-32768,-32768, 2201, 125, 450, 2053,-32768,-32768, 2201, - 2201, 2201, 2201, 2201, 2201, 2201, 2201, 2201, 2201,-32768, - -32768, 2201, 2201, 2201, 2201, 2201, 2201, 2201, 2201, 2201, - -32768,-32768, 2201, 2201, 2201, 2201, 2537, 162, 2201, 1554, - 2201, 2201, 2201, 2201, 2537, 1758, -52, 2201,-32768, 1375, - 69, -52, -52, 1554, 1425, 1425, 2201,-32768, 1375, 1554, - 423, 423, 2201, -52,-32768,-32768, 150,-32768, 1670, 2441, - 2465, 1524, 2556, 1421, 1471, 1471, 863, 905, 905, 2201, - 2201, 782, 782, 782, 782, 579, 579, 573, 573,-32768, - 2201, 2201, 150, 587, 1966, 2537, 2537, 2173,-32768, 1602, - -32768, 1554, 1554, 1554, 1554,-32768, 2537,-32768, 2005, 593, - -32768, 590, 605, 617, 194,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768, 1554,-32768,-32768, 598, 598, 598, 598, - -32768,-32768,-32768,-32768,-32768,-32768,-32768, 1122,-32768, 1169, - -32768,-32768,-32768, 320, 2201, 2201, 905, 905,-32768,-32768, - -32768, 2201,-32768,-32768, 1631,-32768,-32768,-32768,-32768,-32768, - 1375,-32768, 2201, 632, 348,-32768, 102,-32768,-32768,-32768, - 90, 2201,-32768,-32768,-32768,-32768,-32768, 38, 641, 643, - -32768,-32768, 551, 2537, 2537, 553, 2537, 17, 1323, 420, - -32768, 25,-32768, 0, -25, 617,-32768,-32768,-32768, 2331, - 404, 304, 686, 39,-32768, 677, 1,-32768,-32768, 190, - -32768, 191,-32768,-32768, 1375,-32768, 17,-32768,-32768, 1375, - 2201,-32768, 304,-32768,-32768, 577,-32768,-32768, 682, 210, - 598, 598, 598,-32768,-32768, 690, 322,-32768,-32768,-32768, - -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 40,-32768, - -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 687, - 691,-32768,-32768, 673,-32768, 1425, 2201,-32768, 600, 9, - -32768, 2201, 694, 50,-32768, 697,-32768, 699,-32768,-32768, - -32768, 610,-32768, 2231,-32768,-32768, -52,-32768,-32768, 700, - -32768,-32768,-32768,-32768, 713, 569, 611,-32768, 257, 616, - 1425, 1425, 211, 293, 641, 598, 598, 611,-32768,-32768, - 611, -52, 618,-32768, 688,-32768, 8, 2201, 715, 295, - -32768, 743,-32768,-32768,-32768,-32768,-32768,-32768, 1719,-32768, - 63,-32768, 592,-32768, -52, 555, 40,-32768,-32768,-32768, - -32768, 627, 629, 400,-32768,-32768, 322,-32768, 2201,-32768, - -32768,-32768,-32768, 13,-32768, 625, 47,-32768, 190, 190, - -32768,-32768,-32768, 88,-32768, 343,-32768,-32768, 392,-32768, - -32768,-32768,-32768,-32768,-32768,-32768, 2489,-32768,-32768,-32768, - 2201, 312,-32768, 336, 2415,-32768, 390, 729, 54,-32768, - -32768, 730,-32768, 732, 733, 734, 735, 736, 737, 739, - 740,-32768,-32768,-32768,-32768, 742,-32768,-32768,-32768, 304, - 304, 304, 611, 464, 517, 2201,-32768,-32768, 640,-32768, - 741, 314,-32768,-32768, 756, 315,-32768,-32768,-32768,-32768, - 66,-32768, 662, 1807, 744, 280,-32768, 343,-32768,-32768, - -52, 738,-32768, 384, 2201, 667, 2201,-32768, 2201, 65, - -32768, 763, 304, 674,-32768, 696,-32768, 2537, 390, 444, - 308,-32768, 2201, 39, 452, 452, 459, 459, 452, 459, - 452, 459, 207, 668, 1271,-32768,-32768,-32768,-32768,-32768, - 304, 304, 698, 304, 2201,-32768,-32768,-32768, 2201, 625, - -32768,-32768,-32768, 90, 96,-32768,-32768,-32768, 67, 2537, - 1807, 343,-32768, 280,-32768,-32768,-32768, 502,-32768,-32768, - -32768,-32768,-32768,-32768,-32768,-32768, 2513,-32768,-32768, 409, - 783,-32768, 1281, 693, 304,-32768,-32768,-32768, 304, 2537, - 9,-32768,-32768, 794, 701, 322, 702,-32768,-32768, 796, - 704, 322, 705, 706, 709, 714, 716,-32768, 797,-32768, - -32768, 91,-32768, 345, 2263,-32768,-32768,-32768,-32768, 754, - 1271,-32768,-32768, 2201,-32768,-32768, 2537,-32768,-32768,-32768, - 2201, 2201, 1846,-32768, 67,-32768,-32768,-32768,-32768,-32768, - -32768,-32768, 502, 2201, 2201,-32768, 549,-32768,-32768,-32768, - -32768,-32768,-32768,-32768, 452, 833, 814, 452,-32768, 2201, - 837, 2201, 452, 452, 452, 452, 2201, 811,-32768,-32768, - -32768,-32768, 346, 483, 332, 242, 1719, -52,-32768,-32768, - -32768, 788, 724, 2537, 2537,-32768, 2537,-32768, 304, 2537, - 718, 1602,-32768, 44, 726, 426, 2201, 727, 44, 2088, - 426, 1578, 728, 731, 745, 746, 19,-32768,-32768,-32768, - 349,-32768, 349, 826, 82,-32768, 828, 747, 304,-32768, - -32768, 2201,-32768,-32768,-32768,-32768, 748, 8, 2201, 426, - 823,-32768,-32768, 649, 856, 2029, 2201, 8, 827, 304, - -32768, 2201, -52, 2201, 2201, 2201, 2201, 2201,-32768, 82, - 21, 2201, 830, 376,-32768, 349, 2201,-32768, 44,-32768, - 2088, 759,-32768, 392, 392, 392, 392, 2201,-32768, 2088, - -32768,-32768,-32768, -52, 2088,-32768, 2088, 2088, 2127, 2151, - 8,-32768, 2201, 861, 20,-32768,-32768,-32768, 250, 418, - -32768, 304,-32768,-32768,-32768,-32768,-32768, 764, 304,-32768, - 304, 304, 304, 2201, 2201,-32768, 304, 2537, 2201, 2201, - -32768, 2201, 862, 2201,-32768, -52,-32768, -52, -52, -52, - -52, 2088, 1602, 304, 304, 8, 304, 2201, 429,-32768, - -32768,-32768,-32768,-32768, 304, -52,-32768, 304,-32768, 304, - 304, 2201,-32768, -52,-32768,-32768,-32768, 304, 767,-32768, - -32768, 2201, 769, 2201, 304,-32768, 870, 871,-32768 + -1, 25, 26, 27, 28, 44, 153, 360, 391, 243, + 306, 307, 308, 356, 309, 440, 29, 45, 154, 361, + 392, 463, 464, 465, 516, 571, 643, 644, 645, 716, + 784, 441, 609, 442, 677, 491, 676, 757, 324, 395, + 471, 472, 369, 325, 760, 446, 555, 326, 327, 328, + 505, 447, 448, 449, 496, 450, 509, 451, 565, 452, + 558, 559, 690, 632, 633, 772, 453, 500, 398, 399, + 403, 401, 538, 498, 499, 543, 544, 364, 365, 454, + 512, 455, 566, 567, 639, 637, 638, 456, 532, 486, + 583, 700, 590, 591, 654, 655, 656, 657, 658, 457, + 502, 458, 503, 148, 149, 43, 31, 137, 47, 48, + 49, 50, 87, 88, 141, 142, 138, 139, 140, 51, + 52, 53, 46, 54, 55, 56, 353, 80, 32, 143, + 381, 382, 383, 175, 176, 33, 58, 167, 34, 60, + 171, 106, 108, 252, 330, 35, 36, 62, 37, 38, + 459, 487, 533, 534, 604, 605, 665, 606, 675, 753, + 856, 754, 857, 819, 820, 815, 816, 730, 948, 755, + 607, 608, 881, 914, 736, 742, 737, 835, 743, 840, + 869, 874, 875, 642, 797, 39, 67, 160, 197, 821, + 577, 378, 282, 283, 270, 269, 131, 132, 133, 134, + 92, 546, 547, 685, 41, 42, 73, 135, 229, 257, + 575, 150 }; -static const short yypgoto[] = +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -826 +static const short int yypact[] = { - -32768,-32768, 847,-32768,-32768,-32768,-32768,-32768, 749,-32768, - 544, 518,-32768, -270,-32768,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768,-32768,-32768,-32768, 263,-32768,-32768, 123, - -32768,-32768,-32768,-32768,-32768, 234,-32768, -388,-32768, 244, - 36, -79, -386, 255,-32768,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768,-32768,-32768, 374,-32768,-32768,-32768,-32768, - 27,-32768,-32768, -18,-32768,-32768,-32768,-32768, 196,-32768, - 184,-32768,-32768,-32768, 298, 301, 22, -169,-32768,-32768, - -32768,-32768,-32768,-32768, 278, 216,-32768,-32768,-32768,-32768, - 218,-32768, 32, 261,-32768, 198,-32768, 219,-32768,-32768, - -32768,-32768, -43, 15,-32768,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768,-32768,-32768,-32768,-32768, -92,-32768,-32768, - 542, -69, -149, 689,-32768,-32768,-32768,-32768,-32768,-32768, - 695, 692, 775,-32768,-32768,-32768,-32768, -37, 3,-32768, - -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 199, -794, - -319, -187,-32768, -753, -859, -204,-32768, -650,-32768,-32768, - -32768, -427,-32768, -407, -365,-32768,-32768,-32768,-32768, -808, - -775, 77, -190, 212, 205,-32768,-32768, -217, -63,-32768, - -45,-32768,-32768,-32768,-32768, 583,-32768,-32768, 303,-32768, - -447, 441,-32768, 475, 478,-32768,-32768, 669, 137, -612, - -20 + 538, -826, -826, -826, -826, -826, -826, -826, -826, -826, + -826, -826, -826, -826, -826, -826, -826, -826, 58, 117, + 51, -826, 53, 10, 107, 237, -19, -826, -826, -826, + -826, 513, 51, -826, -826, -826, -826, 1, -826, -826, + 80, -826, -826, 239, -9, 248, 245, 1349, 280, 301, + 309, 392, 184, 184, 245, 245, 245, 257, -826, 397, + -826, -826, 398, -826, -826, -826, -826, 4, 416, 2182, + -826, -826, -826, 184, -826, -826, -826, -826, -826, -826, + -826, -826, -51, -16, 1643, 2182, -826, 1305, 1305, 2182, + -826, -826, -826, -826, 356, -826, 2182, 2182, 245, 2182, + 51, 51, 51, 359, 51, -826, 926, -826, 1065, 2182, + 245, 85, -826, 361, 361, 361, 361, 361, 361, 1682, + 361, 361, 361, 361, 470, -826, -826, -826, 1643, 380, + 2383, -826, -826, -826, 296, 676, -826, 504, 2182, 424, + 407, 424, 407, 2182, -826, 244, 2505, 1890, -826, -826, + -826, -826, 1526, 521, 521, 2182, 1526, 1526, 51, 430, + 380, 2505, -826, -826, -826, 2182, -826, -826, -826, -826, + -826, -826, -826, -826, -826, 303, -826, 2505, -826, -826, + -826, -826, -826, -826, -826, -826, -826, -826, -826, 380, + 380, -826, -826, -826, -826, 2182, 153, 443, 2012, -826, + -826, 2182, 2182, 2182, 2182, 2182, 2182, 2182, 2182, -826, + -826, 2182, 2182, 2182, 2182, 2182, 2182, 2182, 2182, 2182, + 2182, 2182, -826, -826, 2182, 2182, 2182, 2182, 2505, -63, + 2182, 1478, 2182, 2182, 2182, 2182, 2505, 1731, 51, 2182, + -826, 1305, 24, 51, 51, 1478, 1349, 1349, 2182, -826, + 1305, 1478, 411, 411, 2182, 51, -826, -826, 303, -826, + 1643, 2409, 2433, 1448, 2524, 2542, 1848, 1848, 2059, 2182, + 2182, 483, 483, 712, 712, 712, 712, 558, 558, 468, + 468, -826, 2182, 2182, 303, 582, 1939, 2505, 2505, 676, + -826, 1526, -826, 1478, 1478, 1478, 1478, -826, 2505, -826, + 1963, 586, -826, 570, 574, 576, 324, -826, -826, -826, + -826, -826, -826, -826, -826, 1478, -826, -826, 590, 590, + 590, 590, -826, -826, -826, -826, -826, -826, -826, 1112, + -826, 1185, -826, -826, -826, 259, 2182, 2182, 483, 483, + -826, -826, -826, 2182, -826, -826, 1594, -826, -826, -826, + -826, -826, 1305, -826, 2182, 593, 276, -826, 132, -826, + -826, -826, 245, 2182, -826, -826, -826, -826, -826, 36, + 594, 605, -826, -826, 530, 2505, 2505, 531, 2505, 0, + 423, 1555, -826, 28, -826, 12, -14, 576, -826, -826, + -826, 2299, 379, 380, 657, 41, -826, 635, 8, -826, + -826, -82, -826, -41, -826, -826, 1305, -826, 0, -826, + -826, 1305, 2182, -826, 380, -826, -826, 535, -826, -826, + 633, 40, 590, 590, 590, -826, -826, 641, 184, -826, + -826, -826, -826, -826, -826, -826, -826, -826, -826, -826, + -826, -826, -826, -826, -826, -826, -826, -826, -826, -826, + 290, -826, -826, -826, -826, -826, -826, -826, -826, -826, + -826, 638, 639, -826, -826, 616, -826, 1349, 2182, -826, + 545, 23, -826, 2182, 642, 52, -826, 643, -826, 645, + -826, -826, -826, 551, -826, 2210, -826, -826, 51, -826, + -826, 649, -826, -826, -826, -826, 666, 500, 564, -826, + 216, 566, 1349, 1349, 204, 279, 594, 590, 590, 564, + -826, -826, 564, 51, 567, -826, 647, -826, 38, 2182, + 667, 298, -826, 698, -826, -826, -826, -826, -826, -826, + 1682, -826, 67, -826, 855, -826, 51, 491, 290, -826, + -826, -826, -826, 579, 587, 282, -826, -826, 184, -826, + 2182, -826, -826, -826, -826, 61, -826, 584, 73, -826, + -82, -82, -826, -826, -826, 195, -826, 434, -826, -826, + 265, -826, -826, -826, -826, -826, -826, -826, 2457, -826, + -826, -826, 2182, 341, -826, 353, 2383, -826, 840, 689, + 75, -826, -826, 690, -826, 692, 693, 697, 699, 700, + 701, 714, 717, -826, -826, -826, -826, 719, -826, -826, + -826, 380, 380, 380, 564, 219, 278, 2182, -826, -826, + 595, -826, 705, 317, -826, -826, 715, 363, -826, -826, + -826, -826, 76, -826, 618, 1770, 723, 277, -826, 434, + -826, -826, 51, 702, -826, 226, 2182, 623, 2182, -826, + 2182, 271, -826, 720, 380, 628, -826, 630, -826, 2505, + 840, 457, 306, -826, 2182, 41, 453, 453, 455, 455, + 453, 455, 453, 455, 190, 626, 1261, -826, -826, -826, + -826, -826, 380, 380, 634, 380, 2182, -826, -826, -826, + 2182, 584, -826, -826, -826, 245, 215, -826, -826, -826, + 74, 2505, 1770, 434, -826, 277, -826, -826, -826, 474, + -826, -826, -826, -826, -826, -826, -826, -826, 2481, -826, + -826, 401, 734, -826, 1219, 637, 380, -826, -826, -826, + 380, 2505, 23, -826, -826, 740, 644, 184, 646, -826, + -826, 742, 648, 184, 651, 652, 653, 655, 656, -826, + 744, -826, -826, 238, -826, 381, 2238, -826, -826, -826, + -826, 731, 1261, -826, -826, 2182, -826, -826, 2505, -826, + -826, -826, 2182, 2182, 1819, -826, 74, -826, -826, -826, + -826, -826, -826, -826, 474, 2182, 2182, -826, 2035, -826, + -826, -826, -826, -826, -826, -826, 453, 755, 746, 453, + -826, 2182, 782, 2182, 453, 453, 453, 453, 2182, 756, + -826, -826, -826, -826, 396, 370, 428, 205, 1682, 51, + -826, -826, -826, 732, 668, 2505, 2505, -826, 2505, -826, + 380, 2505, 662, 1526, -826, 20, 672, 387, 2182, 673, + 20, 2085, 387, 1502, 674, 675, 679, 680, 25, -826, + -826, -826, 405, -826, 405, 773, 91, -826, 780, 684, + 380, -826, -826, 2182, -826, -826, -826, -826, 685, 38, + 2182, 387, 777, -826, -826, 636, 808, 1987, 2182, 38, + 779, 380, -826, 2182, 51, 2182, 2182, 2182, 2182, 2182, + -826, 91, 264, 2182, 783, 418, -826, 405, 2182, -826, + 20, -826, 2085, 686, -826, 265, 265, 265, 265, 2182, + -826, 2085, -826, -826, -826, 51, 2085, -826, 2085, 2085, + 2109, 2160, 38, -826, 2182, 812, 26, -826, -826, -826, + 304, 409, -826, 380, -826, -826, -826, -826, -826, 694, + 380, -826, 380, 380, 380, 2182, 2182, -826, 380, 2505, + 2182, 2182, -826, 2182, 815, 2182, -826, 51, -826, 51, + 51, 51, 51, 2085, 1526, 380, 380, 38, 380, 2182, + 417, -826, -826, -826, -826, -826, 380, 51, -826, 380, + -826, 380, 380, 2182, -826, 51, -826, -826, -826, 380, + 696, -826, -826, 2182, 703, 2182, 380, -826 }; +/* YYPGOTO[NTERM-NUM]. */ +static const short int yypgoto[] = +{ + -826, -826, -826, 801, -826, -826, -826, -826, -826, 678, + -826, 471, 442, -826, -275, -826, -826, -826, -826, -826, + -826, -826, -826, -826, -826, -826, -826, 191, -826, -826, + 49, -826, -826, -826, -826, -826, 158, -826, -389, -826, + 171, 34, -198, -388, 155, -826, -826, -826, -826, -826, + -826, -826, -826, -826, -826, -826, 299, -826, -826, -826, + -826, -11, -826, -826, -77, -826, -826, -826, -826, 152, + -826, 143, -826, -826, -826, 228, 234, -28, -407, -826, + -826, -826, -826, -826, -826, 211, 159, -826, -826, -826, + -826, 166, -826, -6, 201, -826, 131, -826, 144, -826, + -826, -826, -826, 5, 11, -826, -826, -826, -826, -826, + -826, -826, -826, -826, -826, -826, -826, -826, -826, -826, + -826, -826, -826, -826, -826, -826, -826, -826, -94, -826, + -826, 490, -78, -125, 622, -826, -826, -826, -826, -826, + -826, 627, 629, 710, -826, -826, -826, -826, -38, 16, + -826, -826, -826, -826, -826, -826, -826, -826, -826, 133, + -788, -707, -235, -826, -755, -825, -378, -826, -703, -826, + -826, -826, -462, -826, -657, -79, -826, -826, -826, -826, + -806, -635, 14, -214, 146, 212, -826, -826, -84, -68, + -826, -40, -826, -826, -826, -826, 803, -826, -826, 315, + -826, -468, 378, -826, 336, 391, -826, -826, 602, 157, + -514, -20 +}; -#define YYLAST 2585 - - -static const short yytable[] = +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -438 +static const short int yytable[] = { - 62, 441, 472, 442, 156, 127, 283, 410, 92, 571, - 518, 79, 301, 143, 620, 29, 100, 101, 102, 84, - 571, 571, 892, 128, -301, 64, 887, 949, 922, 88, - 877, 923, 409, 355, 80, 82, 83, 144, 145, 394, - 467, 56, 150, 149, 256, 865, 808, 809, 624, 154, - 155, 523, 159, 58, 188, 659, 889, 194, 890, 157, - 562, 93, 175, 857, 585, 880, -202, 693, 771, 952, - 300, 361, 128, 282, 91, 395, 468, 63, 160, 161, - 162, 196, 164, 892, 108, 60, 178, 395, 226, 629, - 930, 229, 807, 586, 901, -202, 234, 768, 71, 5, - 587, 928, -202, 387, 6, 303, 301, 89, 243, 505, - 506, 176, 179, 3, 4, 413, 808, 809, 249, 168, - 83, 172, 3, 4, 375, 3, 4, 3, 4, 473, - 810, 811, 411, 3, 4, 383, 246, 519, 60, 301, - 572, 621, 60, 929, 392, -301, 60, 81, 175, 893, - 60, 572, 572, 235, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 866, 679, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 625, 73, 175, 284, 285, - 286, 87, 660, 289, 60, 291, 292, 293, 294, 333, - 296, 60, 298, 481, 694, 772, 299, -26, 302, 303, - 968, 313, 197, 60, -26, 314, 22, 175, 747, 290, - 893, 109, 551, 144, 110, 22, 297, 197, 22, 812, - 22, 308, 309, 310, 336, 337, 22, 65, 988, 315, - -26, 302, 303, 331, 888, 338, 339, -26, 992, 94, - 994, 361, 226, 807, 748, 235, 368, 369, 552, 516, - 490, 892, 197, 235, 521, 899, 257, 951, 736, 311, - 312, 743, 68, 745, 198, 910, 529, 95, 391, 3, - 4, 345, 346, 347, 348, 808, 809, 287, 252, 508, - 236, 810, 811, 487, 488, 197, 756, 239, 757, 373, - 374, 244, 245, 360, 554, 248, 578, 197, 964, 144, - 574, 966, 742, 39, 744, 96, 746, 382, 945, 726, - 253, 582, 950, 177, 180, 686, 691, 980, 475, 477, - 749, 750, 356, 157, 254, 67, 70, 60, 60, 197, - 555, 619, 468, 851, 144, 405, 560, 561, 586, 364, - 365, 366, 168, 69, 172, 587, 747, 848, 67, 39, - 851, 687, 689, 978, 98, 99, 67, 67, 67, 3, - 4, 479, 852, 645, 288, 502, 480, 508, 504, 853, - 812, 509, 756, 633, 757, 134, 474, 926, 893, 476, - 634, 478, 748, 748, 97, 546, 853, 834, 39, 39, - 837, 650, 103, 332, 60, 842, 843, 844, 845, 67, - 105, 111, 112, 113, 114, 458, 153, 39, 701, 39, - 107, 67, 67, 853, 707, 115, 116, 60, 163, 340, - 117, 406, 118, 119, 120, 121, 344, 3, 4, 718, - 615, 111, 112, 113, 114, 222, 223, 3, 4, 197, - 646, 357, 491, 492, 493, 115, 116, 647, 235, 520, - 117, 372, 118, 119, 120, 121, 869, 3, 4, 870, - -263, -55, -265, 871, 648, 583, 533, 765, 420, 421, - 422, 649, 576, 931, 586, 459, 385, 117, 547, 386, - 515, 587, 938, 584, 3, 4, 316, 940, 847, 941, - 942, 567, 460, 849, 317, 318, 319, 320, 321, 122, - 123, 124, 125, 638, 639, 708, 709, 710, 711, 712, - 713, 616, 193, 407, 608, 549, 550, 228, -228, 651, - 126, 60, 810, 811, 378, -228, 632, 23, 465, 122, - 123, 124, 125, 622, 974, 24, 626, 784, 627, 628, - 240, 657, 39, 538, 785, 540, 953, 39, 39, 482, - 126, 39, 682, 197, 577, 579, 122, 981, 124, 125, - 111, 112, 113, 114, 197, 731, 732, -257, 661, -259, - 128, 733, 737, 738, 115, 116, 247, 126, 739, 117, - 258, 118, 119, 120, 121, 719, 3, 4, 699, 846, - 75, 76, 77, 590, 341, 537, 591, 539, 350, 716, - 219, 220, 221, 128, 217, 218, 219, 220, 221, 850, - 695, 856, 230, 657, 232, 702, 231, 729, 233, 874, - 704, 352, -382, 715, 777, 778, 779, 780, 781, 361, - 39, 759, 39, 592, 593, 594, 595, 596, 597, 598, - 599, 600, 353, 766, 443, 464, 601, 537, 538, 539, - 540, 690, 692, 39, 301, 699, 632, 632, 122, 123, - 124, 125, 384, 67, 903, 904, 905, 906, 522, 524, - 920, 609, 610, 611, 924, 767, 769, 657, 398, 126, - 400, 39, 402, 776, 197, 403, 1, 558, 559, 2, - 937, 725, 727, 466, 181, 182, 183, 184, 185, 186, - 822, 189, 190, 191, 192, 925, 927, 39, 471, 128, - 792, 483, 39, 933, 934, 935, 936, 821, 128, 486, - 495, 830, 3, 4, 511, 823, 824, 826, 512, 499, - 513, 395, 965, 517, 525, 5, 526, 534, 829, 128, - 6, 831, 527, 535, 570, 543, 676, 677, 678, 548, - 580, 568, 468, 858, 839, 613, 841, 614, 623, 658, - 662, 7, 664, 665, 666, 667, 668, 669, 39, 670, - 671, 128, 672, 684, 700, -242, -242, -242, 685, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 721, - 18, 875, 19, 689, 20, 696, 705, 859, 897, 717, - 720, 754, 722, 39, 39, 215, 216, 217, 218, 219, - 220, 221, 21, 786, 820, 22, 128, 761, 762, 23, - 764, 24, 651, 900, 723, 793, 763, 798, 806, 794, - 797, 909, 799, 801, 802, 773, 914, 803, 916, 917, - 918, 919, 804, 835, 805, 836, 617, 840, 748, 618, - 860, 128, 861, 863, 868, 876, 883, 891, 895, 884, - 871, 790, 915, 907, 911, 791, 67, 853, 948, 967, - 997, 998, 74, 885, 886, 896, 898, 947, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 939, 932, 991, 956, 993, 961, 962, - 388, 242, 412, 947, 706, 828, 947, 730, 128, 760, - 612, 827, 681, 166, 680, 703, 2, 775, 774, 724, - 788, 408, 947, 832, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 969, 128, 970, 971, 972, - 973, 330, 789, 329, 251, 327, 128, 902, 128, 3, - 4, 566, 815, 800, 0, 984, 343, 0, 0, 0, - 0, 0, 0, 989, 0, 862, 0, 0, 864, 0, - 0, 0, 0, 0, 0, 0, 0, 39, 882, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, - 0, 894, 0, 0, 0, 0, 67, 67, 0, 0, - 0, 0, -242, -242, -242, 0, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 913, 18, 167, 19, - 0, 20, 0, 0, 0, 0, 921, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 796, 0, - 0, 0, 22, 0, 796, 0, 23, 0, 24, 0, - 170, 0, 0, 2, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 39, 0, 0, 954, 0, 955, 0, - 0, 0, 0, 0, 0, 957, 0, 958, 959, 960, - 0, 0, 0, 963, 0, 0, 3, 4, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 975, - 976, 977, 0, 979, 0, 982, 0, 0, 0, 0, - 0, 983, 0, 0, 985, 0, 986, 987, 0, 0, - 0, 0, 0, 166, 990, 7, 2, 0, 0, 0, - 0, 995, 0, 0, 0, 0, 0, 0, 0, -242, - -242, -242, 0, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 0, 18, 0, 19, 171, 20, 3, - 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 170, 0, 0, 2, 0, 0, 0, 0, 0, 22, - 0, 0, 0, 23, 0, 24, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, - 0, 0, 0, 0, 0, 0, 3, 4, 0, 0, - 0, 0, -242, -242, -242, 0, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 0, 18, 370, 19, - 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, - 0, 0, 22, 0, 0, 0, 23, 0, 24, -242, - -242, -242, 0, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 0, 18, 2, 19, 371, 20, 0, - 0, 0, 787, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 111, 112, 113, 114, 0, 0, 0, 22, - 0, 0, 0, 23, 0, 24, 115, 116, 3, 4, - 0, 117, 0, 118, 119, 120, 121, 0, 3, 4, - 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, - 404, 0, 0, 0, 316, 420, 421, 422, 0, 0, - 0, 0, 317, 318, 319, 320, 321, 7, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3, 4, 0, 0, 0, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 0, 18, 0, 19, 2, - 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 122, 123, 124, 125, 0, 0, 0, 0, 0, 7, - 0, 22, 0, 0, 0, 23, 0, 24, 60, -228, - 0, 126, 3, 4, 0, 0, -228, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 0, 18, 2, - 19, 0, 20, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 7, 0, 22, 0, 0, 0, 23, 0, 24, - 60, 0, 3, 4, 0, 0, 0, 0, 0, 8, + 63, 129, 443, 444, 158, 110, 145, -302, 94, 474, + 738, 30, 81, 745, 492, 747, 102, 103, 104, 412, + 86, 867, 82, 303, 520, 302, 573, 573, 90, 130, + 357, 5, 889, 951, 879, 411, 6, 396, 65, 573, + 69, 564, 469, 510, 146, 147, 477, 3, 4, 152, + 196, 190, 289, 525, 64, 61, 156, 157, 95, 161, + 159, 303, 622, 859, 891, 57, 892, 925, 587, 177, + 258, 363, 199, 397, 626, 773, 661, 695, 470, 130, + 162, 163, 164, -264, 166, -266, 180, 479, 198, 397, + 3, 4, 894, 151, 932, 228, 61, 588, 231, 284, + 562, 563, 849, 236, 589, 954, 91, 851, 75, 930, + 84, 85, 415, 489, 490, 245, 305, 170, -258, 174, + -260, 70, 3, 4, 59, 251, 178, 181, -302, 370, + 371, 510, 111, 389, 83, 112, 475, 72, 248, 836, + 868, 285, 839, 931, 413, 61, 681, 844, 845, 846, + 847, 521, -27, 304, 305, 177, 237, 574, 574, -27, + 61, 261, 262, 263, 264, 265, 266, 267, 268, 303, + 574, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 335, 22, 177, 286, 287, 288, 61, 623, + 291, 749, 293, 294, 295, 296, 631, 298, 61, 300, + 970, 627, 774, 662, 696, 553, 809, 882, 315, 199, + 61, 292, 61, 61, 177, 22, 770, 61, 299, 895, + 146, 3, 4, 310, 311, 312, 199, 750, 990, 338, + 339, 317, 3, 4, 66, 333, 903, 74, 994, 809, + 996, 554, 340, 341, 812, 813, 301, 966, 504, 228, + 968, 506, 3, 4, 511, 316, 709, 313, 314, 377, + -27, 304, 305, 810, 811, 894, 982, -27, 393, 89, + 385, 924, -203, 347, 348, 349, 350, 812, 813, 394, + 556, 237, 3, 4, 259, 93, 200, 758, 759, 810, + 811, 366, 367, 368, 105, 362, 375, 376, 540, 580, + 542, -203, 238, 751, 752, 894, 146, 728, -203, 241, + 96, 953, 617, 246, 247, 40, 557, 250, 688, 3, + 4, 363, 179, 182, 159, 22, 224, 225, 483, 810, + 811, 97, 255, 814, 890, 470, 588, 68, 71, 98, + 170, 146, 174, 589, 548, 22, 256, 710, 711, 712, + 713, 714, 715, 61, 689, 901, 539, 384, 541, 507, + 508, 68, 40, 61, 693, 912, 814, 100, 101, 68, + 68, 68, 237, 758, 759, 22, 640, 641, 476, 199, + 460, 478, 749, 480, 518, 407, 290, 237, 136, 523, + 374, 119, 895, 618, 493, 494, 495, 850, 3, 4, + 691, 531, 40, 40, 387, 703, 853, 388, 947, 812, + 813, 481, 952, 68, 61, 334, 482, 871, 750, 928, + 872, 40, 99, 40, 873, 68, 68, 2, 109, 853, + 406, 254, 895, 750, 107, 576, -56, 852, 199, 858, + 933, 342, 855, 422, 423, 424, 584, 85, 346, 940, + 461, 522, 358, 980, 942, 855, 943, 944, 854, 199, + 3, 4, 585, 359, 635, 855, 621, 462, 535, 648, + 124, 636, 126, 127, 318, 232, 649, 234, 517, 578, + 549, 650, 319, 320, 321, 322, 323, 588, 651, 155, + 586, 128, 165, 569, 589, 221, 222, 223, 647, 7, + 195, 976, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 551, 552, 199, 610, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 634, 18, 786, + 19, 233, 20, 235, 230, 624, 787, 955, 628, 1, + 629, 630, 2, 24, 199, 983, 445, 466, 659, 684, + 467, 242, 199, 22, 579, 581, 40, 23, 23, 24, + 61, 40, 40, 249, 720, 40, 733, 734, 739, 740, + 663, 484, 735, 260, 741, 3, 4, 130, 539, 540, + 541, 542, 721, 219, 220, 221, 222, 223, 5, 343, + 744, 352, 746, 6, 748, 701, 779, 780, 781, 782, + 783, 354, 767, 77, 78, 79, 718, 611, 612, 613, + 130, 355, 697, 303, 7, 692, 694, 704, 769, 771, + 659, 363, 706, 386, 731, 717, 524, 526, -243, -243, + -243, 400, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 402, 18, 40, 19, 40, 20, 560, 561, + 768, 905, 906, 907, 908, 727, 729, 634, 634, 927, + 929, 404, 701, 405, 468, 21, 473, 40, 22, 485, + 488, 497, 23, 515, 24, 513, 514, 68, 519, 397, + 527, 761, 528, 529, 659, 778, 536, 113, 114, 115, + 116, 935, 936, 937, 938, 40, 537, 824, 545, 550, + 570, 117, 118, 572, 470, 582, 119, 615, 120, 121, + 122, 123, 794, 3, 4, 616, 130, 625, 832, 660, + 664, 40, 666, 667, 848, 130, 40, 668, 686, 669, + 670, 671, 825, 826, 828, 217, 218, 219, 220, 221, + 222, 223, 687, 501, 672, 831, 130, 673, 833, 674, + 860, 698, 691, 702, 876, 719, 724, 722, 725, 756, + 707, 841, 765, 843, 788, 837, 653, 823, 678, 679, + 680, 795, 796, 800, 799, 808, 801, 838, 130, 803, + 804, 805, 40, 806, 807, 124, 125, 126, 127, 226, + 227, 822, 842, 750, 862, 899, 863, 865, 877, 861, + 870, 878, 885, 886, 893, 922, 128, 887, 888, 926, + 897, 723, 898, 900, 873, 909, 913, 40, 40, 950, + 855, 934, 969, 130, 993, 939, 958, 76, 414, 390, + 902, 995, 244, 830, 708, 762, 732, 614, 911, 763, + 764, 652, 766, 916, 683, 918, 919, 920, 921, 682, + 705, 113, 114, 115, 116, 790, 592, 775, 130, 593, + 619, 726, 777, 620, 917, 117, 118, 967, 776, 791, + 119, 410, 120, 121, 122, 123, 332, 3, 4, 329, + 68, 253, 331, 792, 949, -383, 904, 793, 817, 802, + 568, 345, 0, 0, 0, 941, 594, 595, 596, 597, + 598, 599, 600, 601, 602, 963, 964, 0, 0, 603, + 949, 0, 0, 949, 0, 130, 183, 184, 185, 186, + 187, 188, 0, 191, 192, 193, 194, 168, 0, 949, + 2, 0, 0, 829, 0, 0, 0, 971, 0, 972, + 973, 974, 975, 130, 0, 834, 0, 0, 0, 124, + 125, 126, 127, 130, 0, 130, 0, 986, 0, 0, + 0, 0, 0, 3, 4, 991, 0, 0, -229, 653, + 128, 0, 0, 0, 0, -229, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 864, 0, 0, + 866, 40, 0, 0, 0, 0, 0, 0, 0, 0, + 884, 0, 7, 0, 0, 0, 0, 0, 0, 0, + 68, 68, 0, 896, 0, 0, -243, -243, -243, 0, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 0, 18, 169, 19, 0, 20, 0, 0, 915, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 923, 0, + 0, 0, 798, 0, 0, 0, 22, 0, 798, 0, + 23, 0, 24, 0, 0, 0, 172, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 956, 0, + 957, 0, 0, 0, 0, 0, 0, 959, 0, 960, + 961, 962, 3, 4, 0, 965, 0, 0, 0, 0, + 0, 0, 0, 168, 0, 0, 2, 0, 0, 0, + 0, 977, 978, 979, 0, 981, 0, 984, 0, 0, + 0, 0, 0, 985, 0, 0, 987, 0, 988, 989, + 0, 7, 0, 0, 0, 0, 992, 0, 0, 3, + 4, 0, 0, 997, 0, -243, -243, -243, 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 0, - 18, 0, 19, 0, 20, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 7, 0, 0, 0, 22, 0, 0, 0, 23, - 0, 24, 60, 0, 0, 0, 0, 0, 0, 8, + 18, 0, 19, 173, 20, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 172, 0, 7, 2, + 0, 0, 0, 0, 0, 22, 0, 0, 0, 23, + 0, 24, -243, -243, -243, 0, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 0, 18, 372, 19, + 789, 20, 3, 4, 0, 0, 0, 0, 0, 0, + 113, 114, 115, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 22, 0, 117, 118, 23, 0, 24, 119, + 0, 120, 121, 122, 123, 0, 3, 4, 0, 0, + 0, 7, 0, 0, 0, 2, 0, 0, 0, 0, + 0, 0, 0, 0, 0, -243, -243, -243, 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 0, - 18, 0, 19, 202, 20, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 0, 22, 0, 0, 0, 23, - 199, 24, 201, 202, 0, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 199, 0, 201, 202, 0, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 199, 0, - 201, 202, 0, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 377, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 111, 112, 113, 114, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 115, 116, 0, 0, - 0, 117, 0, 118, 119, 120, 121, 0, 3, 4, - 0, 142, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 111, 112, 113, 114, 0, 0, 0, 0, 0, - 0, 60, 0, 0, 0, 115, 116, 0, 0, 0, - 117, 0, 118, 119, 120, 121, 881, 3, 4, 0, - 0, 0, 0, 197, 0, 0, 0, 0, 0, 0, - 187, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 111, 112, 113, 114, 0, 378, 0, 197, 0, 0, - 122, 123, 124, 125, 115, 116, 0, 0, 0, 117, - 0, 118, 119, 120, 121, 0, 3, 4, 0, 295, - 0, 126, 0, 0, 0, 0, 0, 0, 0, 111, - 112, 113, 114, 0, 0, 0, 0, 0, 0, 122, - 123, 124, 125, 115, 116, 0, 0, 0, 117, 0, - 118, 119, 120, 121, 0, 3, 4, 0, 0, 0, - 126, 0, 0, 0, 0, 0, 0, 0, 697, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 111, 112, - 113, 114, 0, 0, 0, 0, 0, 0, 122, 123, - 124, 125, 115, 116, 0, 0, 0, 117, 0, 118, - 119, 120, 121, 0, 3, 4, 0, 825, 0, 126, - 0, 0, 0, 0, 0, 0, 0, 111, 112, 113, - 114, 0, 0, 0, 0, 0, 0, 122, 123, 124, - 125, 115, 116, 0, 0, 0, 117, 0, 118, 119, - 120, 121, 0, 3, 4, 0, 0, 0, 126, 199, - 237, 201, 202, 0, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 0, 0, 0, 122, 123, 124, 125, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 126, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 122, 123, 124, 125, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 199, 0, 201, 202, 126, 203, 204, 205, + 18, 0, 19, 373, 20, 0, 0, 0, 3, 4, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 22, 0, 0, 0, 23, + 0, 24, 0, 0, 318, 422, 423, 424, 124, 125, + 126, 127, 319, 320, 321, 322, 323, 7, 0, 0, + 0, 0, 3, 4, 0, 0, 0, -229, 0, 128, + 0, 0, 0, 2, -229, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 0, 18, 0, 19, 0, + 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 7, 0, 0, 0, 0, 3, 4, 0, 0, + 0, 22, 0, 0, 0, 23, 0, 24, 61, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 0, + 18, 0, 19, 0, 20, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 22, 0, 0, 0, 23, + 0, 24, 61, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 0, 18, 0, 19, 204, 20, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 199, 0, 201, 202, 238, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 199, 0, 201, 202, 0, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 199, - 0, 201, 202, 0, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 199, 0, 201, 202, 342, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 0, 0, + 216, 217, 218, 219, 220, 221, 222, 223, 0, 22, + 0, 0, 0, 23, 201, 24, 203, 204, 0, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 201, 0, + 203, 204, 0, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 201, 0, 203, 204, 0, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 408, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 113, 114, 115, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 199, 0, 201, 202, 349, 203, 204, + 117, 118, 0, 0, 0, 119, 0, 120, 121, 122, + 123, 0, 3, 4, 0, 379, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 113, 114, 115, 116, 0, + 0, 0, 0, 0, 0, 61, 0, 0, 0, 117, + 118, 0, 0, 0, 119, 0, 120, 121, 122, 123, + 883, 3, 4, 0, 0, 0, 0, 199, 0, 0, + 0, 0, 0, 0, 144, 0, 0, 0, 409, 0, + 0, 0, 0, 0, 113, 114, 115, 116, 0, 380, + 0, 199, 0, 0, 124, 125, 126, 127, 117, 118, + 0, 0, 0, 119, 0, 120, 121, 122, 123, 0, + 3, 4, 0, 189, 0, 128, 0, 0, 0, 0, + 0, 0, 0, 113, 114, 115, 116, 0, 380, 0, + 0, 0, 0, 124, 125, 126, 127, 117, 118, 0, + 0, 0, 119, 0, 120, 121, 122, 123, 0, 3, + 4, 0, 0, 0, 128, 0, 0, 0, 0, 0, + 0, 0, 297, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 113, 114, 115, 116, 0, 0, 0, 0, + 0, 0, 124, 125, 126, 127, 117, 118, 0, 0, + 0, 119, 0, 120, 121, 122, 123, 0, 3, 4, + 0, 699, 0, 128, 0, 0, 0, 0, 0, 0, + 0, 113, 114, 115, 116, 0, 0, 0, 0, 0, + 0, 124, 125, 126, 127, 117, 118, 0, 0, 0, + 119, 0, 120, 121, 122, 123, 0, 3, 4, 0, + 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, + 827, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 113, 114, 115, 116, 0, 0, 0, 0, 0, 0, + 124, 125, 126, 127, 117, 118, 0, 0, 0, 119, + 0, 120, 121, 122, 123, 0, 3, 4, 0, 0, + 0, 128, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 0, 124, + 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 201, 239, 203, 204, + 128, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 0, 0, 0, 0, 0, 0, 0, 0, 124, 125, + 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 201, 0, 203, 204, 128, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 199, 0, 201, - 202, 908, 203, 204, 205, 206, 207, 208, 209, 210, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 201, + 0, 203, 204, 0, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 0, 0, -436, 111, 112, 113, 114, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 115, 116, - 0, 0, 0, 117, 0, 118, 119, 120, 121, 0, - 3, 4, 111, 112, 113, 114, 878, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 115, 116, 0, 0, - 0, 117, 0, 118, 119, 120, 121, 0, 3, 4, - 0, 0, 111, 112, 113, 114, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 943, 115, 116, 0, 0, - 0, 528, 0, 118, 119, 120, 121, 0, 3, 4, - 0, 0, 0, 0, 111, 112, 113, 114, 0, 944, - 0, 0, 122, 123, 124, 125, 224, 225, 115, 116, - 0, 0, 0, 816, 0, 118, 119, 120, 121, 0, - 3, 4, 0, 126, 0, 0, 0, 0, 0, 0, - 122, 123, 124, 125, 0, 0, 0, 0, 0, 0, + 221, 222, 223, 201, 0, 203, 204, 0, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 0, 201, 0, + 203, 204, 240, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 0, 0, 0, 0, 113, 114, 115, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 126, 414, 0, 0, 0, 0, 0, 0, 0, - 122, 123, 124, 125, 0, 0, 0, 0, 0, 0, + 117, 118, 0, 0, 0, 119, 0, 120, 121, 122, + 123, 344, 3, 4, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 0, + 0, 201, 0, 203, 204, 351, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 201, 0, 203, 204, 910, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 0, + 0, 0, -437, 0, 124, 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 126, 0, 0, 0, 0, 0, 0, 415, 0, - 0, 0, 122, 123, 124, 125, 0, 0, 0, 0, - 0, 0, 0, 416, 417, 0, 0, 0, 0, 0, - 418, 0, 419, 126, 316, 420, 421, 422, 423, 424, - 0, 0, 317, 318, 319, 320, 321, 425, 426, 0, - 0, 427, 428, 429, 430, 431, 432, 433, 434, 435, - 436, 199, 200, 201, 202, 0, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 0, 437, 199, 334, 201, - 202, 0, 203, 204, 205, 206, 207, 208, 209, 210, + 0, 0, 0, 0, 0, 128, 201, 0, 203, 204, + 199, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 0, 0, 0, 113, 114, 115, 116, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 117, 118, 0, + 0, 0, 119, 880, 120, 121, 122, 123, 0, 3, + 4, 113, 114, 115, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 117, 118, 945, 0, 0, + 530, 0, 120, 121, 122, 123, 0, 3, 4, 113, + 114, 115, 116, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 117, 118, 0, 0, 0, 818, 0, + 120, 121, 122, 123, 0, 3, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 946, 0, + 0, 124, 125, 126, 127, 0, 0, 0, 0, 0, + 416, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 128, 0, 0, 0, 0, 0, 0, 124, + 125, 126, 127, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 417, 0, 0, 0, + 128, 0, 0, 0, 0, 0, 0, 124, 125, 126, + 127, 418, 419, 0, 0, 0, 0, 0, 420, 0, + 421, 0, 318, 422, 423, 424, 425, 426, 128, 0, + 319, 320, 321, 322, 323, 427, 428, 0, 0, 429, + 430, 431, 432, 433, 434, 435, 436, 437, 438, 201, + 202, 203, 204, 0, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 199, 335, 201, 202, 0, 203, 204, 205, 206, + 221, 222, 223, 0, 439, 201, 336, 203, 204, 0, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 201, + 337, 203, 204, 0, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 201, 646, 203, 204, 0, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 199, 644, 201, 202, 0, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 199, - 783, 201, 202, 0, 203, 204, 205, 206, 207, 208, + 217, 218, 219, 220, 221, 222, 223, 201, 785, 203, + 204, 0, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 201, 0, 203, 204, 0, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 199, 0, 201, 202, 0, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221 + 219, 220, 221, 222, 223, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223 }; -static const short yycheck[] = +static const short int yycheck[] = { - 20, 389, 1, 389, 96, 68, 223, 7, 45, 1, - 1, 31, 37, 82, 1, 0, 53, 54, 55, 39, - 1, 1, 1, 68, 7, 22, 7, 7, 7, 37, - 838, 890, 7, 303, 20, 30, 31, 82, 83, 1, - 1, 7, 87, 86, 193, 1, 25, 26, 1, 94, - 95, 1, 97, 7, 117, 1, 850, 126, 852, 96, - 507, 46, 107, 816, 1, 840, 1, 1, 1, 928, - 1, 31, 117, 222, 37, 37, 37, 1, 98, 99, - 100, 126, 102, 1, 1, 137, 1, 37, 133, 1, - 898, 136, 1, 30, 869, 30, 141, 1, 30, 50, - 37, 895, 37, 1, 55, 130, 37, 115, 153, 69, - 70, 108, 109, 37, 38, 385, 25, 26, 163, 104, - 31, 106, 37, 38, 341, 37, 38, 37, 38, 128, - 39, 40, 132, 37, 38, 352, 156, 128, 137, 37, - 132, 128, 137, 896, 361, 128, 137, 133, 193, 128, - 137, 132, 132, 128, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 120, 612, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 128, 127, 222, 223, 224, - 225, 30, 128, 228, 137, 230, 231, 232, 233, 258, - 235, 137, 237, 410, 128, 128, 239, 128, 129, 130, - 953, 246, 135, 137, 135, 248, 130, 252, 1, 229, - 128, 128, 1, 258, 131, 130, 236, 135, 130, 128, - 130, 241, 242, 243, 269, 270, 130, 22, 981, 249, - 128, 129, 130, 253, 846, 280, 281, 135, 991, 30, - 993, 31, 287, 1, 37, 128, 325, 326, 37, 466, - 419, 1, 135, 128, 471, 867, 131, 7, 665, 244, - 245, 668, 30, 670, 127, 877, 483, 30, 360, 37, - 38, 291, 292, 293, 294, 25, 26, 115, 128, 448, - 143, 39, 40, 73, 74, 135, 674, 150, 674, 334, - 335, 154, 155, 313, 1, 158, 1, 135, 948, 344, - 517, 951, 667, 0, 669, 30, 671, 350, 920, 1, - 173, 528, 924, 108, 109, 1, 1, 967, 128, 128, - 113, 114, 128, 360, 187, 22, 23, 137, 137, 135, - 37, 548, 37, 1, 379, 378, 505, 506, 30, 317, - 318, 319, 327, 111, 329, 37, 1, 1, 45, 46, - 1, 37, 37, 965, 51, 52, 53, 54, 55, 37, - 38, 404, 30, 580, 227, 444, 409, 536, 447, 37, - 128, 450, 760, 30, 760, 72, 396, 1, 128, 399, - 37, 401, 37, 37, 30, 128, 37, 794, 85, 86, - 797, 1, 37, 256, 137, 802, 803, 804, 805, 96, - 37, 11, 12, 13, 14, 1, 133, 104, 128, 106, - 30, 108, 109, 37, 30, 25, 26, 137, 133, 282, - 30, 1, 32, 33, 34, 35, 289, 37, 38, 646, - 30, 11, 12, 13, 14, 30, 31, 37, 38, 135, - 128, 304, 420, 421, 422, 25, 26, 135, 128, 469, - 30, 131, 32, 33, 34, 35, 30, 37, 38, 33, - 134, 57, 136, 37, 128, 528, 486, 684, 64, 65, - 66, 135, 517, 900, 30, 71, 128, 30, 498, 131, - 465, 37, 909, 528, 37, 38, 63, 914, 807, 916, - 917, 511, 88, 812, 71, 72, 73, 74, 75, 109, - 110, 111, 112, 111, 112, 121, 122, 123, 124, 125, - 126, 111, 30, 93, 534, 500, 501, 30, 128, 129, - 130, 137, 39, 40, 104, 135, 563, 134, 391, 109, - 110, 111, 112, 553, 961, 136, 556, 128, 558, 559, - 30, 586, 239, 79, 135, 81, 128, 244, 245, 412, - 130, 248, 615, 135, 518, 519, 109, 128, 111, 112, - 11, 12, 13, 14, 135, 113, 114, 134, 588, 136, - 615, 119, 113, 114, 25, 26, 133, 130, 119, 30, - 130, 32, 33, 34, 35, 648, 37, 38, 633, 806, - 90, 91, 92, 1, 7, 78, 4, 80, 5, 644, - 27, 28, 29, 648, 25, 26, 27, 28, 29, 813, - 630, 815, 137, 658, 139, 635, 138, 662, 140, 836, - 640, 31, 30, 643, 122, 123, 124, 125, 126, 31, - 327, 674, 329, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 37, 688, 389, 390, 54, 78, 79, 80, - 81, 624, 625, 350, 37, 700, 693, 694, 109, 110, - 111, 112, 30, 360, 15, 16, 17, 18, 472, 473, - 887, 116, 117, 118, 891, 693, 694, 722, 37, 130, - 37, 378, 131, 703, 135, 132, 1, 503, 504, 4, - 907, 659, 660, 7, 111, 112, 113, 114, 115, 116, - 763, 118, 119, 120, 121, 892, 893, 404, 31, 754, - 730, 134, 409, 903, 904, 905, 906, 760, 763, 37, - 30, 784, 37, 38, 37, 770, 771, 772, 37, 426, - 57, 37, 949, 133, 37, 50, 37, 37, 783, 784, - 55, 786, 132, 30, 56, 134, 609, 610, 611, 133, - 7, 133, 37, 816, 799, 128, 801, 128, 133, 30, - 30, 76, 30, 30, 30, 30, 30, 30, 465, 30, - 30, 816, 30, 133, 30, 90, 91, 92, 37, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 652, - 105, 836, 107, 37, 109, 133, 58, 817, 861, 132, - 37, 133, 128, 500, 501, 23, 24, 25, 26, 27, - 28, 29, 127, 30, 60, 130, 861, 680, 681, 134, - 683, 136, 129, 868, 128, 31, 128, 31, 31, 128, - 128, 876, 128, 128, 128, 698, 881, 128, 883, 884, - 885, 886, 128, 10, 128, 31, 543, 10, 37, 546, - 62, 896, 128, 135, 128, 128, 128, 31, 30, 128, - 37, 724, 882, 7, 37, 728, 563, 37, 7, 7, - 0, 0, 25, 128, 128, 128, 128, 922, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 913, 135, 128, 132, 128, 943, 944, - 356, 152, 384, 948, 641, 782, 951, 663, 953, 675, - 536, 774, 614, 1, 613, 637, 4, 701, 700, 658, - 722, 379, 967, 786, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 955, 981, 957, 958, 959, - 960, 252, 723, 251, 169, 250, 991, 870, 993, 37, - 38, 510, 753, 741, -1, 975, 287, -1, -1, -1, - -1, -1, -1, 983, -1, 828, -1, -1, 831, -1, - -1, -1, -1, -1, -1, -1, -1, 674, 841, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 76, -1, - -1, 854, -1, -1, -1, -1, 693, 694, -1, -1, - -1, -1, 90, 91, 92, -1, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 879, 105, 106, 107, - -1, 109, -1, -1, -1, -1, 889, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 735, -1, - -1, -1, 130, -1, 741, -1, 134, -1, 136, -1, - 1, -1, -1, 4, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 760, -1, -1, 929, -1, 931, -1, - -1, -1, -1, -1, -1, 938, -1, 940, 941, 942, - -1, -1, -1, 946, -1, -1, 37, 38, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 962, - 963, 964, -1, 966, -1, 968, -1, -1, -1, -1, - -1, 974, -1, -1, 977, -1, 979, 980, -1, -1, - -1, -1, -1, 1, 987, 76, 4, -1, -1, -1, - -1, 994, -1, -1, -1, -1, -1, -1, -1, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, -1, 105, -1, 107, 108, 109, 37, - 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1, -1, -1, 4, -1, -1, -1, -1, -1, 130, - -1, -1, -1, 134, -1, 136, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 76, -1, - -1, -1, -1, -1, -1, -1, 37, 38, -1, -1, - -1, -1, 90, 91, 92, -1, 94, 95, 96, 97, + 20, 69, 391, 391, 98, 1, 84, 7, 46, 1, + 667, 0, 32, 670, 421, 672, 54, 55, 56, 7, + 40, 1, 21, 37, 1, 1, 1, 1, 37, 69, + 305, 50, 7, 7, 840, 7, 55, 1, 22, 1, + 30, 509, 1, 450, 84, 85, 128, 37, 38, 89, + 128, 119, 115, 1, 1, 137, 96, 97, 47, 99, + 98, 37, 1, 818, 852, 7, 854, 892, 1, 109, + 195, 31, 135, 37, 1, 1, 1, 1, 37, 119, + 100, 101, 102, 134, 104, 136, 1, 128, 128, 37, + 37, 38, 1, 88, 900, 135, 137, 30, 138, 224, + 507, 508, 809, 143, 37, 930, 115, 814, 127, 897, + 30, 31, 387, 73, 74, 155, 130, 106, 134, 108, + 136, 111, 37, 38, 7, 165, 110, 111, 128, 327, + 328, 538, 128, 1, 133, 131, 128, 30, 158, 796, + 120, 225, 799, 898, 132, 137, 614, 804, 805, 806, + 807, 128, 128, 129, 130, 195, 128, 132, 132, 135, + 137, 201, 202, 203, 204, 205, 206, 207, 208, 37, + 132, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 260, 130, 224, 225, 226, 227, 137, 128, + 230, 1, 232, 233, 234, 235, 1, 237, 137, 239, + 955, 128, 128, 128, 128, 1, 1, 842, 248, 135, + 137, 231, 137, 137, 254, 130, 1, 137, 238, 128, + 260, 37, 38, 243, 244, 245, 135, 37, 983, 269, + 270, 251, 37, 38, 22, 255, 871, 0, 993, 1, + 995, 37, 282, 283, 39, 40, 241, 950, 446, 289, + 953, 449, 37, 38, 452, 250, 30, 246, 247, 343, + 128, 129, 130, 25, 26, 1, 969, 135, 362, 30, + 354, 7, 1, 293, 294, 295, 296, 39, 40, 363, + 1, 128, 37, 38, 131, 37, 129, 676, 676, 25, + 26, 319, 320, 321, 37, 315, 336, 337, 79, 1, + 81, 30, 145, 113, 114, 1, 346, 1, 37, 152, + 30, 7, 30, 156, 157, 0, 37, 160, 1, 37, + 38, 31, 110, 111, 362, 130, 30, 31, 412, 25, + 26, 30, 175, 128, 848, 37, 30, 22, 23, 30, + 329, 381, 331, 37, 128, 130, 189, 121, 122, 123, + 124, 125, 126, 137, 37, 869, 78, 352, 80, 69, + 70, 46, 47, 137, 1, 879, 128, 52, 53, 54, + 55, 56, 128, 762, 762, 130, 111, 112, 398, 135, + 1, 401, 1, 403, 468, 380, 229, 128, 73, 473, + 131, 30, 128, 111, 422, 423, 424, 1, 37, 38, + 37, 485, 87, 88, 128, 128, 1, 131, 922, 39, + 40, 406, 926, 98, 137, 258, 411, 30, 37, 1, + 33, 106, 30, 108, 37, 110, 111, 4, 30, 1, + 7, 128, 128, 37, 37, 519, 57, 815, 135, 817, + 902, 284, 37, 64, 65, 66, 530, 31, 291, 911, + 71, 471, 128, 967, 916, 37, 918, 919, 30, 135, + 37, 38, 530, 306, 30, 37, 550, 88, 488, 128, + 109, 37, 111, 112, 63, 139, 135, 141, 467, 519, + 500, 128, 71, 72, 73, 74, 75, 30, 135, 133, + 530, 130, 133, 513, 37, 27, 28, 29, 582, 76, + 30, 963, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 502, 503, 135, 536, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 565, 105, 128, + 107, 140, 109, 142, 30, 555, 135, 128, 558, 1, + 560, 561, 4, 136, 135, 128, 391, 392, 588, 617, + 393, 30, 135, 130, 520, 521, 241, 134, 134, 136, + 137, 246, 247, 133, 648, 250, 113, 114, 113, 114, + 590, 414, 119, 130, 119, 37, 38, 617, 78, 79, + 80, 81, 650, 25, 26, 27, 28, 29, 50, 7, + 669, 5, 671, 55, 673, 635, 122, 123, 124, 125, + 126, 31, 686, 90, 91, 92, 646, 116, 117, 118, + 650, 37, 632, 37, 76, 626, 627, 637, 695, 696, + 660, 31, 642, 30, 664, 645, 474, 475, 90, 91, + 92, 37, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 37, 105, 329, 107, 331, 109, 505, 506, + 690, 15, 16, 17, 18, 661, 662, 695, 696, 894, + 895, 131, 702, 132, 7, 127, 31, 352, 130, 134, + 37, 30, 134, 57, 136, 37, 37, 362, 133, 37, + 37, 676, 37, 132, 724, 705, 37, 11, 12, 13, + 14, 905, 906, 907, 908, 380, 30, 765, 134, 133, + 133, 25, 26, 56, 37, 7, 30, 128, 32, 33, + 34, 35, 732, 37, 38, 128, 756, 133, 786, 30, + 30, 406, 30, 30, 808, 765, 411, 30, 133, 30, + 30, 30, 772, 773, 774, 23, 24, 25, 26, 27, + 28, 29, 37, 428, 30, 785, 786, 30, 788, 30, + 818, 133, 37, 30, 838, 132, 128, 37, 128, 133, + 58, 801, 128, 803, 30, 10, 129, 762, 611, 612, + 613, 31, 128, 31, 128, 31, 128, 31, 818, 128, + 128, 128, 467, 128, 128, 109, 110, 111, 112, 113, + 114, 60, 10, 37, 62, 863, 128, 135, 838, 819, + 128, 128, 128, 128, 31, 889, 130, 128, 128, 893, + 30, 654, 128, 128, 37, 7, 37, 502, 503, 7, + 37, 135, 7, 863, 128, 909, 132, 26, 386, 358, + 870, 128, 154, 784, 643, 677, 665, 538, 878, 682, + 683, 1, 685, 883, 616, 885, 886, 887, 888, 615, + 639, 11, 12, 13, 14, 724, 1, 700, 898, 4, + 545, 660, 703, 548, 884, 25, 26, 951, 702, 725, + 30, 381, 32, 33, 34, 35, 254, 37, 38, 252, + 565, 171, 253, 726, 924, 30, 872, 730, 755, 743, + 512, 289, -1, -1, -1, 915, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 945, 946, -1, -1, 54, + 950, -1, -1, 953, -1, 955, 113, 114, 115, 116, + 117, 118, -1, 120, 121, 122, 123, 1, -1, 969, + 4, -1, -1, 776, -1, -1, -1, 957, -1, 959, + 960, 961, 962, 983, -1, 788, -1, -1, -1, 109, + 110, 111, 112, 993, -1, 995, -1, 977, -1, -1, + -1, -1, -1, 37, 38, 985, -1, -1, 128, 129, + 130, -1, -1, -1, -1, 135, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 830, -1, -1, + 833, 676, -1, -1, -1, -1, -1, -1, -1, -1, + 843, -1, 76, -1, -1, -1, -1, -1, -1, -1, + 695, 696, -1, 856, -1, -1, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + -1, 105, 106, 107, -1, 109, -1, -1, 881, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 891, -1, + -1, -1, 737, -1, -1, -1, 130, -1, 743, -1, + 134, -1, 136, -1, -1, -1, 1, -1, -1, 4, + -1, -1, -1, -1, -1, -1, -1, 762, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 931, -1, + 933, -1, -1, -1, -1, -1, -1, 940, -1, 942, + 943, 944, 37, 38, -1, 948, -1, -1, -1, -1, + -1, -1, -1, 1, -1, -1, 4, -1, -1, -1, + -1, 964, 965, 966, -1, 968, -1, 970, -1, -1, + -1, -1, -1, 976, -1, -1, 979, -1, 981, 982, + -1, 76, -1, -1, -1, -1, 989, -1, -1, 37, + 38, -1, -1, 996, -1, 90, 91, 92, -1, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, -1, + 105, -1, 107, 108, 109, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1, -1, 76, 4, + -1, -1, -1, -1, -1, 130, -1, -1, -1, 134, + -1, 136, 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, -1, 105, 106, 107, - -1, 109, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 76, -1, -1, -1, -1, - -1, -1, 130, -1, -1, -1, 134, -1, 136, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, -1, 105, 4, 107, 108, 109, -1, - -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 11, 12, 13, 14, -1, -1, -1, 130, - -1, -1, -1, 134, -1, 136, 25, 26, 37, 38, - -1, 30, -1, 32, 33, 34, 35, -1, 37, 38, - -1, -1, -1, -1, -1, -1, -1, 4, -1, -1, - 7, -1, -1, -1, 63, 64, 65, 66, -1, -1, - -1, -1, 71, 72, 73, 74, 75, 76, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 37, 38, -1, -1, -1, 94, 95, 96, 97, 98, - 99, 100, 101, 102, 103, -1, 105, -1, 107, 4, - 109, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 109, 110, 111, 112, -1, -1, -1, -1, -1, 76, - -1, 130, -1, -1, -1, 134, -1, 136, 137, 128, - -1, 130, 37, 38, -1, -1, 135, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, -1, 105, 4, - 107, -1, 109, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 76, -1, 130, -1, -1, -1, 134, -1, 136, - 137, -1, 37, 38, -1, -1, -1, -1, -1, 94, + 1, 109, 37, 38, -1, -1, -1, -1, -1, -1, + 11, 12, 13, 14, -1, -1, -1, -1, -1, -1, + -1, -1, 130, -1, 25, 26, 134, -1, 136, 30, + -1, 32, 33, 34, 35, -1, 37, 38, -1, -1, + -1, 76, -1, -1, -1, 4, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, -1, - 105, -1, 107, -1, 109, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 76, -1, -1, -1, 130, -1, -1, -1, 134, - -1, 136, 137, -1, -1, -1, -1, -1, -1, 94, + 105, -1, 107, 108, 109, -1, -1, -1, 37, 38, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 4, + -1, -1, -1, -1, -1, 130, -1, -1, -1, 134, + -1, 136, -1, -1, 63, 64, 65, 66, 109, 110, + 111, 112, 71, 72, 73, 74, 75, 76, -1, -1, + -1, -1, 37, 38, -1, -1, -1, 128, -1, 130, + -1, -1, -1, 4, 135, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, -1, 105, -1, 107, -1, + 109, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 76, -1, -1, -1, -1, 37, 38, -1, -1, + -1, 130, -1, -1, -1, 134, -1, 136, 137, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, -1, - 105, -1, 107, 9, 109, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, -1, 130, -1, -1, -1, 134, - 6, 136, 8, 9, -1, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 6, -1, 8, 9, -1, 11, + 105, -1, 107, -1, 109, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 76, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 130, -1, -1, -1, 134, + -1, 136, 137, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, -1, 105, -1, 107, 9, 109, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 130, + -1, -1, -1, 134, 6, 136, 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 6, -1, 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 11, 12, 13, 14, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 25, 26, -1, -1, - -1, 30, -1, 32, 33, 34, 35, -1, 37, 38, - -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 11, 12, 13, 14, -1, -1, -1, -1, -1, - -1, 137, -1, -1, -1, 25, 26, -1, -1, -1, - 30, -1, 32, 33, 34, 35, 128, 37, 38, -1, - -1, -1, -1, 135, -1, -1, -1, -1, -1, -1, - 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 11, 12, 13, 14, -1, 104, -1, 135, -1, -1, - 109, 110, 111, 112, 25, 26, -1, -1, -1, 30, - -1, 32, 33, 34, 35, -1, 37, 38, -1, 1, - -1, 130, -1, -1, -1, -1, -1, -1, -1, 11, - 12, 13, 14, -1, -1, -1, -1, -1, -1, 109, - 110, 111, 112, 25, 26, -1, -1, -1, 30, -1, - 32, 33, 34, 35, -1, 37, 38, -1, -1, -1, - 130, -1, -1, -1, -1, -1, -1, -1, 1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 11, 12, - 13, 14, -1, -1, -1, -1, -1, -1, 109, 110, - 111, 112, 25, 26, -1, -1, -1, 30, -1, 32, - 33, 34, 35, -1, 37, 38, -1, 1, -1, 130, - -1, -1, -1, -1, -1, -1, -1, 11, 12, 13, - 14, -1, -1, -1, -1, -1, -1, 109, 110, 111, - 112, 25, 26, -1, -1, -1, 30, -1, 32, 33, - 34, 35, -1, 37, 38, -1, -1, -1, 130, 6, - 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, -1, -1, -1, 109, 110, 111, 112, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 130, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 109, 110, 111, 112, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 6, -1, 8, 9, 130, 11, 12, 13, + 28, 29, 6, -1, 8, 9, -1, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 6, -1, 8, 9, 132, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 6, -1, 8, 9, -1, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 6, - -1, 8, 9, -1, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 6, -1, 8, 9, 132, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, -1, -1, + 24, 25, 26, 27, 28, 29, 1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 11, 12, 13, 14, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 6, -1, 8, 9, 132, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 6, -1, 8, - 9, 132, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, -1, -1, 130, 11, 12, 13, 14, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 25, 26, + 25, 26, -1, -1, -1, 30, -1, 32, 33, 34, + 35, -1, 37, 38, -1, 1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 11, 12, 13, 14, -1, + -1, -1, -1, -1, -1, 137, -1, -1, -1, 25, + 26, -1, -1, -1, 30, -1, 32, 33, 34, 35, + 128, 37, 38, -1, -1, -1, -1, 135, -1, -1, + -1, -1, -1, -1, 1, -1, -1, -1, 93, -1, + -1, -1, -1, -1, 11, 12, 13, 14, -1, 104, + -1, 135, -1, -1, 109, 110, 111, 112, 25, 26, -1, -1, -1, 30, -1, 32, 33, 34, 35, -1, - 37, 38, 11, 12, 13, 14, 128, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 25, 26, -1, -1, - -1, 30, -1, 32, 33, 34, 35, -1, 37, 38, + 37, 38, -1, 1, -1, 130, -1, -1, -1, -1, + -1, -1, -1, 11, 12, 13, 14, -1, 104, -1, + -1, -1, -1, 109, 110, 111, 112, 25, 26, -1, + -1, -1, 30, -1, 32, 33, 34, 35, -1, 37, + 38, -1, -1, -1, 130, -1, -1, -1, -1, -1, + -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 11, 12, 13, 14, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 128, 25, 26, -1, -1, + -1, -1, 109, 110, 111, 112, 25, 26, -1, -1, -1, 30, -1, 32, 33, 34, 35, -1, 37, 38, - -1, -1, -1, -1, 11, 12, 13, 14, -1, 128, - -1, -1, 109, 110, 111, 112, 113, 114, 25, 26, - -1, -1, -1, 30, -1, 32, 33, 34, 35, -1, - 37, 38, -1, 130, -1, -1, -1, -1, -1, -1, - 109, 110, 111, 112, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 130, 1, -1, -1, -1, -1, -1, -1, -1, - 109, 110, 111, 112, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 130, -1, -1, -1, -1, -1, -1, 37, -1, - -1, -1, 109, 110, 111, 112, -1, -1, -1, -1, - -1, -1, -1, 52, 53, -1, -1, -1, -1, -1, - 59, -1, 61, 130, 63, 64, 65, 66, 67, 68, - -1, -1, 71, 72, 73, 74, 75, 76, 77, -1, - -1, 80, 81, 82, 83, 84, 85, 86, 87, 88, - 89, 6, 7, 8, 9, -1, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 115, 6, 7, 8, - 9, -1, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 6, 7, 8, 9, -1, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 6, 7, 8, 9, -1, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 6, - 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 6, -1, 8, 9, -1, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29 -}; -#define YYPURE 1 - -/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ -#line 3 "/home/mdh/sourceforge/bison/share/bison/bison.simple" - -/* Skeleton output parser for bison, - - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software - Foundation, Inc. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - -/* As a special exception, when this file is copied by Bison into a - Bison output file, you may use that output file without restriction. - This special exception was added by the Free Software Foundation - in version 1.24 of Bison. */ - -/* This is the parser code that is written into each bison parser when - the %semantic_parser declaration is not specified in the grammar. - It was written by Richard Stallman by simplifying the hairy parser - used when %semantic_parser is specified. */ - -/* All symbols defined below should begin with yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE) - -/* The parser invokes alloca or malloc; define the necessary symbols. */ - -# if YYSTACK_USE_ALLOCA -# define YYSTACK_ALLOC alloca -# else -# ifndef YYSTACK_USE_ALLOCA -# if defined (alloca) || defined (_ALLOCA_H) -# define YYSTACK_ALLOC alloca -# else -# ifdef __GNUC__ -# define YYSTACK_ALLOC __builtin_alloca -# endif -# endif -# endif -# endif - -# ifdef YYSTACK_ALLOC - /* Pacify GCC's `empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) -# else -# if defined (__STDC__) || defined (__cplusplus) -# include /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -# endif -# define YYSTACK_ALLOC malloc -# define YYSTACK_FREE free -# endif -#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */ - - -#if (! defined (yyoverflow) \ - && (! defined (__cplusplus) \ - || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) - -/* A type that is properly aligned for any stack member. */ -union yyalloc -{ - short yyss; - YYSTYPE yyvs; -# if YYLSP_NEEDED - YYLTYPE yyls; -# endif -}; - -/* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) - -/* The size of an array large to enough to hold all stacks, each with - N elements. */ -# if YYLSP_NEEDED -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ - + 2 * YYSTACK_GAP_MAX) -# else -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAX) -# endif - -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if 1 < __GNUC__ -# define YYCOPY(To, From, Count) \ - __builtin_memcpy (To, From, (Count) * sizeof (*(From))) -# else -# define YYCOPY(To, From, Count) \ - do \ - { \ - register YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } \ - while (0) -# endif -# endif - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - elements in the stack, and YYPTR gives the new location of the - stack. Advance YYPTR to a properly aligned location for the next - stack. */ -# define YYSTACK_RELOCATE(Stack) \ - do \ - { \ - YYSIZE_T yynewbytes; \ - YYCOPY (&yyptr->Stack, Stack, yysize); \ - Stack = &yyptr->Stack; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ - yyptr += yynewbytes / sizeof (*yyptr); \ - } \ - while (0) - -#endif + -1, 1, -1, 130, -1, -1, -1, -1, -1, -1, + -1, 11, 12, 13, 14, -1, -1, -1, -1, -1, + -1, 109, 110, 111, 112, 25, 26, -1, -1, -1, + 30, -1, 32, 33, 34, 35, -1, 37, 38, -1, + -1, -1, 130, -1, -1, -1, -1, -1, -1, -1, + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 11, 12, 13, 14, -1, -1, -1, -1, -1, -1, + 109, 110, 111, 112, 25, 26, -1, -1, -1, 30, + -1, 32, 33, 34, 35, -1, 37, 38, -1, -1, + -1, 130, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 109, + 110, 111, 112, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 6, 7, 8, 9, + 130, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + -1, -1, -1, -1, -1, -1, -1, -1, 109, 110, + 111, 112, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 6, -1, 8, 9, 130, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 6, + -1, 8, 9, -1, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 6, -1, 8, 9, -1, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, -1, 6, -1, + 8, 9, 132, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, -1, -1, -1, -1, 11, 12, 13, 14, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 25, 26, -1, -1, -1, 30, -1, 32, 33, 34, + 35, 132, 37, 38, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, -1, + -1, 6, -1, 8, 9, 132, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 6, -1, 8, 9, 132, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, -1, + -1, -1, 130, -1, 109, 110, 111, 112, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 130, 6, -1, 8, 9, + 135, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + -1, -1, -1, 11, 12, 13, 14, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 25, 26, -1, + -1, -1, 30, 128, 32, 33, 34, 35, -1, 37, + 38, 11, 12, 13, 14, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 25, 26, 128, -1, -1, + 30, -1, 32, 33, 34, 35, -1, 37, 38, 11, + 12, 13, 14, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 25, 26, -1, -1, -1, 30, -1, + 32, 33, 34, 35, -1, 37, 38, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 128, -1, + -1, 109, 110, 111, 112, -1, -1, -1, -1, -1, + 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 130, -1, -1, -1, -1, -1, -1, 109, + 110, 111, 112, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 37, -1, -1, -1, + 130, -1, -1, -1, -1, -1, -1, 109, 110, 111, + 112, 52, 53, -1, -1, -1, -1, -1, 59, -1, + 61, -1, 63, 64, 65, 66, 67, 68, 130, -1, + 71, 72, 73, 74, 75, 76, 77, -1, -1, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 6, + 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, -1, 115, 6, 7, 8, 9, -1, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 6, + 7, 8, 9, -1, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 6, 7, 8, 9, -1, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 6, 7, 8, + 9, -1, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 6, -1, 8, 9, -1, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29 +}; +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned short int yystos[] = +{ + 0, 1, 4, 37, 38, 50, 55, 76, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 105, 107, + 109, 127, 130, 134, 136, 139, 140, 141, 142, 154, + 242, 244, 266, 273, 276, 283, 284, 286, 287, 323, + 337, 342, 343, 243, 143, 155, 260, 246, 247, 248, + 249, 257, 258, 259, 261, 262, 263, 7, 274, 7, + 277, 137, 285, 349, 1, 287, 323, 324, 337, 30, + 111, 337, 30, 344, 0, 127, 141, 90, 91, 92, + 265, 349, 21, 133, 30, 31, 349, 250, 251, 30, + 37, 115, 338, 37, 286, 242, 30, 30, 30, 30, + 337, 337, 286, 286, 286, 37, 279, 37, 280, 30, + 1, 128, 131, 11, 12, 13, 14, 25, 26, 30, + 32, 33, 34, 35, 109, 110, 111, 112, 130, 327, + 329, 334, 335, 336, 337, 345, 337, 245, 254, 255, + 256, 252, 253, 267, 1, 270, 329, 329, 241, 242, + 349, 241, 329, 144, 156, 133, 329, 329, 266, 286, + 325, 329, 349, 349, 349, 133, 349, 275, 1, 106, + 242, 278, 1, 108, 242, 271, 272, 329, 287, 323, + 1, 287, 323, 334, 334, 334, 334, 334, 334, 1, + 327, 334, 334, 334, 334, 30, 270, 326, 329, 135, + 347, 6, 7, 8, 9, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 113, 114, 329, 346, + 30, 329, 342, 343, 342, 343, 329, 128, 347, 7, + 132, 347, 30, 147, 147, 329, 347, 347, 349, 133, + 347, 329, 281, 281, 128, 347, 347, 347, 271, 131, + 130, 329, 329, 329, 329, 329, 329, 329, 329, 333, + 332, 329, 329, 329, 329, 329, 329, 329, 329, 329, + 329, 329, 330, 331, 271, 326, 329, 329, 329, 115, + 347, 329, 349, 329, 329, 329, 329, 1, 329, 349, + 329, 241, 1, 37, 129, 130, 148, 149, 150, 152, + 349, 349, 349, 242, 242, 329, 241, 349, 63, 71, + 72, 73, 74, 75, 176, 181, 185, 186, 187, 279, + 282, 280, 272, 349, 347, 270, 7, 7, 329, 329, + 329, 329, 347, 7, 132, 346, 347, 349, 349, 349, + 349, 132, 5, 264, 31, 37, 151, 152, 128, 347, + 145, 157, 349, 31, 215, 216, 215, 215, 215, 180, + 180, 180, 106, 108, 131, 329, 329, 326, 329, 1, + 104, 268, 269, 270, 241, 326, 30, 128, 131, 1, + 149, 146, 158, 266, 326, 177, 1, 37, 206, 207, + 37, 209, 37, 208, 131, 132, 7, 241, 1, 93, + 269, 7, 7, 132, 150, 152, 1, 37, 52, 53, + 59, 61, 64, 65, 66, 67, 68, 76, 77, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 115, + 153, 169, 171, 176, 181, 182, 183, 189, 190, 191, + 193, 195, 197, 204, 217, 219, 225, 237, 239, 288, + 1, 71, 88, 159, 160, 161, 182, 347, 7, 1, + 37, 178, 179, 31, 1, 128, 349, 128, 349, 128, + 349, 241, 241, 326, 347, 134, 227, 289, 37, 73, + 74, 173, 216, 215, 215, 215, 192, 30, 211, 212, + 205, 337, 238, 240, 180, 188, 180, 69, 70, 194, + 216, 180, 218, 37, 37, 57, 162, 242, 326, 133, + 1, 128, 349, 326, 207, 1, 207, 37, 37, 132, + 30, 326, 226, 290, 291, 349, 37, 30, 210, 78, + 79, 80, 81, 213, 214, 134, 339, 340, 128, 349, + 133, 242, 242, 1, 37, 184, 1, 37, 198, 199, + 209, 209, 216, 216, 339, 196, 220, 221, 340, 349, + 133, 163, 56, 1, 132, 348, 326, 328, 329, 179, + 1, 179, 7, 228, 326, 327, 329, 1, 30, 37, + 230, 231, 1, 4, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 54, 292, 293, 295, 308, 309, 170, + 349, 116, 117, 118, 194, 128, 128, 30, 111, 337, + 337, 326, 1, 128, 349, 133, 1, 128, 349, 349, + 349, 1, 201, 202, 286, 30, 37, 223, 224, 222, + 111, 112, 321, 164, 165, 166, 7, 326, 128, 135, + 128, 135, 1, 129, 232, 233, 234, 235, 236, 329, + 30, 1, 128, 349, 30, 294, 30, 30, 30, 30, + 30, 30, 30, 30, 30, 296, 174, 172, 347, 347, + 347, 339, 214, 213, 327, 341, 133, 37, 1, 37, + 200, 37, 199, 1, 199, 1, 128, 349, 133, 1, + 229, 329, 30, 128, 349, 223, 349, 58, 165, 30, + 121, 122, 123, 124, 125, 126, 167, 349, 329, 132, + 326, 327, 37, 347, 128, 128, 232, 231, 1, 231, + 305, 329, 178, 113, 114, 119, 312, 314, 312, 113, + 114, 119, 313, 316, 313, 312, 313, 312, 313, 1, + 37, 113, 114, 297, 299, 307, 133, 175, 176, 181, + 182, 241, 174, 347, 347, 128, 347, 326, 329, 202, + 1, 202, 203, 1, 128, 347, 229, 224, 349, 122, + 123, 124, 125, 126, 168, 7, 128, 135, 30, 1, + 234, 236, 347, 347, 349, 31, 128, 322, 337, 128, + 31, 128, 322, 128, 128, 128, 128, 128, 31, 1, + 25, 26, 39, 40, 128, 303, 304, 297, 30, 301, + 302, 327, 60, 241, 327, 329, 329, 1, 329, 347, + 168, 329, 327, 329, 347, 315, 312, 10, 31, 312, + 317, 329, 10, 329, 312, 312, 312, 312, 326, 299, + 1, 299, 304, 1, 30, 37, 298, 300, 304, 302, + 327, 349, 62, 128, 347, 135, 347, 1, 120, 318, + 128, 30, 33, 37, 319, 320, 326, 329, 128, 318, + 128, 310, 319, 128, 347, 128, 128, 128, 128, 7, + 348, 298, 298, 31, 1, 128, 347, 30, 128, 327, + 128, 348, 329, 319, 320, 15, 16, 17, 18, 7, + 132, 329, 348, 37, 311, 347, 329, 349, 329, 329, + 329, 329, 326, 347, 7, 303, 326, 300, 1, 300, + 298, 302, 318, 310, 135, 321, 321, 321, 321, 326, + 310, 349, 310, 310, 310, 128, 128, 348, 306, 329, + 7, 7, 348, 7, 303, 128, 347, 347, 132, 347, + 347, 347, 347, 329, 329, 347, 306, 326, 306, 7, + 302, 349, 349, 349, 349, 349, 310, 347, 347, 347, + 348, 347, 306, 128, 347, 347, 349, 347, 347, 347, + 302, 349, 347, 128, 302, 128, 302, 347 +}; #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) # define YYSIZE_T __SIZE_TYPE__ @@ -1740,71 +2031,93 @@ union yyalloc #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) -#define YYEMPTY -2 +#define YYEMPTY (-2) #define YYEOF 0 + #define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrlab1 +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ + #define YYFAIL goto yyerrlab + #define YYRECOVERING() (!!yyerrstatus) + #define YYBACKUP(Token, Value) \ do \ if (yychar == YYEMPTY && yylen == 1) \ { \ yychar = (Token); \ yylval = (Value); \ - yychar1 = YYTRANSLATE (yychar); \ + yytoken = YYTRANSLATE (yychar); \ YYPOPSTACK; \ goto yybackup; \ } \ else \ { \ - yyerror ("syntax error: cannot back up"); \ + yyerror ("syntax error: cannot back up");\ YYERROR; \ } \ while (0) + #define YYTERROR 1 #define YYERRCODE 256 -/* YYLLOC_DEFAULT -- Compute the default location (before the actions - are run). - - When YYLLOC_DEFAULT is run, CURRENT is set the location of the - first token. By default, to implement support for ranges, extend - its range to the last symbol. */ +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) #ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - Current.last_line = Rhs[N].last_line; \ - Current.last_column = Rhs[N].last_column; +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (0) #endif -/* YYLEX -- calling `yylex' with the right arguments. */ +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ -#if YYPURE -# if YYLSP_NEEDED -# ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) -# else -# define YYLEX yylex (&yylval, &yylloc) -# endif -# else /* !YYLSP_NEEDED */ -# ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval, YYLEX_PARAM) -# else -# define YYLEX yylex (&yylval) -# endif -# endif /* !YYLSP_NEEDED */ -#else /* !YYPURE */ -# define YYLEX yylex () -#endif /* !YYPURE */ +#ifndef YY_LOCATION_PRINT +# if YYLTYPE_IS_TRIVIAL +# define YY_LOCATION_PRINT(File, Loc) \ + fprintf (File, "%d.%d-%d.%d", \ + (Loc).first_line, (Loc).first_column, \ + (Loc).last_line, (Loc).last_column) +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ +#ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, YYLEX_PARAM) +#else +# define YYLEX yylex (&yylval) +#endif /* Enable debugging if requested. */ #if YYDEBUG @@ -1819,13 +2132,86 @@ do { \ if (yydebug) \ YYFPRINTF Args; \ } while (0) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yysymprint (stderr, \ + Type, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_stack_print (short int *bottom, short int *top) +#else +static void +yy_stack_print (bottom, top) + short int *bottom; + short int *top; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (/* Nothing. */; bottom <= top; ++bottom) + YYFPRINTF (stderr, " %d", *bottom); + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_reduce_print (int yyrule) +#else +static void +yy_reduce_print (yyrule) + int yyrule; +#endif +{ + int yyi; + unsigned int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", + yyrule - 1, yylno); + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) + YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); + YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (Rule); \ +} while (0) + /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ int yydebug; #else /* !YYDEBUG */ # define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) #endif /* !YYDEBUG */ + /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH # define YYINITDEPTH 200 @@ -1838,15 +2224,13 @@ int yydebug; SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) evaluated with infinite-precision integer arithmetic. */ -#if YYMAXDEPTH == 0 -# undef YYMAXDEPTH -#endif - #ifndef YYMAXDEPTH # define YYMAXDEPTH 10000 #endif + -#ifdef YYERROR_VERBOSE + +#if YYERROR_VERBOSE # ifndef yystrlen # if defined (__GLIBC__) && defined (_STRING_H) @@ -1896,86 +2280,139 @@ yystpcpy (yydest, yysrc) } # endif # endif -#endif + +#endif /* !YYERROR_VERBOSE */ + -#line 315 "/home/mdh/sourceforge/bison/share/bison/bison.simple" +#if YYDEBUG +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) +#else +static void +yysymprint (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# endif + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyoutput, ")"); +} + +#endif /* ! YYDEBUG */ +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yymsg, yytype, yyvaluep) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + -/* The user can define YYPARSE_PARAM as the name of an argument to be passed - into yyparse. The argument should have type void *. - It should actually point to an object. - Grammar actions can access the variable by casting it - to the proper pointer type. */ +/* Prevent warnings from -Wmissing-prototypes. */ #ifdef YYPARSE_PARAM # if defined (__STDC__) || defined (__cplusplus) -# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM -# define YYPARSE_PARAM_DECL +int yyparse (void *YYPARSE_PARAM); # else -# define YYPARSE_PARAM_ARG YYPARSE_PARAM -# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +int yyparse (); # endif -#else /* !YYPARSE_PARAM */ -# define YYPARSE_PARAM_ARG -# define YYPARSE_PARAM_DECL -#endif /* !YYPARSE_PARAM */ - -/* Prevent warning if -Wstrict-prototypes. */ -#ifdef __GNUC__ -# ifdef YYPARSE_PARAM -int yyparse (void *); -# else +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) int yyparse (void); -# endif +#else +int yyparse (); #endif +#endif /* ! YYPARSE_PARAM */ -/* YY_DECL_VARIABLES -- depending whether we use a pure parser, - variables are global, or local to YYPARSE. */ - -#define YY_DECL_NON_LSP_VARIABLES \ -/* The lookahead symbol. */ \ -int yychar; \ - \ -/* The semantic value of the lookahead symbol. */ \ -YYSTYPE yylval; \ - \ -/* Number of parse errors so far. */ \ -int yynerrs; -#if YYLSP_NEEDED -# define YY_DECL_VARIABLES \ -YY_DECL_NON_LSP_VARIABLES \ - \ -/* Location data for the lookahead symbol. */ \ -YYLTYPE yylloc; -#else -# define YY_DECL_VARIABLES \ -YY_DECL_NON_LSP_VARIABLES -#endif -/* If nonreentrant, generate the variables here. */ -#if !YYPURE -YY_DECL_VARIABLES -#endif /* !YYPURE */ +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM) +# else +int yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +# endif +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) +int +yyparse (void) +#else int -yyparse (YYPARSE_PARAM_ARG) - YYPARSE_PARAM_DECL +yyparse () + +#endif +#endif { - /* If reentrant, generate the variables here. */ -#if YYPURE - YY_DECL_VARIABLES -#endif /* !YYPURE */ + /* The look-ahead symbol. */ +int yychar; + +/* The semantic value of the look-ahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; register int yystate; register int yyn; int yyresult; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; - /* Lookahead token as an internal (translated) token number. */ - int yychar1 = 0; + /* Look-ahead token as an internal (translated) token number. */ + int yytoken = 0; /* Three stacks and their tools: `yyss': related to states, @@ -1985,41 +2422,29 @@ yyparse (YYPARSE_PARAM_ARG) Refer to the stacks thru separate pointers, to allow yyoverflow to reallocate them elsewhere. */ - /* The state stack. */ - short yyssa[YYINITDEPTH]; - short *yyss = yyssa; - register short *yyssp; + /* The state stack. */ + short int yyssa[YYINITDEPTH]; + short int *yyss = yyssa; + register short int *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE *yyvs = yyvsa; register YYSTYPE *yyvsp; -#if YYLSP_NEEDED - /* The location stack. */ - YYLTYPE yylsa[YYINITDEPTH]; - YYLTYPE *yyls = yylsa; - YYLTYPE *yylsp; -#endif -#if YYLSP_NEEDED -# define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) -#else -# define YYPOPSTACK (yyvsp--, yyssp--) -#endif - YYSIZE_T yystacksize = YYINITDEPTH; +#define YYPOPSTACK (yyvsp--, yyssp--) + YYSIZE_T yystacksize = YYINITDEPTH; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; -#if YYLSP_NEEDED - YYLTYPE yyloc; -#endif + /* When reducing, the number of symbols on the RHS of the reduced - rule. */ + rule. */ int yylen; YYDPRINTF ((stderr, "Starting parse\n")); @@ -2036,9 +2461,10 @@ yyparse (YYPARSE_PARAM_ARG) yyssp = yyss; yyvsp = yyvs; -#if YYLSP_NEEDED - yylsp = yyls; -#endif + + + yyvsp[0] = yylval; + goto yysetstate; /*------------------------------------------------------------. @@ -2053,7 +2479,7 @@ yyparse (YYPARSE_PARAM_ARG) yysetstate: *yyssp = yystate; - if (yyssp >= yyss + yystacksize - 1) + if (yyss + yystacksize - 1 <= yyssp) { /* Get the current used size of the three stacks, in elements. */ YYSIZE_T yysize = yyssp - yyss + 1; @@ -2064,26 +2490,19 @@ yyparse (YYPARSE_PARAM_ARG) these so that the &'s don't force the real ones into memory. */ YYSTYPE *yyvs1 = yyvs; - short *yyss1 = yyss; + short int *yyss1 = yyss; + /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. */ -# if YYLSP_NEEDED - YYLTYPE *yyls1 = yyls; - /* This used to be a conditional around just the two extra args, - but that might be undefined if yyoverflow is a macro. */ - yyoverflow ("parser stack overflow", - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), - &yyls1, yysize * sizeof (*yylsp), - &yystacksize); - yyls = yyls1; -# else + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ yyoverflow ("parser stack overflow", &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); -# endif + yyss = yyss1; yyvs = yyvs1; } @@ -2092,24 +2511,22 @@ yyparse (YYPARSE_PARAM_ARG) goto yyoverflowlab; # else /* Extend the stack our own way. */ - if (yystacksize >= YYMAXDEPTH) + if (YYMAXDEPTH <= yystacksize) goto yyoverflowlab; yystacksize *= 2; - if (yystacksize > YYMAXDEPTH) + if (YYMAXDEPTH < yystacksize) yystacksize = YYMAXDEPTH; { - short *yyss1 = yyss; + short int *yyss1 = yyss; union yyalloc *yyptr = (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); if (! yyptr) goto yyoverflowlab; YYSTACK_RELOCATE (yyss); YYSTACK_RELOCATE (yyvs); -# if YYLSP_NEEDED - YYSTACK_RELOCATE (yyls); -# endif -# undef YYSTACK_RELOCATE + +# undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } @@ -2118,14 +2535,12 @@ yyparse (YYPARSE_PARAM_ARG) yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; -#if YYLSP_NEEDED - yylsp = yyls + yysize - 1; -#endif + YYDPRINTF ((stderr, "Stack size increased to %lu\n", (unsigned long int) yystacksize)); - if (yyssp >= yyss + yystacksize - 1) + if (yyss + yystacksize - 1 <= yyssp) YYABORT; } @@ -2133,101 +2548,67 @@ yyparse (YYPARSE_PARAM_ARG) goto yybackup; - /*-----------. | yybackup. | `-----------*/ yybackup: /* Do appropriate processing given the current state. */ -/* Read a lookahead token if we need one and don't already have one. */ +/* Read a look-ahead token if we need one and don't already have one. */ /* yyresume: */ - /* First try to decide what to do without reference to lookahead token. */ + /* First try to decide what to do without reference to look-ahead token. */ yyn = yypact[yystate]; - if (yyn == YYFLAG) + if (yyn == YYPACT_NINF) goto yydefault; - /* Not known => get a lookahead token if don't already have one. */ - - /* yychar is either YYEMPTY or YYEOF - or a valid token in external form. */ + /* Not known => get a look-ahead token if don't already have one. */ + /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; } - /* Convert token to internal form (in yychar1) for indexing tables with */ - - if (yychar <= 0) /* This means end of input. */ + if (yychar <= YYEOF) { - yychar1 = 0; - yychar = YYEOF; /* Don't call YYLEX any more */ - + yychar = yytoken = YYEOF; YYDPRINTF ((stderr, "Now at end of input.\n")); } else { - yychar1 = YYTRANSLATE (yychar); - -#if YYDEBUG - /* We have to keep this `#if YYDEBUG', since we use variables - which are defined only if `YYDEBUG' is set. */ - if (yydebug) - { - YYFPRINTF (stderr, "Next token is %d (%s", - yychar, yytname[yychar1]); - /* Give the individual parser a way to print the precise - meaning of a token, for further debugging info. */ -# ifdef YYPRINT - YYPRINT (stderr, yychar, yylval); -# endif - YYFPRINTF (stderr, ")\n"); - } -#endif + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); } - yyn += yychar1; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) goto yydefault; - yyn = yytable[yyn]; - - /* yyn is what to do for this token type in this state. - Negative => reduce, -yyn is rule number. - Positive => shift, yyn is new state. - New state is final state => don't bother to shift, - just return success. - 0, or most negative number => error. */ - - if (yyn < 0) + if (yyn <= 0) { - if (yyn == YYFLAG) + if (yyn == 0 || yyn == YYTABLE_NINF) goto yyerrlab; yyn = -yyn; goto yyreduce; } - else if (yyn == 0) - goto yyerrlab; if (yyn == YYFINAL) YYACCEPT; - /* Shift the lookahead token. */ - YYDPRINTF ((stderr, "Shifting token %d (%s), ", - yychar, yytname[yychar1])); + /* Shift the look-ahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; *++yyvsp = yylval; -#if YYLSP_NEEDED - *++yylsp = yylloc; -#endif + /* Count tokens shifted since error; after three, turn off error status. */ @@ -2258,54 +2639,33 @@ yyparse (YYPARSE_PARAM_ARG) /* If YYLEN is nonzero, implement the default value of the action: `$$ = $1'. - Otherwise, the following line sets YYVAL to the semantic value of - the lookahead token. This behavior is undocumented and Bison + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; -#if YYLSP_NEEDED - /* Similarly for the default location. Let the user run additional - commands if for instance locations are ranges. */ - yyloc = yylsp[1-yylen]; - YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); -#endif -#if YYDEBUG - /* We have to keep this `#if YYDEBUG', since we use variables which - are defined only if `YYDEBUG' is set. */ - if (yydebug) + YY_REDUCE_PRINT (yyn); + switch (yyn) { - int yyi; - - YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", - yyn, yyrline[yyn]); - - /* Print the symbols being reduced, and their result. */ - for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++) - YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); - YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); - } -#endif - - switch (yyn) { - -case 1: + case 2: #line 426 "parse.yy" -{ if (!is_interactive) + { if (!is_interactive) YYFAIL; #if VDEBUG != 0 if (vdebug) printf_error_V ("interactive statement\n"); #endif - interactive_statement = yyvsp[0].ttype; + interactive_statement = (yyvsp[0].ttype); fix_lastchar(); YYACCEPT;} break; -case 3: + + case 4: #line 437 "parse.yy" -{ + { #if VDEBUG != 0 if (vdebug) printf ("source error\n"); @@ -2314,35 +2674,39 @@ if (vdebug) YYABORT; } break; -case 4: + + case 5: #line 445 "parse.yy" -{ + { #if VDEBUG != 0 if (vdebug) printf_error_V ("EOF\n"); #endif - yyval.ttype = NULL; } + (yyval.ttype) = NULL; } break; -case 6: + + case 7: #line 456 "parse.yy" -{ yyerrok; + { yyerrok; #if VDEBUG != 0 if (vdebug) printf ("description_list\n"); #endif } break; -case 9: + + case 10: #line 473 "parse.yy" -{ if (is_interactive) { + { if (is_interactive) { YYFAIL; } } break; -case 10: + + case 11: #line 478 "parse.yy" -{ - current_module = current_scope = build_module (yyvsp[0].ttype); + { + current_module = current_scope = build_module ((yyvsp[0].ttype)); push_scope (); /* list of parse modules */ module_list = tree_cons (current_module, NULL_TREE, module_list); @@ -2350,303 +2714,353 @@ case 10: // top_level = chainon (current_module, top_level); } break; -case 11: + + case 12: #line 487 "parse.yy" -{ MODULE_PORT_LIST (current_module) = nreverse (yyvsp[-1].ttype); } + { MODULE_PORT_LIST (current_module) = nreverse ((yyvsp[-1].ttype)); } break; -case 12: + + case 13: #line 489 "parse.yy" -{ + { current_scope = pop_scope (); BLOCK_BODY (current_module) = nreverse (BLOCK_BODY (current_module)); BLOCK_DECL (current_module) = nreverse (BLOCK_DECL (current_module)); end_module (current_module); } break; -case 14: + + case 15: #line 502 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 16: + + case 17: #line 508 "parse.yy" -{ yyval.ttype = yyvsp[-1].ttype; } + { (yyval.ttype) = (yyvsp[-1].ttype); } break; -case 17: + + case 18: #line 510 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 19: + + case 20: #line 516 "parse.yy" -{ yyerrok; - yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-2].ttype); + { yyerrok; + (yyval.ttype) = chainon ((yyvsp[0].ttype), (yyvsp[-2].ttype)); } break; -case 22: + + case 23: #line 530 "parse.yy" -{ if (yyvsp[0].ttype) - yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); + { if ((yyvsp[0].ttype)) + (yyval.ttype) = build_tree_list ((yyvsp[0].ttype), NULL_TREE); else - yyval.ttype = NULL_TREE; + (yyval.ttype) = NULL_TREE; } break; -case 23: + + case 24: #line 536 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[-3].ttype); } + { (yyval.ttype) = build_tree_list ((yyvsp[-1].ttype), (yyvsp[-3].ttype)); } break; -case 25: + + case 26: #line 542 "parse.yy" -{ yyval.ttype = yyvsp[-1].ttype; + { (yyval.ttype) = (yyvsp[-1].ttype); sorry ("Port concatenations not supported in this version"); } break; -case 26: + + case 27: #line 546 "parse.yy" -{ yyval.ttype = NULL_TREE; } + { (yyval.ttype) = NULL_TREE; } break; -case 27: + + case 28: #line 551 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); } + { (yyval.ttype) = build_tree_list ((yyvsp[0].ttype), NULL_TREE); } break; -case 28: + + case 29: #line 553 "parse.yy" -{ yyval.ttype = tree_cons (yyvsp[0].ttype, NULL_TREE, yyvsp[-2].ttype); } + { (yyval.ttype) = tree_cons ((yyvsp[0].ttype), NULL_TREE, (yyvsp[-2].ttype)); } break; -case 29: + + case 30: #line 558 "parse.yy" -{ set_decl (yyvsp[0].ttype, yyvsp[0].ttype); } + { set_decl ((yyvsp[0].ttype), (yyvsp[0].ttype)); } break; -case 30: + + case 31: #line 560 "parse.yy" -{ yyval.ttype = build_bit_ref (yyvsp[-3].ttype, yyvsp[-1].ttype); - set_decl (yyvsp[-3].ttype, yyval.ttype); + { (yyval.ttype) = build_bit_ref ((yyvsp[-3].ttype), (yyvsp[-1].ttype)); + set_decl ((yyvsp[-3].ttype), (yyval.ttype)); // sorry ("Port bit-select not supported in this version"); } break; -case 31: + + case 32: #line 565 "parse.yy" -{ yyval.ttype = build_part_ref (yyvsp[-5].ttype, yyvsp[-3].ttype, yyvsp[-1].ttype); - set_decl (yyvsp[-5].ttype, yyval.ttype); + { (yyval.ttype) = build_part_ref ((yyvsp[-5].ttype), (yyvsp[-3].ttype), (yyvsp[-1].ttype)); + set_decl ((yyvsp[-5].ttype), (yyval.ttype)); // sorry ("Port part-selects not supported in this version"); } break; -case 32: + + case 33: #line 573 "parse.yy" -{} + {} break; -case 33: + + case 34: #line 575 "parse.yy" -{} + {} break; -case 34: + + case 35: #line 577 "parse.yy" -{} + {} break; -case 35: + + case 36: #line 579 "parse.yy" -{} + {} break; -case 37: + + case 38: #line 582 "parse.yy" -{} + {} break; -case 38: + + case 39: #line 584 "parse.yy" -{} + {} break; -case 39: + + case 40: #line 586 "parse.yy" -{} + {} break; -case 40: + + case 41: #line 588 "parse.yy" -{} + {} break; -case 41: + + case 42: #line 590 "parse.yy" -{ BLOCK_BODY (current_module) = tree_cons (yyvsp[0].ttype, + { BLOCK_BODY (current_module) = tree_cons ((yyvsp[0].ttype), (tree)INITIAL_CODE, BLOCK_BODY (current_module)); } break; -case 42: + + case 43: #line 594 "parse.yy" -{ BLOCK_BODY (current_module) = tree_cons (yyvsp[0].ttype, + { BLOCK_BODY (current_module) = tree_cons ((yyvsp[0].ttype), (tree)ALWAYS_CODE, BLOCK_BODY (current_module)); } break; -case 43: + + case 44: #line 598 "parse.yy" -{} + {} break; -case 44: + + case 45: #line 600 "parse.yy" -{} + {} break; -case 45: + + case 46: #line 615 "parse.yy" -{ if (is_interactive) { + { if (is_interactive) { YYFAIL; } } break; -case 46: + + case 47: #line 620 "parse.yy" -{ - current_module = current_scope = build_udp (yyvsp[0].ttype); + { + current_module = current_scope = build_udp ((yyvsp[0].ttype)); push_scope (); /* list of parse modules */ module_list = tree_cons (current_module, NULL_TREE, module_list); } break; -case 47: + + case 48: #line 627 "parse.yy" -{ UDP_PORT_LIST (current_module) = nreverse (yyvsp[-1].ttype); } + { UDP_PORT_LIST (current_module) = nreverse ((yyvsp[-1].ttype)); } break; -case 48: + + case 49: #line 629 "parse.yy" -{ + { current_scope = pop_scope (); UDP_STRING_LIST (current_module) = nreverse (UDP_STRING_LIST (current_module)); end_primitive (current_module); } break; -case 49: + + case 50: #line 637 "parse.yy" -{ yyval.ttype = NULL_TREE; } + { (yyval.ttype) = NULL_TREE; } break; -case 50: + + case 51: #line 639 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 54: + + case 55: #line 650 "parse.yy" -{ - if( strcmp( IDENT(yyvsp[-1].ttype), + { + if( strcmp( IDENT((yyvsp[-1].ttype)), IDENT(DECL_NAME(TREE_PURPOSE(MODULE_PORT_LIST(current_module)))) )!=0 ) { error( "only the first declared port in a udp can be a reg", NULL_CHAR, NULL_CHAR ); } else { - UDP_REG_NAME(current_module) = yyvsp[-1].ttype; + UDP_REG_NAME(current_module) = (yyvsp[-1].ttype); } - yyval.ttype = NULL_TREE; + (yyval.ttype) = NULL_TREE; } break; -case 55: + + case 56: #line 663 "parse.yy" -{ yyval.ttype = NULL_TREE; } + { (yyval.ttype) = NULL_TREE; } break; -case 56: + + case 57: #line 665 "parse.yy" -{ + { if( UDP_REG_NAME(current_module)==NULL_TREE ) { error( "initial statement is no allowed in combinatorial udp's", NULL_CHAR, NULL_CHAR ); - } else if( strcmp(IDENT(yyvsp[-3].ttype),IDENT(UDP_REG_NAME(current_module)))!=0 ) { + } else if( strcmp(IDENT((yyvsp[-3].ttype)),IDENT(UDP_REG_NAME(current_module)))!=0 ) { error( "initial statement does not reference port output", NULL_CHAR, NULL_CHAR ); } else { - UDP_INITIAL_VALUE(current_module) = yyvsp[-1].ttype; + UDP_INITIAL_VALUE(current_module) = (yyvsp[-1].ttype); } - yyval.ttype = NULL_TREE; + (yyval.ttype) = NULL_TREE; } break; -case 57: + + case 58: #line 683 "parse.yy" -{ extern int enable_udp_parse; + { extern int enable_udp_parse; enable_udp_parse = TRUE; current_udp_string = NULL_TREE; } break; -case 58: + + case 59: #line 688 "parse.yy" -{ - UDP_STRING_LIST(current_module) = yyvsp[-1].ttype; - yyval.ttype = NULL_TREE; + { + UDP_STRING_LIST(current_module) = (yyvsp[-1].ttype); + (yyval.ttype) = NULL_TREE; } break; -case 60: + + case 61: #line 696 "parse.yy" -{ - yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-1].ttype); + { + (yyval.ttype) = chainon ((yyvsp[0].ttype), (yyvsp[-1].ttype)); } break; -case 61: + + case 62: #line 702 "parse.yy" -{ + { validate_udp_string( current_module, current_udp_string ); - yyval.ttype = current_udp_string; + (yyval.ttype) = current_udp_string; current_udp_string = NULL_TREE; } break; -case 62: + + case 63: #line 710 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 63: + + case 64: #line 712 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 64: + + case 65: #line 716 "parse.yy" -{ - append_udp_digits( ¤t_udp_string, yyvsp[0].c, yyvsp[0].c ); - yyval.ttype = NULL; + { + append_udp_digits( ¤t_udp_string, (yyvsp[0].c), (yyvsp[0].c) ); + (yyval.ttype) = NULL; } break; -case 65: + + case 66: #line 721 "parse.yy" -{ + { append_udp_digits( ¤t_udp_string,'?','?' ); - yyval.ttype = NULL; + (yyval.ttype) = NULL; } break; -case 66: + + case 67: #line 726 "parse.yy" -{ + { append_udp_digits( ¤t_udp_string,'0','0' ); - yyval.ttype = NULL; + (yyval.ttype) = NULL; } break; -case 67: + + case 68: #line 731 "parse.yy" -{ + { append_udp_digits( ¤t_udp_string,'1','1' ); - yyval.ttype = NULL; + (yyval.ttype) = NULL; } break; -case 68: + + case 69: #line 736 "parse.yy" -{ + { append_udp_digits( ¤t_udp_string,'b','b' ); - yyval.ttype = NULL; + (yyval.ttype) = NULL; } break; -case 69: + + case 70: #line 741 "parse.yy" -{ + { append_udp_digits( ¤t_udp_string,'x','x' ); - yyval.ttype = NULL; + (yyval.ttype) = NULL; } break; -case 70: + + case 71: #line 746 "parse.yy" -{ + { /* ? and b must be convert different but equivilent characters otherwise edges cannot be distinguished from levels */ - if( yyvsp[-2].c=='?' ) { - yyvsp[-2].c = '!'; - } else if( yyvsp[-2].c=='b' ) { - yyvsp[-2].c = '%'; + if( (yyvsp[-2].c)=='?' ) { + (yyvsp[-2].c) = '!'; + } else if( (yyvsp[-2].c)=='b' ) { + (yyvsp[-2].c) = '%'; } - append_udp_digits( ¤t_udp_string,yyvsp[-2].c, yyvsp[-1].c ); - yyval.ttype = NULL; + append_udp_digits( ¤t_udp_string,(yyvsp[-2].c), (yyvsp[-1].c) ); + (yyval.ttype) = NULL; } break; -case 76: + + case 77: #line 769 "parse.yy" -{ syn_warning ("Task definition"); - tmp_tree = build_task (check_task (yyvsp[-1].ttype)); - make_block_decl (yyvsp[0].ttype, current_scope, tmp_tree); + { syn_warning ("Task definition"); + tmp_tree = build_task (check_task ((yyvsp[-1].ttype))); + make_block_decl ((yyvsp[0].ttype), current_scope, tmp_tree); current_scope = tmp_tree; BLOCK_DOWN (current_module) = chainon (current_scope, BLOCK_DOWN (current_module)); BLOCK_UP (current_scope) = current_module; @@ -2654,1927 +3068,2265 @@ case 76: in_tf = 1; } break; -case 77: + + case 78: #line 779 "parse.yy" -{ BLOCK_BODY (current_scope) = yyvsp[-1].ttype; + { BLOCK_BODY (current_scope) = (yyvsp[-1].ttype); in_tf = 0; BLOCK_PORTS (current_scope) = nreverse (BLOCK_PORTS (current_scope)); BLOCK_DECL (current_scope) = nreverse (BLOCK_DECL (current_scope)); current_scope = pop_scope (); } break; -case 78: + + case 79: #line 789 "parse.yy" -{ current_scope = build_function (check_function (yyvsp[-1].ttype)); - make_block_decl (yyvsp[-1].ttype, current_module, current_scope); + { current_scope = build_function (check_function ((yyvsp[-1].ttype))); + make_block_decl ((yyvsp[-1].ttype), current_module, current_scope); push_scope (); /* funct name becomes var inside of funct */ - FUNCT_DECL (current_scope) = make_decl (yyvsp[-1].ttype, yyvsp[-2].ttype, NULL_TREE, NULL_TREE); + FUNCT_DECL (current_scope) = make_decl ((yyvsp[-1].ttype), (yyvsp[-2].ttype), NULL_TREE, NULL_TREE); BLOCK_DOWN (current_module) = chainon (current_scope, BLOCK_DOWN (current_module)); BLOCK_UP (current_scope) = current_module; in_tf = in_function = 1; } break; -case 79: + + case 80: #line 798 "parse.yy" -{ BLOCK_BODY (current_scope) = yyvsp[-1].ttype; + { BLOCK_BODY (current_scope) = (yyvsp[-1].ttype); in_tf = in_function = 0; BLOCK_PORTS (current_scope) = nreverse (BLOCK_PORTS (current_scope)); BLOCK_DECL (current_scope) = nreverse (BLOCK_DECL (current_scope)); current_scope = pop_scope (); } break; -case 80: + + case 81: #line 808 "parse.yy" -{ yyval.ttype = make_reg_spec (NULL_TREE); } + { (yyval.ttype) = make_reg_spec (NULL_TREE); } break; -case 81: + + case 82: #line 810 "parse.yy" -{ yyval.ttype = make_reg_spec (yyvsp[0].ttype); } + { (yyval.ttype) = make_reg_spec ((yyvsp[0].ttype)); } break; -case 82: + + case 83: #line 812 "parse.yy" -{ yyval.ttype = make_integer_spec (NULL_TREE); } + { (yyval.ttype) = make_integer_spec (NULL_TREE); } break; -case 83: + + case 84: #line 814 "parse.yy" -{ yyval.ttype = make_real_spec (NULL_TREE); } + { (yyval.ttype) = make_real_spec (NULL_TREE); } break; -case 84: + + case 85: #line 819 "parse.yy" -{} + {} break; -case 89: + + case 90: #line 835 "parse.yy" -{ current_spec = make_param_spec (yyvsp[0].ttype); } + { current_spec = make_param_spec ((yyvsp[0].ttype)); } break; -case 90: + + case 91: #line 837 "parse.yy" -{ BLOCK_DECL (current_scope) = - chainon (yyvsp[-1].ttype, BLOCK_DECL (current_scope)); + { BLOCK_DECL (current_scope) = + chainon ((yyvsp[-1].ttype), BLOCK_DECL (current_scope)); } break; -case 92: + + case 93: #line 845 "parse.yy" -{ yyerrok; - yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-2].ttype); + { yyerrok; + (yyval.ttype) = chainon ((yyvsp[0].ttype), (yyvsp[-2].ttype)); } break; -case 94: + + case 95: #line 850 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 96: + + case 97: #line 856 "parse.yy" -{ yyval.ttype = make_param_decl (check_non_reg (yyvsp[-2].ttype), current_spec, yyvsp[0].ttype); + { (yyval.ttype) = make_param_decl (check_non_reg ((yyvsp[-2].ttype)), current_spec, (yyvsp[0].ttype)); } break; -case 97: + + case 98: #line 859 "parse.yy" -{ yyval.ttype = make_param_decl (check_non_reg (yyvsp[-2].ttype), current_spec, yyvsp[0].ttype); + { (yyval.ttype) = make_param_decl (check_non_reg ((yyvsp[-2].ttype)), current_spec, (yyvsp[0].ttype)); } break; -case 98: + + case 99: #line 865 "parse.yy" -{} + {} break; -case 99: + + case 100: #line 870 "parse.yy" -{ BLOCK_DECL (current_scope) = - chainon (yyvsp[-1].ttype, BLOCK_DECL (current_scope)); } + { BLOCK_DECL (current_scope) = + chainon ((yyvsp[-1].ttype), BLOCK_DECL (current_scope)); } break; -case 100: + + case 101: #line 873 "parse.yy" -{ BLOCK_DECL (current_scope) = - chainon (yyvsp[-1].ttype, BLOCK_DECL (current_scope)); } + { BLOCK_DECL (current_scope) = + chainon ((yyvsp[-1].ttype), BLOCK_DECL (current_scope)); } break; -case 101: + + case 102: #line 876 "parse.yy" -{ BLOCK_DECL (current_scope) = - chainon (yyvsp[-1].ttype, BLOCK_DECL (current_scope)); } + { BLOCK_DECL (current_scope) = + chainon ((yyvsp[-1].ttype), BLOCK_DECL (current_scope)); } break; -case 102: + + case 103: #line 883 "parse.yy" -{ BLOCK_PORTS (current_scope) = - chainon (yyvsp[-1].ttype, BLOCK_PORTS (current_scope)); } + { BLOCK_PORTS (current_scope) = + chainon ((yyvsp[-1].ttype), BLOCK_PORTS (current_scope)); } break; -case 103: + + case 104: #line 891 "parse.yy" -{ if (in_tf) - yyval.ttype = current_spec = make_reg_spec (yyvsp[0].ttype); + { if (in_tf) + (yyval.ttype) = current_spec = make_reg_spec ((yyvsp[0].ttype)); else - yyval.ttype = current_spec = make_net_spec (default_net_type, yyvsp[0].ttype, NULL_TREE); - PORT_INPUT_ATTR (yyval.ttype) = 1; + (yyval.ttype) = current_spec = make_net_spec (default_net_type, (yyvsp[0].ttype), NULL_TREE); + PORT_INPUT_ATTR ((yyval.ttype)) = 1; } break; -case 104: + + case 105: #line 898 "parse.yy" -{ function_error; + { function_error; if (in_tf) - yyval.ttype = current_spec = make_reg_spec (yyvsp[0].ttype); + (yyval.ttype) = current_spec = make_reg_spec ((yyvsp[0].ttype)); else - yyval.ttype = current_spec = make_net_spec (default_net_type, yyvsp[0].ttype, NULL_TREE); - PORT_OUTPUT_ATTR (yyval.ttype) = 1; + (yyval.ttype) = current_spec = make_net_spec (default_net_type, (yyvsp[0].ttype), NULL_TREE); + PORT_OUTPUT_ATTR ((yyval.ttype)) = 1; } break; -case 105: + + case 106: #line 906 "parse.yy" -{ function_error; + { function_error; if (in_tf) - yyval.ttype = current_spec = make_reg_spec (yyvsp[0].ttype); + (yyval.ttype) = current_spec = make_reg_spec ((yyvsp[0].ttype)); else - yyval.ttype = current_spec = make_net_spec (default_net_type, yyvsp[0].ttype, NULL_TREE); - PORT_INPUT_ATTR (yyval.ttype) = 1; - PORT_OUTPUT_ATTR (yyval.ttype) = 1; + (yyval.ttype) = current_spec = make_net_spec (default_net_type, (yyvsp[0].ttype), NULL_TREE); + PORT_INPUT_ATTR ((yyval.ttype)) = 1; + PORT_OUTPUT_ATTR ((yyval.ttype)) = 1; } break; -case 106: + + case 107: #line 918 "parse.yy" -{ yyval.ttype = make_decl (check_port (yyvsp[0].ttype), current_spec, NULL_TREE, NULL_TREE); } + { (yyval.ttype) = make_decl (check_port ((yyvsp[0].ttype)), current_spec, NULL_TREE, NULL_TREE); } break; -case 107: + + case 108: #line 920 "parse.yy" -{ yyerrok; - yyval.ttype = chainon (make_decl (check_port (yyvsp[0].ttype), current_spec, NULL_TREE, NULL_TREE), yyvsp[-2].ttype); + { yyerrok; + (yyval.ttype) = chainon (make_decl (check_port ((yyvsp[0].ttype)), current_spec, NULL_TREE, NULL_TREE), (yyvsp[-2].ttype)); } break; -case 110: + + case 111: #line 926 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 112: + + case 113: #line 932 "parse.yy" -{ current_spec = make_reg_spec (yyvsp[0].ttype); } + { current_spec = make_reg_spec ((yyvsp[0].ttype)); } break; -case 113: + + case 114: #line 934 "parse.yy" -{ if (!yyvsp[0].ttype) + { if (!(yyvsp[0].ttype)) syn_warning ("Integer Range"); - current_spec = make_integer_spec (yyvsp[0].ttype); + current_spec = make_integer_spec ((yyvsp[0].ttype)); } break; -case 114: + + case 115: #line 939 "parse.yy" -{ syn_warning ("TIME"); - current_spec = make_time_spec (yyvsp[0].ttype); + { syn_warning ("TIME"); + current_spec = make_time_spec ((yyvsp[0].ttype)); } break; -case 115: + + case 116: #line 946 "parse.yy" -{ current_spec = make_real_spec (NULL_TREE); } + { current_spec = make_real_spec (NULL_TREE); } break; -case 116: + + case 117: #line 951 "parse.yy" -{ syn_warning ("EVENT"); + { syn_warning ("EVENT"); current_spec = make_event_spec (); } break; -case 117: + + case 118: #line 957 "parse.yy" -{ lval_type = LVAL_NEW_NET; } + { lval_type = LVAL_NEW_NET; } break; -case 118: + + case 119: #line 962 "parse.yy" -{ BLOCK_DECL (current_scope) = - chainon (yyvsp[-1].ttype, BLOCK_DECL (current_scope)); + { BLOCK_DECL (current_scope) = + chainon ((yyvsp[-1].ttype), BLOCK_DECL (current_scope)); lval_type = LVAL_REG; current_delay = NULL_TREE; } break; -case 120: + + case 121: #line 969 "parse.yy" -{ lval_type = LVAL_REG; + { lval_type = LVAL_REG; MODULE_ASSIGNMENTS (current_module) = - chainon (yyvsp[-1].ttype, MODULE_ASSIGNMENTS (current_module)); + chainon ((yyvsp[-1].ttype), MODULE_ASSIGNMENTS (current_module)); current_delay = NULL_TREE; } break; -case 121: + + case 122: #line 978 "parse.yy" -{ yyval.ttype = current_spec = make_net_spec (yyvsp[-2].ntype, yyvsp[-1].ttype, yyvsp[0].ttype); - current_delay = yyvsp[0].ttype; + { (yyval.ttype) = current_spec = make_net_spec ((yyvsp[-2].ntype), (yyvsp[-1].ttype), (yyvsp[0].ttype)); + current_delay = (yyvsp[0].ttype); } break; -case 122: + + case 123: #line 985 "parse.yy" -{ syn_warning ("TRIREG net"); + { syn_warning ("TRIREG net"); sorry ("TRIREG net type is not supported in this version"); } break; -case 123: + + case 124: #line 989 "parse.yy" -{ yyval.ttype = error_mark_node; } + { (yyval.ttype) = error_mark_node; } break; -case 125: + + case 126: #line 995 "parse.yy" -{ syn_warning ("SUPPLY0 net"); } + { syn_warning ("SUPPLY0 net"); } break; -case 126: + + case 127: #line 997 "parse.yy" -{ syn_warning ("SUPPLY1 net"); } + { syn_warning ("SUPPLY1 net"); } break; -case 128: + + case 129: #line 1010 "parse.yy" -{ sorry ("SCALARED keyword not supported; all nets treated as vectored"); - NET_SCALARED_ATTR (yyvsp[0].ttype) = 1; - yyval.ttype = yyvsp[0].ttype; + { sorry ("SCALARED keyword not supported; all nets treated as vectored"); + NET_SCALARED_ATTR ((yyvsp[0].ttype)) = 1; + (yyval.ttype) = (yyvsp[0].ttype); } break; -case 129: + + case 130: #line 1015 "parse.yy" -{ sorry ("VECTORED keyword is not supported; all nets treated as vectored"); - NET_VECTORED_ATTR (yyvsp[0].ttype) = 1; - yyval.ttype = yyvsp[0].ttype; + { sorry ("VECTORED keyword is not supported; all nets treated as vectored"); + NET_VECTORED_ATTR ((yyvsp[0].ttype)) = 1; + (yyval.ttype) = (yyvsp[0].ttype); } break; -case 130: + + case 131: #line 1020 "parse.yy" -{ yyval.ttype = NULL_TREE; } + { (yyval.ttype) = NULL_TREE; } break; -case 131: + + case 132: #line 1025 "parse.yy" -{ lval_type = LVAL_NET; } + { lval_type = LVAL_NET; } break; -case 132: + + case 133: #line 1027 "parse.yy" -{ lval_type = LVAL_REG; + { lval_type = LVAL_REG; MODULE_ASSIGNMENTS (current_module) = - chainon (yyvsp[-1].ttype, MODULE_ASSIGNMENTS (current_module)); + chainon ((yyvsp[-1].ttype), MODULE_ASSIGNMENTS (current_module)); } break; -case 133: + + case 134: #line 1035 "parse.yy" -{ current_delay = yyvsp[0].ttype; /* strength not supported */ - yyval.ttype = NULL; + { current_delay = (yyvsp[0].ttype); /* strength not supported */ + (yyval.ttype) = NULL; } break; -case 134: + + case 135: #line 1042 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); } + { (yyval.ttype) = build_tree_list ((yyvsp[0].ttype), NULL_TREE); } break; -case 135: + + case 136: #line 1044 "parse.yy" -{ yyerrok; - yyval.ttype = tree_cons (yyvsp[0].ttype, NULL_TREE, yyvsp[-2].ttype); + { yyerrok; + (yyval.ttype) = tree_cons ((yyvsp[0].ttype), NULL_TREE, (yyvsp[-2].ttype)); } break; -case 138: + + case 139: #line 1050 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 140: + + case 141: #line 1055 "parse.yy" -{ yyval.ltype = stmt_lineno; } + { (yyval.ltype) = stmt_lineno; } break; -case 141: + + case 142: #line 1057 "parse.yy" -{ yyval.ttype = build_cont_assign ( - check_lval (yyvsp[-3].ttype, lval_type, current_spec), - yyvsp[0].ttype, yyvsp[-1].ltype, current_delay, current_delay!=0); + { (yyval.ttype) = build_cont_assign ( + check_lval ((yyvsp[-3].ttype), lval_type, current_spec), + (yyvsp[0].ttype), (yyvsp[-1].ltype), current_delay, current_delay!=0); } break; -case 142: + + case 143: #line 1066 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); } + { (yyval.ttype) = build_tree_list ((yyvsp[0].ttype), NULL_TREE); } break; -case 143: + + case 144: #line 1068 "parse.yy" -{ yyerrok; - yyval.ttype = tree_cons (yyvsp[0].ttype, NULL_TREE, yyvsp[-2].ttype); + { yyerrok; + (yyval.ttype) = tree_cons ((yyvsp[0].ttype), NULL_TREE, (yyvsp[-2].ttype)); } break; -case 146: + + case 147: #line 1074 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 148: + + case 149: #line 1079 "parse.yy" -{ yyval.ltype = stmt_lineno; } + { (yyval.ltype) = stmt_lineno; } break; -case 149: + + case 150: #line 1081 "parse.yy" -{ yyval.ttype = build_cont_assign (yyvsp[-3].ttype, yyvsp[0].ttype, yyvsp[-1].ltype, current_delay, + { (yyval.ttype) = build_cont_assign ((yyvsp[-3].ttype), (yyvsp[0].ttype), (yyvsp[-1].ltype), current_delay, current_delay!=0); } break; -case 150: + + case 151: #line 1086 "parse.yy" -{ syn_warning ("DEFPARAM"); } + { syn_warning ("DEFPARAM"); } break; -case 151: + + case 152: #line 1091 "parse.yy" -{ MODULE_DEFPARAMS (current_module) = chainon ( - build_stmt (ASSIGN_STMT, stmt_lineno, yyvsp[-2].ttype, yyvsp[0].ttype), + { MODULE_DEFPARAMS (current_module) = chainon ( + build_stmt (ASSIGN_STMT, stmt_lineno, (yyvsp[-2].ttype), (yyvsp[0].ttype)), MODULE_DEFPARAMS (current_module)); } break; -case 152: + + case 153: #line 1096 "parse.yy" -{ + { MODULE_DEFPARAMS (current_module) = chainon ( - build_stmt (ASSIGN_STMT, stmt_lineno, yyvsp[-2].ttype, yyvsp[0].ttype), + build_stmt (ASSIGN_STMT, stmt_lineno, (yyvsp[-2].ttype), (yyvsp[0].ttype)), MODULE_DEFPARAMS (current_module)); } break; -case 154: + + case 155: #line 1106 "parse.yy" -{ yyerrok; - yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-2].ttype); + { yyerrok; + (yyval.ttype) = chainon ((yyvsp[0].ttype), (yyvsp[-2].ttype)); } break; -case 157: + + case 158: #line 1112 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 159: + + case 160: #line 1118 "parse.yy" -{ yyval.ttype = make_decl (check_reg (yyvsp[0].ttype), current_spec, NULL_TREE, NULL_TREE); } + { (yyval.ttype) = make_decl (check_reg ((yyvsp[0].ttype)), current_spec, NULL_TREE, NULL_TREE); } break; -case 160: + + case 161: #line 1120 "parse.yy" -{ yyval.ttype = make_decl (check_reg (yyvsp[-5].ttype), current_spec, yyvsp[-3].ttype, yyvsp[-1].ttype); + { (yyval.ttype) = make_decl (check_reg ((yyvsp[-5].ttype)), current_spec, (yyvsp[-3].ttype), (yyvsp[-1].ttype)); syn_warning ("REG/INTEGER arrays"); } break; -case 161: + + case 162: #line 1127 "parse.yy" -{ yyval.ttype = make_decl (check_non_reg (yyvsp[0].ttype), current_spec, NULL_TREE, NULL_TREE); } + { (yyval.ttype) = make_decl (check_non_reg ((yyvsp[0].ttype)), current_spec, NULL_TREE, NULL_TREE); } break; -case 162: + + case 163: #line 1129 "parse.yy" -{ yyval.ttype = chainon (make_decl (check_non_reg (yyvsp[0].ttype), current_spec, NULL_TREE, NULL_TREE), yyvsp[-2].ttype); } + { (yyval.ttype) = chainon (make_decl (check_non_reg ((yyvsp[0].ttype)), current_spec, NULL_TREE, NULL_TREE), (yyvsp[-2].ttype)); } break; -case 163: + + case 164: #line 1134 "parse.yy" -{ yyval.ttype = make_decl (check_net (yyvsp[0].ttype), current_spec, NULL_TREE, NULL_TREE); } + { (yyval.ttype) = make_decl (check_net ((yyvsp[0].ttype)), current_spec, NULL_TREE, NULL_TREE); } break; -case 164: + + case 165: #line 1136 "parse.yy" -{ yyval.ttype = chainon (make_decl (check_net (yyvsp[0].ttype), current_spec, NULL_TREE, NULL_TREE), yyvsp[-2].ttype); } + { (yyval.ttype) = chainon (make_decl (check_net ((yyvsp[0].ttype)), current_spec, NULL_TREE, NULL_TREE), (yyvsp[-2].ttype)); } break; -case 165: + + case 166: #line 1141 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 166: + + case 167: #line 1143 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 167: + + case 168: #line 1145 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 168: + + case 169: #line 1147 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 169: + + case 170: #line 1152 "parse.yy" -{} + {} break; -case 170: + + case 171: #line 1154 "parse.yy" -{ + { warning ("Strength specification is not supported and is ignored", NULL_CHAR, NULL_CHAR); } break; -case 171: + + case 172: #line 1162 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 172: + + case 173: #line 1164 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 177: + + case 178: #line 1188 "parse.yy" -{ yyval.ttype = NULL_TREE;} + { (yyval.ttype) = NULL_TREE;} break; -case 179: + + case 180: #line 1194 "parse.yy" -{ TREE_OPERAND (range_handle, 0) = yyvsp[-3].ttype; - TREE_OPERAND (range_handle, 1) = yyvsp[-1].ttype; - yyval.ttype = range_handle; + { TREE_OPERAND (range_handle, 0) = (yyvsp[-3].ttype); + TREE_OPERAND (range_handle, 1) = (yyvsp[-1].ttype); + (yyval.ttype) = range_handle; } break; -case 180: + + case 181: #line 1210 "parse.yy" -{ current_gatetype = yyvsp[0].gtype; + { current_gatetype = (yyvsp[0].gtype); in_instantiation = 1; } break; -case 181: + + case 182: #line 1214 "parse.yy" -{ in_instantiation = 0; } + { in_instantiation = 0; } break; -case 183: + + case 184: #line 1223 "parse.yy" -{ yyval.gtype = GATE_OR_TYPE; } + { (yyval.gtype) = GATE_OR_TYPE; } break; -case 184: + + case 185: #line 1225 "parse.yy" -{ syn_warning ("Buffer gate"); } + { syn_warning ("Buffer gate"); } break; -case 185: + + case 186: #line 1227 "parse.yy" -{ syn_warning ("Bufif gate"); } + { syn_warning ("Bufif gate"); } break; -case 186: + + case 187: #line 1229 "parse.yy" -{ syn_warning ("CMOS gate"); } + { syn_warning ("CMOS gate"); } break; -case 187: + + case 188: #line 1231 "parse.yy" -{ syn_warning ("PULL gate"); } + { syn_warning ("PULL gate"); } break; -case 188: + + case 189: #line 1233 "parse.yy" -{ syn_warning ("TRAN gate"); } + { syn_warning ("TRAN gate"); } break; -case 189: + + case 190: #line 1246 "parse.yy" -{ current_delay = NULL_TREE; } + { current_delay = NULL_TREE; } break; -case 191: + + case 192: #line 1252 "parse.yy" -{ current_delay = yyvsp[0].ttype; } + { current_delay = (yyvsp[0].ttype); } break; -case 195: + + case 196: #line 1263 "parse.yy" -{ yyval.ttype = build_gate_instance (current_gatetype, input_filename, lineno, - yyvsp[-3].ttype, nreverse (yyvsp[-1].ttype), current_delay, NULL_TREE); - MODULE_INSTANCES (current_module) = chainon (yyval.ttype, + { (yyval.ttype) = build_gate_instance (current_gatetype, input_filename, lineno, + (yyvsp[-3].ttype), nreverse ((yyvsp[-1].ttype)), current_delay, NULL_TREE); + MODULE_INSTANCES (current_module) = chainon ((yyval.ttype), MODULE_INSTANCES (current_module)); } break; -case 196: + + case 197: #line 1269 "parse.yy" -{ yyval.ttype = build_gate_instance (current_gatetype, input_filename, lineno, - NULL_TREE, nreverse (yyvsp[-1].ttype), current_delay, NULL_TREE); - MODULE_INSTANCES (current_module) = chainon (yyval.ttype, + { (yyval.ttype) = build_gate_instance (current_gatetype, input_filename, lineno, + NULL_TREE, nreverse ((yyvsp[-1].ttype)), current_delay, NULL_TREE); + MODULE_INSTANCES (current_module) = chainon ((yyval.ttype), MODULE_INSTANCES (current_module)); } break; -case 197: + + case 198: #line 1280 "parse.yy" -{ current_instance_module = yyvsp[-1].ttype; - current_instance_param = yyvsp[0].ttype; + { current_instance_module = (yyvsp[-1].ttype); + current_instance_param = (yyvsp[0].ttype); in_instantiation = 1; } break; -case 198: + + case 199: #line 1285 "parse.yy" -{ current_instance_module = NULL_TREE; + { current_instance_module = NULL_TREE; current_instance_param = NULL_TREE; in_instantiation = 0; } break; -case 199: + + case 200: #line 1316 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 200: + + case 201: #line 1318 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); } + { (yyval.ttype) = build_tree_list ((yyvsp[0].ttype), NULL_TREE); } break; -case 201: + + case 202: #line 1320 "parse.yy" -{ yyval.ttype = nreverse (yyvsp[-1].ttype); } + { (yyval.ttype) = nreverse ((yyvsp[-1].ttype)); } break; -case 202: + + case 203: #line 1322 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, NULL_TREE); } + { (yyval.ttype) = build_tree_list ((yyvsp[-1].ttype), NULL_TREE); } break; -case 203: + + case 204: #line 1324 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, NULL_TREE); - yyval.ttype = tree_cons (yyvsp[-3].ttype, NULL_TREE, yyval.ttype); + { (yyval.ttype) = build_tree_list ((yyvsp[-1].ttype), NULL_TREE); + (yyval.ttype) = tree_cons ((yyvsp[-3].ttype), NULL_TREE, (yyval.ttype)); } break; -case 204: + + case 205: #line 1328 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, NULL_TREE); - yyval.ttype = tree_cons (yyvsp[-3].ttype, NULL_TREE, yyval.ttype); - yyval.ttype = tree_cons (yyvsp[-5].ttype, NULL_TREE, yyval.ttype); + { (yyval.ttype) = build_tree_list ((yyvsp[-1].ttype), NULL_TREE); + (yyval.ttype) = tree_cons ((yyvsp[-3].ttype), NULL_TREE, (yyval.ttype)); + (yyval.ttype) = tree_cons ((yyvsp[-5].ttype), NULL_TREE, (yyval.ttype)); } break; -case 205: + + case 206: #line 1336 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); } + { (yyval.ttype) = build_tree_list ((yyvsp[0].ttype), NULL_TREE); } break; -case 206: + + case 207: #line 1338 "parse.yy" -{ yyval.ttype = tree_cons (yyvsp[0].ttype, NULL_TREE, yyvsp[-2].ttype); } + { (yyval.ttype) = tree_cons ((yyvsp[0].ttype), NULL_TREE, (yyvsp[-2].ttype)); } break; -case 207: + + case 208: #line 1365 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); } + { (yyval.ttype) = build_tree_list ((yyvsp[0].ttype), NULL_TREE); } break; -case 208: + + case 209: #line 1367 "parse.yy" -{ yyval.ttype = tree_cons (yyvsp[0].ttype, NULL_TREE, yyvsp[-2].ttype); yyerrok; } + { (yyval.ttype) = tree_cons ((yyvsp[0].ttype), NULL_TREE, (yyvsp[-2].ttype)); yyerrok; } break; -case 211: + + case 212: #line 1372 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 214: + + case 215: #line 1385 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 217: + + case 218: #line 1389 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 219: + + case 220: #line 1395 "parse.yy" -{ yyval.ttype = build_stmt (INSTANCE_NODE, lineno, check_non_reg (yyvsp[-3].ttype), + { (yyval.ttype) = build_stmt (INSTANCE_NODE, lineno, check_non_reg ((yyvsp[-3].ttype)), current_instance_module, - nreverse (yyvsp[-1].ttype), current_instance_param); - MODULE_INSTANCES (current_module) = chainon (yyval.ttype, + nreverse ((yyvsp[-1].ttype)), current_instance_param); + MODULE_INSTANCES (current_module) = chainon ((yyval.ttype), MODULE_INSTANCES (current_module)); // make_block_decl ($1, current_module, NULL_TREE); } break; -case 220: + + case 221: #line 1403 "parse.yy" -{ yyval.ttype = build_stmt (INSTANCE_NODE, lineno, NULL_TREE, + { (yyval.ttype) = build_stmt (INSTANCE_NODE, lineno, NULL_TREE, current_instance_module, - nreverse (yyvsp[-1].ttype), current_instance_param); - MODULE_INSTANCES (current_module) = chainon (yyval.ttype, + nreverse ((yyvsp[-1].ttype)), current_instance_param); + MODULE_INSTANCES (current_module) = chainon ((yyval.ttype), MODULE_INSTANCES (current_module)); } break; -case 224: + + case 225: #line 1419 "parse.yy" -{ yyerrok; - yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-2].ttype); + { yyerrok; + (yyval.ttype) = chainon ((yyvsp[0].ttype), (yyvsp[-2].ttype)); } break; -case 227: + + case 228: #line 1428 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); } + { (yyval.ttype) = build_tree_list ((yyvsp[0].ttype), NULL_TREE); } break; -case 228: + + case 229: #line 1430 "parse.yy" -{ yyval.ttype = build_tree_list (NULL_TREE, NULL_TREE); } + { (yyval.ttype) = build_tree_list (NULL_TREE, NULL_TREE); } break; -case 230: + + case 231: #line 1436 "parse.yy" -{ yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-2].ttype); } + { (yyval.ttype) = chainon ((yyvsp[0].ttype), (yyvsp[-2].ttype)); } break; -case 231: + + case 232: #line 1441 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[-3].ttype); } + { (yyval.ttype) = build_tree_list ((yyvsp[-1].ttype), (yyvsp[-3].ttype)); } break; -case 232: + + case 233: #line 1443 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 233: + + case 234: #line 1451 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; syn_warning ("INITIAL"); } break; -case 234: + + case 235: #line 1454 "parse.yy" -{ yyval.ttype = build_stmt (INITIAL_BLOCK, yyvsp[-1].ltype, yyvsp[0].ttype); } + { (yyval.ttype) = build_stmt (INITIAL_BLOCK, (yyvsp[-1].ltype), (yyvsp[0].ttype)); } break; -case 235: + + case 236: #line 1458 "parse.yy" -{ yyval.ltype = stmt_lineno; } + { (yyval.ltype) = stmt_lineno; } break; -case 236: + + case 237: #line 1460 "parse.yy" -{ yyval.ttype = build_stmt (ALWAYS_BLOCK, yyvsp[-1].ltype, yyvsp[0].ttype); } + { (yyval.ttype) = build_stmt (ALWAYS_BLOCK, (yyvsp[-1].ltype), (yyvsp[0].ttype)); } break; -case 238: + + case 239: #line 1466 "parse.yy" -{ yyval.ttype = build_stmt (NULL_STMT, lineno); } + { (yyval.ttype) = build_stmt (NULL_STMT, lineno); } break; -case 240: + + case 241: #line 1473 "parse.yy" -{ yyval.ltype = stmt_lineno; } + { (yyval.ltype) = stmt_lineno; } break; -case 241: + + case 242: #line 1475 "parse.yy" -{ yyval.ttype = build_stmt (IF_STMT, yyvsp[-5].ltype, yyvsp[-3].ttype, yyvsp[-1].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_stmt (IF_STMT, (yyvsp[-5].ltype), (yyvsp[-3].ttype), (yyvsp[-1].ttype), (yyvsp[0].ttype)); } break; -case 242: + + case 243: #line 1477 "parse.yy" -{ yyval.ttype = current_case; } + { (yyval.ttype) = current_case; } break; -case 243: + + case 244: #line 1479 "parse.yy" -{ current_case = yyvsp[0].ttype; } + { current_case = (yyvsp[0].ttype); } break; -case 244: + + case 245: #line 1481 "parse.yy" -{ STMT_CASE_EXPR (yyvsp[-6].ttype) = yyvsp[-3].ttype; - STMT_CASE_LIST (yyvsp[-6].ttype) = nreverse (yyvsp[-1].ttype); - current_case = yyvsp[-7].ttype; - yyval.ttype = yyvsp[-6].ttype; + { STMT_CASE_EXPR ((yyvsp[-6].ttype)) = (yyvsp[-3].ttype); + STMT_CASE_LIST ((yyvsp[-6].ttype)) = nreverse ((yyvsp[-1].ttype)); + current_case = (yyvsp[-7].ttype); + (yyval.ttype) = (yyvsp[-6].ttype); } break; -case 245: + + case 246: #line 1488 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; syn_warning ("FOREVER"); } break; -case 246: + + case 247: #line 1491 "parse.yy" -{ yyval.ttype = build_stmt (FOREVER_STMT, yyvsp[-1].ltype, yyvsp[0].ttype); } + { (yyval.ttype) = build_stmt (FOREVER_STMT, (yyvsp[-1].ltype), (yyvsp[0].ttype)); } break; -case 247: + + case 248: #line 1494 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; syn_warning ("REPEAT"); } break; -case 248: + + case 249: #line 1497 "parse.yy" -{ yyval.ttype = build_stmt (REPEAT_INIT_STMT, yyvsp[-4].ltype, yyvsp[0].ttype, yyvsp[-2].ttype); - tmp_tree = build_stmt (REPEAT_STMT, yyvsp[-4].ltype, yyval.ttype, yyvsp[-2].ttype); - chainon (yyvsp[0].ttype, tmp_tree); + { (yyval.ttype) = build_stmt (REPEAT_INIT_STMT, (yyvsp[-4].ltype), (yyvsp[0].ttype), (yyvsp[-2].ttype)); + tmp_tree = build_stmt (REPEAT_STMT, (yyvsp[-4].ltype), (yyval.ttype), (yyvsp[-2].ttype)); + chainon ((yyvsp[0].ttype), tmp_tree); } break; -case 249: + + case 250: #line 1503 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; syn_warning ("WHILE"); } break; -case 250: + + case 251: #line 1506 "parse.yy" -{ yyval.ttype = build_stmt (WHILE_STMT, yyvsp[-4].ltype, yyvsp[0].ttype, yyvsp[-2].ttype); } + { (yyval.ttype) = build_stmt (WHILE_STMT, (yyvsp[-4].ltype), (yyvsp[0].ttype), (yyvsp[-2].ttype)); } break; -case 251: + + case 252: #line 1508 "parse.yy" -{ yyval.ltype = stmt_lineno; } + { (yyval.ltype) = stmt_lineno; } break; -case 252: + + case 253: #line 1510 "parse.yy" -{ stmt_lineno = yyvsp[-8].ltype; - tmp_tree = build_stmt (FOR_STMT, yyvsp[-8].ltype, yyvsp[0].ttype, yyvsp[-2].ttype, yyvsp[-4].ttype); + { stmt_lineno = (yyvsp[-8].ltype); + tmp_tree = build_stmt (FOR_STMT, (yyvsp[-8].ltype), (yyvsp[0].ttype), (yyvsp[-2].ttype), (yyvsp[-4].ttype)); STMT_SURROGATE_ATTR (tmp_tree) = 1; - yyval.ttype = build_stmt (FOR_STMT, yyvsp[-8].ltype, yyvsp[0].ttype, yyvsp[-6].ttype, yyvsp[-4].ttype); - TREE_CHAIN (tmp_tree) = yyval.ttype; /* Fix this in pass 3 */ - chainon (yyvsp[0].ttype, tmp_tree); /* at end of statement sequence */ + (yyval.ttype) = build_stmt (FOR_STMT, (yyvsp[-8].ltype), (yyvsp[0].ttype), (yyvsp[-6].ttype), (yyvsp[-4].ttype)); + TREE_CHAIN (tmp_tree) = (yyval.ttype); /* Fix this in pass 3 */ + chainon ((yyvsp[0].ttype), tmp_tree); /* at end of statement sequence */ } break; -case 253: + + case 254: #line 1519 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; syn_warning ("delay control"); function_error; } break; -case 254: + + case 255: #line 1524 "parse.yy" -{ yyval.ttype = build_stmt (DELAY_STMT, yyvsp[-1].ltype, yyvsp[0].ttype, yyvsp[-2].ttype); } + { (yyval.ttype) = build_stmt (DELAY_STMT, (yyvsp[-1].ltype), (yyvsp[0].ttype), (yyvsp[-2].ttype)); } break; -case 255: + + case 256: #line 1527 "parse.yy" -{ stmt_lineno = lineno; + { stmt_lineno = lineno; function_error; } break; -case 256: + + case 257: #line 1531 "parse.yy" -{ STMT_BODY (yyvsp[-2].ttype) = yyvsp[0].ttype; - yyval.ttype = yyvsp[-2].ttype; + { STMT_BODY ((yyvsp[-2].ttype)) = (yyvsp[0].ttype); + (yyval.ttype) = (yyvsp[-2].ttype); } break; -case 257: + + case 258: #line 1536 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; function_error; } break; -case 258: + + case 259: #line 1540 "parse.yy" -{ yyval.ttype = build_stmt (ASSIGN_DELAY_STMT, yyvsp[-3].ltype, yyvsp[-5].ttype, - implicit_conversion (yyvsp[-5].ttype, yyvsp[-1].ttype), + { (yyval.ttype) = build_stmt (ASSIGN_DELAY_STMT, (yyvsp[-3].ltype), (yyvsp[-5].ttype), + implicit_conversion ((yyvsp[-5].ttype), (yyvsp[-1].ttype)), NULL_TREE, NULL_TREE, - build_stmt (DELAY_STMT, yyvsp[-3].ltype, yyvsp[-5].ttype, yyvsp[-2].ttype)); + build_stmt (DELAY_STMT, (yyvsp[-3].ltype), (yyvsp[-5].ttype), (yyvsp[-2].ttype))); } break; -case 259: + + case 260: #line 1547 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; function_error; } break; -case 260: + + case 261: #line 1551 "parse.yy" -{ yyval.ttype = build_stmt (ASSIGN_EVENT_STMT, yyvsp[-3].ltype, yyvsp[-5].ttype, - implicit_conversion (yyvsp[-5].ttype, yyvsp[-1].ttype), - NULL_TREE, NULL_TREE, yyvsp[-2].ttype); + { (yyval.ttype) = build_stmt (ASSIGN_EVENT_STMT, (yyvsp[-3].ltype), (yyvsp[-5].ttype), + implicit_conversion ((yyvsp[-5].ttype), (yyvsp[-1].ttype)), + NULL_TREE, NULL_TREE, (yyvsp[-2].ttype)); } break; -case 261: + + case 262: #line 1557 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; function_error; } break; -case 262: + + case 263: #line 1561 "parse.yy" -{ yyval.ttype = build_stmt (ASSIGN_NONBLK_DELAY_STMT, yyvsp[-2].ltype, yyvsp[-4].ttype, - implicit_conversion (yyvsp[-4].ttype, yyvsp[-1].ttype), + { (yyval.ttype) = build_stmt (ASSIGN_NONBLK_DELAY_STMT, (yyvsp[-2].ltype), (yyvsp[-4].ttype), + implicit_conversion ((yyvsp[-4].ttype), (yyvsp[-1].ttype)), NULL_TREE, NULL_TREE, - build_stmt (DELAY_STMT, yyvsp[-2].ltype, yyvsp[-4].ttype, integer_zero_node)); + build_stmt (DELAY_STMT, (yyvsp[-2].ltype), (yyvsp[-4].ttype), integer_zero_node)); } break; -case 263: + + case 264: #line 1568 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; function_error; } break; -case 264: + + case 265: #line 1572 "parse.yy" -{ yyval.ttype = build_stmt (ASSIGN_NONBLK_DELAY_STMT, yyvsp[-3].ltype, yyvsp[-5].ttype, - implicit_conversion (yyvsp[-5].ttype, yyvsp[-1].ttype), + { (yyval.ttype) = build_stmt (ASSIGN_NONBLK_DELAY_STMT, (yyvsp[-3].ltype), (yyvsp[-5].ttype), + implicit_conversion ((yyvsp[-5].ttype), (yyvsp[-1].ttype)), NULL_TREE, NULL_TREE, - build_stmt (DELAY_STMT, yyvsp[-3].ltype, yyvsp[-5].ttype, yyvsp[-2].ttype)); + build_stmt (DELAY_STMT, (yyvsp[-3].ltype), (yyvsp[-5].ttype), (yyvsp[-2].ttype))); } break; -case 265: + + case 266: #line 1579 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; function_error; } break; -case 266: + + case 267: #line 1583 "parse.yy" -{ yyval.ttype = build_stmt (ASSIGN_NONBLK_EVENT_STMT, yyvsp[-3].ltype, yyvsp[-5].ttype, - implicit_conversion (yyvsp[-5].ttype, yyvsp[-1].ttype), - NULL_TREE, NULL_TREE, yyvsp[-2].ttype); + { (yyval.ttype) = build_stmt (ASSIGN_NONBLK_EVENT_STMT, (yyvsp[-3].ltype), (yyvsp[-5].ttype), + implicit_conversion ((yyvsp[-5].ttype), (yyvsp[-1].ttype)), + NULL_TREE, NULL_TREE, (yyvsp[-2].ttype)); } break; -case 267: + + case 268: #line 1595 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; syn_warning ("WAIT"); function_error; } break; -case 268: + + case 269: #line 1600 "parse.yy" -{ yyval.ttype = build_stmt (WAIT_STMT, yyvsp[-4].ltype, yyvsp[0].ttype, yyvsp[-2].ttype); } + { (yyval.ttype) = build_stmt (WAIT_STMT, (yyvsp[-4].ltype), (yyvsp[0].ttype), (yyvsp[-2].ttype)); } break; -case 269: + + case 270: #line 1603 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; syn_warning ("Event trigger"); function_error; } break; -case 270: + + case 271: #line 1608 "parse.yy" -{ yyval.ttype= build_stmt (ARROW_STMT, yyvsp[-2].ltype, check_named_event (yyvsp[-1].ttype)); } + { (yyval.ttype)= build_stmt (ARROW_STMT, (yyvsp[-2].ltype), check_named_event ((yyvsp[-1].ttype))); } break; -case 275: + + case 276: #line 1614 "parse.yy" -{ yyval.ltype = stmt_lineno; } + { (yyval.ltype) = stmt_lineno; } break; -case 276: + + case 277: #line 1616 "parse.yy" -{ yyval.ttype = build_stmt (DISABLE_STMT, yyvsp[-2].ltype, yyvsp[-1].ttype); - HIERARCHICAL_ATTR (yyval.ttype) = HIERARCHICAL_ATTR (yyvsp[-1].ttype); + { (yyval.ttype) = build_stmt (DISABLE_STMT, (yyvsp[-2].ltype), (yyvsp[-1].ttype)); + HIERARCHICAL_ATTR ((yyval.ttype)) = HIERARCHICAL_ATTR ((yyvsp[-1].ttype)); } break; -case 277: + + case 278: #line 1621 "parse.yy" -{ yyval.ltype = stmt_lineno; } + { (yyval.ltype) = stmt_lineno; } break; -case 278: + + case 279: #line 1623 "parse.yy" -{ yyval.ttype = build_stmt (ASSIGN_PROC_STMT, yyvsp[-4].ltype, yyvsp[-3].ttype, yyvsp[-1].ttype, NULL_TREE, + { (yyval.ttype) = build_stmt (ASSIGN_PROC_STMT, (yyvsp[-4].ltype), (yyvsp[-3].ttype), (yyvsp[-1].ttype), NULL_TREE, NULL_TREE); } break; -case 279: + + case 280: #line 1627 "parse.yy" -{ yyval.ltype = stmt_lineno; } + { (yyval.ltype) = stmt_lineno; } break; -case 280: + + case 281: #line 1629 "parse.yy" -{ yyval.ttype = build_stmt (DEASSIGN_STMT, yyvsp[-2].ltype, yyvsp[-1].ttype); } + { (yyval.ttype) = build_stmt (DEASSIGN_STMT, (yyvsp[-2].ltype), (yyvsp[-1].ttype)); } break; -case 281: + + case 282: #line 1631 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; lval_type = LVAL_REG_NET; } break; -case 282: + + case 283: #line 1634 "parse.yy" -{ syn_warning ("FORCE"); - yyval.ttype = build_stmt (FORCE_STMT, yyvsp[-4].ltype, yyvsp[-3].ttype, yyvsp[-1].ttype, NULL_TREE, + { syn_warning ("FORCE"); + (yyval.ttype) = build_stmt (FORCE_STMT, (yyvsp[-4].ltype), (yyvsp[-3].ttype), (yyvsp[-1].ttype), NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE); lval_type = LVAL_REG; } break; -case 283: + + case 284: #line 1640 "parse.yy" -{ yyval.ltype = stmt_lineno; + { (yyval.ltype) = stmt_lineno; lval_type = LVAL_REG_NET; } break; -case 284: + + case 285: #line 1643 "parse.yy" -{ syn_warning ("RELEASE"); - yyval.ttype = build_stmt (RELEASE_STMT, yyvsp[-2].ltype, yyvsp[-1].ttype); + { syn_warning ("RELEASE"); + (yyval.ttype) = build_stmt (RELEASE_STMT, (yyvsp[-2].ltype), (yyvsp[-1].ttype)); lval_type = LVAL_REG; } break; -case 285: + + case 286: #line 1653 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 286: + + case 287: #line 1655 "parse.yy" -{ yyval.ttype = yyvsp[0].ttype; } + { (yyval.ttype) = (yyvsp[0].ttype); } break; -case 287: + + case 288: #line 1660 "parse.yy" -{ yyval.ttype = build_stmt (CASE_STMT, stmt_lineno, NULL_TREE, NULL_TREE, NULL_TREE); } + { (yyval.ttype) = build_stmt (CASE_STMT, stmt_lineno, NULL_TREE, NULL_TREE, NULL_TREE); } break; -case 288: + + case 289: #line 1662 "parse.yy" -{ yyval.ttype = build_stmt (CASEZ_STMT, stmt_lineno, NULL_TREE, NULL_TREE, NULL_TREE); } + { (yyval.ttype) = build_stmt (CASEZ_STMT, stmt_lineno, NULL_TREE, NULL_TREE, NULL_TREE); } break; -case 289: + + case 290: #line 1664 "parse.yy" -{ yyval.ttype = build_stmt (CASEX_STMT, stmt_lineno, NULL_TREE, NULL_TREE, NULL_TREE); } + { (yyval.ttype) = build_stmt (CASEX_STMT, stmt_lineno, NULL_TREE, NULL_TREE, NULL_TREE); } break; -case 290: + + case 291: #line 1675 "parse.yy" -{ yyval.ltype = stmt_lineno; } + { (yyval.ltype) = stmt_lineno; } break; -case 291: + + case 292: #line 1677 "parse.yy" -{ yyval.ttype = build_stmt (ASSIGN_STMT, yyvsp[-1].ltype, yyvsp[-3].ttype, - implicit_conversion (yyvsp[-3].ttype, yyvsp[0].ttype)); } + { (yyval.ttype) = build_stmt (ASSIGN_STMT, (yyvsp[-1].ltype), (yyvsp[-3].ttype), + implicit_conversion ((yyvsp[-3].ttype), (yyvsp[0].ttype))); } break; -case 293: + + case 294: #line 1684 "parse.yy" -{ yyerrok; - yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-1].ttype); + { yyerrok; + (yyval.ttype) = chainon ((yyvsp[0].ttype), (yyvsp[-1].ttype)); } break; -case 296: + + case 297: #line 1693 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_tree_list ((yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 297: + + case 298: #line 1696 "parse.yy" -{ if (STMT_CASE_DEFAULT (current_case)) + { if (STMT_CASE_DEFAULT (current_case)) error ("More than one 'DEFAULT' within CASE", NULL_CHAR, NULL_CHAR); - STMT_CASE_DEFAULT (current_case) = yyvsp[0].ttype; + STMT_CASE_DEFAULT (current_case) = (yyvsp[0].ttype); } break; -case 298: + + case 299: #line 1701 "parse.yy" -{ if (STMT_CASE_DEFAULT (current_case)) + { if (STMT_CASE_DEFAULT (current_case)) error ("More than one 'DEFAULT' within CASE", NULL_CHAR, NULL_CHAR); - STMT_CASE_DEFAULT (current_case) = yyvsp[0].ttype; + STMT_CASE_DEFAULT (current_case) = (yyvsp[0].ttype); } break; -case 299: + + case 300: #line 1709 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); } + { (yyval.ttype) = build_tree_list ((yyvsp[0].ttype), NULL_TREE); } break; -case 300: + + case 301: #line 1711 "parse.yy" -{ yyval.ttype = tree_cons (yyvsp[0].ttype, NULL_TREE, yyvsp[-2].ttype); } + { (yyval.ttype) = tree_cons ((yyvsp[0].ttype), NULL_TREE, (yyvsp[-2].ttype)); } break; -case 303: + + case 304: #line 1718 "parse.yy" -{ if( yyvsp[0].ttype != NULL_TREE ) { - yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); + { if( (yyvsp[0].ttype) != NULL_TREE ) { + (yyval.ttype) = build_tree_list ((yyvsp[0].ttype), NULL_TREE); } else { - yyval.ttype = yyvsp[0].ttype; + (yyval.ttype) = (yyvsp[0].ttype); } } break; -case 304: + + case 305: #line 1725 "parse.yy" -{ yyval.ttype = tree_cons (yyvsp[0].ttype, NULL_TREE, yyvsp[-2].ttype); } + { (yyval.ttype) = tree_cons ((yyvsp[0].ttype), NULL_TREE, (yyvsp[-2].ttype)); } break; -case 305: + + case 306: #line 1734 "parse.yy" -{ yyval.ttype = NULL_TREE; } + { (yyval.ttype) = NULL_TREE; } break; -case 307: + + case 308: #line 1740 "parse.yy" -{ yyval.ttype = build_stmt (BEGIN_STMT, stmt_lineno); } + { (yyval.ttype) = build_stmt (BEGIN_STMT, stmt_lineno); } break; -case 308: + + case 309: #line 1742 "parse.yy" -{ STMT_BODY (yyvsp[-2].ttype) = nreverse - (chainon (build_stmt (END_STMT, stmt_lineno), yyvsp[-1].ttype)); - yyval.ttype = yyvsp[-2].ttype; + { STMT_BODY ((yyvsp[-2].ttype)) = nreverse + (chainon (build_stmt (END_STMT, stmt_lineno), (yyvsp[-1].ttype))); + (yyval.ttype) = (yyvsp[-2].ttype); } break; -case 309: + + case 310: #line 1747 "parse.yy" -{ tmp_tree = make_node (NAMED_BLOCK); + { tmp_tree = make_node (NAMED_BLOCK); BLOCK_DOWN (current_scope) = chainon (tmp_tree, BLOCK_DOWN (current_scope)); BLOCK_UP (tmp_tree) = current_scope; - BLOCK_NAME (tmp_tree) = yyvsp[0].ttype; + BLOCK_NAME (tmp_tree) = (yyvsp[0].ttype); BLOCK_BODY (tmp_tree) = NULL_TREE; BLOCK_CONTEXT_LIST (tmp_tree) = NULL; - make_block_decl (check_block (yyvsp[0].ttype), current_scope, tmp_tree); + make_block_decl (check_block ((yyvsp[0].ttype)), current_scope, tmp_tree); current_scope = tmp_tree; push_scope (); - yyval.ttype = build_stmt (BEGIN_NAMED_STMT, stmt_lineno, + (yyval.ttype) = build_stmt (BEGIN_NAMED_STMT, stmt_lineno, NULL_TREE, tmp_tree); } break; -case 310: + + case 311: #line 1760 "parse.yy" -{ tmp_tree = build_stmt (END_NAMED_STMT, stmt_lineno, - NULL_TREE, STMT_BLOCK (yyvsp[-3].ttype)); + { tmp_tree = build_stmt (END_NAMED_STMT, stmt_lineno, + NULL_TREE, STMT_BLOCK ((yyvsp[-3].ttype))); /* STMT_BEGIN_NAMED_END ($4) = tmp_tree; */ - STMT_BODY (yyvsp[-3].ttype) = nreverse (chainon (tmp_tree, yyvsp[-1].ttype)); + STMT_BODY ((yyvsp[-3].ttype)) = nreverse (chainon (tmp_tree, (yyvsp[-1].ttype))); current_scope = pop_scope (); - yyval.ttype = yyvsp[-3].ttype; + (yyval.ttype) = (yyvsp[-3].ttype); } break; -case 311: + + case 312: #line 1771 "parse.yy" -{ yyval.ttype = build_stmt (FORK_STMT, stmt_lineno); } + { (yyval.ttype) = build_stmt (FORK_STMT, stmt_lineno); } break; -case 312: + + case 313: #line 1773 "parse.yy" -{ STMT_BODY (yyvsp[-2].ttype) = chainon /* thread JOIN to BEGINNING */ + { STMT_BODY ((yyvsp[-2].ttype)) = chainon /* thread JOIN to BEGINNING */ (build_stmt (JOIN_STMT, stmt_lineno, NULL_TREE), - nreverse (yyvsp[-1].ttype)); - yyval.ttype = yyvsp[-2].ttype; + nreverse ((yyvsp[-1].ttype))); + (yyval.ttype) = (yyvsp[-2].ttype); } break; -case 313: + + case 314: #line 1779 "parse.yy" -{ tmp_tree = make_node (NAMED_BLOCK); + { tmp_tree = make_node (NAMED_BLOCK); BLOCK_DOWN (current_scope) = chainon (tmp_tree, BLOCK_DOWN (current_scope)); BLOCK_UP (tmp_tree) = current_scope; - BLOCK_NAME (tmp_tree) = yyvsp[0].ttype; + BLOCK_NAME (tmp_tree) = (yyvsp[0].ttype); BLOCK_BODY (tmp_tree) = NULL_TREE; - make_block_decl (check_block (yyvsp[0].ttype), current_scope, tmp_tree); + make_block_decl (check_block ((yyvsp[0].ttype)), current_scope, tmp_tree); current_scope = tmp_tree; push_scope (); - yyval.ttype = build_stmt (FORK_NAMED_STMT, stmt_lineno, + (yyval.ttype) = build_stmt (FORK_NAMED_STMT, stmt_lineno, NULL_TREE, tmp_tree); } break; -case 314: + + case 315: #line 1791 "parse.yy" -{ tmp_tree = build_stmt (JOIN_NAMED_STMT, stmt_lineno, - NULL_TREE, STMT_BLOCK (yyvsp[-3].ttype)); + { tmp_tree = build_stmt (JOIN_NAMED_STMT, stmt_lineno, + NULL_TREE, STMT_BLOCK ((yyvsp[-3].ttype))); /* STMT_BEGIN_NAMED_END ($4) = tmp_tree; */ - STMT_BODY (yyvsp[-3].ttype) = chainon (tmp_tree, nreverse (yyvsp[-1].ttype)); + STMT_BODY ((yyvsp[-3].ttype)) = chainon (tmp_tree, nreverse ((yyvsp[-1].ttype))); current_scope = pop_scope (); - yyval.ttype = yyvsp[-3].ttype; + (yyval.ttype) = (yyvsp[-3].ttype); } break; -case 315: + + case 316: #line 1802 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 316: + + case 317: #line 1804 "parse.yy" -{ yyerrok; - yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-1].ttype); + { yyerrok; + (yyval.ttype) = chainon ((yyvsp[0].ttype), (yyvsp[-1].ttype)); } break; -case 318: + + case 319: #line 1812 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 319: + + case 320: #line 1814 "parse.yy" -{ yyerrok; - yyval.ttype = tree_cons (yyvsp[0].ttype, NULL_TREE, yyvsp[-1].ttype); + { yyerrok; + (yyval.ttype) = tree_cons ((yyvsp[0].ttype), NULL_TREE, (yyvsp[-1].ttype)); } break; -case 321: + + case 322: #line 1822 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 325: + + case 326: #line 1833 "parse.yy" -{ syn_warning ("task enable"); + { syn_warning ("task enable"); function_error; - yyval.ttype = build_stmt (TASK_STMT, lineno, IDENTIFIER_POINTER (yyvsp[-1].ttype), NULL_TREE); - HIERARCHICAL_ATTR (yyval.ttype) = HIERARCHICAL_ATTR (yyvsp[-1].ttype); + (yyval.ttype) = build_stmt (TASK_STMT, lineno, IDENTIFIER_POINTER ((yyvsp[-1].ttype)), NULL_TREE); + HIERARCHICAL_ATTR ((yyval.ttype)) = HIERARCHICAL_ATTR ((yyvsp[-1].ttype)); } break; -case 326: + + case 327: #line 1839 "parse.yy" -{ syn_warning ("task enable"); - yyval.ttype = build_stmt (TASK_STMT, lineno, IDENTIFIER_POINTER (yyvsp[-4].ttype), nreverse (yyvsp[-2].ttype)); - HIERARCHICAL_ATTR (yyval.ttype) = HIERARCHICAL_ATTR (yyvsp[-4].ttype); + { syn_warning ("task enable"); + (yyval.ttype) = build_stmt (TASK_STMT, lineno, IDENTIFIER_POINTER ((yyvsp[-4].ttype)), nreverse ((yyvsp[-2].ttype))); + HIERARCHICAL_ATTR ((yyval.ttype)) = HIERARCHICAL_ATTR ((yyvsp[-4].ttype)); } break; -case 327: + + case 328: #line 1847 "parse.yy" -{ yyval.ttype = build_stmt (SYSTASK_STMT, lineno, IDENTIFIER_POINTER (yyvsp[-1].ttype), NULL_TREE); } + { (yyval.ttype) = build_stmt (SYSTASK_STMT, lineno, IDENTIFIER_POINTER ((yyvsp[-1].ttype)), NULL_TREE); } break; -case 328: + + case 329: #line 1849 "parse.yy" -{ in_systask = 1; } + { in_systask = 1; } break; -case 329: + + case 330: #line 1851 "parse.yy" -{ yyval.ttype = build_stmt (SYSTASK_STMT, lineno, IDENTIFIER_POINTER (yyvsp[-5].ttype), nreverse (yyvsp[-2].ttype)); + { (yyval.ttype) = build_stmt (SYSTASK_STMT, lineno, IDENTIFIER_POINTER ((yyvsp[-5].ttype)), nreverse ((yyvsp[-2].ttype))); in_systask = 0; } break; -case 330: + + case 331: #line 1858 "parse.yy" -{ stmt_lineno = lineno; } + { stmt_lineno = lineno; } break; -case 331: + + case 332: #line 1860 "parse.yy" -{ stmt_lineno = lineno; } + { stmt_lineno = lineno; } break; -case 332: + + case 333: #line 1865 "parse.yy" -{ yyval.ttype = check_lval (yyvsp[0].ttype, lval_type, current_spec); } + { (yyval.ttype) = check_lval ((yyvsp[0].ttype), lval_type, current_spec); } break; -case 333: + + case 334: #line 1867 "parse.yy" -{ yyval.ttype = build_bit_ref ( - check_lval_nocheck (yyvsp[-3].ttype, lval_type, current_spec), yyvsp[-1].ttype); } + { (yyval.ttype) = build_bit_ref ( + check_lval_nocheck ((yyvsp[-3].ttype), lval_type, current_spec), (yyvsp[-1].ttype)); } break; -case 334: + + case 335: #line 1870 "parse.yy" -{ yyval.ttype = build_part_ref ( - check_lval_nocheck (yyvsp[-5].ttype, lval_type, current_spec), yyvsp[-3].ttype, yyvsp[-1].ttype); } + { (yyval.ttype) = build_part_ref ( + check_lval_nocheck ((yyvsp[-5].ttype), lval_type, current_spec), (yyvsp[-3].ttype), (yyvsp[-1].ttype)); } break; -case 335: + + case 336: #line 1880 "parse.yy" -{ + { } break; -case 336: + + case 337: #line 1883 "parse.yy" -{} + {} break; -case 337: + + case 338: #line 1889 "parse.yy" -{} + {} break; -case 338: + + case 339: #line 1894 "parse.yy" -{ yyval.ttype = NULL; } + { (yyval.ttype) = NULL; } break; -case 339: + + case 340: #line 1896 "parse.yy" -{ yyerrok; - yyval.ttype = NULL; + { yyerrok; + (yyval.ttype) = NULL; // $$ = chainon ($2, $1); } break; -case 343: + + case 344: #line 1906 "parse.yy" -{ - if( yyvsp[0].ttype!=NULL_TREE ) { - STMT_SOURCE_LINE(yyvsp[0].ttype) = stmt_lineno; - STMT_SOURCE_FILE(yyvsp[0].ttype) = input_filename; + { + if( (yyvsp[0].ttype)!=NULL_TREE ) { + STMT_SOURCE_LINE((yyvsp[0].ttype)) = stmt_lineno; + STMT_SOURCE_FILE((yyvsp[0].ttype)) = input_filename; MODULE_SPECDEFS(current_module) = - chainon(MODULE_SPECDEFS(current_module),yyvsp[0].ttype); + chainon(MODULE_SPECDEFS(current_module),(yyvsp[0].ttype)); } } break; -case 344: + + case 345: #line 1924 "parse.yy" -{ current_spec = make_param_spec (NULL_TREE); } + { current_spec = make_param_spec (NULL_TREE); } break; -case 345: + + case 346: #line 1926 "parse.yy" -{ - specify_save_param_list( current_module, yyvsp[-1].ttype ); + { + specify_save_param_list( current_module, (yyvsp[-1].ttype) ); } break; -case 346: + + case 347: #line 1933 "parse.yy" -{ - PATH_CONDITION(yyvsp[-3].ttype) = yyvsp[-4].ttype; - PATH_DELAYS(yyvsp[-3].ttype) = yyvsp[-1].ttype; + { + PATH_CONDITION((yyvsp[-3].ttype)) = (yyvsp[-4].ttype); + PATH_DELAYS((yyvsp[-3].ttype)) = (yyvsp[-1].ttype); MODULE_SPECDEFS(current_module) = - chainon(MODULE_SPECDEFS(current_module),check_path(yyvsp[-3].ttype)); + chainon(MODULE_SPECDEFS(current_module),check_path((yyvsp[-3].ttype))); } break; -case 347: + + case 348: #line 1947 "parse.yy" -{ - yyval.ttype = build_path( nreverse(yyvsp[-7].ttype), nreverse(yyvsp[-4].ttype), yyvsp[-2].ttype, NULL_TREE, NULL_TREE, - yyvsp[-6].integer, 0, 0 ); + { + (yyval.ttype) = build_path( nreverse((yyvsp[-7].ttype)), nreverse((yyvsp[-4].ttype)), (yyvsp[-2].ttype), NULL_TREE, NULL_TREE, + (yyvsp[-6].integer), 0, 0 ); } break; -case 348: + + case 349: #line 1955 "parse.yy" -{ - yyval.ttype = build_path( nreverse(yyvsp[-7].ttype), nreverse(yyvsp[-4].ttype), yyvsp[-2].ttype, NULL_TREE, NULL_TREE, - yyvsp[-6].integer, yyvsp[-8].integer, 0 ); + { + (yyval.ttype) = build_path( nreverse((yyvsp[-7].ttype)), nreverse((yyvsp[-4].ttype)), (yyvsp[-2].ttype), NULL_TREE, NULL_TREE, + (yyvsp[-6].integer), (yyvsp[-8].integer), 0 ); } break; -case 349: + + case 350: #line 1963 "parse.yy" -{ - yyval.ttype = build_path( nreverse(yyvsp[-8].ttype), nreverse(yyvsp[-5].ttype), yyvsp[-2].ttype, NULL_TREE, NULL_TREE, - yyvsp[-7].integer, 0, yyvsp[-4].integer ); + { + (yyval.ttype) = build_path( nreverse((yyvsp[-8].ttype)), nreverse((yyvsp[-5].ttype)), (yyvsp[-2].ttype), NULL_TREE, NULL_TREE, + (yyvsp[-7].integer), 0, (yyvsp[-4].integer) ); } break; -case 350: + + case 351: #line 1971 "parse.yy" -{ - yyval.ttype = build_path( nreverse(yyvsp[-8].ttype), nreverse(yyvsp[-5].ttype), yyvsp[-2].ttype, NULL_TREE, NULL_TREE, - yyvsp[-7].integer, yyvsp[-9].integer, yyvsp[-4].integer ); + { + (yyval.ttype) = build_path( nreverse((yyvsp[-8].ttype)), nreverse((yyvsp[-5].ttype)), (yyvsp[-2].ttype), NULL_TREE, NULL_TREE, + (yyvsp[-7].integer), (yyvsp[-9].integer), (yyvsp[-4].integer) ); } break; -case 351: + + case 352: #line 1977 "parse.yy" -{ - yyval.ttype = build_path( nreverse(yyvsp[-3].ttype), nreverse(yyvsp[-1].ttype), NULL_TREE, NULL_TREE, NULL_TREE, - yyvsp[-2].integer, 0, 0 ); + { + (yyval.ttype) = build_path( nreverse((yyvsp[-3].ttype)), nreverse((yyvsp[-1].ttype)), NULL_TREE, NULL_TREE, NULL_TREE, + (yyvsp[-2].integer), 0, 0 ); } break; -case 352: + + case 353: #line 1983 "parse.yy" -{ - yyval.ttype = build_path( nreverse(yyvsp[-4].ttype), nreverse(yyvsp[-1].ttype), NULL_TREE, NULL_TREE, NULL_TREE, - yyvsp[-2].integer, 0, yyvsp[-3].integer ); + { + (yyval.ttype) = build_path( nreverse((yyvsp[-4].ttype)), nreverse((yyvsp[-1].ttype)), NULL_TREE, NULL_TREE, NULL_TREE, + (yyvsp[-2].integer), 0, (yyvsp[-3].integer) ); } break; -case 354: + + case 355: #line 1991 "parse.yy" -{ yyerrok; - yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-2].ttype); + { yyerrok; + (yyval.ttype) = chainon ((yyvsp[0].ttype), (yyvsp[-2].ttype)); } break; -case 356: + + case 357: #line 1996 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 359: + + case 360: #line 2002 "parse.yy" -{ yyerrok; - yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-2].ttype); + { yyerrok; + (yyval.ttype) = chainon ((yyvsp[0].ttype), (yyvsp[-2].ttype)); } break; -case 361: + + case 362: #line 2007 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 363: + + case 364: #line 2012 "parse.yy" -{ - yyval.ttype = build_tree_list( check_input_port(yyvsp[0].ttype), NULL_TREE ); + { + (yyval.ttype) = build_tree_list( check_input_port((yyvsp[0].ttype)), NULL_TREE ); } break; -case 364: + + case 365: #line 2016 "parse.yy" -{ - yyval.ttype = build_tree_list( build_bit_ref (check_input_port(yyvsp[-3].ttype), yyvsp[-1].ttype), NULL_TREE ); + { + (yyval.ttype) = build_tree_list( build_bit_ref (check_input_port((yyvsp[-3].ttype)), (yyvsp[-1].ttype)), NULL_TREE ); } break; -case 365: + + case 366: #line 2020 "parse.yy" -{ - yyval.ttype = build_tree_list( build_part_ref (check_input_port(yyvsp[-5].ttype), yyvsp[-3].ttype, yyvsp[-1].ttype), NULL_TREE ); + { + (yyval.ttype) = build_tree_list( build_part_ref (check_input_port((yyvsp[-5].ttype)), (yyvsp[-3].ttype), (yyvsp[-1].ttype)), NULL_TREE ); } break; -case 366: + + case 367: #line 2026 "parse.yy" -{ - yyval.ttype = build_tree_list( check_output_port(yyvsp[0].ttype), NULL_TREE ); + { + (yyval.ttype) = build_tree_list( check_output_port((yyvsp[0].ttype)), NULL_TREE ); } break; -case 367: + + case 368: #line 2030 "parse.yy" -{ - yyval.ttype = build_tree_list( build_bit_ref (check_output_port(yyvsp[-3].ttype), yyvsp[-1].ttype), NULL_TREE ); + { + (yyval.ttype) = build_tree_list( build_bit_ref (check_output_port((yyvsp[-3].ttype)), (yyvsp[-1].ttype)), NULL_TREE ); } break; -case 368: + + case 369: #line 2034 "parse.yy" -{ - yyval.ttype = build_tree_list( build_part_ref (check_output_port(yyvsp[-5].ttype), yyvsp[-3].ttype, yyvsp[-1].ttype), NULL_TREE ); + { + (yyval.ttype) = build_tree_list( build_part_ref (check_output_port((yyvsp[-5].ttype)), (yyvsp[-3].ttype), (yyvsp[-1].ttype)), NULL_TREE ); } break; -case 370: + + case 371: #line 2041 "parse.yy" -{ - yyval.ttype = chainon( yyvsp[-3].ttype, yyvsp[-1].ttype ); + { + (yyval.ttype) = chainon( (yyvsp[-3].ttype), (yyvsp[-1].ttype) ); } break; -case 371: + + case 372: #line 2046 "parse.yy" -{ + { tree t; - t = chainon( yyvsp[-5].ttype, yyvsp[-3].ttype ); - yyval.ttype = chainon( t, yyvsp[-1].ttype ); + t = chainon( (yyvsp[-5].ttype), (yyvsp[-3].ttype) ); + (yyval.ttype) = chainon( t, (yyvsp[-1].ttype) ); } break; -case 372: + + case 373: #line 2054 "parse.yy" -{ + { tree t; - t = chainon( yyvsp[-11].ttype, yyvsp[-9].ttype ); - t = chainon( t, yyvsp[-7].ttype ); - t = chainon( t, yyvsp[-5].ttype ); - t = chainon( t, yyvsp[-3].ttype ); - yyval.ttype = chainon( t, yyvsp[-1].ttype ); + t = chainon( (yyvsp[-11].ttype), (yyvsp[-9].ttype) ); + t = chainon( t, (yyvsp[-7].ttype) ); + t = chainon( t, (yyvsp[-5].ttype) ); + t = chainon( t, (yyvsp[-3].ttype) ); + (yyval.ttype) = chainon( t, (yyvsp[-1].ttype) ); } break; -case 373: + + case 374: #line 2065 "parse.yy" -{ - yyval.ttype = build_tree_list(yyvsp[0].ttype,NULL_TREE); + { + (yyval.ttype) = build_tree_list((yyvsp[0].ttype),NULL_TREE); } break; -case 374: + + case 375: #line 2071 "parse.yy" -{ - yyval.integer = 1; + { + (yyval.integer) = 1; } break; -case 375: + + case 376: #line 2075 "parse.yy" -{ - yyval.integer = -1; + { + (yyval.integer) = -1; } break; -case 376: + + case 377: #line 2081 "parse.yy" -{ - yyval.integer = FALSE; + { + (yyval.integer) = FALSE; } break; -case 377: + + case 378: #line 2085 "parse.yy" -{ - yyval.integer = TRUE; + { + (yyval.integer) = TRUE; } break; -case 380: + + case 381: #line 2099 "parse.yy" -{ - yyval.integer = 1; + { + (yyval.integer) = 1; } break; -case 381: + + case 382: #line 2103 "parse.yy" -{ - yyval.integer = -1; + { + (yyval.integer) = -1; } break; -case 382: + + case 383: #line 2109 "parse.yy" -{ - yyval.ttype = 0; + { + (yyval.ttype) = 0; } break; -case 383: + + case 384: #line 2113 "parse.yy" -{ - yyval.ttype = yyvsp[-1].ttype; + { + (yyval.ttype) = (yyvsp[-1].ttype); } break; -case 384: + + case 385: #line 2121 "parse.yy" -{ - yyval.ttype = build_timing_statement( SETUP, yyvsp[-7].ttype, yyvsp[-5].ttype, yyvsp[-3].ttype, NULL_TREE, yyvsp[-2].ttype ); + { + (yyval.ttype) = build_timing_statement( SETUP, (yyvsp[-7].ttype), (yyvsp[-5].ttype), (yyvsp[-3].ttype), NULL_TREE, (yyvsp[-2].ttype) ); } break; -case 385: + + case 386: #line 2126 "parse.yy" -{ - yyval.ttype = build_timing_statement( HOLD, yyvsp[-7].ttype, yyvsp[-5].ttype, yyvsp[-3].ttype, NULL_TREE, yyvsp[-2].ttype ); + { + (yyval.ttype) = build_timing_statement( HOLD, (yyvsp[-7].ttype), (yyvsp[-5].ttype), (yyvsp[-3].ttype), NULL_TREE, (yyvsp[-2].ttype) ); } break; -case 386: + + case 387: #line 2131 "parse.yy" -{ - yyval.ttype = build_timing_statement( PERIOD, yyvsp[-5].ttype, NULL_TREE, yyvsp[-3].ttype, NULL_TREE, yyvsp[-2].ttype ); + { + (yyval.ttype) = build_timing_statement( PERIOD, (yyvsp[-5].ttype), NULL_TREE, (yyvsp[-3].ttype), NULL_TREE, (yyvsp[-2].ttype) ); } break; -case 387: + + case 388: #line 2136 "parse.yy" -{ - yyval.ttype = build_timing_statement( WIDTH, yyvsp[-4].ttype, NULL_TREE, yyvsp[-2].ttype, NULL_TREE, NULL_TREE ); + { + (yyval.ttype) = build_timing_statement( WIDTH, (yyvsp[-4].ttype), NULL_TREE, (yyvsp[-2].ttype), NULL_TREE, NULL_TREE ); } break; -case 388: + + case 389: #line 2141 "parse.yy" -{ - yyval.ttype = build_timing_statement( WIDTH, yyvsp[-7].ttype, NULL_TREE, yyvsp[-5].ttype, yyvsp[-3].ttype, yyvsp[-2].ttype ); + { + (yyval.ttype) = build_timing_statement( WIDTH, (yyvsp[-7].ttype), NULL_TREE, (yyvsp[-5].ttype), (yyvsp[-3].ttype), (yyvsp[-2].ttype) ); } break; -case 389: + + case 390: #line 2146 "parse.yy" -{ - yyval.ttype = build_timing_statement( SKEW, yyvsp[-7].ttype, yyvsp[-5].ttype, yyvsp[-3].ttype, NULL_TREE, yyvsp[-2].ttype ); + { + (yyval.ttype) = build_timing_statement( SKEW, (yyvsp[-7].ttype), (yyvsp[-5].ttype), (yyvsp[-3].ttype), NULL_TREE, (yyvsp[-2].ttype) ); } break; -case 390: + + case 391: #line 2151 "parse.yy" -{ - yyval.ttype = build_timing_statement( RECOVERY, yyvsp[-7].ttype, yyvsp[-5].ttype, yyvsp[-3].ttype, NULL_TREE, yyvsp[-2].ttype ); + { + (yyval.ttype) = build_timing_statement( RECOVERY, (yyvsp[-7].ttype), (yyvsp[-5].ttype), (yyvsp[-3].ttype), NULL_TREE, (yyvsp[-2].ttype) ); } break; -case 391: + + case 392: #line 2156 "parse.yy" -{ - yyval.ttype = build_timing_statement( SETUPHOLD, yyvsp[-9].ttype, yyvsp[-7].ttype, yyvsp[-5].ttype, yyvsp[-3].ttype, yyvsp[-2].ttype ); + { + (yyval.ttype) = build_timing_statement( SETUPHOLD, (yyvsp[-9].ttype), (yyvsp[-7].ttype), (yyvsp[-5].ttype), (yyvsp[-3].ttype), (yyvsp[-2].ttype) ); } break; -case 392: + + case 393: #line 2161 "parse.yy" -{ - yyval.ttype = NULL_TREE; + { + (yyval.ttype) = NULL_TREE; } break; -case 393: + + case 394: #line 2167 "parse.yy" -{ - yyval.ttype = 0; + { + (yyval.ttype) = 0; } break; -case 394: + + case 395: #line 2171 "parse.yy" -{ - yyval.ttype = yyvsp[0].ttype; + { + (yyval.ttype) = (yyvsp[0].ttype); } break; -case 396: + + case 397: #line 2180 "parse.yy" -{ - yyval.ttype = build_timing_event( yyvsp[-1].integer, yyvsp[0].ttype, NULL_TREE ); + { + (yyval.ttype) = build_timing_event( (yyvsp[-1].integer), (yyvsp[0].ttype), NULL_TREE ); } break; -case 397: + + case 398: #line 2185 "parse.yy" -{ - yyval.ttype = build_timing_event( yyvsp[-3].integer, yyvsp[-2].ttype, yyvsp[0].ttype ); + { + (yyval.ttype) = build_timing_event( (yyvsp[-3].integer), (yyvsp[-2].ttype), (yyvsp[0].ttype) ); } break; -case 398: + + case 399: #line 2191 "parse.yy" -{ - yyval.ttype = build_timing_event( yyvsp[-1].integer, yyvsp[0].ttype, NULL_TREE ); + { + (yyval.ttype) = build_timing_event( (yyvsp[-1].integer), (yyvsp[0].ttype), NULL_TREE ); } break; -case 399: + + case 400: #line 2196 "parse.yy" -{ - yyval.ttype = build_timing_event( yyvsp[-3].integer, yyvsp[-2].ttype, yyvsp[0].ttype ); + { + (yyval.ttype) = build_timing_event( (yyvsp[-3].integer), (yyvsp[-2].ttype), (yyvsp[0].ttype) ); } break; -case 400: + + case 401: #line 2202 "parse.yy" -{ + { extern unsigned int alledgeMask; - yyval.integer = alledgeMask; + (yyval.integer) = alledgeMask; } break; -case 401: + + case 402: #line 2207 "parse.yy" -{ + { extern unsigned int posedgeMask; - yyval.integer = posedgeMask; + (yyval.integer) = posedgeMask; } break; -case 402: + + case 403: #line 2212 "parse.yy" -{ + { extern unsigned int negedgeMask; - yyval.integer = negedgeMask; + (yyval.integer) = negedgeMask; } break; -case 403: + + case 404: #line 2217 "parse.yy" -{ extern int enable_edge_digit; + { extern int enable_edge_digit; enable_edge_digit = TRUE; } break; -case 404: + + case 405: #line 2221 "parse.yy" -{ + { extern int enable_edge_digit; enable_edge_digit = FALSE; - yyval.integer = yyvsp[-1].integer; + (yyval.integer) = (yyvsp[-1].integer); } break; -case 405: + + case 406: #line 2229 "parse.yy" -{ + { extern unsigned int posedgeMask; - yyval.integer = posedgeMask; + (yyval.integer) = posedgeMask; } break; -case 406: + + case 407: #line 2234 "parse.yy" -{ + { extern unsigned int negedgeMask; - yyval.integer = negedgeMask; + (yyval.integer) = negedgeMask; } break; -case 407: + + case 408: #line 2239 "parse.yy" -{ extern int enable_edge_digit; + { extern int enable_edge_digit; enable_edge_digit = TRUE; } break; -case 408: + + case 409: #line 2243 "parse.yy" -{ + { extern int enable_edge_digit; enable_edge_digit = FALSE; - yyval.integer = yyvsp[-1].integer; + (yyval.integer) = (yyvsp[-1].integer); } break; -case 409: + + case 410: #line 2251 "parse.yy" -{ + { extern unsigned int edge_mask[4][4]; - yyval.integer = edge_mask[yyvsp[0].double_digit[0]][yyvsp[0].double_digit[1]]; + (yyval.integer) = edge_mask[(yyvsp[0].double_digit)[0]][(yyvsp[0].double_digit)[1]]; } break; -case 410: + + case 411: #line 2256 "parse.yy" -{ + { extern unsigned int edge_mask[4][4]; - yyval.integer = yyvsp[0].integer | edge_mask[yyvsp[-2].double_digit[0]][yyvsp[-2].double_digit[1]]; + (yyval.integer) = (yyvsp[0].integer) | edge_mask[(yyvsp[-2].double_digit)[0]][(yyvsp[-2].double_digit)[1]]; } break; -case 411: + + case 412: #line 2261 "parse.yy" -{ - yyval.integer = 0; + { + (yyval.integer) = 0; } break; -case 413: + + case 414: #line 2268 "parse.yy" -{ yyval.ttype = yyvsp[-1].ttype; } + { (yyval.ttype) = (yyvsp[-1].ttype); } break; -case 414: + + case 415: #line 2270 "parse.yy" -{ yyval.ttype = build_unary_op (BIT_NOT_EXPR, yyvsp[0].ttype); } + { (yyval.ttype) = build_unary_op (BIT_NOT_EXPR, (yyvsp[0].ttype)); } break; -case 415: + + case 416: #line 2272 "parse.yy" -{ yyval.ttype = build_binary_op (EQ_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (EQ_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 416: + + case 417: #line 2274 "parse.yy" -{ yyval.ttype = build_binary_op (EQ_CASE_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (EQ_CASE_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 417: + + case 418: #line 2276 "parse.yy" -{ yyval.ttype = build_binary_op (NE_CASE_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (NE_CASE_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 418: + + case 419: #line 2278 "parse.yy" -{ yyval.ttype = build_binary_op (NE_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (NE_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 419: + + case 420: #line 2282 "parse.yy" -{ yyval.ttype = check_rval (yyvsp[0].ttype); } + { (yyval.ttype) = check_rval ((yyvsp[0].ttype)); } break; -case 420: + + case 421: #line 2286 "parse.yy" -{ - yyval.ttype = check_one_bit_constant(yyvsp[0].ttype); + { + (yyval.ttype) = check_one_bit_constant((yyvsp[0].ttype)); } break; -case 421: + + case 422: #line 2290 "parse.yy" -{ - yyval.ttype = check_one_bit_constant(yyvsp[0].ttype); + { + (yyval.ttype) = check_one_bit_constant((yyvsp[0].ttype)); } break; -case 422: + + case 423: #line 2297 "parse.yy" -{ - check_input_port(yyvsp[0].ttype); - yyval.ttype = check_rval (yyvsp[0].ttype); + { + check_input_port((yyvsp[0].ttype)); + (yyval.ttype) = check_rval ((yyvsp[0].ttype)); } break; -case 423: + + case 424: #line 2302 "parse.yy" -{ - check_input_port(yyvsp[-3].ttype); - yyval.ttype = build_bit_ref ( check_rval_nocheck (yyvsp[-3].ttype), yyvsp[-1].ttype); + { + check_input_port((yyvsp[-3].ttype)); + (yyval.ttype) = build_bit_ref ( check_rval_nocheck ((yyvsp[-3].ttype)), (yyvsp[-1].ttype)); } break; -case 424: + + case 425: #line 2307 "parse.yy" -{ - check_input_port(yyvsp[-5].ttype); - yyval.ttype = build_part_ref ( check_rval_nocheck (yyvsp[-5].ttype), yyvsp[-3].ttype, yyvsp[-1].ttype); + { + check_input_port((yyvsp[-5].ttype)); + (yyval.ttype) = build_part_ref ( check_rval_nocheck ((yyvsp[-5].ttype)), (yyvsp[-3].ttype), (yyvsp[-1].ttype)); } break; -case 425: + + case 426: #line 2320 "parse.yy" -{ yyval.ttype = make_node (CONCAT_REF); - CONCAT_LIST (yyval.ttype) = yyvsp[-1].ttype; - concat_labels (yyval.ttype); + { (yyval.ttype) = make_node (CONCAT_REF); + CONCAT_LIST ((yyval.ttype)) = (yyvsp[-1].ttype); + concat_labels ((yyval.ttype)); } break; -case 426: + + case 427: #line 2328 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); } + { (yyval.ttype) = build_tree_list ((yyvsp[0].ttype), NULL_TREE); } break; -case 427: + + case 428: #line 2330 "parse.yy" -{ yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); } + { (yyval.ttype) = build_tree_list ((yyvsp[0].ttype), NULL_TREE); } break; -case 428: + + case 429: #line 2332 "parse.yy" -{ yyval.ttype = tree_cons (yyvsp[0].ttype, NULL_TREE, yyvsp[-2].ttype); } + { (yyval.ttype) = tree_cons ((yyvsp[0].ttype), NULL_TREE, (yyvsp[-2].ttype)); } break; -case 429: + + case 430: #line 2334 "parse.yy" -{ yyval.ttype = tree_cons (yyvsp[0].ttype, NULL_TREE, yyvsp[-2].ttype); } + { (yyval.ttype) = tree_cons ((yyvsp[0].ttype), NULL_TREE, (yyvsp[-2].ttype)); } break; -case 436: + + case 437: #line 2348 "parse.yy" -{ if (!TREE_CONSTANT_ATTR (yyvsp[0].ttype)) { + { if (!TREE_CONSTANT_ATTR ((yyvsp[0].ttype))) { error ("Illegal non-constant expression", NULL_CHAR, NULL_CHAR); - yyval.ttype = error_mark_node; + (yyval.ttype) = error_mark_node; } else - yyval.ttype = yyvsp[0].ttype; + (yyval.ttype) = (yyvsp[0].ttype); } break; -case 438: + + case 439: #line 2360 "parse.yy" -{ switch (delay_type) { - case (MIN_DELAY): yyval.ttype = yyvsp[-4].ttype; break; - case (TYP_DELAY): yyval.ttype = yyvsp[-2].ttype; break; - case (MAX_DELAY): yyval.ttype = yyvsp[0].ttype; break; + { switch (delay_type) { + case (MIN_DELAY): (yyval.ttype) = (yyvsp[-4].ttype); break; + case (TYP_DELAY): (yyval.ttype) = (yyvsp[-2].ttype); break; + case (MAX_DELAY): (yyval.ttype) = (yyvsp[0].ttype); break; } } break; -case 439: + + case 440: #line 2370 "parse.yy" -{ switch (delay_type) { - case (MIN_DELAY): yyval.ttype = yyvsp[-4].ttype; break; - case (TYP_DELAY): yyval.ttype = yyvsp[-2].ttype; break; - case (MAX_DELAY): yyval.ttype = yyvsp[0].ttype; break; + { switch (delay_type) { + case (MIN_DELAY): (yyval.ttype) = (yyvsp[-4].ttype); break; + case (TYP_DELAY): (yyval.ttype) = (yyvsp[-2].ttype); break; + case (MAX_DELAY): (yyval.ttype) = (yyvsp[0].ttype); break; } } break; -case 441: + + case 442: #line 2381 "parse.yy" -{ yyval.ttype = yyvsp[0].ttype; } + { (yyval.ttype) = (yyvsp[0].ttype); } break; -case 442: + + case 443: #line 2383 "parse.yy" -{ yyval.ttype = build_unary_op (NEGATE_EXPR, yyvsp[0].ttype); } + { (yyval.ttype) = build_unary_op (NEGATE_EXPR, (yyvsp[0].ttype)); } break; -case 443: + + case 444: #line 2385 "parse.yy" -{ yyval.ttype = build_unary_op (TRUTH_NOT_EXPR, yyvsp[0].ttype); } + { (yyval.ttype) = build_unary_op (TRUTH_NOT_EXPR, (yyvsp[0].ttype)); } break; -case 444: + + case 445: #line 2387 "parse.yy" -{ yyval.ttype = build_unary_op (BIT_NOT_EXPR, yyvsp[0].ttype); } + { (yyval.ttype) = build_unary_op (BIT_NOT_EXPR, (yyvsp[0].ttype)); } break; -case 445: + + case 446: #line 2389 "parse.yy" -{ yyval.ttype = build_unary_op (AND_REDUCE_EXPR, yyvsp[0].ttype); } + { (yyval.ttype) = build_unary_op (AND_REDUCE_EXPR, (yyvsp[0].ttype)); } break; -case 446: + + case 447: #line 2391 "parse.yy" -{ yyval.ttype = build_unary_op (NAND_REDUCE_EXPR, yyvsp[0].ttype); } + { (yyval.ttype) = build_unary_op (NAND_REDUCE_EXPR, (yyvsp[0].ttype)); } break; -case 447: + + case 448: #line 2393 "parse.yy" -{ yyval.ttype = build_unary_op (OR_REDUCE_EXPR, yyvsp[0].ttype); } + { (yyval.ttype) = build_unary_op (OR_REDUCE_EXPR, (yyvsp[0].ttype)); } break; -case 448: + + case 449: #line 2395 "parse.yy" -{ yyval.ttype = build_unary_op (NOR_REDUCE_EXPR, yyvsp[0].ttype); } + { (yyval.ttype) = build_unary_op (NOR_REDUCE_EXPR, (yyvsp[0].ttype)); } break; -case 449: + + case 450: #line 2397 "parse.yy" -{ yyval.ttype = build_unary_op (XOR_REDUCE_EXPR, yyvsp[0].ttype); } + { (yyval.ttype) = build_unary_op (XOR_REDUCE_EXPR, (yyvsp[0].ttype)); } break; -case 450: + + case 451: #line 2399 "parse.yy" -{ yyval.ttype = build_unary_op (XNOR_REDUCE_EXPR, yyvsp[0].ttype); } + { (yyval.ttype) = build_unary_op (XNOR_REDUCE_EXPR, (yyvsp[0].ttype)); } break; -case 451: + + case 452: #line 2401 "parse.yy" -{ yyval.ttype = build_binary_op (PLUS_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (PLUS_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 452: + + case 453: #line 2403 "parse.yy" -{ yyval.ttype = build_binary_op (MINUS_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (MINUS_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 453: + + case 454: #line 2405 "parse.yy" -{ yyval.ttype = build_binary_op (MULT_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (MULT_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 454: + + case 455: #line 2407 "parse.yy" -{ syn_warning ("Division operator"); } + { syn_warning ("Division operator"); } break; -case 455: + + case 456: #line 2409 "parse.yy" -{ yyval.ttype = build_binary_op (DIV_EXPR, yyvsp[-3].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (DIV_EXPR, (yyvsp[-3].ttype), (yyvsp[0].ttype)); } break; -case 456: + + case 457: #line 2411 "parse.yy" -{ syn_warning ("Modulus operator"); } + { syn_warning ("Modulus operator"); } break; -case 457: + + case 458: #line 2413 "parse.yy" -{ yyval.ttype = build_binary_op (MOD_EXPR, yyvsp[-3].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (MOD_EXPR, (yyvsp[-3].ttype), (yyvsp[0].ttype)); } break; -case 458: + + case 459: #line 2415 "parse.yy" -{ yyval.ttype = build_binary_op (EQ_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (EQ_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 459: + + case 460: #line 2417 "parse.yy" -{ yyval.ttype = build_binary_op (NE_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (NE_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 460: + + case 461: #line 2419 "parse.yy" -{ syn_warning ("Case equality"); } + { syn_warning ("Case equality"); } break; -case 461: + + case 462: #line 2421 "parse.yy" -{ yyval.ttype = build_binary_op (EQ_CASE_EXPR, yyvsp[-3].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (EQ_CASE_EXPR, (yyvsp[-3].ttype), (yyvsp[0].ttype)); } break; -case 462: + + case 463: #line 2423 "parse.yy" -{ syn_warning ("Case inequality"); } + { syn_warning ("Case inequality"); } break; -case 463: + + case 464: #line 2425 "parse.yy" -{ yyval.ttype = build_binary_op (NE_CASE_EXPR, yyvsp[-3].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (NE_CASE_EXPR, (yyvsp[-3].ttype), (yyvsp[0].ttype)); } break; -case 464: + + case 465: #line 2427 "parse.yy" -{ yyval.ttype = build_binary_op (TRUTH_ANDIF_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (TRUTH_ANDIF_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 465: + + case 466: #line 2429 "parse.yy" -{ yyval.ttype = build_binary_op (TRUTH_ORIF_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (TRUTH_ORIF_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 466: + + case 467: #line 2431 "parse.yy" -{ yyval.ttype = build_binary_op (LT_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (LT_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 467: + + case 468: #line 2433 "parse.yy" -{ yyval.ttype = build_binary_op (LE_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (LE_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 468: + + case 469: #line 2435 "parse.yy" -{ yyval.ttype = build_binary_op (GT_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (GT_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 469: + + case 470: #line 2437 "parse.yy" -{ yyval.ttype = build_binary_op (GE_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (GE_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 470: + + case 471: #line 2439 "parse.yy" -{ yyval.ttype = build_binary_op (BIT_AND_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (BIT_AND_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 471: + + case 472: #line 2441 "parse.yy" -{ yyval.ttype = build_binary_op (BIT_OR_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (BIT_OR_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 472: + + case 473: #line 2443 "parse.yy" -{ yyval.ttype = build_binary_op (BIT_XOR_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (BIT_XOR_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 473: + + case 474: #line 2445 "parse.yy" -{ yyval.ttype = build_binary_op (BIT_XNOR_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (BIT_XNOR_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 474: + + case 475: #line 2447 "parse.yy" -{ yyval.ttype = build_binary_op (LSHIFT_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (LSHIFT_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 475: + + case 476: #line 2449 "parse.yy" -{ yyval.ttype = build_binary_op (RSHIFT_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_binary_op (RSHIFT_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 476: + + case 477: #line 2451 "parse.yy" -{ yyval.ttype = build_cond_expr (yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = build_cond_expr ((yyvsp[-4].ttype), (yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 480: + + case 481: #line 2475 "parse.yy" -{ yyval.ttype = check_rval (yyvsp[0].ttype); } + { (yyval.ttype) = check_rval ((yyvsp[0].ttype)); } break; -case 481: + + case 482: #line 2477 "parse.yy" -{ yyval.ttype = build_bit_ref (check_rval_nocheck (yyvsp[-3].ttype), yyvsp[-1].ttype); } + { (yyval.ttype) = build_bit_ref (check_rval_nocheck ((yyvsp[-3].ttype)), (yyvsp[-1].ttype)); } break; -case 482: + + case 483: #line 2479 "parse.yy" -{ yyval.ttype = build_part_ref (check_rval_nocheck (yyvsp[-5].ttype), yyvsp[-3].ttype, yyvsp[-1].ttype); } + { (yyval.ttype) = build_part_ref (check_rval_nocheck ((yyvsp[-5].ttype)), (yyvsp[-3].ttype), (yyvsp[-1].ttype)); } break; -case 485: + + case 486: #line 2483 "parse.yy" -{ yyval.ttype = yyvsp[-1].ttype; } + { (yyval.ttype) = (yyvsp[-1].ttype); } break; -case 486: + + case 487: #line 2485 "parse.yy" -{ yyval.ttype = error_mark_node; } + { (yyval.ttype) = error_mark_node; } break; -case 487: + + case 488: #line 2518 "parse.yy" -{ yyval.ttype = make_node (CONCAT_REF); - CONCAT_LIST (yyval.ttype) = yyvsp[-1].ttype; - concat_labels (yyval.ttype); + { (yyval.ttype) = make_node (CONCAT_REF); + CONCAT_LIST ((yyval.ttype)) = (yyvsp[-1].ttype); + concat_labels ((yyval.ttype)); } break; -case 488: + + case 489: #line 2523 "parse.yy" -{ yyval.ttype = make_node (CONCAT_REP_REF); - CONCAT_LIST (yyval.ttype) = yyvsp[-2].ttype; - CONCAT_EXPR (yyval.ttype) = yyvsp[-4].ttype; - concat_labels (yyval.ttype); + { (yyval.ttype) = make_node (CONCAT_REP_REF); + CONCAT_LIST ((yyval.ttype)) = (yyvsp[-2].ttype); + CONCAT_EXPR ((yyval.ttype)) = (yyvsp[-4].ttype); + concat_labels ((yyval.ttype)); } break; -case 489: + + case 490: #line 2532 "parse.yy" -{ yyval.ttype = build_function_call (yyvsp[-3].ttype, nreverse (yyvsp[-1].ttype)); - HIERARCHICAL_ATTR (yyval.ttype) = HIERARCHICAL_ATTR (yyvsp[-3].ttype); - UNKNOWN_TYPE_ATTR (yyval.ttype) = 1; + { (yyval.ttype) = build_function_call ((yyvsp[-3].ttype), nreverse ((yyvsp[-1].ttype))); + HIERARCHICAL_ATTR ((yyval.ttype)) = HIERARCHICAL_ATTR ((yyvsp[-3].ttype)); + UNKNOWN_TYPE_ATTR ((yyval.ttype)) = 1; } break; -case 490: + + case 491: #line 2538 "parse.yy" -{ yyval.ttype = build_nt (SYSFUNCTION_REF, IDENTIFIER_POINTER (yyvsp[-3].ttype), - nreverse (yyvsp[-1].ttype), NULL_TREE, NULL_TREE, lineno, input_filename); } + { (yyval.ttype) = build_nt (SYSFUNCTION_REF, IDENTIFIER_POINTER ((yyvsp[-3].ttype)), + nreverse ((yyvsp[-1].ttype)), NULL_TREE, NULL_TREE, lineno, input_filename); } break; -case 491: + + case 492: #line 2542 "parse.yy" -{ yyval.ttype = build_nt (SYSFUNCTION_REF, IDENTIFIER_POINTER (yyvsp[0].ttype), + { (yyval.ttype) = build_nt (SYSFUNCTION_REF, IDENTIFIER_POINTER ((yyvsp[0].ttype)), NULL_TREE, NULL_TREE, NULL_TREE, lineno, input_filename); } break; -case 492: + + case 493: #line 2552 "parse.yy" -{ + { syn_warning ("Hierachical name"); /* hierarchical_list = link_tree_cons ($1, NULL_TREE, hierarchical_list); */ - HIERARCHICAL_ATTR (yyvsp[0].ttype) = 1; - UNKNOWN_TYPE_ATTR (yyvsp[0].ttype) = 1; - TREE_CONSTANT_ATTR (yyvsp[0].ttype) = 1; /* assume this is true for now */ + HIERARCHICAL_ATTR ((yyvsp[0].ttype)) = 1; + UNKNOWN_TYPE_ATTR ((yyvsp[0].ttype)) = 1; + TREE_CONSTANT_ATTR ((yyvsp[0].ttype)) = 1; /* assume this is true for now */ } break; -case 495: + + case 496: #line 2566 "parse.yy" -{ yyval.ttype = get_identifier ("or"); } + { (yyval.ttype) = get_identifier ("or"); } break; -case 496: + + case 497: #line 2585 "parse.yy" -{ yyval.ttype = NULL_TREE; } + { (yyval.ttype) = NULL_TREE; } break; -case 498: + + case 499: #line 2591 "parse.yy" -{ yyval.ttype = build_nt (DELAY_EXPR, yyvsp[0].ttype, yyvsp[0].ttype, NULL_TREE); - TREE_LABEL (yyval.ttype) = 1; + { (yyval.ttype) = build_nt (DELAY_EXPR, (yyvsp[0].ttype), (yyvsp[0].ttype), NULL_TREE); + TREE_LABEL ((yyval.ttype)) = 1; } break; -case 499: + + case 500: #line 2595 "parse.yy" -{ yyval.ttype = check_rval (yyvsp[0].ttype); - yyval.ttype = build_nt (DELAY_EXPR, yyval.ttype, yyval.ttype, NULL_TREE); - TREE_LABEL (yyval.ttype) = 1; + { (yyval.ttype) = check_rval ((yyvsp[0].ttype)); + (yyval.ttype) = build_nt (DELAY_EXPR, (yyval.ttype), (yyval.ttype), NULL_TREE); + TREE_LABEL ((yyval.ttype)) = 1; } break; -case 500: + + case 501: #line 2600 "parse.yy" -{ yyval.ttype = yyvsp[-1].ttype; } + { (yyval.ttype) = (yyvsp[-1].ttype); } break; -case 501: + + case 502: #line 2609 "parse.yy" -{ yyval.ttype = build_nt (DELAY_EXPR, yyvsp[0].ttype, yyvsp[0].ttype, NULL_TREE); - TREE_LABEL (yyval.ttype) = 1; + { (yyval.ttype) = build_nt (DELAY_EXPR, (yyvsp[0].ttype), (yyvsp[0].ttype), NULL_TREE); + TREE_LABEL ((yyval.ttype)) = 1; } break; -case 502: + + case 503: #line 2613 "parse.yy" -{ yyval.ttype = build_nt (DELAY_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE); - TREE_LABEL (yyval.ttype) = 2; + { (yyval.ttype) = build_nt (DELAY_EXPR, (yyvsp[-2].ttype), (yyvsp[0].ttype), NULL_TREE); + TREE_LABEL ((yyval.ttype)) = 2; } break; -case 503: + + case 504: #line 2617 "parse.yy" -{ yyval.ttype = build_nt (DELAY_EXPR, yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype); - TREE_LABEL (yyval.ttype) = 3; + { (yyval.ttype) = build_nt (DELAY_EXPR, (yyvsp[-4].ttype), (yyvsp[-2].ttype), (yyvsp[0].ttype)); + TREE_LABEL ((yyval.ttype)) = 3; } break; -case 504: + + case 505: #line 2624 "parse.yy" -{ yyval.ttype = yyvsp[0].ttype; } + { (yyval.ttype) = (yyvsp[0].ttype); } break; -case 505: + + case 506: #line 2626 "parse.yy" -{ yyval.ttype = check_rval (yyvsp[0].ttype); } + { (yyval.ttype) = check_rval ((yyvsp[0].ttype)); } break; -case 506: + + case 507: #line 2628 "parse.yy" -{ yyval.ttype = yyvsp[-1].ttype; } + { (yyval.ttype) = (yyvsp[-1].ttype); } break; -case 507: + + case 508: #line 2632 "parse.yy" -{ in_event = 1; } + { in_event = 1; } break; -case 508: + + case 509: #line 2634 "parse.yy" -{if (!HIERARCHICAL_ATTR (yyvsp[0].ttype) && - TREE_CODE (IDENT_CURRENT_DECL (yyvsp[0].ttype)) == EVENT_DECL) - yyval.ttype = build_stmt (EVENT_STMT, lineno, NULL_TREE, - build_tree_list (IDENT_CURRENT_DECL (yyvsp[0].ttype), NULL_TREE)); + {if (!HIERARCHICAL_ATTR ((yyvsp[0].ttype)) && + TREE_CODE (IDENT_CURRENT_DECL ((yyvsp[0].ttype))) == EVENT_DECL) + (yyval.ttype) = build_stmt (EVENT_STMT, lineno, NULL_TREE, + build_tree_list (IDENT_CURRENT_DECL ((yyvsp[0].ttype)), NULL_TREE)); else - yyval.ttype = build_stmt (EVENT_STMT, lineno, NULL_TREE, + (yyval.ttype) = build_stmt (EVENT_STMT, lineno, NULL_TREE, build_tree_list (build_unary_op - (ANYEDGE_EXPR, check_rval (yyvsp[0].ttype)), NULL_TREE)); + (ANYEDGE_EXPR, check_rval ((yyvsp[0].ttype))), NULL_TREE)); in_event = 0; } break; -case 509: + + case 510: #line 2644 "parse.yy" -{ in_event = 1; } + { in_event = 1; } break; -case 510: + + case 511: #line 2646 "parse.yy" -{ yyval.ttype = build_stmt (EVENT_STMT, lineno, NULL_TREE, yyvsp[-1].ttype); + { (yyval.ttype) = build_stmt (EVENT_STMT, lineno, NULL_TREE, (yyvsp[-1].ttype)); in_event = 0; } break; -case 511: + + case 512: #line 2652 "parse.yy" -{ /*if (TREE_CODE ($1) == EVENT_DECL) + { /*if (TREE_CODE ($1) == EVENT_DECL) $$ = build_tree_list ($1, NULL_TREE); else */ - yyval.ttype = build_tree_list - (build_unary_op (ANYEDGE_EXPR, yyvsp[0].ttype), NULL_TREE); + (yyval.ttype) = build_tree_list + (build_unary_op (ANYEDGE_EXPR, (yyvsp[0].ttype)), NULL_TREE); } break; -case 512: + + case 513: #line 2659 "parse.yy" -{ yyval.ttype = build_tree_list - (build_unary_op (POSEDGE_EXPR, yyvsp[0].ttype), NULL_TREE); } + { (yyval.ttype) = build_tree_list + (build_unary_op (POSEDGE_EXPR, (yyvsp[0].ttype)), NULL_TREE); } break; -case 513: + + case 514: #line 2662 "parse.yy" -{ yyval.ttype = build_tree_list - (build_unary_op (NEGEDGE_EXPR, yyvsp[0].ttype), NULL_TREE); } + { (yyval.ttype) = build_tree_list + (build_unary_op (NEGEDGE_EXPR, (yyvsp[0].ttype)), NULL_TREE); } break; -case 514: + + case 515: #line 2665 "parse.yy" -{ yyval.ttype = chainon (yyvsp[-2].ttype, yyvsp[0].ttype); } + { (yyval.ttype) = chainon ((yyvsp[-2].ttype), (yyvsp[0].ttype)); } break; -case 515: + + case 516: #line 2674 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 516: + + case 517: #line 2679 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 517: + + case 518: #line 2681 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -case 518: + + case 519: #line 2686 "parse.yy" -{ yyerrok; } + { yyerrok; } break; -} -#line 705 "/home/mdh/sourceforge/bison/share/bison/bison.simple" + } + +/* Line 1037 of yacc.c. */ +#line 5321 "parse.cc" yyvsp -= yylen; yyssp -= yylen; -#if YYLSP_NEEDED - yylsp -= yylen; -#endif -#if YYDEBUG - if (yydebug) - { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); - } -#endif + + YY_STACK_PRINT (yyss, yyssp); *++yyvsp = yyval; -#if YYLSP_NEEDED - *++yylsp = yyloc; -#endif + /* Now `shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule @@ -4582,11 +5334,11 @@ case 518: yyn = yyr1[yyn]; - yystate = yypgoto[yyn - YYNTBASE] + *yyssp; - if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else - yystate = yydefgoto[yyn - YYNTBASE]; + yystate = yydefgoto[yyn - YYNTOKENS]; goto yynewstate; @@ -4599,155 +5351,159 @@ case 518: if (!yyerrstatus) { ++yynerrs; - -#ifdef YYERROR_VERBOSE +#if YYERROR_VERBOSE yyn = yypact[yystate]; - if (yyn > YYFLAG && yyn < YYLAST) + if (YYPACT_NINF < yyn && yyn < YYLAST) { YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + const char* yyprefix; char *yymsg; - int yyx, yycount; + int yyx; - yycount = 0; /* Start YYX at -YYN if negative to avoid negative indexes in YYCHECK. */ - for (yyx = yyn < 0 ? -yyn : 0; - yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) - if (yycheck[yyx + yyn] == yyx) - yysize += yystrlen (yytname[yyx]) + 15, yycount++; - yysize += yystrlen ("parse error, unexpected ") + 1; - yysize += yystrlen (yytname[YYTRANSLATE (yychar)]); + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 0; + + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); + yycount += 1; + if (yycount == 5) + { + yysize = 0; + break; + } + } + yysize += (sizeof ("syntax error, unexpected ") + + yystrlen (yytname[yytype])); yymsg = (char *) YYSTACK_ALLOC (yysize); if (yymsg != 0) { - char *yyp = yystpcpy (yymsg, "parse error, unexpected "); - yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]); + char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); if (yycount < 5) { - yycount = 0; - for (yyx = yyn < 0 ? -yyn : 0; - yyx < (int) (sizeof (yytname) / sizeof (char *)); - yyx++) - if (yycheck[yyx + yyn] == yyx) + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) { - const char *yyq = ! yycount ? ", expecting " : " or "; - yyp = yystpcpy (yyp, yyq); + yyp = yystpcpy (yyp, yyprefix); yyp = yystpcpy (yyp, yytname[yyx]); - yycount++; + yyprefix = " or "; } } yyerror (yymsg); YYSTACK_FREE (yymsg); } else - yyerror ("parse error; also virtual memory exhausted"); + yyerror ("syntax error; also virtual memory exhausted"); } else -#endif /* defined (YYERROR_VERBOSE) */ - yyerror ("parse error"); +#endif /* YYERROR_VERBOSE */ + yyerror ("syntax error"); } - goto yyerrlab1; -/*--------------------------------------------------. -| yyerrlab1 -- error raised explicitly by an action | -`--------------------------------------------------*/ -yyerrlab1: + if (yyerrstatus == 3) { - /* If just tried and failed to reuse lookahead token after an + /* If just tried and failed to reuse look-ahead token after an error, discard it. */ - /* return failure if at end of input */ - if (yychar == YYEOF) - YYABORT; - YYDPRINTF ((stderr, "Discarding token %d (%s).\n", - yychar, yytname[yychar1])); - yychar = YYEMPTY; + if (yychar <= YYEOF) + { + /* If at end of input, pop the error token, + then the rest of the stack, then return failure. */ + if (yychar == YYEOF) + for (;;) + { + + YYPOPSTACK; + if (yyssp == yyss) + YYABORT; + yydestruct ("Error: popping", + yystos[*yyssp], yyvsp); + } + } + else + { + yydestruct ("Error: discarding", yytoken, &yylval); + yychar = YYEMPTY; + } } - /* Else will try to reuse lookahead token after shifting the error + /* Else will try to reuse look-ahead token after shifting the error token. */ - - yyerrstatus = 3; /* Each real token shifted decrements this */ - - goto yyerrhandle; + goto yyerrlab1; -/*-------------------------------------------------------------------. -| yyerrdefault -- current state does not do anything special for the | -| error token. | -`-------------------------------------------------------------------*/ -yyerrdefault: -#if 0 - /* This is wrong; only states that explicitly want error tokens - should shift them. */ +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: - /* If its default is to accept any token, ok. Otherwise pop it. */ - yyn = yydefact[yystate]; - if (yyn) - goto yydefault; +#ifdef __GNUC__ + /* Pacify GCC when the user code never invokes YYERROR and the label + yyerrorlab therefore never appears in user code. */ + if (0) + goto yyerrorlab; #endif +yyvsp -= yylen; + yyssp -= yylen; + yystate = *yyssp; + goto yyerrlab1; -/*---------------------------------------------------------------. -| yyerrpop -- pop the current state because it cannot handle the | -| error token | -`---------------------------------------------------------------*/ -yyerrpop: - if (yyssp == yyss) - YYABORT; - yyvsp--; - yystate = *--yyssp; -#if YYLSP_NEEDED - yylsp--; -#endif -#if YYDEBUG - if (yydebug) +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "Error: state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); - } -#endif + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } -/*--------------. -| yyerrhandle. | -`--------------*/ -yyerrhandle: - yyn = yypact[yystate]; - if (yyn == YYFLAG) - goto yyerrdefault; + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; - yyn += YYTERROR; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) - goto yyerrdefault; - yyn = yytable[yyn]; - if (yyn < 0) - { - if (yyn == YYFLAG) - goto yyerrpop; - yyn = -yyn; - goto yyreduce; + yydestruct ("Error: popping", yystos[yystate], yyvsp); + YYPOPSTACK; + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); } - else if (yyn == 0) - goto yyerrpop; if (yyn == YYFINAL) YYACCEPT; - YYDPRINTF ((stderr, "Shifting error token, ")); - *++yyvsp = yylval; -#if YYLSP_NEEDED - *++yylsp = yylloc; -#endif + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); yystate = yyn; goto yynewstate; @@ -4764,16 +5520,21 @@ case 518: | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ yyabortlab: + yydestruct ("Error: discarding lookahead", + yytoken, &yylval); + yychar = YYEMPTY; yyresult = 1; goto yyreturn; -/*---------------------------------------------. -| yyoverflowab -- parser overflow comes here. | -`---------------------------------------------*/ +#ifndef yyoverflow +/*----------------------------------------------. +| yyoverflowlab -- parser overflow comes here. | +`----------------------------------------------*/ yyoverflowlab: yyerror ("parser stack overflow"); yyresult = 2; /* Fall through. */ +#endif yyreturn: #ifndef yyoverflow @@ -4782,6 +5543,8 @@ case 518: #endif return yyresult; } + + #line 2689 "parse.yy" void @@ -4794,3 +5557,4 @@ eat_block (short token) return; } + diff --git a/src/parse.h b/src/parse.h index d68ce04..51fe7c6 100644 --- a/src/parse.h +++ b/src/parse.h @@ -1,8 +1,265 @@ -#ifndef BISON_PARSE_H -# define BISON_PARSE_H +/* A Bison parser, made by GNU Bison 2.0. */ -#ifndef YYSTYPE -typedef union { +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + LOWEST = 258, + IF = 259, + ELSE = 260, + OROR = 261, + ANDAND = 262, + ANDANDAND = 263, + XNOR = 264, + CASE_INEQUALITY = 265, + CASE_EQUALITY = 266, + LOGICAL_INEQUALITY = 267, + LOGICAL_EQUALITY = 268, + GE = 269, + GT = 270, + LE = 271, + LT = 272, + RIGHT_SHIFT = 273, + LEFT_SHIFT = 274, + REDUCTION_NOR = 275, + REDUCTION_NAND = 276, + UNARY = 277, + IDENTIFIER = 278, + HIERARCHY_IDENTIFIER = 279, + STARARROW = 280, + EQUALARROW = 281, + SPECPARAM = 282, + SETUP = 283, + HOLD = 284, + PERIOD = 285, + WIDTH = 286, + SKEW = 287, + RECOVERY = 288, + SETUPHOLD = 289, + NOCHANGE = 290, + MODULE = 291, + MACROMODULE = 292, + ENDMODULE = 293, + SPECIFY = 294, + ENDSPECIFY = 295, + PRIMITIVE = 296, + ENDPRIMITIVE = 297, + TABLE = 298, + ENDTABLE = 299, + TASK = 300, + ENDTASK = 301, + FUNCTION = 302, + ENDFUNCTION = 303, + PARAMETER = 304, + INPUT = 305, + OUTPUT = 306, + INOUT = 307, + NETTYPE = 308, + TRIREG = 309, + SCALARED = 310, + VECTORED = 311, + REG = 312, + TIME = 313, + INTEGER = 314, + REAL = 315, + EVENT = 316, + ASSIGN = 317, + DEFPARAM = 318, + STRENGTH0 = 319, + STRENGTH1 = 320, + SUPPLY0 = 321, + SUPPLY1 = 322, + LOGIC = 323, + BUFFER = 324, + BUFIF = 325, + CMOS = 326, + PULL = 327, + TRAN = 328, + INITIAL = 329, + ALWAYS = 330, + CASE = 331, + CASEZ = 332, + CASEX = 333, + ENDCASE = 334, + FOREVER = 335, + REPEAT = 336, + WHILE = 337, + FOR = 338, + WAIT_ = 339, + ARROW_ = 340, + DISABLE = 341, + DEASSIGN = 342, + FORCE = 343, + RELEASE = 344, + DEFAULT = 345, + BEGIN = 346, + END = 347, + FORK = 348, + JOIN = 349, + SYSTEM_IDENTIFIER = 350, + STRING = 351, + NUMBER = 352, + BASE_NUMBER = 353, + POSEDGE = 354, + NEGEDGE = 355, + OR = 356, + SMALL = 357, + MEDIUM = 358, + LARGE = 359, + EDGE = 360, + DOUBLE_DIGIT = 361, + UDP_CHAR = 362, + UDP_ONE = 363, + UDP_ZERO = 364, + UDP_X = 365, + UDP_B = 366, + UDP_HOOK = 367, + EOF_ = 368 + }; +#endif +#define LOWEST 258 +#define IF 259 +#define ELSE 260 +#define OROR 261 +#define ANDAND 262 +#define ANDANDAND 263 +#define XNOR 264 +#define CASE_INEQUALITY 265 +#define CASE_EQUALITY 266 +#define LOGICAL_INEQUALITY 267 +#define LOGICAL_EQUALITY 268 +#define GE 269 +#define GT 270 +#define LE 271 +#define LT 272 +#define RIGHT_SHIFT 273 +#define LEFT_SHIFT 274 +#define REDUCTION_NOR 275 +#define REDUCTION_NAND 276 +#define UNARY 277 +#define IDENTIFIER 278 +#define HIERARCHY_IDENTIFIER 279 +#define STARARROW 280 +#define EQUALARROW 281 +#define SPECPARAM 282 +#define SETUP 283 +#define HOLD 284 +#define PERIOD 285 +#define WIDTH 286 +#define SKEW 287 +#define RECOVERY 288 +#define SETUPHOLD 289 +#define NOCHANGE 290 +#define MODULE 291 +#define MACROMODULE 292 +#define ENDMODULE 293 +#define SPECIFY 294 +#define ENDSPECIFY 295 +#define PRIMITIVE 296 +#define ENDPRIMITIVE 297 +#define TABLE 298 +#define ENDTABLE 299 +#define TASK 300 +#define ENDTASK 301 +#define FUNCTION 302 +#define ENDFUNCTION 303 +#define PARAMETER 304 +#define INPUT 305 +#define OUTPUT 306 +#define INOUT 307 +#define NETTYPE 308 +#define TRIREG 309 +#define SCALARED 310 +#define VECTORED 311 +#define REG 312 +#define TIME 313 +#define INTEGER 314 +#define REAL 315 +#define EVENT 316 +#define ASSIGN 317 +#define DEFPARAM 318 +#define STRENGTH0 319 +#define STRENGTH1 320 +#define SUPPLY0 321 +#define SUPPLY1 322 +#define LOGIC 323 +#define BUFFER 324 +#define BUFIF 325 +#define CMOS 326 +#define PULL 327 +#define TRAN 328 +#define INITIAL 329 +#define ALWAYS 330 +#define CASE 331 +#define CASEZ 332 +#define CASEX 333 +#define ENDCASE 334 +#define FOREVER 335 +#define REPEAT 336 +#define WHILE 337 +#define FOR 338 +#define WAIT_ 339 +#define ARROW_ 340 +#define DISABLE 341 +#define DEASSIGN 342 +#define FORCE 343 +#define RELEASE 344 +#define DEFAULT 345 +#define BEGIN 346 +#define END 347 +#define FORK 348 +#define JOIN 349 +#define SYSTEM_IDENTIFIER 350 +#define STRING 351 +#define NUMBER 352 +#define BASE_NUMBER 353 +#define POSEDGE 354 +#define NEGEDGE 355 +#define OR 356 +#define SMALL 357 +#define MEDIUM 358 +#define LARGE 359 +#define EDGE 360 +#define DOUBLE_DIGIT 361 +#define UDP_CHAR 362 +#define UDP_ONE 363 +#define UDP_ZERO 364 +#define UDP_X 365 +#define UDP_B 366 +#define UDP_HOOK 367 +#define EOF_ 368 + + + + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +#line 133 "parse.yy" +typedef union YYSTYPE { tree ttype; /* pointer to a tree node */ int integer; /* used for integers */ // inst ctype; /* pointer to an instruction node (code) */ @@ -13,121 +270,15 @@ typedef union { enum tree_type ntype; /* for nets (same as gtype, buy more readable) */ char double_digit[2]; /* structure for parsing edges */ char c; /* char used in udp parsing */ -} yystype; -# define YYSTYPE yystype +} YYSTYPE; +/* Line 1318 of yacc.c. */ +#line 276 "parse.h" +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 #endif -# define LOWEST 257 -# define IF 258 -# define ELSE 259 -# define OROR 260 -# define ANDAND 261 -# define ANDANDAND 262 -# define XNOR 263 -# define LOGICAL_EQUALITY 264 -# define LOGICAL_INEQUALITY 265 -# define CASE_EQUALITY 266 -# define CASE_INEQUALITY 267 -# define LT 268 -# define LE 269 -# define GT 270 -# define GE 271 -# define LEFT_SHIFT 272 -# define RIGHT_SHIFT 273 -# define REDUCTION_NOR 274 -# define REDUCTION_NAND 275 -# define UNARY 276 -# define IDENTIFIER 277 -# define HIERARCHY_IDENTIFIER 278 -# define STARARROW 279 -# define EQUALARROW 280 -# define SPECPARAM 281 -# define SETUP 282 -# define HOLD 283 -# define PERIOD 284 -# define WIDTH 285 -# define SKEW 286 -# define RECOVERY 287 -# define SETUPHOLD 288 -# define NOCHANGE 289 -# define MODULE 290 -# define MACROMODULE 291 -# define ENDMODULE 292 -# define SPECIFY 293 -# define ENDSPECIFY 294 -# define PRIMITIVE 295 -# define ENDPRIMITIVE 296 -# define TABLE 297 -# define ENDTABLE 298 -# define TASK 299 -# define ENDTASK 300 -# define FUNCTION 301 -# define ENDFUNCTION 302 -# define PARAMETER 303 -# define INPUT 304 -# define OUTPUT 305 -# define INOUT 306 -# define NETTYPE 307 -# define TRIREG 308 -# define SCALARED 309 -# define VECTORED 310 -# define REG 311 -# define TIME 312 -# define INTEGER 313 -# define REAL 314 -# define EVENT 315 -# define ASSIGN 316 -# define DEFPARAM 317 -# define STRENGTH0 318 -# define STRENGTH1 319 -# define SUPPLY0 320 -# define SUPPLY1 321 -# define LOGIC 322 -# define BUFFER 323 -# define BUFIF 324 -# define CMOS 325 -# define PULL 326 -# define TRAN 327 -# define INITIAL 328 -# define ALWAYS 329 -# define CASE 330 -# define CASEZ 331 -# define CASEX 332 -# define ENDCASE 333 -# define FOREVER 334 -# define REPEAT 335 -# define WHILE 336 -# define FOR 337 -# define WAIT_ 338 -# define ARROW_ 339 -# define DISABLE 340 -# define DEASSIGN 341 -# define FORCE 342 -# define RELEASE 343 -# define DEFAULT 344 -# define BEGIN 345 -# define END 346 -# define FORK 347 -# define JOIN 348 -# define SYSTEM_IDENTIFIER 349 -# define STRING 350 -# define NUMBER 351 -# define BASE_NUMBER 352 -# define POSEDGE 353 -# define NEGEDGE 354 -# define OR 355 -# define SMALL 356 -# define MEDIUM 357 -# define LARGE 358 -# define EDGE 359 -# define DOUBLE_DIGIT 360 -# define UDP_CHAR 361 -# define UDP_ONE 362 -# define UDP_ZERO 363 -# define UDP_X 364 -# define UDP_B 365 -# define UDP_HOOK 366 -# define EOF_ 367 -#endif /* not BISON_PARSE_H */ + + + diff --git a/src/sdfcpars.cc b/src/sdfcpars.cc index 83a8c5b..1258799 100644 --- a/src/sdfcpars.cc +++ b/src/sdfcpars.cc @@ -1,73 +1,193 @@ -/* A Bison parser, made from /home/mdh/sourceforge/veriwell/src/sdfcpars.yy - by GNU bison 1.35. */ - -#define YYBISON 1 /* Identify Bison output. */ - -# define IF 257 -# define ELSE 258 -# define OROR 259 -# define ANDAND 260 -# define ANDANDAND 261 -# define XNOR 262 -# define LOGICAL_EQUALITY 263 -# define LOGICAL_INEQUALITY 264 -# define CASE_EQUALITY 265 -# define CASE_INEQUALITY 266 -# define LT 267 -# define LE 268 -# define GT 269 -# define GE 270 -# define LEFT_SHIFT 271 -# define RIGHT_SHIFT 272 -# define REDUCTION_NOR 273 -# define REDUCTION_NAND 274 -# define UNARY 275 -# define INTEGER 276 -# define SCALAR_CONSTANT 277 -# define FLOATING 278 -# define QSTRING 279 -# define IDENTIFIER 280 -# define IOPATH 281 -# define PORT 282 -# define INTERCONNECT 283 -# define NETDELAY 284 -# define DEVICE 285 -# define SETUP 286 -# define HOLD 287 -# define SETUPHOLD 288 -# define RECOVERY 289 -# define SKEW 290 -# define WIDTH 291 -# define PERIOD 292 -# define NOCHANGE 293 -# define PATHPULSE 294 -# define IGNORE 295 -# define INTERMOD_PATH 296 -# define MIPD 297 -# define CELL 298 -# define USE 299 -# define INTERCONNECT_MIPD 300 -# define MINIMUM 301 -# define MAXIMUM 302 -# define AVERAGE 303 -# define MTM 304 -# define TOOL_CONTROL 305 -# define TYPICAL 306 -# define SCALE_FACTORS 307 -# define SCALE_TYPE 308 -# define FROM_MINIMUM 309 -# define FROM_TYPICAL 310 -# define FROM_MAXIMUM 311 -# define FROM_MTM 312 -# define FROM_FILE 313 -# define TURNOFF_DELAY 314 -# define TURNON_DELAY 315 -# define MODULE 316 -# define MAP_INNER 317 -# define ADD 318 -# define OVERRIDE 319 -# define EOF_ 320 +/* A Bison parser, made by GNU Bison 2.0. */ +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Written by Richard Stallman by simplifying the original so called + ``semantic'' parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 1 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + IF = 258, + ELSE = 259, + OROR = 260, + ANDAND = 261, + ANDANDAND = 262, + XNOR = 263, + CASE_INEQUALITY = 264, + CASE_EQUALITY = 265, + LOGICAL_INEQUALITY = 266, + LOGICAL_EQUALITY = 267, + GE = 268, + GT = 269, + LE = 270, + LT = 271, + RIGHT_SHIFT = 272, + LEFT_SHIFT = 273, + REDUCTION_NOR = 274, + REDUCTION_NAND = 275, + UNARY = 276, + INTEGER = 277, + SCALAR_CONSTANT = 278, + FLOATING = 279, + QSTRING = 280, + IDENTIFIER = 281, + IOPATH = 282, + PORT = 283, + INTERCONNECT = 284, + NETDELAY = 285, + DEVICE = 286, + SETUP = 287, + HOLD = 288, + SETUPHOLD = 289, + RECOVERY = 290, + SKEW = 291, + WIDTH = 292, + PERIOD = 293, + NOCHANGE = 294, + PATHPULSE = 295, + IGNORE = 296, + INTERMOD_PATH = 297, + MIPD = 298, + CELL = 299, + USE = 300, + INTERCONNECT_MIPD = 301, + MINIMUM = 302, + MAXIMUM = 303, + AVERAGE = 304, + MTM = 305, + TOOL_CONTROL = 306, + TYPICAL = 307, + SCALE_FACTORS = 308, + SCALE_TYPE = 309, + FROM_MINIMUM = 310, + FROM_TYPICAL = 311, + FROM_MAXIMUM = 312, + FROM_MTM = 313, + FROM_FILE = 314, + TURNOFF_DELAY = 315, + TURNON_DELAY = 316, + MODULE = 317, + MAP_INNER = 318, + ADD = 319, + OVERRIDE = 320, + EOF_ = 321 + }; +#endif +#define IF 258 +#define ELSE 259 +#define OROR 260 +#define ANDAND 261 +#define ANDANDAND 262 +#define XNOR 263 +#define CASE_INEQUALITY 264 +#define CASE_EQUALITY 265 +#define LOGICAL_INEQUALITY 266 +#define LOGICAL_EQUALITY 267 +#define GE 268 +#define GT 269 +#define LE 270 +#define LT 271 +#define RIGHT_SHIFT 272 +#define LEFT_SHIFT 273 +#define REDUCTION_NOR 274 +#define REDUCTION_NAND 275 +#define UNARY 276 +#define INTEGER 277 +#define SCALAR_CONSTANT 278 +#define FLOATING 279 +#define QSTRING 280 +#define IDENTIFIER 281 +#define IOPATH 282 +#define PORT 283 +#define INTERCONNECT 284 +#define NETDELAY 285 +#define DEVICE 286 +#define SETUP 287 +#define HOLD 288 +#define SETUPHOLD 289 +#define RECOVERY 290 +#define SKEW 291 +#define WIDTH 292 +#define PERIOD 293 +#define NOCHANGE 294 +#define PATHPULSE 295 +#define IGNORE 296 +#define INTERMOD_PATH 297 +#define MIPD 298 +#define CELL 299 +#define USE 300 +#define INTERCONNECT_MIPD 301 +#define MINIMUM 302 +#define MAXIMUM 303 +#define AVERAGE 304 +#define MTM 305 +#define TOOL_CONTROL 306 +#define TYPICAL 307 +#define SCALE_FACTORS 308 +#define SCALE_TYPE 309 +#define FROM_MINIMUM 310 +#define FROM_TYPICAL 311 +#define FROM_MAXIMUM 312 +#define FROM_MTM 313 +#define FROM_FILE 314 +#define TURNOFF_DELAY 315 +#define TURNON_DELAY 316 +#define MODULE 317 +#define MAP_INNER 318 +#define ADD 319 +#define OVERRIDE 320 +#define EOF_ 321 + + + + +/* Copy the first part of user declarations. */ #line 22 "sdfcpars.yy" #define YYERROR_VERBOSE @@ -140,9 +260,23 @@ void initSDFCParse() } + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) #line 96 "sdfcpars.yy" -#ifndef YYSTYPE -typedef union { +typedef union YYSTYPE { int integer; double floating; char *ptr; @@ -150,25 +284,142 @@ typedef union { eDelayType_t dtype; eSDFConstruct_t stype; eVerilogConstruct_t vtype; -} yystype; -# define YYSTYPE yystype +} YYSTYPE; +/* Line 190 of yacc.c. */ +#line 290 "sdfcpars.cc" +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 #endif -#ifndef YYDEBUG -# define YYDEBUG 0 -#endif -#define YYFINAL 73 -#define YYFLAG -32768 -#define YYNTBASE 83 +/* Copy the second part of user declarations. */ + + +/* Line 213 of yacc.c. */ +#line 302 "sdfcpars.cc" + +#if ! defined (yyoverflow) || YYERROR_VERBOSE + +# ifndef YYFREE +# define YYFREE free +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# endif + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# else +# define YYSTACK_ALLOC alloca +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# endif +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short int yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined (__GNUC__) && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif -/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */ -#define YYTRANSLATE(x) ((unsigned)(x) <= 320 ? yytranslate[x] : 94) +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short int yysigned_char; +#endif -/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */ -static const char yytranslate[] = +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 31 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 88 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 83 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 12 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 46 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 73 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 321 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -195,308 +446,207 @@ static const char yytranslate[] = 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 3, 4, 7, - 8, 9, 12, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80 + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 7, 8, 9, 12, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80 }; #if YYDEBUG -static const short yyprhs[] = +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned char yyprhs[] = { - 0, 0, 3, 5, 7, 10, 12, 17, 22, 27, - 32, 41, 46, 51, 56, 58, 60, 62, 64, 66, - 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, - 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, - 108, 110, 112, 114, 116, 118 + 0, 0, 3, 6, 8, 10, 13, 15, 20, 25, + 30, 35, 44, 49, 54, 59, 61, 63, 65, 67, + 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, + 89, 91, 93, 95, 97, 99, 101, 103, 105, 107, + 109, 111, 113, 115, 117, 119, 121 }; -static const short yyrhs[] = + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yysigned_char yyrhs[] = { - 84, 80, 0, 80, 0, 85, 0, 85, 84, 0, - 86, 0, 89, 81, 90, 93, 0, 60, 81, 91, - 93, 0, 64, 81, 92, 93, 0, 64, 81, 65, - 93, 0, 67, 81, 88, 6, 88, 6, 88, 93, - 0, 68, 81, 87, 93, 0, 74, 81, 91, 93, - 0, 74, 81, 73, 93, 0, 69, 0, 70, 0, - 71, 0, 72, 0, 38, 0, 36, 0, 41, 0, - 42, 0, 43, 0, 44, 0, 45, 0, 46, 0, - 47, 0, 48, 0, 49, 0, 50, 0, 51, 0, - 52, 0, 53, 0, 54, 0, 55, 0, 56, 0, - 57, 0, 58, 0, 59, 0, 61, 0, 62, 0, - 63, 0, 61, 0, 66, 0, 62, 0, 82, 0 + 84, 0, -1, 85, 80, -1, 80, -1, 86, -1, + 86, 85, -1, 87, -1, 90, 81, 91, 94, -1, + 60, 81, 92, 94, -1, 64, 81, 93, 94, -1, + 64, 81, 65, 94, -1, 67, 81, 89, 6, 89, + 6, 89, 94, -1, 68, 81, 88, 94, -1, 74, + 81, 92, 94, -1, 74, 81, 73, 94, -1, 69, + -1, 70, -1, 71, -1, 72, -1, 38, -1, 36, + -1, 41, -1, 42, -1, 43, -1, 44, -1, 45, + -1, 46, -1, 47, -1, 48, -1, 49, -1, 50, + -1, 51, -1, 52, -1, 53, -1, 54, -1, 55, + -1, 56, -1, 57, -1, 58, -1, 59, -1, 61, + -1, 62, -1, 63, -1, 61, -1, 66, -1, 62, + -1, 82, -1 }; -#endif - -#if YYDEBUG -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const short yyrline[] = +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned short int yyrline[] = { - 0, 188, 189, 193, 194, 198, 202, 208, 212, 216, - 220, 224, 228, 232, 239, 241, 243, 245, 250, 251, - 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, - 278, 280, 282, 284, 289, 291, 293, 295, 297, 302, - 304, 306, 311, 313, 315, 325 + 0, 188, 188, 189, 193, 194, 198, 202, 208, 212, + 216, 220, 224, 228, 232, 239, 241, 243, 245, 250, + 251, 258, 260, 262, 264, 266, 268, 270, 272, 274, + 276, 278, 280, 282, 284, 289, 291, 293, 295, 297, + 302, 304, 306, 311, 313, 315, 325 }; #endif - -#if (YYDEBUG) || defined YYERROR_VERBOSE - -/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */ +#if YYDEBUG || YYERROR_VERBOSE +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ static const char *const yytname[] = { - "$", "error", "$undefined.", "IF", "ELSE", "'?'", "':'", "OROR", "ANDAND", - "ANDANDAND", "'|'", "'^'", "XNOR", "'&'", "LOGICAL_EQUALITY", - "LOGICAL_INEQUALITY", "CASE_EQUALITY", "CASE_INEQUALITY", "LT", "LE", - "GT", "GE", "LEFT_SHIFT", "RIGHT_SHIFT", "'+'", "'-'", "'*'", "'/'", - "'%'", "'('", "'['", "'!'", "'~'", "REDUCTION_NOR", "REDUCTION_NAND", - "UNARY", "INTEGER", "SCALAR_CONSTANT", "FLOATING", "QSTRING", - "IDENTIFIER", "IOPATH", "PORT", "INTERCONNECT", "NETDELAY", "DEVICE", - "SETUP", "HOLD", "SETUPHOLD", "RECOVERY", "SKEW", "WIDTH", "PERIOD", - "NOCHANGE", "PATHPULSE", "IGNORE", "INTERMOD_PATH", "MIPD", "CELL", - "USE", "INTERCONNECT_MIPD", "MINIMUM", "MAXIMUM", "AVERAGE", "MTM", - "TOOL_CONTROL", "TYPICAL", "SCALE_FACTORS", "SCALE_TYPE", - "FROM_MINIMUM", "FROM_TYPICAL", "FROM_MAXIMUM", "FROM_MTM", "FROM_FILE", - "TURNOFF_DELAY", "TURNON_DELAY", "MODULE", "MAP_INNER", "ADD", - "OVERRIDE", "EOF_", "'='", "';'", "config", "statements", "statement", - "map", "stype", "real", "sdf_construct", "veritool_map", "min_max_avg", - "min_typ_max", "sc", 0 + "$end", "error", "$undefined", "IF", "ELSE", "'?'", "':'", "OROR", + "ANDAND", "ANDANDAND", "'|'", "'^'", "XNOR", "'&'", "CASE_INEQUALITY", + "CASE_EQUALITY", "LOGICAL_INEQUALITY", "LOGICAL_EQUALITY", "GE", "GT", + "LE", "LT", "RIGHT_SHIFT", "LEFT_SHIFT", "'+'", "'-'", "'*'", "'/'", + "'%'", "'('", "'['", "'!'", "'~'", "REDUCTION_NOR", "REDUCTION_NAND", + "UNARY", "INTEGER", "SCALAR_CONSTANT", "FLOATING", "QSTRING", + "IDENTIFIER", "IOPATH", "PORT", "INTERCONNECT", "NETDELAY", "DEVICE", + "SETUP", "HOLD", "SETUPHOLD", "RECOVERY", "SKEW", "WIDTH", "PERIOD", + "NOCHANGE", "PATHPULSE", "IGNORE", "INTERMOD_PATH", "MIPD", "CELL", + "USE", "INTERCONNECT_MIPD", "MINIMUM", "MAXIMUM", "AVERAGE", "MTM", + "TOOL_CONTROL", "TYPICAL", "SCALE_FACTORS", "SCALE_TYPE", "FROM_MINIMUM", + "FROM_TYPICAL", "FROM_MAXIMUM", "FROM_MTM", "FROM_FILE", "TURNOFF_DELAY", + "TURNON_DELAY", "MODULE", "MAP_INNER", "ADD", "OVERRIDE", "EOF_", "'='", + "';'", "$accept", "config", "statements", "statement", "map", "stype", + "real", "sdf_construct", "veritool_map", "min_max_avg", "min_typ_max", + "sc", 0 }; #endif -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const short yyr1[] = +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const unsigned short int yytoknum[] = +{ + 0, 256, 257, 258, 259, 63, 58, 260, 261, 262, + 124, 94, 263, 38, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 43, 45, 42, 47, 37, 40, + 91, 33, 126, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 61, 59 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned char yyr1[] = { - 0, 83, 83, 84, 84, 85, 86, 86, 86, 86, - 86, 86, 86, 86, 87, 87, 87, 87, 88, 88, - 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, - 89, 89, 89, 89, 90, 90, 90, 90, 90, 91, - 91, 91, 92, 92, 92, 93 + 0, 83, 84, 84, 85, 85, 86, 87, 87, 87, + 87, 87, 87, 87, 87, 88, 88, 88, 88, 89, + 89, 90, 90, 90, 90, 90, 90, 90, 90, 90, + 90, 90, 90, 90, 90, 91, 91, 91, 91, 91, + 92, 92, 92, 93, 93, 93, 94 }; -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const short yyr2[] = +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const unsigned char yyr2[] = { - 0, 2, 1, 1, 2, 1, 4, 4, 4, 4, - 8, 4, 4, 4, 1, 1, 1, 1, 1, 1, + 0, 2, 2, 1, 1, 2, 1, 4, 4, 4, + 4, 8, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1 + 1, 1, 1, 1, 1, 1, 1 }; -/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE - doesn't specify something else to do. Zero means the default is an - error. */ -static const short yydefact[] = +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const unsigned char yydefact[] = { - 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 0, 0, 0, 0, 0, - 2, 0, 3, 5, 0, 0, 0, 0, 0, 0, - 1, 4, 0, 39, 40, 41, 0, 42, 44, 0, - 43, 0, 19, 18, 0, 14, 15, 16, 17, 0, - 0, 0, 34, 35, 36, 37, 38, 0, 45, 7, - 9, 8, 0, 11, 13, 12, 6, 0, 0, 0, - 10, 0, 0, 0 + 0, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 0, 0, 0, 0, 0, + 3, 0, 0, 4, 6, 0, 0, 0, 0, 0, + 0, 1, 2, 5, 0, 40, 41, 42, 0, 43, + 45, 0, 44, 0, 20, 19, 0, 15, 16, 17, + 18, 0, 0, 0, 35, 36, 37, 38, 39, 0, + 46, 8, 10, 9, 0, 12, 14, 13, 7, 0, + 0, 0, 11 }; -static const short yydefgoto[] = +/* YYDEFGOTO[NTERM-NUM]. */ +static const yysigned_char yydefgoto[] = { - 71, 21, 22, 23, 49, 44, 24, 57, 36, 41, - 59 + -1, 21, 22, 23, 24, 51, 46, 25, 59, 38, + 43, 61 }; -static const short yypact[] = +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -67 +static const yysigned_char yypact[] = { - -41,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768,-32768,-32768, -66, -60, -56, -52, -49, - -32768, -19, -1,-32768, -17, -25, -31, -14, -15, -45, - -32768,-32768, 22,-32768,-32768,-32768, -20,-32768,-32768, -20, - -32768, -20,-32768,-32768, 59,-32768,-32768,-32768,-32768, -20, - -20, -20,-32768,-32768,-32768,-32768,-32768, -20,-32768,-32768, - -32768,-32768, -14,-32768,-32768,-32768,-32768, 65, -14, -20, - -32768, 72, 74,-32768 + -41, -67, -67, -67, -67, -67, -67, -67, -67, -67, + -67, -67, -67, -67, -67, -66, -60, -56, -52, -49, + -67, 61, -18, -1, -67, -17, -25, -31, -14, -15, + -45, -67, -67, -67, 22, -67, -67, -67, -11, -67, + -67, -11, -67, -11, -67, -67, 59, -67, -67, -67, + -67, -11, -11, -11, -67, -67, -67, -67, -67, -11, + -67, -67, -67, -67, -14, -67, -67, -67, -67, 66, + -14, -11, -67 }; -static const short yypgoto[] = +/* YYPGOTO[NTERM-NUM]. */ +static const yysigned_char yypgoto[] = { - -32768, 53,-32768,-32768,-32768, -48,-32768,-32768, 54,-32768, - 19 + -67, -67, 51, -67, -67, -67, -50, -67, -67, 45, + -67, 17 }; - -#define YYLAST 88 - - -static const short yytable[] = +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -1 +static const unsigned char yytable[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 67, 25, 33, 34, 35, 15, - 69, 26, 42, 16, 43, 27, 17, 18, 50, 28, - 37, 38, 29, 19, 39, 40, 33, 34, 35, 20, + 11, 12, 13, 14, 69, 26, 35, 36, 37, 15, + 71, 27, 44, 16, 45, 28, 17, 18, 52, 29, + 39, 40, 30, 19, 41, 42, 35, 36, 37, 20, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 45, 46, 47, 48, 60, 15, - 61, 30, 58, 16, 32, 62, 17, 18, 63, 64, - 65, 68, 72, 19, 73, 31, 66, 52, 53, 54, - 55, 56, 0, 51, 0, 0, 0, 0, 70 + 11, 12, 13, 14, 47, 48, 49, 50, 62, 15, + 63, 31, 32, 16, 34, 64, 17, 18, 65, 66, + 67, 60, 70, 19, 33, 53, 68, 54, 55, 56, + 57, 58, 0, 0, 0, 0, 0, 0, 72 }; -static const short yycheck[] = +static const yysigned_char yycheck[] = { 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 62, 81, 61, 62, 63, 60, - 68, 81, 36, 64, 38, 81, 67, 68, 73, 81, + 51, 52, 53, 54, 64, 81, 61, 62, 63, 60, + 70, 81, 36, 64, 38, 81, 67, 68, 73, 81, 61, 62, 81, 74, 65, 66, 61, 62, 63, 80, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 69, 70, 71, 72, 39, 60, - 41, 80, 82, 64, 81, 6, 67, 68, 49, 50, - 51, 6, 0, 74, 0, 22, 57, 55, 56, 57, - 58, 59, -1, 29, -1, -1, -1, -1, 69 + 51, 52, 53, 54, 69, 70, 71, 72, 41, 60, + 43, 0, 80, 64, 81, 6, 67, 68, 51, 52, + 53, 82, 6, 74, 23, 30, 59, 55, 56, 57, + 58, 59, -1, -1, -1, -1, -1, -1, 71 }; -#define YYPURE 1 - -/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ -#line 3 "/home/mdh/sourceforge/bison/share/bison/bison.simple" - -/* Skeleton output parser for bison, - - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software - Foundation, Inc. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - -/* As a special exception, when this file is copied by Bison into a - Bison output file, you may use that output file without restriction. - This special exception was added by the Free Software Foundation - in version 1.24 of Bison. */ - -/* This is the parser code that is written into each bison parser when - the %semantic_parser declaration is not specified in the grammar. - It was written by Richard Stallman by simplifying the hairy parser - used when %semantic_parser is specified. */ - -/* All symbols defined below should begin with yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE) - -/* The parser invokes alloca or malloc; define the necessary symbols. */ - -# if YYSTACK_USE_ALLOCA -# define YYSTACK_ALLOC alloca -# else -# ifndef YYSTACK_USE_ALLOCA -# if defined (alloca) || defined (_ALLOCA_H) -# define YYSTACK_ALLOC alloca -# else -# ifdef __GNUC__ -# define YYSTACK_ALLOC __builtin_alloca -# endif -# endif -# endif -# endif - -# ifdef YYSTACK_ALLOC - /* Pacify GCC's `empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) -# else -# if defined (__STDC__) || defined (__cplusplus) -# include /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -# endif -# define YYSTACK_ALLOC malloc -# define YYSTACK_FREE free -# endif -#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */ - -#if (! defined (yyoverflow) \ - && (! defined (__cplusplus) \ - || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) - -/* A type that is properly aligned for any stack member. */ -union yyalloc +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned char yystos[] = { - short yyss; - YYSTYPE yyvs; -# if YYLSP_NEEDED - YYLTYPE yyls; -# endif + 0, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 60, 64, 67, 68, 74, + 80, 84, 85, 86, 87, 90, 81, 81, 81, 81, + 81, 0, 80, 85, 81, 61, 62, 63, 92, 61, + 62, 65, 66, 93, 36, 38, 89, 69, 70, 71, + 72, 88, 73, 92, 55, 56, 57, 58, 59, 91, + 82, 94, 94, 94, 6, 94, 94, 94, 94, 89, + 6, 89, 94 }; -/* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) - -/* The size of an array large to enough to hold all stacks, each with - N elements. */ -# if YYLSP_NEEDED -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ - + 2 * YYSTACK_GAP_MAX) -# else -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAX) -# endif - -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if 1 < __GNUC__ -# define YYCOPY(To, From, Count) \ - __builtin_memcpy (To, From, (Count) * sizeof (*(From))) -# else -# define YYCOPY(To, From, Count) \ - do \ - { \ - register YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } \ - while (0) -# endif -# endif - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - elements in the stack, and YYPTR gives the new location of the - stack. Advance YYPTR to a properly aligned location for the next - stack. */ -# define YYSTACK_RELOCATE(Stack) \ - do \ - { \ - YYSIZE_T yynewbytes; \ - YYCOPY (&yyptr->Stack, Stack, yysize); \ - Stack = &yyptr->Stack; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ - yyptr += yynewbytes / sizeof (*yyptr); \ - } \ - while (0) - -#endif - - #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) # define YYSIZE_T __SIZE_TYPE__ #endif @@ -515,71 +665,93 @@ union yyalloc #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) -#define YYEMPTY -2 +#define YYEMPTY (-2) #define YYEOF 0 + #define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrlab1 +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ + #define YYFAIL goto yyerrlab + #define YYRECOVERING() (!!yyerrstatus) + #define YYBACKUP(Token, Value) \ do \ if (yychar == YYEMPTY && yylen == 1) \ { \ yychar = (Token); \ yylval = (Value); \ - yychar1 = YYTRANSLATE (yychar); \ + yytoken = YYTRANSLATE (yychar); \ YYPOPSTACK; \ goto yybackup; \ } \ else \ { \ - yyerror ("syntax error: cannot back up"); \ + yyerror ("syntax error: cannot back up");\ YYERROR; \ } \ while (0) + #define YYTERROR 1 #define YYERRCODE 256 -/* YYLLOC_DEFAULT -- Compute the default location (before the actions - are run). - - When YYLLOC_DEFAULT is run, CURRENT is set the location of the - first token. By default, to implement support for ranges, extend - its range to the last symbol. */ +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) #ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - Current.last_line = Rhs[N].last_line; \ - Current.last_column = Rhs[N].last_column; +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (0) #endif -/* YYLEX -- calling `yylex' with the right arguments. */ +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ -#if YYPURE -# if YYLSP_NEEDED -# ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) -# else -# define YYLEX yylex (&yylval, &yylloc) -# endif -# else /* !YYLSP_NEEDED */ -# ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval, YYLEX_PARAM) -# else -# define YYLEX yylex (&yylval) -# endif -# endif /* !YYLSP_NEEDED */ -#else /* !YYPURE */ -# define YYLEX yylex () -#endif /* !YYPURE */ +#ifndef YY_LOCATION_PRINT +# if YYLTYPE_IS_TRIVIAL +# define YY_LOCATION_PRINT(File, Loc) \ + fprintf (File, "%d.%d-%d.%d", \ + (Loc).first_line, (Loc).first_column, \ + (Loc).last_line, (Loc).last_column) +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ +#ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, YYLEX_PARAM) +#else +# define YYLEX yylex (&yylval) +#endif /* Enable debugging if requested. */ #if YYDEBUG @@ -594,13 +766,86 @@ do { \ if (yydebug) \ YYFPRINTF Args; \ } while (0) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yysymprint (stderr, \ + Type, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_stack_print (short int *bottom, short int *top) +#else +static void +yy_stack_print (bottom, top) + short int *bottom; + short int *top; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (/* Nothing. */; bottom <= top; ++bottom) + YYFPRINTF (stderr, " %d", *bottom); + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_reduce_print (int yyrule) +#else +static void +yy_reduce_print (yyrule) + int yyrule; +#endif +{ + int yyi; + unsigned int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", + yyrule - 1, yylno); + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) + YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); + YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (Rule); \ +} while (0) + /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ int yydebug; #else /* !YYDEBUG */ # define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) #endif /* !YYDEBUG */ + /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH # define YYINITDEPTH 200 @@ -613,15 +858,13 @@ int yydebug; SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) evaluated with infinite-precision integer arithmetic. */ -#if YYMAXDEPTH == 0 -# undef YYMAXDEPTH -#endif - #ifndef YYMAXDEPTH # define YYMAXDEPTH 10000 #endif + -#ifdef YYERROR_VERBOSE + +#if YYERROR_VERBOSE # ifndef yystrlen # if defined (__GLIBC__) && defined (_STRING_H) @@ -671,86 +914,139 @@ yystpcpy (yydest, yysrc) } # endif # endif -#endif + +#endif /* !YYERROR_VERBOSE */ + -#line 315 "/home/mdh/sourceforge/bison/share/bison/bison.simple" +#if YYDEBUG +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) +#else +static void +yysymprint (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# endif + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyoutput, ")"); +} + +#endif /* ! YYDEBUG */ +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yymsg, yytype, yyvaluep) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); -/* The user can define YYPARSE_PARAM as the name of an argument to be passed - into yyparse. The argument should have type void *. - It should actually point to an object. - Grammar actions can access the variable by casting it - to the proper pointer type. */ + switch (yytype) + { + + default: + break; + } +} + + +/* Prevent warnings from -Wmissing-prototypes. */ #ifdef YYPARSE_PARAM # if defined (__STDC__) || defined (__cplusplus) -# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM -# define YYPARSE_PARAM_DECL +int yyparse (void *YYPARSE_PARAM); # else -# define YYPARSE_PARAM_ARG YYPARSE_PARAM -# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +int yyparse (); # endif -#else /* !YYPARSE_PARAM */ -# define YYPARSE_PARAM_ARG -# define YYPARSE_PARAM_DECL -#endif /* !YYPARSE_PARAM */ - -/* Prevent warning if -Wstrict-prototypes. */ -#ifdef __GNUC__ -# ifdef YYPARSE_PARAM -int yyparse (void *); -# else +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) int yyparse (void); -# endif +#else +int yyparse (); #endif +#endif /* ! YYPARSE_PARAM */ -/* YY_DECL_VARIABLES -- depending whether we use a pure parser, - variables are global, or local to YYPARSE. */ - -#define YY_DECL_NON_LSP_VARIABLES \ -/* The lookahead symbol. */ \ -int yychar; \ - \ -/* The semantic value of the lookahead symbol. */ \ -YYSTYPE yylval; \ - \ -/* Number of parse errors so far. */ \ -int yynerrs; -#if YYLSP_NEEDED -# define YY_DECL_VARIABLES \ -YY_DECL_NON_LSP_VARIABLES \ - \ -/* Location data for the lookahead symbol. */ \ -YYLTYPE yylloc; -#else -# define YY_DECL_VARIABLES \ -YY_DECL_NON_LSP_VARIABLES -#endif -/* If nonreentrant, generate the variables here. */ -#if !YYPURE -YY_DECL_VARIABLES -#endif /* !YYPURE */ +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM) +# else +int yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +# endif +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) +int +yyparse (void) +#else int -yyparse (YYPARSE_PARAM_ARG) - YYPARSE_PARAM_DECL +yyparse () + +#endif +#endif { - /* If reentrant, generate the variables here. */ -#if YYPURE - YY_DECL_VARIABLES -#endif /* !YYPURE */ + /* The look-ahead symbol. */ +int yychar; + +/* The semantic value of the look-ahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; register int yystate; register int yyn; int yyresult; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; - /* Lookahead token as an internal (translated) token number. */ - int yychar1 = 0; + /* Look-ahead token as an internal (translated) token number. */ + int yytoken = 0; /* Three stacks and their tools: `yyss': related to states, @@ -760,41 +1056,29 @@ yyparse (YYPARSE_PARAM_ARG) Refer to the stacks thru separate pointers, to allow yyoverflow to reallocate them elsewhere. */ - /* The state stack. */ - short yyssa[YYINITDEPTH]; - short *yyss = yyssa; - register short *yyssp; + /* The state stack. */ + short int yyssa[YYINITDEPTH]; + short int *yyss = yyssa; + register short int *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE *yyvs = yyvsa; register YYSTYPE *yyvsp; -#if YYLSP_NEEDED - /* The location stack. */ - YYLTYPE yylsa[YYINITDEPTH]; - YYLTYPE *yyls = yylsa; - YYLTYPE *yylsp; -#endif -#if YYLSP_NEEDED -# define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) -#else -# define YYPOPSTACK (yyvsp--, yyssp--) -#endif - YYSIZE_T yystacksize = YYINITDEPTH; +#define YYPOPSTACK (yyvsp--, yyssp--) + YYSIZE_T yystacksize = YYINITDEPTH; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; -#if YYLSP_NEEDED - YYLTYPE yyloc; -#endif + /* When reducing, the number of symbols on the RHS of the reduced - rule. */ + rule. */ int yylen; YYDPRINTF ((stderr, "Starting parse\n")); @@ -811,9 +1095,10 @@ yyparse (YYPARSE_PARAM_ARG) yyssp = yyss; yyvsp = yyvs; -#if YYLSP_NEEDED - yylsp = yyls; -#endif + + + yyvsp[0] = yylval; + goto yysetstate; /*------------------------------------------------------------. @@ -828,7 +1113,7 @@ yyparse (YYPARSE_PARAM_ARG) yysetstate: *yyssp = yystate; - if (yyssp >= yyss + yystacksize - 1) + if (yyss + yystacksize - 1 <= yyssp) { /* Get the current used size of the three stacks, in elements. */ YYSIZE_T yysize = yyssp - yyss + 1; @@ -839,26 +1124,19 @@ yyparse (YYPARSE_PARAM_ARG) these so that the &'s don't force the real ones into memory. */ YYSTYPE *yyvs1 = yyvs; - short *yyss1 = yyss; + short int *yyss1 = yyss; + /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. */ -# if YYLSP_NEEDED - YYLTYPE *yyls1 = yyls; - /* This used to be a conditional around just the two extra args, - but that might be undefined if yyoverflow is a macro. */ - yyoverflow ("parser stack overflow", - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), - &yyls1, yysize * sizeof (*yylsp), - &yystacksize); - yyls = yyls1; -# else + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ yyoverflow ("parser stack overflow", &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); -# endif + yyss = yyss1; yyvs = yyvs1; } @@ -867,24 +1145,22 @@ yyparse (YYPARSE_PARAM_ARG) goto yyoverflowlab; # else /* Extend the stack our own way. */ - if (yystacksize >= YYMAXDEPTH) + if (YYMAXDEPTH <= yystacksize) goto yyoverflowlab; yystacksize *= 2; - if (yystacksize > YYMAXDEPTH) + if (YYMAXDEPTH < yystacksize) yystacksize = YYMAXDEPTH; { - short *yyss1 = yyss; + short int *yyss1 = yyss; union yyalloc *yyptr = (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); if (! yyptr) goto yyoverflowlab; YYSTACK_RELOCATE (yyss); YYSTACK_RELOCATE (yyvs); -# if YYLSP_NEEDED - YYSTACK_RELOCATE (yyls); -# endif -# undef YYSTACK_RELOCATE + +# undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } @@ -893,14 +1169,12 @@ yyparse (YYPARSE_PARAM_ARG) yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; -#if YYLSP_NEEDED - yylsp = yyls + yysize - 1; -#endif + YYDPRINTF ((stderr, "Stack size increased to %lu\n", (unsigned long int) yystacksize)); - if (yyssp >= yyss + yystacksize - 1) + if (yyss + yystacksize - 1 <= yyssp) YYABORT; } @@ -908,101 +1182,67 @@ yyparse (YYPARSE_PARAM_ARG) goto yybackup; - /*-----------. | yybackup. | `-----------*/ yybackup: /* Do appropriate processing given the current state. */ -/* Read a lookahead token if we need one and don't already have one. */ +/* Read a look-ahead token if we need one and don't already have one. */ /* yyresume: */ - /* First try to decide what to do without reference to lookahead token. */ + /* First try to decide what to do without reference to look-ahead token. */ yyn = yypact[yystate]; - if (yyn == YYFLAG) + if (yyn == YYPACT_NINF) goto yydefault; - /* Not known => get a lookahead token if don't already have one. */ - - /* yychar is either YYEMPTY or YYEOF - or a valid token in external form. */ + /* Not known => get a look-ahead token if don't already have one. */ + /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; } - /* Convert token to internal form (in yychar1) for indexing tables with */ - - if (yychar <= 0) /* This means end of input. */ + if (yychar <= YYEOF) { - yychar1 = 0; - yychar = YYEOF; /* Don't call YYLEX any more */ - + yychar = yytoken = YYEOF; YYDPRINTF ((stderr, "Now at end of input.\n")); } else { - yychar1 = YYTRANSLATE (yychar); - -#if YYDEBUG - /* We have to keep this `#if YYDEBUG', since we use variables - which are defined only if `YYDEBUG' is set. */ - if (yydebug) - { - YYFPRINTF (stderr, "Next token is %d (%s", - yychar, yytname[yychar1]); - /* Give the individual parser a way to print the precise - meaning of a token, for further debugging info. */ -# ifdef YYPRINT - YYPRINT (stderr, yychar, yylval); -# endif - YYFPRINTF (stderr, ")\n"); - } -#endif + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); } - yyn += yychar1; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) goto yydefault; - yyn = yytable[yyn]; - - /* yyn is what to do for this token type in this state. - Negative => reduce, -yyn is rule number. - Positive => shift, yyn is new state. - New state is final state => don't bother to shift, - just return success. - 0, or most negative number => error. */ - - if (yyn < 0) + if (yyn <= 0) { - if (yyn == YYFLAG) + if (yyn == 0 || yyn == YYTABLE_NINF) goto yyerrlab; yyn = -yyn; goto yyreduce; } - else if (yyn == 0) - goto yyerrlab; if (yyn == YYFINAL) YYACCEPT; - /* Shift the lookahead token. */ - YYDPRINTF ((stderr, "Shifting token %d (%s), ", - yychar, yytname[yychar1])); + /* Shift the look-ahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; *++yyvsp = yylval; -#if YYLSP_NEEDED - *++yylsp = yylloc; -#endif + /* Count tokens shifted since error; after three, turn off error status. */ @@ -1033,241 +1273,246 @@ yyparse (YYPARSE_PARAM_ARG) /* If YYLEN is nonzero, implement the default value of the action: `$$ = $1'. - Otherwise, the following line sets YYVAL to the semantic value of - the lookahead token. This behavior is undocumented and Bison + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; -#if YYLSP_NEEDED - /* Similarly for the default location. Let the user run additional - commands if for instance locations are ranges. */ - yyloc = yylsp[1-yylen]; - YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); -#endif -#if YYDEBUG - /* We have to keep this `#if YYDEBUG', since we use variables which - are defined only if `YYDEBUG' is set. */ - if (yydebug) + YY_REDUCE_PRINT (yyn); + switch (yyn) { - int yyi; - - YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", - yyn, yyrline[yyn]); - - /* Print the symbols being reduced, and their result. */ - for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++) - YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); - YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); - } -#endif - - switch (yyn) { - -case 6: + case 7: #line 203 "sdfcpars.yy" -{ - if( ! setMap( yyvsp[-3].stype, yyvsp[-1].vtype ) ) { + { + if( ! setMap( (yyvsp[-3].stype), (yyvsp[-1].vtype) ) ) { sdfconfig_error( "illegal construct mapping" ); } } break; -case 7: + + case 8: #line 209 "sdfcpars.yy" -{ - setInterconnectMipd( yyvsp[-1].dtype ); + { + setInterconnectMipd( (yyvsp[-1].dtype) ); } break; -case 8: + + case 9: #line 213 "sdfcpars.yy" -{ - setMTMSpec( yyvsp[-1].dtype ); + { + setMTMSpec( (yyvsp[-1].dtype) ); } break; -case 9: + + case 10: #line 217 "sdfcpars.yy" -{ + { setMTMSpec( eTOOL_CONTROL ); } break; -case 10: + + case 11: #line 221 "sdfcpars.yy" -{ - setScaleFactors( yyvsp[-5].floating, yyvsp[-3].floating, yyvsp[-1].floating ); + { + setScaleFactors( (yyvsp[-5].floating), (yyvsp[-3].floating), (yyvsp[-1].floating) ); } break; -case 11: + + case 12: #line 225 "sdfcpars.yy" -{ - setScaleType( yyvsp[-1].etype ); + { + setScaleType( (yyvsp[-1].etype) ); } break; -case 12: + + case 13: #line 229 "sdfcpars.yy" -{ - setTurnOffDelay( yyvsp[-1].dtype ); + { + setTurnOffDelay( (yyvsp[-1].dtype) ); } break; -case 13: + + case 14: #line 233 "sdfcpars.yy" -{ + { setTurnOffDelay( eFROM_FILE ); } break; -case 14: + + case 15: #line 240 "sdfcpars.yy" -{ yyval.etype = eFROM_MINIMUM; } + { (yyval.etype) = eFROM_MINIMUM; } break; -case 15: + + case 16: #line 242 "sdfcpars.yy" -{ yyval.etype = eFROM_TYPICAL; } + { (yyval.etype) = eFROM_TYPICAL; } break; -case 16: + + case 17: #line 244 "sdfcpars.yy" -{ yyval.etype = eFROM_MAXIMUM; } + { (yyval.etype) = eFROM_MAXIMUM; } break; -case 17: + + case 18: #line 246 "sdfcpars.yy" -{ yyval.etype = eFROM_MTM; } + { (yyval.etype) = eFROM_MTM; } break; -case 19: + + case 20: #line 252 "sdfcpars.yy" -{ - yyval.floating = (double) yyvsp[0].integer; + { + (yyval.floating) = (double) (yyvsp[0].integer); } break; -case 20: + + case 21: #line 259 "sdfcpars.yy" -{ yyval.stype = eIOPATH; } + { (yyval.stype) = eIOPATH; } break; -case 21: + + case 22: #line 261 "sdfcpars.yy" -{ yyval.stype = ePORT; } + { (yyval.stype) = ePORT; } break; -case 22: + + case 23: #line 263 "sdfcpars.yy" -{ yyval.stype = eINTERCONNECT; } + { (yyval.stype) = eINTERCONNECT; } break; -case 23: + + case 24: #line 265 "sdfcpars.yy" -{ yyval.stype = eNETDELAY; } + { (yyval.stype) = eNETDELAY; } break; -case 24: + + case 25: #line 267 "sdfcpars.yy" -{ yyval.stype = eDEVICE; } + { (yyval.stype) = eDEVICE; } break; -case 25: + + case 26: #line 269 "sdfcpars.yy" -{ yyval.stype = eSETUP; } + { (yyval.stype) = eSETUP; } break; -case 26: + + case 27: #line 271 "sdfcpars.yy" -{ yyval.stype = eHOLD; } + { (yyval.stype) = eHOLD; } break; -case 27: + + case 28: #line 273 "sdfcpars.yy" -{ yyval.stype = eSETUPHOLD; } + { (yyval.stype) = eSETUPHOLD; } break; -case 28: + + case 29: #line 275 "sdfcpars.yy" -{ yyval.stype = eRECOVERY; } + { (yyval.stype) = eRECOVERY; } break; -case 29: + + case 30: #line 277 "sdfcpars.yy" -{ yyval.stype = eSKEW; } + { (yyval.stype) = eSKEW; } break; -case 30: + + case 31: #line 279 "sdfcpars.yy" -{ yyval.stype = eWIDTH; } + { (yyval.stype) = eWIDTH; } break; -case 31: + + case 32: #line 281 "sdfcpars.yy" -{ yyval.stype = ePERIOD; } + { (yyval.stype) = ePERIOD; } break; -case 32: + + case 33: #line 283 "sdfcpars.yy" -{ yyval.stype = eNOCHANGE; } + { (yyval.stype) = eNOCHANGE; } break; -case 33: + + case 34: #line 285 "sdfcpars.yy" -{ yyval.stype = ePATHPULSE; } + { (yyval.stype) = ePATHPULSE; } break; -case 34: + + case 35: #line 290 "sdfcpars.yy" -{ yyval.vtype = eVIGNORE; } + { (yyval.vtype) = eVIGNORE; } break; -case 35: + + case 36: #line 292 "sdfcpars.yy" -{ yyval.vtype = eVINTERMODPATH; } + { (yyval.vtype) = eVINTERMODPATH; } break; -case 36: + + case 37: #line 294 "sdfcpars.yy" -{ yyval.vtype = eVMIPD; } + { (yyval.vtype) = eVMIPD; } break; -case 37: + + case 38: #line 296 "sdfcpars.yy" -{ yyval.vtype = eVCELL; } + { (yyval.vtype) = eVCELL; } break; -case 38: + + case 39: #line 298 "sdfcpars.yy" -{ yyval.vtype = eVUSE; } + { (yyval.vtype) = eVUSE; } break; -case 39: + + case 40: #line 303 "sdfcpars.yy" -{ yyval.dtype = eMINIMUM; } + { (yyval.dtype) = eMINIMUM; } break; -case 40: + + case 41: #line 305 "sdfcpars.yy" -{ yyval.dtype = eMAXIMUM; } + { (yyval.dtype) = eMAXIMUM; } break; -case 41: + + case 42: #line 307 "sdfcpars.yy" -{ yyval.dtype = eAVERAGE; } + { (yyval.dtype) = eAVERAGE; } break; -case 42: + + case 43: #line 312 "sdfcpars.yy" -{ yyval.dtype = eMINIMUM; } + { (yyval.dtype) = eMINIMUM; } break; -case 43: + + case 44: #line 314 "sdfcpars.yy" -{ yyval.dtype = eTYPICAL; } + { (yyval.dtype) = eTYPICAL; } break; -case 44: + + case 45: #line 316 "sdfcpars.yy" -{ yyval.dtype = eMAXIMUM; } + { (yyval.dtype) = eMAXIMUM; } break; -case 45: + + case 46: #line 326 "sdfcpars.yy" -{ yyerrok; } + { yyerrok; } break; -} -#line 705 "/home/mdh/sourceforge/bison/share/bison/bison.simple" + } + +/* Line 1037 of yacc.c. */ +#line 1507 "sdfcpars.cc" yyvsp -= yylen; yyssp -= yylen; -#if YYLSP_NEEDED - yylsp -= yylen; -#endif -#if YYDEBUG - if (yydebug) - { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); - } -#endif + + YY_STACK_PRINT (yyss, yyssp); *++yyvsp = yyval; -#if YYLSP_NEEDED - *++yylsp = yyloc; -#endif + /* Now `shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule @@ -1275,11 +1520,11 @@ case 45: yyn = yyr1[yyn]; - yystate = yypgoto[yyn - YYNTBASE] + *yyssp; - if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else - yystate = yydefgoto[yyn - YYNTBASE]; + yystate = yydefgoto[yyn - YYNTOKENS]; goto yynewstate; @@ -1292,155 +1537,159 @@ case 45: if (!yyerrstatus) { ++yynerrs; - -#ifdef YYERROR_VERBOSE +#if YYERROR_VERBOSE yyn = yypact[yystate]; - if (yyn > YYFLAG && yyn < YYLAST) + if (YYPACT_NINF < yyn && yyn < YYLAST) { YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + const char* yyprefix; char *yymsg; - int yyx, yycount; + int yyx; - yycount = 0; /* Start YYX at -YYN if negative to avoid negative indexes in YYCHECK. */ - for (yyx = yyn < 0 ? -yyn : 0; - yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) - if (yycheck[yyx + yyn] == yyx) - yysize += yystrlen (yytname[yyx]) + 15, yycount++; - yysize += yystrlen ("parse error, unexpected ") + 1; - yysize += yystrlen (yytname[YYTRANSLATE (yychar)]); + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 0; + + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); + yycount += 1; + if (yycount == 5) + { + yysize = 0; + break; + } + } + yysize += (sizeof ("syntax error, unexpected ") + + yystrlen (yytname[yytype])); yymsg = (char *) YYSTACK_ALLOC (yysize); if (yymsg != 0) { - char *yyp = yystpcpy (yymsg, "parse error, unexpected "); - yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]); + char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); if (yycount < 5) { - yycount = 0; - for (yyx = yyn < 0 ? -yyn : 0; - yyx < (int) (sizeof (yytname) / sizeof (char *)); - yyx++) - if (yycheck[yyx + yyn] == yyx) + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) { - const char *yyq = ! yycount ? ", expecting " : " or "; - yyp = yystpcpy (yyp, yyq); + yyp = yystpcpy (yyp, yyprefix); yyp = yystpcpy (yyp, yytname[yyx]); - yycount++; + yyprefix = " or "; } } yyerror (yymsg); YYSTACK_FREE (yymsg); } else - yyerror ("parse error; also virtual memory exhausted"); + yyerror ("syntax error; also virtual memory exhausted"); } else -#endif /* defined (YYERROR_VERBOSE) */ - yyerror ("parse error"); +#endif /* YYERROR_VERBOSE */ + yyerror ("syntax error"); } - goto yyerrlab1; -/*--------------------------------------------------. -| yyerrlab1 -- error raised explicitly by an action | -`--------------------------------------------------*/ -yyerrlab1: + if (yyerrstatus == 3) { - /* If just tried and failed to reuse lookahead token after an + /* If just tried and failed to reuse look-ahead token after an error, discard it. */ - /* return failure if at end of input */ - if (yychar == YYEOF) - YYABORT; - YYDPRINTF ((stderr, "Discarding token %d (%s).\n", - yychar, yytname[yychar1])); - yychar = YYEMPTY; + if (yychar <= YYEOF) + { + /* If at end of input, pop the error token, + then the rest of the stack, then return failure. */ + if (yychar == YYEOF) + for (;;) + { + + YYPOPSTACK; + if (yyssp == yyss) + YYABORT; + yydestruct ("Error: popping", + yystos[*yyssp], yyvsp); + } + } + else + { + yydestruct ("Error: discarding", yytoken, &yylval); + yychar = YYEMPTY; + } } - /* Else will try to reuse lookahead token after shifting the error + /* Else will try to reuse look-ahead token after shifting the error token. */ - - yyerrstatus = 3; /* Each real token shifted decrements this */ - - goto yyerrhandle; + goto yyerrlab1; -/*-------------------------------------------------------------------. -| yyerrdefault -- current state does not do anything special for the | -| error token. | -`-------------------------------------------------------------------*/ -yyerrdefault: -#if 0 - /* This is wrong; only states that explicitly want error tokens - should shift them. */ +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: - /* If its default is to accept any token, ok. Otherwise pop it. */ - yyn = yydefact[yystate]; - if (yyn) - goto yydefault; +#ifdef __GNUC__ + /* Pacify GCC when the user code never invokes YYERROR and the label + yyerrorlab therefore never appears in user code. */ + if (0) + goto yyerrorlab; #endif +yyvsp -= yylen; + yyssp -= yylen; + yystate = *yyssp; + goto yyerrlab1; -/*---------------------------------------------------------------. -| yyerrpop -- pop the current state because it cannot handle the | -| error token | -`---------------------------------------------------------------*/ -yyerrpop: - if (yyssp == yyss) - YYABORT; - yyvsp--; - yystate = *--yyssp; -#if YYLSP_NEEDED - yylsp--; -#endif -#if YYDEBUG - if (yydebug) +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "Error: state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); - } -#endif + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } -/*--------------. -| yyerrhandle. | -`--------------*/ -yyerrhandle: - yyn = yypact[yystate]; - if (yyn == YYFLAG) - goto yyerrdefault; + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; - yyn += YYTERROR; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) - goto yyerrdefault; - yyn = yytable[yyn]; - if (yyn < 0) - { - if (yyn == YYFLAG) - goto yyerrpop; - yyn = -yyn; - goto yyreduce; + yydestruct ("Error: popping", yystos[yystate], yyvsp); + YYPOPSTACK; + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); } - else if (yyn == 0) - goto yyerrpop; if (yyn == YYFINAL) YYACCEPT; - YYDPRINTF ((stderr, "Shifting error token, ")); - *++yyvsp = yylval; -#if YYLSP_NEEDED - *++yylsp = yylloc; -#endif + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); yystate = yyn; goto yynewstate; @@ -1457,16 +1706,21 @@ case 45: | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ yyabortlab: + yydestruct ("Error: discarding lookahead", + yytoken, &yylval); + yychar = YYEMPTY; yyresult = 1; goto yyreturn; -/*---------------------------------------------. -| yyoverflowab -- parser overflow comes here. | -`---------------------------------------------*/ +#ifndef yyoverflow +/*----------------------------------------------. +| yyoverflowlab -- parser overflow comes here. | +`----------------------------------------------*/ yyoverflowlab: yyerror ("parser stack overflow"); yyresult = 2; /* Fall through. */ +#endif yyreturn: #ifndef yyoverflow @@ -1475,6 +1729,9 @@ case 45: #endif return yyresult; } + + #line 329 "sdfcpars.yy" + diff --git a/src/sdfcpars.h b/src/sdfcpars.h index fa2c71e..37f9e23 100644 --- a/src/sdfcpars.h +++ b/src/sdfcpars.h @@ -1,8 +1,171 @@ -#ifndef BISON_SDFCPARS_H -# define BISON_SDFCPARS_H +/* A Bison parser, made by GNU Bison 2.0. */ -#ifndef YYSTYPE -typedef union { +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + IF = 258, + ELSE = 259, + OROR = 260, + ANDAND = 261, + ANDANDAND = 262, + XNOR = 263, + CASE_INEQUALITY = 264, + CASE_EQUALITY = 265, + LOGICAL_INEQUALITY = 266, + LOGICAL_EQUALITY = 267, + GE = 268, + GT = 269, + LE = 270, + LT = 271, + RIGHT_SHIFT = 272, + LEFT_SHIFT = 273, + REDUCTION_NOR = 274, + REDUCTION_NAND = 275, + UNARY = 276, + INTEGER = 277, + SCALAR_CONSTANT = 278, + FLOATING = 279, + QSTRING = 280, + IDENTIFIER = 281, + IOPATH = 282, + PORT = 283, + INTERCONNECT = 284, + NETDELAY = 285, + DEVICE = 286, + SETUP = 287, + HOLD = 288, + SETUPHOLD = 289, + RECOVERY = 290, + SKEW = 291, + WIDTH = 292, + PERIOD = 293, + NOCHANGE = 294, + PATHPULSE = 295, + IGNORE = 296, + INTERMOD_PATH = 297, + MIPD = 298, + CELL = 299, + USE = 300, + INTERCONNECT_MIPD = 301, + MINIMUM = 302, + MAXIMUM = 303, + AVERAGE = 304, + MTM = 305, + TOOL_CONTROL = 306, + TYPICAL = 307, + SCALE_FACTORS = 308, + SCALE_TYPE = 309, + FROM_MINIMUM = 310, + FROM_TYPICAL = 311, + FROM_MAXIMUM = 312, + FROM_MTM = 313, + FROM_FILE = 314, + TURNOFF_DELAY = 315, + TURNON_DELAY = 316, + MODULE = 317, + MAP_INNER = 318, + ADD = 319, + OVERRIDE = 320, + EOF_ = 321 + }; +#endif +#define IF 258 +#define ELSE 259 +#define OROR 260 +#define ANDAND 261 +#define ANDANDAND 262 +#define XNOR 263 +#define CASE_INEQUALITY 264 +#define CASE_EQUALITY 265 +#define LOGICAL_INEQUALITY 266 +#define LOGICAL_EQUALITY 267 +#define GE 268 +#define GT 269 +#define LE 270 +#define LT 271 +#define RIGHT_SHIFT 272 +#define LEFT_SHIFT 273 +#define REDUCTION_NOR 274 +#define REDUCTION_NAND 275 +#define UNARY 276 +#define INTEGER 277 +#define SCALAR_CONSTANT 278 +#define FLOATING 279 +#define QSTRING 280 +#define IDENTIFIER 281 +#define IOPATH 282 +#define PORT 283 +#define INTERCONNECT 284 +#define NETDELAY 285 +#define DEVICE 286 +#define SETUP 287 +#define HOLD 288 +#define SETUPHOLD 289 +#define RECOVERY 290 +#define SKEW 291 +#define WIDTH 292 +#define PERIOD 293 +#define NOCHANGE 294 +#define PATHPULSE 295 +#define IGNORE 296 +#define INTERMOD_PATH 297 +#define MIPD 298 +#define CELL 299 +#define USE 300 +#define INTERCONNECT_MIPD 301 +#define MINIMUM 302 +#define MAXIMUM 303 +#define AVERAGE 304 +#define MTM 305 +#define TOOL_CONTROL 306 +#define TYPICAL 307 +#define SCALE_FACTORS 308 +#define SCALE_TYPE 309 +#define FROM_MINIMUM 310 +#define FROM_TYPICAL 311 +#define FROM_MAXIMUM 312 +#define FROM_MTM 313 +#define FROM_FILE 314 +#define TURNOFF_DELAY 315 +#define TURNON_DELAY 316 +#define MODULE 317 +#define MAP_INNER 318 +#define ADD 319 +#define OVERRIDE 320 +#define EOF_ 321 + + + + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +#line 96 "sdfcpars.yy" +typedef union YYSTYPE { int integer; double floating; char *ptr; @@ -10,74 +173,15 @@ typedef union { eDelayType_t dtype; eSDFConstruct_t stype; eVerilogConstruct_t vtype; -} yystype; -# define YYSTYPE yystype +} YYSTYPE; +/* Line 1318 of yacc.c. */ +#line 179 "sdfcpars.h" +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 #endif -# define IF 257 -# define ELSE 258 -# define OROR 259 -# define ANDAND 260 -# define ANDANDAND 261 -# define XNOR 262 -# define LOGICAL_EQUALITY 263 -# define LOGICAL_INEQUALITY 264 -# define CASE_EQUALITY 265 -# define CASE_INEQUALITY 266 -# define LT 267 -# define LE 268 -# define GT 269 -# define GE 270 -# define LEFT_SHIFT 271 -# define RIGHT_SHIFT 272 -# define REDUCTION_NOR 273 -# define REDUCTION_NAND 274 -# define UNARY 275 -# define INTEGER 276 -# define SCALAR_CONSTANT 277 -# define FLOATING 278 -# define QSTRING 279 -# define IDENTIFIER 280 -# define IOPATH 281 -# define PORT 282 -# define INTERCONNECT 283 -# define NETDELAY 284 -# define DEVICE 285 -# define SETUP 286 -# define HOLD 287 -# define SETUPHOLD 288 -# define RECOVERY 289 -# define SKEW 290 -# define WIDTH 291 -# define PERIOD 292 -# define NOCHANGE 293 -# define PATHPULSE 294 -# define IGNORE 295 -# define INTERMOD_PATH 296 -# define MIPD 297 -# define CELL 298 -# define USE 299 -# define INTERCONNECT_MIPD 300 -# define MINIMUM 301 -# define MAXIMUM 302 -# define AVERAGE 303 -# define MTM 304 -# define TOOL_CONTROL 305 -# define TYPICAL 306 -# define SCALE_FACTORS 307 -# define SCALE_TYPE 308 -# define FROM_MINIMUM 309 -# define FROM_TYPICAL 310 -# define FROM_MAXIMUM 311 -# define FROM_MTM 312 -# define FROM_FILE 313 -# define TURNOFF_DELAY 314 -# define TURNON_DELAY 315 -# define MODULE 316 -# define MAP_INNER 317 -# define ADD 318 -# define OVERRIDE 319 -# define EOF_ 320 -#endif /* not BISON_SDFCPARS_H */ + + + diff --git a/src/sdfparse.cc b/src/sdfparse.cc index 0cd7a3d..2620072 100644 --- a/src/sdfparse.cc +++ b/src/sdfparse.cc @@ -1,87 +1,221 @@ -/* A Bison parser, made from /home/mdh/sourceforge/veriwell/src/sdfparse.yy - by GNU bison 1.35. */ - -#define YYBISON 1 /* Identify Bison output. */ - -# define IF 257 -# define ELSE 258 -# define OROR 259 -# define ANDAND 260 -# define ANDANDAND 261 -# define XNOR 262 -# define LOGICAL_EQUALITY 263 -# define LOGICAL_INEQUALITY 264 -# define CASE_EQUALITY 265 -# define CASE_INEQUALITY 266 -# define LT 267 -# define LE 268 -# define GT 269 -# define GE 270 -# define LEFT_SHIFT 271 -# define RIGHT_SHIFT 272 -# define REDUCTION_NOR 273 -# define REDUCTION_NAND 274 -# define UNARY 275 -# define INTEGER 276 -# define SCALAR_CONSTANT 277 -# define FLOATING 278 -# define QSTRING 279 -# define IDENTIFIER 280 -# define BLOB 281 -# define POSEDGE 282 -# define NEGEDGE 283 -# define DELAYFILE 284 -# define SDFVERSION 285 -# define DESIGN 286 -# define DATE 287 -# define VENDOR 288 -# define PROGRAM 289 -# define VERSION_ 290 -# define DIVIDER 291 -# define VOLTAGE 292 -# define PROCESS 293 -# define TEMPERATURE 294 -# define TIMESCALE 295 -# define CELL 296 -# define CELLTYPE 297 -# define INSTANCE 298 -# define DELAY 299 -# define TIMINGCHECK 300 -# define INCLUDE 301 -# define ABSOLUTE 302 -# define INCREMENT 303 -# define USERDEF 304 -# define PATHPULSE 305 -# define GLOBALPATHPULSE 306 -# define IOPATH 307 -# define COND 308 -# define PORT 309 -# define INTERCONNECT 310 -# define NETDELAY 311 -# define DEVICE 312 -# define SETUP 313 -# define HOLD 314 -# define SETUPHOLD 315 -# define RECOVERY 316 -# define SKEW 317 -# define WIDTH 318 -# define PERIOD 319 -# define NOCHANGE 320 -# define PATHCONSTRAINT 321 -# define SUM 322 -# define DIFF 323 -# define SKEWCONSTRAINT 324 -# define MICROSECOND 325 -# define NANOSECOND 326 -# define PICOSECOND 327 -# define EDGE_01 328 -# define EDGE_10 329 -# define EDGE_0z 330 -# define EDGE_1z 331 -# define EDGE_z0 332 -# define EDGE_z1 333 -# define EOF_ 334 +/* A Bison parser, made by GNU Bison 2.0. */ +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Written by Richard Stallman by simplifying the original so called + ``semantic'' parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 1 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + IF = 258, + ELSE = 259, + OROR = 260, + ANDAND = 261, + ANDANDAND = 262, + XNOR = 263, + CASE_INEQUALITY = 264, + CASE_EQUALITY = 265, + LOGICAL_INEQUALITY = 266, + LOGICAL_EQUALITY = 267, + GE = 268, + GT = 269, + LE = 270, + LT = 271, + RIGHT_SHIFT = 272, + LEFT_SHIFT = 273, + REDUCTION_NOR = 274, + REDUCTION_NAND = 275, + UNARY = 276, + INTEGER = 277, + SCALAR_CONSTANT = 278, + FLOATING = 279, + QSTRING = 280, + IDENTIFIER = 281, + BLOB = 282, + POSEDGE = 283, + NEGEDGE = 284, + DELAYFILE = 285, + SDFVERSION = 286, + DESIGN = 287, + DATE = 288, + VENDOR = 289, + PROGRAM = 290, + VERSION_ = 291, + DIVIDER = 292, + VOLTAGE = 293, + PROCESS = 294, + TEMPERATURE = 295, + TIMESCALE = 296, + CELL = 297, + CELLTYPE = 298, + INSTANCE = 299, + DELAY = 300, + TIMINGCHECK = 301, + INCLUDE = 302, + ABSOLUTE = 303, + INCREMENT = 304, + USERDEF = 305, + PATHPULSE = 306, + GLOBALPATHPULSE = 307, + IOPATH = 308, + COND = 309, + PORT = 310, + INTERCONNECT = 311, + NETDELAY = 312, + DEVICE = 313, + SETUP = 314, + HOLD = 315, + SETUPHOLD = 316, + RECOVERY = 317, + SKEW = 318, + WIDTH = 319, + PERIOD = 320, + NOCHANGE = 321, + PATHCONSTRAINT = 322, + SUM = 323, + DIFF = 324, + SKEWCONSTRAINT = 325, + MICROSECOND = 326, + NANOSECOND = 327, + PICOSECOND = 328, + EDGE_01 = 329, + EDGE_10 = 330, + EDGE_0z = 331, + EDGE_1z = 332, + EDGE_z0 = 333, + EDGE_z1 = 334, + EOF_ = 335 + }; +#endif +#define IF 258 +#define ELSE 259 +#define OROR 260 +#define ANDAND 261 +#define ANDANDAND 262 +#define XNOR 263 +#define CASE_INEQUALITY 264 +#define CASE_EQUALITY 265 +#define LOGICAL_INEQUALITY 266 +#define LOGICAL_EQUALITY 267 +#define GE 268 +#define GT 269 +#define LE 270 +#define LT 271 +#define RIGHT_SHIFT 272 +#define LEFT_SHIFT 273 +#define REDUCTION_NOR 274 +#define REDUCTION_NAND 275 +#define UNARY 276 +#define INTEGER 277 +#define SCALAR_CONSTANT 278 +#define FLOATING 279 +#define QSTRING 280 +#define IDENTIFIER 281 +#define BLOB 282 +#define POSEDGE 283 +#define NEGEDGE 284 +#define DELAYFILE 285 +#define SDFVERSION 286 +#define DESIGN 287 +#define DATE 288 +#define VENDOR 289 +#define PROGRAM 290 +#define VERSION_ 291 +#define DIVIDER 292 +#define VOLTAGE 293 +#define PROCESS 294 +#define TEMPERATURE 295 +#define TIMESCALE 296 +#define CELL 297 +#define CELLTYPE 298 +#define INSTANCE 299 +#define DELAY 300 +#define TIMINGCHECK 301 +#define INCLUDE 302 +#define ABSOLUTE 303 +#define INCREMENT 304 +#define USERDEF 305 +#define PATHPULSE 306 +#define GLOBALPATHPULSE 307 +#define IOPATH 308 +#define COND 309 +#define PORT 310 +#define INTERCONNECT 311 +#define NETDELAY 312 +#define DEVICE 313 +#define SETUP 314 +#define HOLD 315 +#define SETUPHOLD 316 +#define RECOVERY 317 +#define SKEW 318 +#define WIDTH 319 +#define PERIOD 320 +#define NOCHANGE 321 +#define PATHCONSTRAINT 322 +#define SUM 323 +#define DIFF 324 +#define SKEWCONSTRAINT 325 +#define MICROSECOND 326 +#define NANOSECOND 327 +#define PICOSECOND 328 +#define EDGE_01 329 +#define EDGE_10 330 +#define EDGE_0z 331 +#define EDGE_1z 332 +#define EDGE_z0 333 +#define EDGE_z1 334 +#define EOF_ 335 + + + + +/* Copy the first part of user declarations. */ #line 22 "sdfparse.yy" #define YYERROR_VERBOSE @@ -152,9 +286,23 @@ void initSDFParse() } + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) #line 93 "sdfparse.yy" -#ifndef YYSTYPE -typedef union { +typedef union YYSTYPE { int integer; double floating; char *ptr; @@ -167,505 +315,39 @@ typedef union { triple_t triple; elist_t elist; port_t port; -} yystype; -# define YYSTYPE yystype +} YYSTYPE; +/* Line 190 of yacc.c. */ +#line 321 "sdfparse.cc" +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 #endif -#ifndef YYDEBUG -# define YYDEBUG 0 -#endif -#define YYFINAL 376 -#define YYFLAG -32768 -#define YYNTBASE 97 +/* Copy the second part of user declarations. */ -/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */ -#define YYTRANSLATE(x) ((unsigned)(x) <= 334 ? yytranslate[x] : 160) -/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */ -static const char yytranslate[] = -{ - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 31, 2, 2, 2, 28, 13, 2, - 29, 95, 26, 24, 2, 25, 2, 27, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 6, 2, - 2, 2, 2, 5, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 30, 2, 96, 11, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 10, 2, 32, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 3, 4, 7, - 8, 9, 12, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94 -}; - -#if YYDEBUG -static const short yyprhs[] = -{ - 0, 0, 3, 19, 24, 29, 34, 39, 44, 49, - 50, 56, 61, 65, 70, 75, 79, 85, 91, 97, - 101, 103, 106, 108, 109, 110, 119, 124, 128, 131, - 135, 139, 143, 145, 149, 150, 154, 155, 160, 161, - 166, 169, 171, 177, 179, 180, 187, 194, 201, 208, - 215, 221, 227, 234, 237, 239, 240, 246, 247, 253, - 256, 258, 261, 263, 265, 267, 269, 272, 274, 276, - 279, 286, 297, 303, 310, 316, 321, 327, 328, 335, - 346, 352, 359, 365, 370, 376, 378, 379, 383, 385, - 387, 392, 399, 403, 407, 411, 415, 419, 423, 427, - 431, 435, 437, 440, 444, 448, 452, 454, 458, 465, - 475, 488, 504, 523, 527, 534, 544, 557, 573, 592, - 598, 604, 610, 611, 617, 623, 629, 630, 632, 635, - 638, 640, 642, 644, 645, 647, 648, 650, 651, 653, - 655 -}; -static const short yyrhs[] = -{ - 98, 94, 0, 29, 44, 99, 100, 101, 102, 103, - 104, 105, 107, 108, 109, 110, 112, 158, 0, 29, - 45, 157, 158, 0, 29, 46, 157, 158, 0, 29, - 47, 157, 158, 0, 29, 48, 157, 158, 0, 29, - 49, 157, 158, 0, 29, 50, 157, 158, 0, 0, - 29, 51, 106, 41, 158, 0, 29, 52, 151, 158, - 0, 29, 52, 158, 0, 29, 53, 157, 158, 0, - 29, 54, 151, 158, 0, 29, 54, 158, 0, 29, - 55, 111, 86, 158, 0, 29, 55, 111, 85, 158, - 0, 29, 55, 111, 87, 158, 0, 29, 55, 158, - 0, 36, 0, 113, 112, 0, 113, 0, 0, 0, - 29, 56, 114, 115, 29, 116, 119, 158, 0, 29, - 57, 39, 158, 0, 117, 29, 116, 0, 117, 29, - 0, 58, 40, 158, 0, 58, 26, 158, 0, 58, - 40, 158, 0, 120, 0, 120, 29, 119, 0, 0, - 59, 127, 158, 0, 0, 60, 121, 123, 158, 0, - 0, 61, 122, 41, 158, 0, 124, 123, 0, 124, - 0, 29, 68, 125, 126, 158, 0, 126, 0, 0, - 29, 73, 142, 140, 147, 158, 0, 29, 74, 142, - 140, 147, 158, 0, 29, 75, 142, 140, 146, 158, - 0, 29, 76, 140, 140, 147, 158, 0, 29, 77, - 140, 140, 147, 158, 0, 29, 78, 140, 147, 158, - 0, 29, 79, 140, 147, 158, 0, 29, 80, 140, - 142, 146, 158, 0, 128, 127, 0, 128, 0, 0, - 29, 62, 129, 131, 158, 0, 0, 29, 63, 130, - 132, 158, 0, 137, 131, 0, 137, 0, 139, 139, - 0, 139, 0, 136, 0, 134, 0, 135, 0, 118, - 135, 0, 40, 0, 142, 0, 118, 142, 0, 29, - 67, 140, 142, 145, 158, 0, 29, 68, 138, 29, - 67, 140, 142, 145, 158, 158, 0, 29, 69, 142, - 145, 158, 0, 29, 70, 136, 136, 145, 158, 0, - 29, 71, 133, 145, 158, 0, 29, 72, 145, 158, - 0, 29, 72, 136, 145, 158, 0, 0, 29, 67, - 140, 142, 148, 158, 0, 29, 68, 138, 29, 67, - 140, 142, 148, 158, 158, 0, 29, 69, 142, 148, - 158, 0, 29, 70, 136, 136, 148, 158, 0, 29, - 71, 133, 148, 158, 0, 29, 72, 145, 158, 0, - 29, 72, 136, 148, 158, 0, 142, 0, 0, 29, - 141, 144, 0, 143, 0, 40, 0, 40, 30, 36, - 159, 0, 40, 30, 36, 6, 36, 159, 0, 42, - 142, 158, 0, 43, 142, 158, 0, 88, 142, 158, - 0, 89, 142, 158, 0, 93, 142, 158, 0, 92, - 142, 158, 0, 91, 142, 158, 0, 90, 142, 158, - 0, 29, 154, 158, 0, 149, 0, 147, 147, 0, - 29, 153, 158, 0, 29, 151, 158, 0, 29, 153, - 158, 0, 150, 0, 29, 152, 158, 0, 29, 152, - 158, 29, 152, 158, 0, 29, 152, 158, 29, 152, - 158, 29, 152, 158, 0, 29, 152, 158, 29, 152, - 158, 29, 152, 158, 29, 152, 158, 0, 29, 152, - 158, 29, 152, 158, 29, 152, 158, 29, 152, 158, - 29, 152, 158, 0, 29, 152, 158, 29, 152, 158, - 29, 152, 158, 29, 152, 158, 29, 152, 158, 29, - 152, 158, 0, 29, 151, 158, 0, 29, 151, 158, - 29, 151, 158, 0, 29, 151, 158, 29, 151, 158, - 29, 151, 158, 0, 29, 151, 158, 29, 151, 158, - 29, 151, 158, 29, 151, 158, 0, 29, 151, 158, - 29, 151, 158, 29, 151, 158, 29, 151, 158, 29, - 151, 158, 0, 29, 151, 158, 29, 151, 158, 29, - 151, 158, 29, 151, 158, 29, 151, 158, 29, 151, - 158, 0, 153, 6, 155, 6, 155, 0, 155, 6, - 153, 6, 155, 0, 155, 6, 155, 6, 153, 0, - 0, 154, 6, 156, 6, 156, 0, 156, 6, 154, - 6, 156, 0, 156, 6, 156, 6, 154, 0, 0, - 154, 0, 24, 154, 0, 25, 154, 0, 38, 0, - 36, 0, 153, 0, 0, 154, 0, 0, 39, 0, - 0, 95, 0, 96, 0, 1, 0 -}; - -#endif - -#if YYDEBUG -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const short yyrline[] = -{ - 0, 222, 226, 233, 238, 243, 248, 253, 258, 263, - 263, 268, 270, 275, 280, 282, 287, 292, 297, 302, - 310, 329, 330, 331, 334, 334, 345, 353, 354, 358, - 363, 371, 378, 379, 382, 383, 384, 384, 385, 385, - 392, 393, 397, 400, 405, 409, 413, 417, 421, 425, - 429, 433, 437, 444, 445, 449, 449, 455, 455, 464, - 465, 469, 470, 474, 475, 479, 480, 488, 498, 499, - 508, 512, 517, 521, 525, 529, 533, 540, 544, 548, - 553, 557, 561, 565, 569, 575, 576, 576, 583, 587, - 594, 603, 615, 620, 625, 630, 635, 640, 645, 650, - 659, 670, 674, 683, 694, 702, 713, 717, 722, 728, - 735, 744, 754, 769, 774, 780, 787, 796, 806, 820, - 827, 834, 841, 850, 857, 864, 871, 880, 881, 883, - 887, 888, 893, 898, 903, 908, 913, 914, 923, 928, - 930 -}; -#endif - - -#if (YYDEBUG) || defined YYERROR_VERBOSE - -/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */ -static const char *const yytname[] = -{ - "$", "error", "$undefined.", "IF", "ELSE", "'?'", "':'", "OROR", "ANDAND", - "ANDANDAND", "'|'", "'^'", "XNOR", "'&'", "LOGICAL_EQUALITY", - "LOGICAL_INEQUALITY", "CASE_EQUALITY", "CASE_INEQUALITY", "LT", "LE", - "GT", "GE", "LEFT_SHIFT", "RIGHT_SHIFT", "'+'", "'-'", "'*'", "'/'", - "'%'", "'('", "'['", "'!'", "'~'", "REDUCTION_NOR", "REDUCTION_NAND", - "UNARY", "INTEGER", "SCALAR_CONSTANT", "FLOATING", "QSTRING", - "IDENTIFIER", "BLOB", "POSEDGE", "NEGEDGE", "DELAYFILE", "SDFVERSION", - "DESIGN", "DATE", "VENDOR", "PROGRAM", "VERSION_", "DIVIDER", "VOLTAGE", - "PROCESS", "TEMPERATURE", "TIMESCALE", "CELL", "CELLTYPE", "INSTANCE", - "DELAY", "TIMINGCHECK", "INCLUDE", "ABSOLUTE", "INCREMENT", "USERDEF", - "PATHPULSE", "GLOBALPATHPULSE", "IOPATH", "COND", "PORT", - "INTERCONNECT", "NETDELAY", "DEVICE", "SETUP", "HOLD", "SETUPHOLD", - "RECOVERY", "SKEW", "WIDTH", "PERIOD", "NOCHANGE", "PATHCONSTRAINT", - "SUM", "DIFF", "SKEWCONSTRAINT", "MICROSECOND", "NANOSECOND", - "PICOSECOND", "EDGE_01", "EDGE_10", "EDGE_0z", "EDGE_1z", "EDGE_z0", - "EDGE_z1", "EOF_", "')'", "']'", "sdf", "delay_file", "sdf_version", - "design_name", "date", "vendor", "program_name", "program_version", - "hierarchy_divider", "@1", "voltage", "process", "temperature", - "time_scale", "ts", "cells", "cell", "@2", "celltype", "instances", - "instance", "string_instance", "timing_specs", "timing_spec", "@3", - "@4", "tcdefs", "tcdef", "timing_check_condition", "tcheck", "deltypes", - "deltype", "@5", "@6", "absvals", "incvals", "name", "net_instance", - "net", "port_instance", "absval", "conditional_port_expr", "incval", - "port_spec", "@7", "port_path", "port", "port_edge", "value", - "double_tc_rvalue", "tc_rvalue", "rvalue", "exp_list", "rexp_list", - "rexpression", "expression", "real", "preal", "creal", "cpreal", - "nstring", "rp", "rb", 0 -}; -#endif +/* Line 213 of yacc.c. */ +#line 333 "sdfparse.cc" -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const short yyr1[] = -{ - 0, 97, 98, 99, 100, 101, 102, 103, 104, 106, - 105, 107, 107, 108, 109, 109, 110, 110, 110, 110, - 111, 112, 112, 112, 114, 113, 115, 116, 116, 117, - 117, 118, 119, 119, 120, 120, 121, 120, 122, 120, - 123, 123, 124, 124, 125, 126, 126, 126, 126, 126, - 126, 126, 126, 127, 127, 129, 128, 130, 128, 131, - 131, 132, 132, 133, 133, 134, 134, 135, 136, 136, - 137, 137, 137, 137, 137, 137, 137, 138, 139, 139, - 139, 139, 139, 139, 139, 140, 141, 140, 142, 143, - 143, 143, 144, 144, 144, 144, 144, 144, 144, 144, - 145, 145, 146, 147, 147, 148, 148, 149, 149, 149, - 149, 149, 149, 150, 150, 150, 150, 150, 150, 151, - 151, 151, 151, 152, 152, 152, 152, 153, 153, 153, - 154, 154, 155, 155, 156, 156, 157, 157, 158, 159, - 159 -}; +#if ! defined (yyoverflow) || YYERROR_VERBOSE -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const short yyr2[] = -{ - 0, 2, 15, 4, 4, 4, 4, 4, 4, 0, - 5, 4, 3, 4, 4, 3, 5, 5, 5, 3, - 1, 2, 1, 0, 0, 8, 4, 3, 2, 3, - 3, 3, 1, 3, 0, 3, 0, 4, 0, 4, - 2, 1, 5, 1, 0, 6, 6, 6, 6, 6, - 5, 5, 6, 2, 1, 0, 5, 0, 5, 2, - 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, - 6, 10, 5, 6, 5, 4, 5, 0, 6, 10, - 5, 6, 5, 4, 5, 1, 0, 3, 1, 1, - 4, 6, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 1, 2, 3, 3, 3, 1, 3, 6, 9, - 12, 15, 18, 3, 6, 9, 12, 15, 18, 5, - 5, 5, 0, 5, 5, 5, 0, 1, 2, 2, - 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, - 1 -}; - -/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE - doesn't specify something else to do. Zero means the default is an - error. */ -static const short yydefact[] = -{ - 0, 0, 0, 0, 1, 0, 0, 137, 0, 0, - 136, 0, 137, 0, 0, 138, 3, 0, 137, 0, - 0, 4, 0, 137, 0, 0, 5, 0, 137, 0, - 0, 6, 0, 137, 0, 0, 7, 0, 9, 0, - 0, 8, 0, 133, 0, 0, 0, 0, 0, 131, - 130, 0, 0, 127, 0, 12, 137, 0, 0, 10, - 128, 129, 11, 133, 133, 0, 133, 0, 23, 132, - 0, 0, 0, 13, 0, 15, 0, 0, 0, 22, - 133, 133, 0, 14, 20, 0, 19, 24, 2, 21, - 119, 120, 121, 0, 0, 0, 0, 17, 16, 18, - 0, 0, 0, 0, 0, 0, 34, 0, 26, 0, - 0, 0, 36, 38, 0, 32, 28, 30, 29, 0, - 0, 54, 0, 0, 25, 34, 27, 55, 57, 35, - 53, 0, 0, 41, 43, 0, 33, 0, 0, 44, - 0, 0, 0, 0, 0, 0, 0, 0, 37, 40, - 39, 0, 0, 60, 0, 0, 62, 0, 89, 0, - 88, 0, 0, 86, 0, 85, 0, 0, 0, 0, - 0, 77, 0, 0, 0, 0, 56, 59, 0, 77, - 0, 0, 0, 0, 58, 61, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 122, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 68, 67, 0, 0, 64, - 65, 63, 126, 0, 0, 101, 0, 0, 0, 0, - 0, 0, 0, 42, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 87, 0, 0, - 0, 0, 50, 51, 0, 0, 0, 0, 0, 69, - 0, 66, 0, 0, 0, 0, 0, 75, 0, 0, - 122, 0, 106, 0, 0, 0, 83, 140, 0, 139, - 90, 45, 46, 47, 102, 0, 0, 0, 0, 0, - 0, 0, 0, 48, 49, 104, 103, 52, 0, 0, - 72, 31, 0, 74, 107, 135, 100, 135, 76, 0, - 0, 0, 0, 80, 0, 82, 84, 0, 92, 93, - 94, 95, 99, 98, 97, 96, 70, 0, 73, 126, - 134, 0, 0, 0, 78, 0, 113, 105, 81, 91, - 0, 0, 0, 135, 135, 0, 0, 122, 0, 108, - 123, 124, 125, 0, 0, 0, 126, 0, 114, 71, - 0, 79, 122, 109, 0, 126, 115, 0, 122, 110, - 0, 126, 116, 0, 122, 111, 0, 126, 117, 0, - 122, 112, 0, 118, 0, 0, 0 -}; - -static const short yydefgoto[] = -{ - 374, 2, 6, 9, 14, 20, 25, 30, 35, 42, - 40, 45, 58, 68, 85, 78, 79, 96, 101, 106, - 107, 203, 114, 115, 122, 123, 132, 133, 157, 134, - 120, 121, 137, 138, 152, 155, 208, 209, 210, 211, - 153, 200, 156, 164, 192, 165, 160, 237, 214, 227, - 228, 261, 215, 262, 51, 253, 52, 53, 54, 255, - 11, 16, 270 -}; - -static const short yypact[] = -{ - -2, -13, -58, 23,-32768, 8, 35, 30, 39, 62, - -32768, 19, 30, 63, 87,-32768,-32768, 19, 30, 69, - 90,-32768, 19, 30, 71, 94,-32768, 19, 30, 76, - 102,-32768, 19, 30, 81, 105,-32768, 19,-32768, 85, - 111,-32768, 113, -6, 93, 123, 19, 52, 52,-32768, - -32768, 19, 157,-32768, 159,-32768, 30, 112, 140,-32768, - -32768,-32768,-32768, 103, 103, 19, -6, 116, 143,-32768, - 171, 172, 175,-32768, 19,-32768, -32, 133, 19, 143, - 103, 103, 103,-32768,-32768, 64,-32768,-32768,-32768,-32768, - -32768,-32768,-32768, 19, 19, 19, 163,-32768,-32768,-32768, - 146, 177, 174, 156, 19, 54, 124, 186,-32768, 19, - 19, 187,-32768,-32768, 19, 188, 156,-32768,-32768, -51, - 19, 187, 190, 179,-32768, 124,-32768,-32768,-32768,-32768, - -32768, 283, 19, 190,-32768, 19,-32768, 197, 203,-32768, - 193, 193, 193, 4, 4, 4, 4, 4,-32768,-32768, - -32768, 305, 19, 197, 311, 19, 203, 205, 208, 4, - -32768, 4, 4,-32768, 4,-32768, 4, 212, 212, 193, - 4,-32768, 193, -3, 46, 25,-32768,-32768, 4,-32768, - 193, -3, 46, 25,-32768,-32768, 291, 19, 206, 212, - 212, 212, -18, 212, 212, 162, 19, 19, 212, 193, - 216, 217, 209, 193, -3,-32768, 208, 213, 217,-32768, - -32768,-32768, 22, 217, 19,-32768, 193, 225, 226, -3, - 226, 226, 19,-32768, 0, 19, 19, 19, 212, 193, - 193, 193, 193, 193, 193, 193, 193,-32768, 19, 19, - 19, 7,-32768,-32768, 19, 217, 189, 19, 19,-32768, - 217,-32768, 19, 19, 17, 251, 19,-32768, 226, 199, - 162, 19,-32768, 226, 19, 19,-32768,-32768, 231,-32768, - -32768,-32768,-32768,-32768,-32768, 19, 19, 19, 19, 19, - 19, 19, 19,-32768,-32768,-32768,-32768,-32768, 19, 4, - -32768,-32768, 19,-32768, 239, 52,-32768, 52,-32768, 19, - 4, 19, 7,-32768, 19,-32768,-32768, 15,-32768,-32768, - -32768,-32768,-32768,-32768,-32768,-32768,-32768, 193,-32768, 22, - -32768, 263, 264, 266,-32768, 193, 244,-32768,-32768,-32768, - 217, 19, 270, 52, 52, 52, 226, 162, 19, 248, - -32768,-32768,-32768, 19, 19, 19, 22, 19, 250,-32768, - 19,-32768, 162, 252, 19, 22, 254, 19, 162, 257, - 19, 22, 265, 19, 162, 267, 19, 22, 269, 19, - 162,-32768, 19,-32768, 280, 292,-32768 -}; - -static const short yypgoto[] = -{ - -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768,-32768,-32768, 221,-32768,-32768,-32768, 192, - -32768, -69, 170,-32768,-32768,-32768, 173,-32768,-32768, 147, - 182,-32768,-32768,-32768, 160,-32768, 127,-32768, 108, 21, - -32768, 138, 164, 29,-32768, -74,-32768,-32768, -166, 121, - -46, -212,-32768,-32768, -59, -305, -42, -45, 148, -252, - 279, -17, 16 -}; - - -#define YYLAST 383 - - -static const short yytable[] = -{ - 21, 267, 60, 61, 84, 26, 268, 74, 264, 265, - 31, 127, 128, 63, 331, 36, 267, 222, 47, 48, - 41, 69, 71, 295, 229, 230, 55, 1, -135, 59, - 49, 3, 50, 163, 62, 247, 4, 158, 69, 69, - 92, 350, 252, 321, 158, 323, 299, 256, 73, 75, - 357, 304, 5, 7, 212, 202, 363, 83, 49, 86, - 50, 88, 369, 15, 8, 158, 159, 161, 162, 10, - 231, 232, 233, 234, 235, 236, 97, 98, 99, 288, - 109, 340, 341, 202, 292, 12, 206, 108, 49, 15, - 50, 13, 117, 118, 110, 198, 269, 124, 201, 205, - 205, 205, 15, 129, 202, 207, 218, 205, 205, 205, - 18, 269, 15, 207, 15, 148, 19, 23, 150, 24, - 28, 196, 197, 29, 343, 245, 33, 47, 48, 249, - 205, 34, 38, 249, 39, 176, 240, 43, 184, 49, - 44, 50, 258, 225, 226, 205, 56, 238, 239, 93, - 94, 95, 57, 241, 46, 275, 276, 277, 278, 279, - 280, 281, 282, 63, 338, 64, 66, 254, -133, 67, - 223, 76, 77, 166, 167, 168, 169, 80, 81, 242, - 243, 82, 274, 111, 112, 113, 47, 48, 189, 87, - 190, 191, 100, 193, 204, 194, 213, 257, 49, 199, - 50, 301, 219, 102, 221, 266, 103, 216, 271, 272, - 273, 70, 72, 104, 105, 116, 119, 125, 302, 131, - 135, 283, 284, 285, 286, 250, 151, 287, 90, 91, - 290, 291, 154, 158, 186, 293, 294, 296, 188, 298, - 263, 195, 224, 330, 303, 246, 212, 305, 306, 248, - 320, 336, 322, 206, 259, 260, 289, 297, 308, 309, - 310, 311, 312, 313, 314, 315, 300, 307, 319, 333, - 334, 316, 335, 337, 332, 318, 295, 346, 344, 352, - 375, 355, 324, 358, 326, 327, 361, 328, 320, 320, - 342, 17, 376, 354, 364, 136, 367, 22, 370, 360, - 89, 332, 27, 130, 187, 366, 149, 32, 126, 220, - 332, 372, 37, 177, 339, 251, 332, 217, 317, 244, - 185, 345, 332, 329, 0, 0, 347, 348, 349, 325, - 351, 0, 0, 353, 0, 65, 0, 356, 0, 0, - 359, 0, 0, 362, 0, 0, 365, 0, 0, 368, - 0, 139, 371, 0, 0, 373, 140, 141, 142, 143, - 144, 145, 146, 147, 140, 141, 142, 143, 144, 145, - 146, 147, 170, 171, 172, 173, 174, 175, 178, 179, - 180, 181, 182, 183 -}; - -static const short yycheck[] = -{ - 17, 1, 47, 48, 36, 22, 6, 66, 220, 221, - 27, 62, 63, 6, 319, 32, 1, 183, 24, 25, - 37, 63, 64, 6, 42, 43, 43, 29, 6, 46, - 36, 44, 38, 29, 51, 201, 94, 40, 80, 81, - 82, 346, 208, 295, 40, 297, 258, 213, 65, 66, - 355, 263, 29, 45, 29, 58, 361, 74, 36, 76, - 38, 78, 367, 95, 29, 40, 140, 141, 142, 39, - 88, 89, 90, 91, 92, 93, 93, 94, 95, 245, - 26, 333, 334, 58, 250, 46, 40, 104, 36, 95, - 38, 29, 109, 110, 40, 169, 96, 114, 172, 173, - 174, 175, 95, 120, 58, 174, 180, 181, 182, 183, - 47, 96, 95, 182, 95, 132, 29, 48, 135, 29, - 49, 167, 168, 29, 336, 199, 50, 24, 25, 203, - 204, 29, 51, 207, 29, 152, 195, 52, 155, 36, - 29, 38, 216, 189, 190, 219, 53, 193, 194, 85, - 86, 87, 29, 195, 41, 229, 230, 231, 232, 233, - 234, 235, 236, 6, 330, 6, 54, 212, 6, 29, - 187, 55, 29, 144, 145, 146, 147, 6, 6, 196, - 197, 6, 228, 59, 60, 61, 24, 25, 159, 56, - 161, 162, 29, 164, 173, 166, 175, 214, 36, 170, - 38, 260, 181, 57, 183, 222, 29, 178, 225, 226, - 227, 63, 64, 39, 58, 29, 29, 29, 260, 29, - 41, 238, 239, 240, 241, 204, 29, 244, 80, 81, - 247, 248, 29, 40, 29, 252, 253, 254, 30, 256, - 219, 29, 36, 317, 261, 29, 29, 264, 265, 40, - 295, 325, 297, 40, 29, 29, 67, 6, 275, 276, - 277, 278, 279, 280, 281, 282, 67, 36, 29, 6, - 6, 288, 6, 29, 319, 292, 6, 29, 337, 29, - 0, 29, 299, 29, 301, 302, 29, 304, 333, 334, - 335, 12, 0, 352, 29, 125, 29, 18, 29, 358, - 79, 346, 23, 121, 157, 364, 133, 28, 116, 182, - 355, 370, 33, 153, 331, 207, 361, 179, 289, 198, - 156, 338, 367, 307, -1, -1, 343, 344, 345, 300, - 347, -1, -1, 350, -1, 56, -1, 354, -1, -1, - 357, -1, -1, 360, -1, -1, 363, -1, -1, 366, - -1, 68, 369, -1, -1, 372, 73, 74, 75, 76, - 77, 78, 79, 80, 73, 74, 75, 76, 77, 78, - 79, 80, 67, 68, 69, 70, 71, 72, 67, 68, - 69, 70, 71, 72 -}; -#define YYPURE 1 - -/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ -#line 3 "/home/mdh/sourceforge/bison/share/bison/bison.simple" - -/* Skeleton output parser for bison, - - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software - Foundation, Inc. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - -/* As a special exception, when this file is copied by Bison into a - Bison output file, you may use that output file without restriction. - This special exception was added by the Free Software Foundation - in version 1.24 of Bison. */ - -/* This is the parser code that is written into each bison parser when - the %semantic_parser declaration is not specified in the grammar. - It was written by Richard Stallman by simplifying the hairy parser - used when %semantic_parser is specified. */ - -/* All symbols defined below should begin with yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE) +# ifndef YYFREE +# define YYFREE free +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# endif /* The parser invokes alloca or malloc; define the necessary symbols. */ -# if YYSTACK_USE_ALLOCA -# define YYSTACK_ALLOC alloca -# else -# ifndef YYSTACK_USE_ALLOCA -# if defined (alloca) || defined (_ALLOCA_H) -# define YYSTACK_ALLOC alloca +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca # else -# ifdef __GNUC__ -# define YYSTACK_ALLOC __builtin_alloca -# endif +# define YYSTACK_ALLOC alloca # endif # endif # endif @@ -678,45 +360,36 @@ static const short yycheck[] = # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # endif -# define YYSTACK_ALLOC malloc -# define YYSTACK_FREE free +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE # endif -#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */ +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ #if (! defined (yyoverflow) \ && (! defined (__cplusplus) \ - || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) /* A type that is properly aligned for any stack member. */ union yyalloc { - short yyss; + short int yyss; YYSTYPE yyvs; -# if YYLSP_NEEDED - YYLTYPE yyls; -# endif -}; + }; /* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) /* The size of an array large to enough to hold all stacks, each with N elements. */ -# if YYLSP_NEEDED -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ - + 2 * YYSTACK_GAP_MAX) -# else -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAX) -# endif +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) /* Copy COUNT objects from FROM to TO. The source and destination do not overlap. */ # ifndef YYCOPY -# if 1 < __GNUC__ +# if defined (__GNUC__) && 1 < __GNUC__ # define YYCOPY(To, From, Count) \ __builtin_memcpy (To, From, (Count) * sizeof (*(From))) # else @@ -742,13 +415,533 @@ union yyalloc YYSIZE_T yynewbytes; \ YYCOPY (&yyptr->Stack, Stack, yysize); \ Stack = &yyptr->Stack; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ yyptr += yynewbytes / sizeof (*yyptr); \ } \ while (0) #endif +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short int yysigned_char; +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 5 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 383 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 97 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 64 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 141 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 376 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 335 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 31, 2, 2, 2, 28, 13, 2, + 29, 95, 26, 24, 2, 25, 2, 27, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 6, 2, + 2, 2, 2, 5, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 30, 2, 96, 11, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 10, 2, 32, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 7, 8, 9, 12, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned short int yyprhs[] = +{ + 0, 0, 3, 6, 22, 27, 32, 37, 42, 47, + 52, 53, 59, 64, 68, 73, 78, 82, 88, 94, + 100, 104, 106, 109, 111, 112, 113, 122, 127, 131, + 134, 138, 142, 146, 148, 152, 153, 157, 158, 163, + 164, 169, 172, 174, 180, 182, 183, 190, 197, 204, + 211, 218, 224, 230, 237, 240, 242, 243, 249, 250, + 256, 259, 261, 264, 266, 268, 270, 272, 275, 277, + 279, 282, 289, 300, 306, 313, 319, 324, 330, 331, + 338, 349, 355, 362, 368, 373, 379, 381, 382, 386, + 388, 390, 395, 402, 406, 410, 414, 418, 422, 426, + 430, 434, 438, 440, 443, 447, 451, 455, 457, 461, + 468, 478, 491, 507, 526, 530, 537, 547, 560, 576, + 595, 601, 607, 613, 614, 620, 626, 632, 633, 635, + 638, 641, 643, 645, 647, 648, 650, 651, 653, 654, + 656, 658 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const short int yyrhs[] = +{ + 98, 0, -1, 99, 94, -1, 29, 44, 100, 101, + 102, 103, 104, 105, 106, 108, 109, 110, 111, 113, + 159, -1, 29, 45, 158, 159, -1, 29, 46, 158, + 159, -1, 29, 47, 158, 159, -1, 29, 48, 158, + 159, -1, 29, 49, 158, 159, -1, 29, 50, 158, + 159, -1, -1, 29, 51, 107, 41, 159, -1, 29, + 52, 152, 159, -1, 29, 52, 159, -1, 29, 53, + 158, 159, -1, 29, 54, 152, 159, -1, 29, 54, + 159, -1, 29, 55, 112, 86, 159, -1, 29, 55, + 112, 85, 159, -1, 29, 55, 112, 87, 159, -1, + 29, 55, 159, -1, 36, -1, 114, 113, -1, 114, + -1, -1, -1, 29, 56, 115, 116, 29, 117, 120, + 159, -1, 29, 57, 39, 159, -1, 118, 29, 117, + -1, 118, 29, -1, 58, 40, 159, -1, 58, 26, + 159, -1, 58, 40, 159, -1, 121, -1, 121, 29, + 120, -1, -1, 59, 128, 159, -1, -1, 60, 122, + 124, 159, -1, -1, 61, 123, 41, 159, -1, 125, + 124, -1, 125, -1, 29, 68, 126, 127, 159, -1, + 127, -1, -1, 29, 73, 143, 141, 148, 159, -1, + 29, 74, 143, 141, 148, 159, -1, 29, 75, 143, + 141, 147, 159, -1, 29, 76, 141, 141, 148, 159, + -1, 29, 77, 141, 141, 148, 159, -1, 29, 78, + 141, 148, 159, -1, 29, 79, 141, 148, 159, -1, + 29, 80, 141, 143, 147, 159, -1, 129, 128, -1, + 129, -1, -1, 29, 62, 130, 132, 159, -1, -1, + 29, 63, 131, 133, 159, -1, 138, 132, -1, 138, + -1, 140, 140, -1, 140, -1, 137, -1, 135, -1, + 136, -1, 119, 136, -1, 40, -1, 143, -1, 119, + 143, -1, 29, 67, 141, 143, 146, 159, -1, 29, + 68, 139, 29, 67, 141, 143, 146, 159, 159, -1, + 29, 69, 143, 146, 159, -1, 29, 70, 137, 137, + 146, 159, -1, 29, 71, 134, 146, 159, -1, 29, + 72, 146, 159, -1, 29, 72, 137, 146, 159, -1, + -1, 29, 67, 141, 143, 149, 159, -1, 29, 68, + 139, 29, 67, 141, 143, 149, 159, 159, -1, 29, + 69, 143, 149, 159, -1, 29, 70, 137, 137, 149, + 159, -1, 29, 71, 134, 149, 159, -1, 29, 72, + 146, 159, -1, 29, 72, 137, 149, 159, -1, 143, + -1, -1, 29, 142, 145, -1, 144, -1, 40, -1, + 40, 30, 36, 160, -1, 40, 30, 36, 6, 36, + 160, -1, 42, 143, 159, -1, 43, 143, 159, -1, + 88, 143, 159, -1, 89, 143, 159, -1, 93, 143, + 159, -1, 92, 143, 159, -1, 91, 143, 159, -1, + 90, 143, 159, -1, 29, 155, 159, -1, 150, -1, + 148, 148, -1, 29, 154, 159, -1, 29, 152, 159, + -1, 29, 154, 159, -1, 151, -1, 29, 153, 159, + -1, 29, 153, 159, 29, 153, 159, -1, 29, 153, + 159, 29, 153, 159, 29, 153, 159, -1, 29, 153, + 159, 29, 153, 159, 29, 153, 159, 29, 153, 159, + -1, 29, 153, 159, 29, 153, 159, 29, 153, 159, + 29, 153, 159, 29, 153, 159, -1, 29, 153, 159, + 29, 153, 159, 29, 153, 159, 29, 153, 159, 29, + 153, 159, 29, 153, 159, -1, 29, 152, 159, -1, + 29, 152, 159, 29, 152, 159, -1, 29, 152, 159, + 29, 152, 159, 29, 152, 159, -1, 29, 152, 159, + 29, 152, 159, 29, 152, 159, 29, 152, 159, -1, + 29, 152, 159, 29, 152, 159, 29, 152, 159, 29, + 152, 159, 29, 152, 159, -1, 29, 152, 159, 29, + 152, 159, 29, 152, 159, 29, 152, 159, 29, 152, + 159, 29, 152, 159, -1, 154, 6, 156, 6, 156, + -1, 156, 6, 154, 6, 156, -1, 156, 6, 156, + 6, 154, -1, -1, 155, 6, 157, 6, 157, -1, + 157, 6, 155, 6, 157, -1, 157, 6, 157, 6, + 155, -1, -1, 155, -1, 24, 155, -1, 25, 155, + -1, 38, -1, 36, -1, 154, -1, -1, 155, -1, + -1, 39, -1, -1, 95, -1, 96, -1, 1, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned short int yyrline[] = +{ + 0, 222, 222, 226, 233, 238, 243, 248, 253, 258, + 263, 263, 268, 270, 275, 280, 282, 287, 292, 297, + 302, 310, 329, 330, 331, 335, 334, 345, 353, 354, + 358, 363, 371, 378, 379, 381, 383, 384, 384, 385, + 385, 392, 393, 398, 400, 404, 409, 413, 417, 421, + 425, 429, 433, 437, 444, 445, 450, 449, 456, 455, + 464, 465, 469, 470, 474, 475, 479, 480, 488, 498, + 499, 508, 512, 517, 521, 525, 529, 533, 539, 544, + 548, 553, 557, 561, 565, 569, 575, 576, 576, 583, + 587, 594, 603, 615, 620, 625, 630, 635, 640, 645, + 650, 659, 670, 674, 683, 694, 702, 713, 717, 722, + 728, 735, 744, 754, 769, 774, 780, 787, 796, 806, + 820, 827, 834, 842, 850, 857, 864, 872, 880, 881, + 883, 887, 888, 893, 899, 903, 909, 913, 915, 923, + 928, 930 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "IF", "ELSE", "'?'", "':'", "OROR", + "ANDAND", "ANDANDAND", "'|'", "'^'", "XNOR", "'&'", "CASE_INEQUALITY", + "CASE_EQUALITY", "LOGICAL_INEQUALITY", "LOGICAL_EQUALITY", "GE", "GT", + "LE", "LT", "RIGHT_SHIFT", "LEFT_SHIFT", "'+'", "'-'", "'*'", "'/'", + "'%'", "'('", "'['", "'!'", "'~'", "REDUCTION_NOR", "REDUCTION_NAND", + "UNARY", "INTEGER", "SCALAR_CONSTANT", "FLOATING", "QSTRING", + "IDENTIFIER", "BLOB", "POSEDGE", "NEGEDGE", "DELAYFILE", "SDFVERSION", + "DESIGN", "DATE", "VENDOR", "PROGRAM", "VERSION_", "DIVIDER", "VOLTAGE", + "PROCESS", "TEMPERATURE", "TIMESCALE", "CELL", "CELLTYPE", "INSTANCE", + "DELAY", "TIMINGCHECK", "INCLUDE", "ABSOLUTE", "INCREMENT", "USERDEF", + "PATHPULSE", "GLOBALPATHPULSE", "IOPATH", "COND", "PORT", "INTERCONNECT", + "NETDELAY", "DEVICE", "SETUP", "HOLD", "SETUPHOLD", "RECOVERY", "SKEW", + "WIDTH", "PERIOD", "NOCHANGE", "PATHCONSTRAINT", "SUM", "DIFF", + "SKEWCONSTRAINT", "MICROSECOND", "NANOSECOND", "PICOSECOND", "EDGE_01", + "EDGE_10", "EDGE_0z", "EDGE_1z", "EDGE_z0", "EDGE_z1", "EOF_", "')'", + "']'", "$accept", "sdf", "delay_file", "sdf_version", "design_name", + "date", "vendor", "program_name", "program_version", "hierarchy_divider", + "@1", "voltage", "process", "temperature", "time_scale", "ts", "cells", + "cell", "@2", "celltype", "instances", "instance", "string_instance", + "timing_specs", "timing_spec", "@3", "@4", "tcdefs", "tcdef", + "timing_check_condition", "tcheck", "deltypes", "deltype", "@5", "@6", + "absvals", "incvals", "name", "net_instance", "net", "port_instance", + "absval", "conditional_port_expr", "incval", "port_spec", "@7", + "port_path", "port", "port_edge", "value", "double_tc_rvalue", + "tc_rvalue", "rvalue", "exp_list", "rexp_list", "rexpression", + "expression", "real", "preal", "creal", "cpreal", "nstring", "rp", "rb", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const unsigned short int yytoknum[] = +{ + 0, 256, 257, 258, 259, 63, 58, 260, 261, 262, + 124, 94, 263, 38, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 43, 45, 42, 47, 37, 40, + 91, 33, 126, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 41, 93 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned char yyr1[] = +{ + 0, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 107, 106, 108, 108, 109, 110, 110, 111, 111, 111, + 111, 112, 113, 113, 113, 115, 114, 116, 117, 117, + 118, 118, 119, 120, 120, 121, 121, 122, 121, 123, + 121, 124, 124, 125, 125, 126, 127, 127, 127, 127, + 127, 127, 127, 127, 128, 128, 130, 129, 131, 129, + 132, 132, 133, 133, 134, 134, 135, 135, 136, 137, + 137, 138, 138, 138, 138, 138, 138, 138, 139, 140, + 140, 140, 140, 140, 140, 140, 141, 142, 141, 143, + 144, 144, 144, 145, 145, 145, 145, 145, 145, 145, + 145, 146, 146, 147, 148, 148, 149, 149, 150, 150, + 150, 150, 150, 150, 151, 151, 151, 151, 151, 151, + 152, 152, 152, 152, 153, 153, 153, 153, 154, 154, + 154, 155, 155, 156, 156, 157, 157, 158, 158, 159, + 160, 160 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const unsigned char yyr2[] = +{ + 0, 2, 2, 15, 4, 4, 4, 4, 4, 4, + 0, 5, 4, 3, 4, 4, 3, 5, 5, 5, + 3, 1, 2, 1, 0, 0, 8, 4, 3, 2, + 3, 3, 3, 1, 3, 0, 3, 0, 4, 0, + 4, 2, 1, 5, 1, 0, 6, 6, 6, 6, + 6, 5, 5, 6, 2, 1, 0, 5, 0, 5, + 2, 1, 2, 1, 1, 1, 1, 2, 1, 1, + 2, 6, 10, 5, 6, 5, 4, 5, 0, 6, + 10, 5, 6, 5, 4, 5, 1, 0, 3, 1, + 1, 4, 6, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 1, 2, 3, 3, 3, 1, 3, 6, + 9, 12, 15, 18, 3, 6, 9, 12, 15, 18, + 5, 5, 5, 0, 5, 5, 5, 0, 1, 2, + 2, 1, 1, 1, 0, 1, 0, 1, 0, 1, + 1, 1 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const unsigned char yydefact[] = +{ + 0, 0, 0, 0, 0, 1, 2, 0, 0, 138, + 0, 0, 137, 0, 138, 0, 0, 139, 4, 0, + 138, 0, 0, 5, 0, 138, 0, 0, 6, 0, + 138, 0, 0, 7, 0, 138, 0, 0, 8, 0, + 10, 0, 0, 9, 0, 134, 0, 0, 0, 0, + 0, 132, 131, 0, 0, 128, 0, 13, 138, 0, + 0, 11, 129, 130, 12, 134, 134, 0, 134, 0, + 24, 133, 0, 0, 0, 14, 0, 16, 0, 0, + 0, 23, 134, 134, 0, 15, 21, 0, 20, 25, + 3, 22, 120, 121, 122, 0, 0, 0, 0, 18, + 17, 19, 0, 0, 0, 0, 0, 0, 35, 0, + 27, 0, 0, 0, 37, 39, 0, 33, 29, 31, + 30, 0, 0, 55, 0, 0, 26, 35, 28, 56, + 58, 36, 54, 0, 0, 42, 44, 0, 34, 0, + 0, 45, 0, 0, 0, 0, 0, 0, 0, 0, + 38, 41, 40, 0, 0, 61, 0, 0, 63, 0, + 90, 0, 89, 0, 0, 87, 0, 86, 0, 0, + 0, 0, 0, 78, 0, 0, 0, 0, 57, 60, + 0, 78, 0, 0, 0, 0, 59, 62, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 123, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 69, 68, 0, + 0, 65, 66, 64, 127, 0, 0, 102, 0, 0, + 0, 0, 0, 0, 0, 43, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, + 0, 0, 0, 0, 51, 52, 0, 0, 0, 0, + 0, 70, 0, 67, 0, 0, 0, 0, 0, 76, + 0, 0, 123, 0, 107, 0, 0, 0, 84, 141, + 0, 140, 91, 46, 47, 48, 103, 0, 0, 0, + 0, 0, 0, 0, 0, 49, 50, 105, 104, 53, + 0, 0, 73, 32, 0, 75, 108, 136, 101, 136, + 77, 0, 0, 0, 0, 81, 0, 83, 85, 0, + 93, 94, 95, 96, 100, 99, 98, 97, 71, 0, + 74, 127, 135, 0, 0, 0, 79, 0, 114, 106, + 82, 92, 0, 0, 0, 136, 136, 0, 0, 123, + 0, 109, 124, 125, 126, 0, 0, 0, 127, 0, + 115, 72, 0, 80, 123, 110, 0, 127, 116, 0, + 123, 111, 0, 127, 117, 0, 123, 112, 0, 127, + 118, 0, 123, 113, 0, 119 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const short int yydefgoto[] = +{ + -1, 2, 3, 8, 11, 16, 22, 27, 32, 37, + 44, 42, 47, 60, 70, 87, 80, 81, 98, 103, + 108, 109, 205, 116, 117, 124, 125, 134, 135, 159, + 136, 122, 123, 139, 140, 154, 157, 210, 211, 212, + 213, 155, 202, 158, 166, 194, 167, 162, 239, 216, + 229, 230, 263, 217, 264, 53, 255, 54, 55, 56, + 257, 13, 18, 272 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -308 +static const short int yypact[] = +{ + -2, -13, 36, -42, 24, -308, -308, 40, 35, 30, + 45, 81, -308, 21, 30, 67, 88, -308, -308, 21, + 30, 71, 91, -308, 21, 30, 74, 97, -308, 21, + 30, 82, 102, -308, 21, 30, 83, 108, -308, 21, + -308, 94, 111, -308, 113, -6, 99, 134, 21, 52, + 52, -308, -308, 21, 159, -308, 160, -308, 30, 115, + 142, -308, -308, -308, -308, 103, 103, 21, -6, 117, + 148, -308, 172, 175, 183, -308, 21, -308, -32, 136, + 21, 148, 103, 103, 103, -308, -308, 64, -308, -308, + -308, -308, -308, -308, -308, 21, 21, 21, 174, -308, + -308, -308, 149, 184, 176, 156, 21, 54, 124, 187, + -308, 21, 21, 188, -308, -308, 21, 190, 156, -308, + -308, -51, 21, 188, 191, 185, -308, 124, -308, -308, + -308, -308, -308, 283, 21, 191, -308, 21, -308, 203, + 204, -308, 194, 194, 194, 4, 4, 4, 4, 4, + -308, -308, -308, 305, 21, 203, 311, 21, 204, 209, + 211, 4, -308, 4, 4, -308, 4, -308, 4, 213, + 213, 194, 4, -308, 194, -3, 46, 25, -308, -308, + 4, -308, 194, -3, 46, 25, -308, -308, 291, 21, + 210, 213, 213, 213, -18, 213, 213, 162, 21, 21, + 213, 194, 216, 220, 214, 194, -3, -308, 211, 215, + 220, -308, -308, -308, 22, 220, 21, -308, 194, 224, + 227, -3, 227, 227, 21, -308, 0, 21, 21, 21, + 213, 194, 194, 194, 194, 194, 194, 194, 194, -308, + 21, 21, 21, 7, -308, -308, 21, 220, 199, 21, + 21, -308, 220, -308, 21, 21, 17, 251, 21, -308, + 227, 200, 162, 21, -308, 227, 21, 21, -308, -308, + 232, -308, -308, -308, -308, -308, -308, 21, 21, 21, + 21, 21, 21, 21, 21, -308, -308, -308, -308, -308, + 21, 4, -308, -308, 21, -308, 240, 52, -308, 52, + -308, 21, 4, 21, 7, -308, 21, -308, -308, 15, + -308, -308, -308, -308, -308, -308, -308, -308, -308, 194, + -308, 22, -308, 264, 266, 267, -308, 194, 247, -308, + -308, -308, 220, 21, 271, 52, 52, 52, 227, 162, + 21, 250, -308, -308, -308, 21, 21, 21, 22, 21, + 252, -308, 21, -308, 162, 254, 21, 22, 257, 21, + 162, 263, 21, 22, 265, 21, 162, 269, 21, 22, + 274, 21, 162, -308, 21, -308 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const short int yypgoto[] = +{ + -308, -308, -308, -308, -308, -308, -308, -308, -308, -308, + -308, -308, -308, -308, -308, -308, 219, -308, -308, -308, + 177, -308, -71, 153, -308, -308, -308, 161, -308, -308, + 145, 186, -308, -308, -308, 151, -308, 129, -308, 106, + 19, -308, 127, 165, 27, -308, -76, -308, -308, -168, + 119, -48, -214, -308, -308, -61, -307, -44, -47, 146, + -254, 277, -19, 8 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -137 +static const short int yytable[] = +{ + 23, 269, 62, 63, 86, 28, 270, 76, 266, 267, + 33, 129, 130, 65, 333, 38, 269, 224, 49, 50, + 43, 71, 73, 297, 231, 232, 57, 1, -136, 61, + 51, 4, 52, 165, 64, 249, 5, 160, 71, 71, + 94, 352, 254, 323, 160, 325, 301, 258, 75, 77, + 359, 306, 6, 7, 214, 204, 365, 85, 51, 88, + 52, 90, 371, 17, 10, 160, 161, 163, 164, 12, + 233, 234, 235, 236, 237, 238, 99, 100, 101, 290, + 111, 342, 343, 204, 294, 9, 208, 110, 51, 17, + 52, 14, 119, 120, 112, 200, 271, 126, 203, 207, + 207, 207, 17, 131, 204, 209, 220, 207, 207, 207, + 15, 271, 17, 209, 20, 150, 17, 21, 152, 25, + 26, 198, 199, 30, 345, 247, 31, 49, 50, 251, + 207, 36, 35, 251, 40, 178, 242, 41, 186, 51, + 46, 52, 260, 227, 228, 207, 45, 240, 241, 95, + 96, 97, 58, 243, 48, 277, 278, 279, 280, 281, + 282, 283, 284, 59, 340, 65, 66, 256, -134, 68, + 225, 69, 78, 168, 169, 170, 171, 79, 82, 244, + 245, 83, 276, 113, 114, 115, 49, 50, 191, 84, + 192, 193, 89, 195, 206, 196, 215, 259, 51, 201, + 52, 303, 221, 102, 223, 268, 104, 218, 273, 274, + 275, 72, 74, 105, 107, 106, 118, 121, 304, 127, + 133, 285, 286, 287, 288, 252, 137, 289, 92, 93, + 292, 293, 153, 156, 160, 295, 296, 298, 188, 300, + 265, 190, 197, 332, 305, 248, 226, 307, 308, 214, + 322, 338, 324, 261, 250, 208, 262, 299, 310, 311, + 312, 313, 314, 315, 316, 317, 291, 302, 309, 321, + 335, 318, 336, 337, 334, 320, 339, 297, 346, 348, + 138, 354, 326, 357, 328, 329, 360, 330, 322, 322, + 344, 19, 363, 356, 366, 128, 151, 24, 369, 362, + 91, 334, 29, 372, 189, 368, 179, 34, 219, 132, + 334, 374, 39, 222, 341, 253, 334, 331, 319, 246, + 0, 347, 334, 187, 0, 0, 349, 350, 351, 327, + 353, 0, 0, 355, 0, 67, 0, 358, 0, 0, + 361, 0, 0, 364, 0, 0, 367, 0, 0, 370, + 0, 141, 373, 0, 0, 375, 142, 143, 144, 145, + 146, 147, 148, 149, 142, 143, 144, 145, 146, 147, + 148, 149, 172, 173, 174, 175, 176, 177, 180, 181, + 182, 183, 184, 185 +}; + +static const short int yycheck[] = +{ + 19, 1, 49, 50, 36, 24, 6, 68, 222, 223, + 29, 62, 63, 6, 321, 34, 1, 185, 24, 25, + 39, 65, 66, 6, 42, 43, 45, 29, 6, 48, + 36, 44, 38, 29, 53, 203, 0, 40, 82, 83, + 84, 348, 210, 297, 40, 299, 260, 215, 67, 68, + 357, 265, 94, 29, 29, 58, 363, 76, 36, 78, + 38, 80, 369, 95, 29, 40, 142, 143, 144, 39, + 88, 89, 90, 91, 92, 93, 95, 96, 97, 247, + 26, 335, 336, 58, 252, 45, 40, 106, 36, 95, + 38, 46, 111, 112, 40, 171, 96, 116, 174, 175, + 176, 177, 95, 122, 58, 176, 182, 183, 184, 185, + 29, 96, 95, 184, 47, 134, 95, 29, 137, 48, + 29, 169, 170, 49, 338, 201, 29, 24, 25, 205, + 206, 29, 50, 209, 51, 154, 197, 29, 157, 36, + 29, 38, 218, 191, 192, 221, 52, 195, 196, 85, + 86, 87, 53, 197, 41, 231, 232, 233, 234, 235, + 236, 237, 238, 29, 332, 6, 6, 214, 6, 54, + 189, 29, 55, 146, 147, 148, 149, 29, 6, 198, + 199, 6, 230, 59, 60, 61, 24, 25, 161, 6, + 163, 164, 56, 166, 175, 168, 177, 216, 36, 172, + 38, 262, 183, 29, 185, 224, 57, 180, 227, 228, + 229, 65, 66, 29, 58, 39, 29, 29, 262, 29, + 29, 240, 241, 242, 243, 206, 41, 246, 82, 83, + 249, 250, 29, 29, 40, 254, 255, 256, 29, 258, + 221, 30, 29, 319, 263, 29, 36, 266, 267, 29, + 297, 327, 299, 29, 40, 40, 29, 6, 277, 278, + 279, 280, 281, 282, 283, 284, 67, 67, 36, 29, + 6, 290, 6, 6, 321, 294, 29, 6, 339, 29, + 127, 29, 301, 29, 303, 304, 29, 306, 335, 336, + 337, 14, 29, 354, 29, 118, 135, 20, 29, 360, + 81, 348, 25, 29, 159, 366, 155, 30, 181, 123, + 357, 372, 35, 184, 333, 209, 363, 309, 291, 200, + -1, 340, 369, 158, -1, -1, 345, 346, 347, 302, + 349, -1, -1, 352, -1, 58, -1, 356, -1, -1, + 359, -1, -1, 362, -1, -1, 365, -1, -1, 368, + -1, 68, 371, -1, -1, 374, 73, 74, 75, 76, + 77, 78, 79, 80, 73, 74, 75, 76, 77, 78, + 79, 80, 67, 68, 69, 70, 71, 72, 67, 68, + 69, 70, 71, 72 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned char yystos[] = +{ + 0, 29, 98, 99, 44, 0, 94, 29, 100, 45, + 29, 101, 39, 158, 46, 29, 102, 95, 159, 158, + 47, 29, 103, 159, 158, 48, 29, 104, 159, 158, + 49, 29, 105, 159, 158, 50, 29, 106, 159, 158, + 51, 29, 108, 159, 107, 52, 29, 109, 41, 24, + 25, 36, 38, 152, 154, 155, 156, 159, 53, 29, + 110, 159, 155, 155, 159, 6, 6, 158, 54, 29, + 111, 154, 156, 154, 156, 159, 152, 159, 55, 29, + 113, 114, 6, 6, 6, 159, 36, 112, 159, 56, + 159, 113, 156, 156, 154, 85, 86, 87, 115, 159, + 159, 159, 29, 116, 57, 29, 39, 58, 117, 118, + 159, 26, 40, 59, 60, 61, 120, 121, 29, 159, + 159, 29, 128, 129, 122, 123, 159, 29, 117, 62, + 63, 159, 128, 29, 124, 125, 127, 41, 120, 130, + 131, 68, 73, 74, 75, 76, 77, 78, 79, 80, + 159, 124, 159, 29, 132, 138, 29, 133, 140, 126, + 40, 143, 144, 143, 143, 29, 141, 143, 141, 141, + 141, 141, 67, 68, 69, 70, 71, 72, 159, 132, + 67, 68, 69, 70, 71, 72, 159, 140, 29, 127, + 30, 141, 141, 141, 142, 141, 141, 29, 148, 148, + 143, 141, 139, 143, 58, 119, 137, 143, 40, 119, + 134, 135, 136, 137, 29, 137, 146, 150, 141, 139, + 143, 137, 134, 137, 146, 159, 36, 148, 148, 147, + 148, 42, 43, 88, 89, 90, 91, 92, 93, 145, + 148, 148, 152, 154, 159, 159, 147, 143, 29, 146, + 40, 143, 137, 136, 146, 153, 155, 157, 146, 159, + 143, 29, 29, 149, 151, 137, 149, 149, 159, 1, + 6, 96, 160, 159, 159, 159, 148, 143, 143, 143, + 143, 143, 143, 143, 143, 159, 159, 159, 159, 159, + 146, 67, 159, 159, 146, 159, 159, 6, 159, 6, + 159, 149, 67, 152, 154, 159, 149, 159, 159, 36, + 159, 159, 159, 159, 159, 159, 159, 159, 159, 141, + 159, 29, 155, 157, 155, 157, 159, 141, 159, 159, + 159, 160, 143, 153, 155, 6, 6, 6, 143, 29, + 146, 159, 157, 157, 155, 149, 152, 159, 29, 159, + 159, 159, 153, 159, 29, 159, 152, 29, 159, 153, + 29, 159, 152, 29, 159, 153, 29, 159, 152, 29, + 159, 153, 29, 159, 152, 159 +}; #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) # define YYSIZE_T __SIZE_TYPE__ @@ -768,72 +961,94 @@ union yyalloc #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) -#define YYEMPTY -2 +#define YYEMPTY (-2) #define YYEOF 0 + #define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrlab1 +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ + #define YYFAIL goto yyerrlab + #define YYRECOVERING() (!!yyerrstatus) + #define YYBACKUP(Token, Value) \ do \ if (yychar == YYEMPTY && yylen == 1) \ { \ yychar = (Token); \ yylval = (Value); \ - yychar1 = YYTRANSLATE (yychar); \ + yytoken = YYTRANSLATE (yychar); \ YYPOPSTACK; \ goto yybackup; \ } \ else \ { \ - yyerror ("syntax error: cannot back up"); \ + yyerror ("syntax error: cannot back up");\ YYERROR; \ } \ while (0) + #define YYTERROR 1 #define YYERRCODE 256 -/* YYLLOC_DEFAULT -- Compute the default location (before the actions - are run). - - When YYLLOC_DEFAULT is run, CURRENT is set the location of the - first token. By default, to implement support for ranges, extend - its range to the last symbol. */ +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) #ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - Current.last_line = Rhs[N].last_line; \ - Current.last_column = Rhs[N].last_column; +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (0) #endif -/* YYLEX -- calling `yylex' with the right arguments. */ +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ -#if YYPURE -# if YYLSP_NEEDED -# ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) -# else -# define YYLEX yylex (&yylval, &yylloc) -# endif -# else /* !YYLSP_NEEDED */ -# ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval, YYLEX_PARAM) -# else -# define YYLEX yylex (&yylval) -# endif -# endif /* !YYLSP_NEEDED */ -#else /* !YYPURE */ -# define YYLEX yylex () -#endif /* !YYPURE */ +#ifndef YY_LOCATION_PRINT +# if YYLTYPE_IS_TRIVIAL +# define YY_LOCATION_PRINT(File, Loc) \ + fprintf (File, "%d.%d-%d.%d", \ + (Loc).first_line, (Loc).first_column, \ + (Loc).last_line, (Loc).last_column) +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +#endif +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, YYLEX_PARAM) +#else +# define YYLEX yylex (&yylval) +#endif + /* Enable debugging if requested. */ #if YYDEBUG @@ -847,13 +1062,86 @@ do { \ if (yydebug) \ YYFPRINTF Args; \ } while (0) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yysymprint (stderr, \ + Type, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_stack_print (short int *bottom, short int *top) +#else +static void +yy_stack_print (bottom, top) + short int *bottom; + short int *top; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (/* Nothing. */; bottom <= top; ++bottom) + YYFPRINTF (stderr, " %d", *bottom); + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_reduce_print (int yyrule) +#else +static void +yy_reduce_print (yyrule) + int yyrule; +#endif +{ + int yyi; + unsigned int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", + yyrule - 1, yylno); + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) + YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); + YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (Rule); \ +} while (0) + /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ int yydebug; #else /* !YYDEBUG */ # define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) #endif /* !YYDEBUG */ + /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH # define YYINITDEPTH 200 @@ -866,15 +1154,13 @@ int yydebug; SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) evaluated with infinite-precision integer arithmetic. */ -#if YYMAXDEPTH == 0 -# undef YYMAXDEPTH -#endif - #ifndef YYMAXDEPTH # define YYMAXDEPTH 10000 #endif + -#ifdef YYERROR_VERBOSE + +#if YYERROR_VERBOSE # ifndef yystrlen # if defined (__GLIBC__) && defined (_STRING_H) @@ -924,86 +1210,139 @@ yystpcpy (yydest, yysrc) } # endif # endif -#endif + +#endif /* !YYERROR_VERBOSE */ + -#line 315 "/home/mdh/sourceforge/bison/share/bison/bison.simple" +#if YYDEBUG +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) +#else +static void +yysymprint (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# endif + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyoutput, ")"); +} + +#endif /* ! YYDEBUG */ +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ -/* The user can define YYPARSE_PARAM as the name of an argument to be passed - into yyparse. The argument should have type void *. - It should actually point to an object. - Grammar actions can access the variable by casting it - to the proper pointer type. */ +#if defined (__STDC__) || defined (__cplusplus) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yymsg, yytype, yyvaluep) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + + +/* Prevent warnings from -Wmissing-prototypes. */ #ifdef YYPARSE_PARAM # if defined (__STDC__) || defined (__cplusplus) -# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM -# define YYPARSE_PARAM_DECL +int yyparse (void *YYPARSE_PARAM); # else -# define YYPARSE_PARAM_ARG YYPARSE_PARAM -# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +int yyparse (); # endif -#else /* !YYPARSE_PARAM */ -# define YYPARSE_PARAM_ARG -# define YYPARSE_PARAM_DECL -#endif /* !YYPARSE_PARAM */ - -/* Prevent warning if -Wstrict-prototypes. */ -#ifdef __GNUC__ -# ifdef YYPARSE_PARAM -int yyparse (void *); -# else +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) int yyparse (void); -# endif +#else +int yyparse (); #endif +#endif /* ! YYPARSE_PARAM */ -/* YY_DECL_VARIABLES -- depending whether we use a pure parser, - variables are global, or local to YYPARSE. */ - -#define YY_DECL_NON_LSP_VARIABLES \ -/* The lookahead symbol. */ \ -int yychar; \ - \ -/* The semantic value of the lookahead symbol. */ \ -YYSTYPE yylval; \ - \ -/* Number of parse errors so far. */ \ -int yynerrs; -#if YYLSP_NEEDED -# define YY_DECL_VARIABLES \ -YY_DECL_NON_LSP_VARIABLES \ - \ -/* Location data for the lookahead symbol. */ \ -YYLTYPE yylloc; -#else -# define YY_DECL_VARIABLES \ -YY_DECL_NON_LSP_VARIABLES -#endif -/* If nonreentrant, generate the variables here. */ -#if !YYPURE -YY_DECL_VARIABLES -#endif /* !YYPURE */ +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM) +# else +int yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +# endif +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) +int +yyparse (void) +#else int -yyparse (YYPARSE_PARAM_ARG) - YYPARSE_PARAM_DECL +yyparse () + +#endif +#endif { - /* If reentrant, generate the variables here. */ -#if YYPURE - YY_DECL_VARIABLES -#endif /* !YYPURE */ + /* The look-ahead symbol. */ +int yychar; + +/* The semantic value of the look-ahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; register int yystate; register int yyn; int yyresult; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; - /* Lookahead token as an internal (translated) token number. */ - int yychar1 = 0; + /* Look-ahead token as an internal (translated) token number. */ + int yytoken = 0; /* Three stacks and their tools: `yyss': related to states, @@ -1013,41 +1352,29 @@ yyparse (YYPARSE_PARAM_ARG) Refer to the stacks thru separate pointers, to allow yyoverflow to reallocate them elsewhere. */ - /* The state stack. */ - short yyssa[YYINITDEPTH]; - short *yyss = yyssa; - register short *yyssp; + /* The state stack. */ + short int yyssa[YYINITDEPTH]; + short int *yyss = yyssa; + register short int *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE *yyvs = yyvsa; register YYSTYPE *yyvsp; -#if YYLSP_NEEDED - /* The location stack. */ - YYLTYPE yylsa[YYINITDEPTH]; - YYLTYPE *yyls = yylsa; - YYLTYPE *yylsp; -#endif -#if YYLSP_NEEDED -# define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) -#else -# define YYPOPSTACK (yyvsp--, yyssp--) -#endif - YYSIZE_T yystacksize = YYINITDEPTH; +#define YYPOPSTACK (yyvsp--, yyssp--) + YYSIZE_T yystacksize = YYINITDEPTH; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; -#if YYLSP_NEEDED - YYLTYPE yyloc; -#endif + /* When reducing, the number of symbols on the RHS of the reduced - rule. */ + rule. */ int yylen; YYDPRINTF ((stderr, "Starting parse\n")); @@ -1064,9 +1391,10 @@ yyparse (YYPARSE_PARAM_ARG) yyssp = yyss; yyvsp = yyvs; -#if YYLSP_NEEDED - yylsp = yyls; -#endif + + + yyvsp[0] = yylval; + goto yysetstate; /*------------------------------------------------------------. @@ -1081,7 +1409,7 @@ yyparse (YYPARSE_PARAM_ARG) yysetstate: *yyssp = yystate; - if (yyssp >= yyss + yystacksize - 1) + if (yyss + yystacksize - 1 <= yyssp) { /* Get the current used size of the three stacks, in elements. */ YYSIZE_T yysize = yyssp - yyss + 1; @@ -1092,26 +1420,19 @@ yyparse (YYPARSE_PARAM_ARG) these so that the &'s don't force the real ones into memory. */ YYSTYPE *yyvs1 = yyvs; - short *yyss1 = yyss; + short int *yyss1 = yyss; + /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. */ -# if YYLSP_NEEDED - YYLTYPE *yyls1 = yyls; - /* This used to be a conditional around just the two extra args, - but that might be undefined if yyoverflow is a macro. */ - yyoverflow ("parser stack overflow", - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), - &yyls1, yysize * sizeof (*yylsp), - &yystacksize); - yyls = yyls1; -# else + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ yyoverflow ("parser stack overflow", &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); -# endif + yyss = yyss1; yyvs = yyvs1; } @@ -1120,24 +1441,22 @@ yyparse (YYPARSE_PARAM_ARG) goto yyoverflowlab; # else /* Extend the stack our own way. */ - if (yystacksize >= YYMAXDEPTH) + if (YYMAXDEPTH <= yystacksize) goto yyoverflowlab; yystacksize *= 2; - if (yystacksize > YYMAXDEPTH) + if (YYMAXDEPTH < yystacksize) yystacksize = YYMAXDEPTH; { - short *yyss1 = yyss; + short int *yyss1 = yyss; union yyalloc *yyptr = (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); if (! yyptr) goto yyoverflowlab; YYSTACK_RELOCATE (yyss); YYSTACK_RELOCATE (yyvs); -# if YYLSP_NEEDED - YYSTACK_RELOCATE (yyls); -# endif -# undef YYSTACK_RELOCATE + +# undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } @@ -1146,14 +1465,12 @@ yyparse (YYPARSE_PARAM_ARG) yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; -#if YYLSP_NEEDED - yylsp = yyls + yysize - 1; -#endif + YYDPRINTF ((stderr, "Stack size increased to %lu\n", (unsigned long int) yystacksize)); - if (yyssp >= yyss + yystacksize - 1) + if (yyss + yystacksize - 1 <= yyssp) YYABORT; } @@ -1161,101 +1478,67 @@ yyparse (YYPARSE_PARAM_ARG) goto yybackup; - /*-----------. | yybackup. | `-----------*/ yybackup: /* Do appropriate processing given the current state. */ -/* Read a lookahead token if we need one and don't already have one. */ +/* Read a look-ahead token if we need one and don't already have one. */ /* yyresume: */ - /* First try to decide what to do without reference to lookahead token. */ + /* First try to decide what to do without reference to look-ahead token. */ yyn = yypact[yystate]; - if (yyn == YYFLAG) + if (yyn == YYPACT_NINF) goto yydefault; - /* Not known => get a lookahead token if don't already have one. */ - - /* yychar is either YYEMPTY or YYEOF - or a valid token in external form. */ + /* Not known => get a look-ahead token if don't already have one. */ + /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; } - /* Convert token to internal form (in yychar1) for indexing tables with */ - - if (yychar <= 0) /* This means end of input. */ + if (yychar <= YYEOF) { - yychar1 = 0; - yychar = YYEOF; /* Don't call YYLEX any more */ - + yychar = yytoken = YYEOF; YYDPRINTF ((stderr, "Now at end of input.\n")); } else { - yychar1 = YYTRANSLATE (yychar); - -#if YYDEBUG - /* We have to keep this `#if YYDEBUG', since we use variables - which are defined only if `YYDEBUG' is set. */ - if (yydebug) - { - YYFPRINTF (stderr, "Next token is %d (%s", - yychar, yytname[yychar1]); - /* Give the individual parser a way to print the precise - meaning of a token, for further debugging info. */ -# ifdef YYPRINT - YYPRINT (stderr, yychar, yylval); -# endif - YYFPRINTF (stderr, ")\n"); - } -#endif + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); } - yyn += yychar1; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) goto yydefault; - yyn = yytable[yyn]; - - /* yyn is what to do for this token type in this state. - Negative => reduce, -yyn is rule number. - Positive => shift, yyn is new state. - New state is final state => don't bother to shift, - just return success. - 0, or most negative number => error. */ - - if (yyn < 0) + if (yyn <= 0) { - if (yyn == YYFLAG) + if (yyn == 0 || yyn == YYTABLE_NINF) goto yyerrlab; yyn = -yyn; goto yyreduce; } - else if (yyn == 0) - goto yyerrlab; if (yyn == YYFINAL) YYACCEPT; - /* Shift the lookahead token. */ - YYDPRINTF ((stderr, "Shifting token %d (%s), ", - yychar, yytname[yychar1])); + /* Shift the look-ahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; *++yyvsp = yylval; -#if YYLSP_NEEDED - *++yylsp = yylloc; -#endif + /* Count tokens shifted since error; after three, turn off error status. */ @@ -1286,783 +1569,854 @@ yyparse (YYPARSE_PARAM_ARG) /* If YYLEN is nonzero, implement the default value of the action: `$$ = $1'. - Otherwise, the following line sets YYVAL to the semantic value of - the lookahead token. This behavior is undocumented and Bison + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; -#if YYLSP_NEEDED - /* Similarly for the default location. Let the user run additional - commands if for instance locations are ranges. */ - yyloc = yylsp[1-yylen]; - YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); -#endif -#if YYDEBUG - /* We have to keep this `#if YYDEBUG', since we use variables which - are defined only if `YYDEBUG' is set. */ - if (yydebug) + YY_REDUCE_PRINT (yyn); + switch (yyn) { - int yyi; - - YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", - yyn, yyrline[yyn]); - - /* Print the symbols being reduced, and their result. */ - for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++) - YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); - YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); - } -#endif - - switch (yyn) { - -case 2: + case 3: #line 229 "sdfparse.yy" -{} + {} break; -case 3: + + case 4: #line 234 "sdfparse.yy" -{} + {} break; -case 4: + + case 5: #line 239 "sdfparse.yy" -{} + {} break; -case 5: + + case 6: #line 244 "sdfparse.yy" -{} + {} break; -case 6: + + case 7: #line 249 "sdfparse.yy" -{} + {} break; -case 7: + + case 8: #line 254 "sdfparse.yy" -{} + {} break; -case 8: + + case 9: #line 259 "sdfparse.yy" -{} + {} break; -case 9: + + case 10: #line 263 "sdfparse.yy" -{ setParseBlob(); } + { setParseBlob(); } break; -case 10: + + case 11: #line 264 "sdfparse.yy" -{} + {} break; -case 11: + + case 12: #line 269 "sdfparse.yy" -{} + {} break; -case 12: + + case 13: #line 271 "sdfparse.yy" -{} + {} break; -case 13: + + case 14: #line 276 "sdfparse.yy" -{} + {} break; -case 14: + + case 15: #line 281 "sdfparse.yy" -{} + {} break; -case 15: + + case 16: #line 283 "sdfparse.yy" -{} + {} break; -case 16: + + case 17: #line 288 "sdfparse.yy" -{ + { /* set time scale for back annotation */ - setTimeScale( yyvsp[-2].integer - 9 ); + setTimeScale( (yyvsp[-2].integer) - 9 ); } break; -case 17: + + case 18: #line 293 "sdfparse.yy" -{ + { /* set time scale for back annotation */ - setTimeScale( yyvsp[-2].integer - 6 ); + setTimeScale( (yyvsp[-2].integer) - 6 ); } break; -case 18: + + case 19: #line 298 "sdfparse.yy" -{ + { /* set time scale for back annotation */ - setTimeScale( yyvsp[-2].integer - 12 ); + setTimeScale( (yyvsp[-2].integer) - 12 ); } break; -case 19: + + case 20: #line 303 "sdfparse.yy" -{ + { /* set default (1ns) time scale for back annotation */ setTimeScale( -9 ); } break; -case 20: + + case 21: #line 311 "sdfparse.yy" -{ - switch( yyvsp[0].integer ) { + { + switch( (yyvsp[0].integer) ) { case 1: - yyval.integer = 0; + (yyval.integer) = 0; break; case 10: - yyval.integer = 1; + (yyval.integer) = 1; break; case 100: - yyval.integer = 2; + (yyval.integer) = 2; break; default: sdf_error( "Timescale multiplier must be either 1,10, or 100" ); - yyval.integer = 0; + (yyval.integer) = 0; } } break; -case 24: + + case 25: #line 335 "sdfparse.yy" -{ + { /* reset current instance */ resetInstance(); /* free all allocated strings */ purgeStrings(); } break; -case 26: + + case 27: #line 346 "sdfparse.yy" -{ + { /* set current cell type */ - setCellType( yyvsp[-1].ptr ); + setCellType( (yyvsp[-1].ptr) ); } break; -case 29: + + case 30: #line 359 "sdfparse.yy" -{ + { /* set down thru the hierarchy */ - findInstance( yyvsp[-1].ptr ); + findInstance( (yyvsp[-1].ptr) ); } break; -case 30: + + case 31: #line 364 "sdfparse.yy" -{ + { /* this is a wild card */ findInstance( "*" ); } break; -case 31: + + case 32: #line 372 "sdfparse.yy" -{ - yyval.ptr = yyvsp[-1].ptr; + { + (yyval.ptr) = (yyvsp[-1].ptr); } break; -case 36: + + case 37: #line 384 "sdfparse.yy" -{setAbsoluteDelay(TRUE);} + {setAbsoluteDelay(TRUE);} break; -case 38: + + case 39: #line 385 "sdfparse.yy" -{ setParseBlob(); } + { setParseBlob(); } break; -case 39: + + case 40: #line 386 "sdfparse.yy" -{ - sdflexOpenFile( yyvsp[-1].ptr ); + { + sdflexOpenFile( (yyvsp[-1].ptr) ); } break; -case 42: + + case 43: #line 399 "sdfparse.yy" -{} + {} break; -case 43: + + case 44: #line 401 "sdfparse.yy" -{} + {} break; -case 45: + + case 46: #line 410 "sdfparse.yy" -{ - setConstraint( eSETUP, &yyvsp[-3].port, &yyvsp[-2].port, yyvsp[-1].elist ); + { + setConstraint( eSETUP, &(yyvsp[-3].port), &(yyvsp[-2].port), (yyvsp[-1].elist) ); } break; -case 46: + + case 47: #line 414 "sdfparse.yy" -{ - setConstraint( eHOLD, &yyvsp[-2].port, &yyvsp[-3].port, yyvsp[-1].elist ); + { + setConstraint( eHOLD, &(yyvsp[-2].port), &(yyvsp[-3].port), (yyvsp[-1].elist) ); } break; -case 47: + + case 48: #line 418 "sdfparse.yy" -{ - setConstraint( eSETUPHOLD, &yyvsp[-2].port, &yyvsp[-3].port, yyvsp[-1].elist ); + { + setConstraint( eSETUPHOLD, &(yyvsp[-2].port), &(yyvsp[-3].port), (yyvsp[-1].elist) ); } break; -case 48: + + case 49: #line 422 "sdfparse.yy" -{ - setConstraint( eRECOVERY, &yyvsp[-2].port, &yyvsp[-3].port, yyvsp[-1].elist ); + { + setConstraint( eRECOVERY, &(yyvsp[-2].port), &(yyvsp[-3].port), (yyvsp[-1].elist) ); } break; -case 49: + + case 50: #line 426 "sdfparse.yy" -{ - setConstraint( eSKEW, &yyvsp[-3].port, &yyvsp[-2].port, yyvsp[-1].elist ); + { + setConstraint( eSKEW, &(yyvsp[-3].port), &(yyvsp[-2].port), (yyvsp[-1].elist) ); } break; -case 50: + + case 51: #line 430 "sdfparse.yy" -{ - setConstraint( eWIDTH, &yyvsp[-2].port, NULL, yyvsp[-1].elist ); + { + setConstraint( eWIDTH, &(yyvsp[-2].port), NULL, (yyvsp[-1].elist) ); } break; -case 51: + + case 52: #line 434 "sdfparse.yy" -{ - setConstraint( ePERIOD, &yyvsp[-2].port, NULL, yyvsp[-1].elist ); + { + setConstraint( ePERIOD, &(yyvsp[-2].port), NULL, (yyvsp[-1].elist) ); } break; -case 52: + + case 53: #line 438 "sdfparse.yy" -{ - setConstraint( eNOCHANGE, &yyvsp[-3].port, &yyvsp[-2].port, yyvsp[-1].elist ); + { + setConstraint( eNOCHANGE, &(yyvsp[-3].port), &(yyvsp[-2].port), (yyvsp[-1].elist) ); } break; -case 55: + + case 56: #line 450 "sdfparse.yy" -{ + { /* mark delay type as absolute */ setAbsoluteDelay( TRUE ); } break; -case 57: + + case 58: #line 456 "sdfparse.yy" -{ + { /* mark delay type as incremental */ setAbsoluteDelay( FALSE ); } break; -case 66: + + case 67: #line 481 "sdfparse.yy" -{ - yyval.port = yyvsp[0].port; - yyval.port.path = yyvsp[-1].ptr; + { + (yyval.port) = (yyvsp[0].port); + (yyval.port).path = (yyvsp[-1].ptr); } break; -case 67: + + case 68: #line 489 "sdfparse.yy" -{ - yyval.port.path = NULL; - yyval.port.name = yyvsp[0].ptr; - yyval.port.scalar = TRUE; - yyval.port.edge = accNoEdge; + { + (yyval.port).path = NULL; + (yyval.port).name = (yyvsp[0].ptr); + (yyval.port).scalar = TRUE; + (yyval.port).edge = accNoEdge; } break; -case 69: + + case 70: #line 500 "sdfparse.yy" -{ - yyval.port = yyvsp[0].port; - yyval.port.path = yyvsp[-1].ptr; + { + (yyval.port) = (yyvsp[0].port); + (yyval.port).path = (yyvsp[-1].ptr); } break; -case 70: + + case 71: #line 509 "sdfparse.yy" -{ - setConstraint( eIOPATH, &yyvsp[-3].port, &yyvsp[-2].port, yyvsp[-1].elist ); + { + setConstraint( eIOPATH, &(yyvsp[-3].port), &(yyvsp[-2].port), (yyvsp[-1].elist) ); } break; -case 71: + + case 72: #line 513 "sdfparse.yy" -{ + { /* -------- support for COND needs to be added ----------- */ - setConstraint( eIOPATH, &yyvsp[-4].port, &yyvsp[-3].port, yyvsp[-2].elist ); + setConstraint( eIOPATH, &(yyvsp[-4].port), &(yyvsp[-3].port), (yyvsp[-2].elist) ); } break; -case 72: + + case 73: #line 518 "sdfparse.yy" -{ - setConstraint( ePORT, &yyvsp[-2].port, (port_t*)NULL, yyvsp[-1].elist ); + { + setConstraint( ePORT, &(yyvsp[-2].port), (port_t*)NULL, (yyvsp[-1].elist) ); } break; -case 73: + + case 74: #line 522 "sdfparse.yy" -{ - setConstraint( eINTERCONNECT, &yyvsp[-3].port, &yyvsp[-2].port, yyvsp[-1].elist ); + { + setConstraint( eINTERCONNECT, &(yyvsp[-3].port), &(yyvsp[-2].port), (yyvsp[-1].elist) ); } break; -case 74: + + case 75: #line 526 "sdfparse.yy" -{ - setConstraint( eNETDELAY, &yyvsp[-2].port, (port_t*)NULL, yyvsp[-1].elist ); + { + setConstraint( eNETDELAY, &(yyvsp[-2].port), (port_t*)NULL, (yyvsp[-1].elist) ); } break; -case 75: + + case 76: #line 530 "sdfparse.yy" -{ - setConstraint( eDEVICE, (port_t*)NULL, (port_t*)NULL, yyvsp[-1].elist ); + { + setConstraint( eDEVICE, (port_t*)NULL, (port_t*)NULL, (yyvsp[-1].elist) ); } break; -case 76: + + case 77: #line 534 "sdfparse.yy" -{ - setConstraint( eDEVICE, &yyvsp[-2].port, (port_t*)NULL, yyvsp[-1].elist ); + { + setConstraint( eDEVICE, &(yyvsp[-2].port), (port_t*)NULL, (yyvsp[-1].elist) ); } break; -case 78: + + case 79: #line 545 "sdfparse.yy" -{ - setConstraint( eIOPATH, &yyvsp[-3].port, &yyvsp[-2].port, yyvsp[-1].elist ); + { + setConstraint( eIOPATH, &(yyvsp[-3].port), &(yyvsp[-2].port), (yyvsp[-1].elist) ); } break; -case 79: + + case 80: #line 549 "sdfparse.yy" -{ + { /* -------- support for COND needs to be added ----------- */ - setConstraint( eIOPATH, &yyvsp[-4].port, &yyvsp[-3].port, yyvsp[-2].elist ); + setConstraint( eIOPATH, &(yyvsp[-4].port), &(yyvsp[-3].port), (yyvsp[-2].elist) ); } break; -case 80: + + case 81: #line 554 "sdfparse.yy" -{ - setConstraint( ePORT, &yyvsp[-2].port, (port_t*)NULL, yyvsp[-1].elist ); + { + setConstraint( ePORT, &(yyvsp[-2].port), (port_t*)NULL, (yyvsp[-1].elist) ); } break; -case 81: + + case 82: #line 558 "sdfparse.yy" -{ - setConstraint( eINTERCONNECT, &yyvsp[-3].port, &yyvsp[-2].port, yyvsp[-1].elist ); + { + setConstraint( eINTERCONNECT, &(yyvsp[-3].port), &(yyvsp[-2].port), (yyvsp[-1].elist) ); } break; -case 82: + + case 83: #line 562 "sdfparse.yy" -{ - setConstraint( eNETDELAY, &yyvsp[-2].port, (port_t*)NULL, yyvsp[-1].elist ); + { + setConstraint( eNETDELAY, &(yyvsp[-2].port), (port_t*)NULL, (yyvsp[-1].elist) ); } break; -case 83: + + case 84: #line 566 "sdfparse.yy" -{ - setConstraint( eDEVICE, (port_t*)NULL, (port_t*)NULL, yyvsp[-1].elist ); + { + setConstraint( eDEVICE, (port_t*)NULL, (port_t*)NULL, (yyvsp[-1].elist) ); } break; -case 84: + + case 85: #line 570 "sdfparse.yy" -{ - setConstraint( eDEVICE, &yyvsp[-2].port, (port_t*)NULL, yyvsp[-1].elist ); + { + setConstraint( eDEVICE, &(yyvsp[-2].port), (port_t*)NULL, (yyvsp[-1].elist) ); } break; -case 86: + + case 87: #line 576 "sdfparse.yy" -{sdfEnableEdges( TRUE ); } + {sdfEnableEdges( TRUE ); } break; -case 87: + + case 88: #line 577 "sdfparse.yy" -{ + { sdfEnableEdges( FALSE ); - yyval.port = yyvsp[0].port; + (yyval.port) = (yyvsp[0].port); } break; -case 89: + + case 90: #line 588 "sdfparse.yy" -{ - yyval.port.path = NULL; - yyval.port.name = yyvsp[0].ptr; - yyval.port.scalar = TRUE; - yyval.port.edge = accNoEdge; + { + (yyval.port).path = NULL; + (yyval.port).name = (yyvsp[0].ptr); + (yyval.port).scalar = TRUE; + (yyval.port).edge = accNoEdge; } break; -case 90: + + case 91: #line 595 "sdfparse.yy" -{ - yyval.port.path = NULL; - yyval.port.name = yyvsp[-3].ptr; - yyval.port.scalar = FALSE; - yyval.port.msb = yyvsp[-1].integer; - yyval.port.lsb = yyvsp[-1].integer; - yyval.port.edge = accNoEdge; + { + (yyval.port).path = NULL; + (yyval.port).name = (yyvsp[-3].ptr); + (yyval.port).scalar = FALSE; + (yyval.port).msb = (yyvsp[-1].integer); + (yyval.port).lsb = (yyvsp[-1].integer); + (yyval.port).edge = accNoEdge; } break; -case 91: + + case 92: #line 604 "sdfparse.yy" -{ - yyval.port.path = NULL; - yyval.port.name = yyvsp[-5].ptr; - yyval.port.scalar = FALSE; - yyval.port.msb = yyvsp[-3].integer; - yyval.port.lsb = yyvsp[-1].integer; - yyval.port.edge = accNoedge; + { + (yyval.port).path = NULL; + (yyval.port).name = (yyvsp[-5].ptr); + (yyval.port).scalar = FALSE; + (yyval.port).msb = (yyvsp[-3].integer); + (yyval.port).lsb = (yyvsp[-1].integer); + (yyval.port).edge = accNoedge; } break; -case 92: + + case 93: #line 616 "sdfparse.yy" -{ - yyval.port = yyvsp[-1].port; - yyval.port.edge = accPosedge; + { + (yyval.port) = (yyvsp[-1].port); + (yyval.port).edge = accPosedge; } break; -case 93: + + case 94: #line 621 "sdfparse.yy" -{ - yyval.port = yyvsp[-1].port; - yyval.port.edge = accNegedge; + { + (yyval.port) = (yyvsp[-1].port); + (yyval.port).edge = accNegedge; } break; -case 94: + + case 95: #line 626 "sdfparse.yy" -{ - yyval.port = yyvsp[-1].port; - yyval.port.edge = accEdge01; + { + (yyval.port) = (yyvsp[-1].port); + (yyval.port).edge = accEdge01; } break; -case 95: + + case 96: #line 631 "sdfparse.yy" -{ - yyval.port = yyvsp[-1].port; - yyval.port.edge = accEdge10; + { + (yyval.port) = (yyvsp[-1].port); + (yyval.port).edge = accEdge10; } break; -case 96: + + case 97: #line 636 "sdfparse.yy" -{ - yyval.port = yyvsp[-1].port; - yyval.port.edge = accEdgex1; + { + (yyval.port) = (yyvsp[-1].port); + (yyval.port).edge = accEdgex1; } break; -case 97: + + case 98: #line 641 "sdfparse.yy" -{ - yyval.port = yyvsp[-1].port; - yyval.port.edge = accEdgex0; + { + (yyval.port) = (yyvsp[-1].port); + (yyval.port).edge = accEdgex0; } break; -case 98: + + case 99: #line 646 "sdfparse.yy" -{ - yyval.port = yyvsp[-1].port; - yyval.port.edge = accEdge1x; + { + (yyval.port) = (yyvsp[-1].port); + (yyval.port).edge = accEdge1x; } break; -case 99: + + case 100: #line 651 "sdfparse.yy" -{ - yyval.port = yyvsp[-1].port; - yyval.port.edge = accEdge0x; + { + (yyval.port) = (yyvsp[-1].port); + (yyval.port).edge = accEdge0x; } break; -case 100: + + case 101: #line 660 "sdfparse.yy" -{ - memset( &yyval.elist, 0, sizeof(yyval.elist) ); - yyval.elist.values[0].triple[0].value = yyvsp[-1].floating; - yyval.elist.values[0].triple[0].valid = TRUE; - yyval.elist.values[0].triple[1].value = yyvsp[-1].floating; - yyval.elist.values[0].triple[1].valid = TRUE; - yyval.elist.values[0].triple[2].value = yyvsp[-1].floating; - yyval.elist.values[0].triple[2].valid = TRUE; - yyval.elist.argCount = 1; + { + memset( &(yyval.elist), 0, sizeof((yyval.elist)) ); + (yyval.elist).values[0].triple[0].value = (yyvsp[-1].floating); + (yyval.elist).values[0].triple[0].valid = TRUE; + (yyval.elist).values[0].triple[1].value = (yyvsp[-1].floating); + (yyval.elist).values[0].triple[1].valid = TRUE; + (yyval.elist).values[0].triple[2].value = (yyvsp[-1].floating); + (yyval.elist).values[0].triple[2].valid = TRUE; + (yyval.elist).argCount = 1; } break; -case 102: + + case 103: #line 675 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-1].elist.values[0]; - yyval.elist.values[1] = yyvsp[0].elist.values[0]; - yyval.elist.argCount = 2; + { + (yyval.elist).values[0] = (yyvsp[-1].elist).values[0]; + (yyval.elist).values[1] = (yyvsp[0].elist).values[0]; + (yyval.elist).argCount = 2; } break; -case 103: + + case 104: #line 684 "sdfparse.yy" -{ - memset( &yyval.elist, 0, sizeof(yyval.elist) ); - yyval.elist.values[0].triple[0].value = yyvsp[-1].floating; - yyval.elist.values[0].triple[0].valid = TRUE; - yyval.elist.values[0].triple[1].value = yyvsp[-1].floating; - yyval.elist.values[0].triple[1].valid = TRUE; - yyval.elist.values[0].triple[2].value = yyvsp[-1].floating; - yyval.elist.values[0].triple[2].valid = TRUE; - yyval.elist.argCount = 1; + { + memset( &(yyval.elist), 0, sizeof((yyval.elist)) ); + (yyval.elist).values[0].triple[0].value = (yyvsp[-1].floating); + (yyval.elist).values[0].triple[0].valid = TRUE; + (yyval.elist).values[0].triple[1].value = (yyvsp[-1].floating); + (yyval.elist).values[0].triple[1].valid = TRUE; + (yyval.elist).values[0].triple[2].value = (yyvsp[-1].floating); + (yyval.elist).values[0].triple[2].valid = TRUE; + (yyval.elist).argCount = 1; } break; -case 104: + + case 105: #line 695 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-1].triple; - yyval.elist.argCount = 1; + { + (yyval.elist).values[0] = (yyvsp[-1].triple); + (yyval.elist).argCount = 1; } break; -case 105: + + case 106: #line 703 "sdfparse.yy" -{ - memset( &yyval.elist, 0, sizeof(yyval.elist) ); - yyval.elist.values[0].triple[0].value = yyvsp[-1].floating; - yyval.elist.values[0].triple[0].valid = TRUE; - yyval.elist.values[0].triple[1].value = yyvsp[-1].floating; - yyval.elist.values[0].triple[1].valid = TRUE; - yyval.elist.values[0].triple[2].value = yyvsp[-1].floating; - yyval.elist.values[0].triple[2].valid = TRUE; - yyval.elist.argCount = 1; + { + memset( &(yyval.elist), 0, sizeof((yyval.elist)) ); + (yyval.elist).values[0].triple[0].value = (yyvsp[-1].floating); + (yyval.elist).values[0].triple[0].valid = TRUE; + (yyval.elist).values[0].triple[1].value = (yyvsp[-1].floating); + (yyval.elist).values[0].triple[1].valid = TRUE; + (yyval.elist).values[0].triple[2].value = (yyvsp[-1].floating); + (yyval.elist).values[0].triple[2].valid = TRUE; + (yyval.elist).argCount = 1; } break; -case 107: + + case 108: #line 718 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-1].triple; - yyval.elist.argCount = 1; + { + (yyval.elist).values[0] = (yyvsp[-1].triple); + (yyval.elist).argCount = 1; } break; -case 108: + + case 109: #line 723 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-4].triple; - yyval.elist.values[1] = yyvsp[-1].triple; - yyval.elist.argCount = 2; + { + (yyval.elist).values[0] = (yyvsp[-4].triple); + (yyval.elist).values[1] = (yyvsp[-1].triple); + (yyval.elist).argCount = 2; } break; -case 109: + + case 110: #line 729 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-7].triple; - yyval.elist.values[1] = yyvsp[-4].triple; - yyval.elist.values[2] = yyvsp[-1].triple; - yyval.elist.argCount = 3; + { + (yyval.elist).values[0] = (yyvsp[-7].triple); + (yyval.elist).values[1] = (yyvsp[-4].triple); + (yyval.elist).values[2] = (yyvsp[-1].triple); + (yyval.elist).argCount = 3; } break; -case 110: + + case 111: #line 737 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-10].triple; - yyval.elist.values[1] = yyvsp[-7].triple; - yyval.elist.values[2] = yyvsp[-4].triple; - yyval.elist.values[3] = yyvsp[-1].triple; - yyval.elist.argCount = 4; + { + (yyval.elist).values[0] = (yyvsp[-10].triple); + (yyval.elist).values[1] = (yyvsp[-7].triple); + (yyval.elist).values[2] = (yyvsp[-4].triple); + (yyval.elist).values[3] = (yyvsp[-1].triple); + (yyval.elist).argCount = 4; } break; -case 111: + + case 112: #line 746 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-13].triple; - yyval.elist.values[1] = yyvsp[-10].triple; - yyval.elist.values[2] = yyvsp[-7].triple; - yyval.elist.values[3] = yyvsp[-4].triple; - yyval.elist.values[4] = yyvsp[-1].triple; - yyval.elist.argCount = 5; + { + (yyval.elist).values[0] = (yyvsp[-13].triple); + (yyval.elist).values[1] = (yyvsp[-10].triple); + (yyval.elist).values[2] = (yyvsp[-7].triple); + (yyval.elist).values[3] = (yyvsp[-4].triple); + (yyval.elist).values[4] = (yyvsp[-1].triple); + (yyval.elist).argCount = 5; } break; -case 112: + + case 113: #line 756 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-16].triple; - yyval.elist.values[1] = yyvsp[-13].triple; - yyval.elist.values[2] = yyvsp[-10].triple; - yyval.elist.values[3] = yyvsp[-7].triple; - yyval.elist.values[4] = yyvsp[-4].triple; - yyval.elist.values[5] = yyvsp[-1].triple; - yyval.elist.argCount = 6; + { + (yyval.elist).values[0] = (yyvsp[-16].triple); + (yyval.elist).values[1] = (yyvsp[-13].triple); + (yyval.elist).values[2] = (yyvsp[-10].triple); + (yyval.elist).values[3] = (yyvsp[-7].triple); + (yyval.elist).values[4] = (yyvsp[-4].triple); + (yyval.elist).values[5] = (yyvsp[-1].triple); + (yyval.elist).argCount = 6; } break; -case 113: + + case 114: #line 770 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-1].triple; - yyval.elist.argCount = 1; + { + (yyval.elist).values[0] = (yyvsp[-1].triple); + (yyval.elist).argCount = 1; } break; -case 114: + + case 115: #line 775 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-4].triple; - yyval.elist.values[1] = yyvsp[-1].triple; - yyval.elist.argCount = 2; + { + (yyval.elist).values[0] = (yyvsp[-4].triple); + (yyval.elist).values[1] = (yyvsp[-1].triple); + (yyval.elist).argCount = 2; } break; -case 115: + + case 116: #line 781 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-7].triple; - yyval.elist.values[1] = yyvsp[-4].triple; - yyval.elist.values[2] = yyvsp[-1].triple; - yyval.elist.argCount = 3; + { + (yyval.elist).values[0] = (yyvsp[-7].triple); + (yyval.elist).values[1] = (yyvsp[-4].triple); + (yyval.elist).values[2] = (yyvsp[-1].triple); + (yyval.elist).argCount = 3; } break; -case 116: + + case 117: #line 789 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-10].triple; - yyval.elist.values[1] = yyvsp[-7].triple; - yyval.elist.values[2] = yyvsp[-4].triple; - yyval.elist.values[3] = yyvsp[-1].triple; - yyval.elist.argCount = 4; + { + (yyval.elist).values[0] = (yyvsp[-10].triple); + (yyval.elist).values[1] = (yyvsp[-7].triple); + (yyval.elist).values[2] = (yyvsp[-4].triple); + (yyval.elist).values[3] = (yyvsp[-1].triple); + (yyval.elist).argCount = 4; } break; -case 117: + + case 118: #line 798 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-13].triple; - yyval.elist.values[1] = yyvsp[-10].triple; - yyval.elist.values[2] = yyvsp[-7].triple; - yyval.elist.values[3] = yyvsp[-4].triple; - yyval.elist.values[4] = yyvsp[-1].triple; - yyval.elist.argCount = 5; + { + (yyval.elist).values[0] = (yyvsp[-13].triple); + (yyval.elist).values[1] = (yyvsp[-10].triple); + (yyval.elist).values[2] = (yyvsp[-7].triple); + (yyval.elist).values[3] = (yyvsp[-4].triple); + (yyval.elist).values[4] = (yyvsp[-1].triple); + (yyval.elist).argCount = 5; } break; -case 118: + + case 119: #line 808 "sdfparse.yy" -{ - yyval.elist.values[0] = yyvsp[-16].triple; - yyval.elist.values[1] = yyvsp[-13].triple; - yyval.elist.values[2] = yyvsp[-10].triple; - yyval.elist.values[3] = yyvsp[-7].triple; - yyval.elist.values[4] = yyvsp[-4].triple; - yyval.elist.values[5] = yyvsp[-1].triple; - yyval.elist.argCount = 6; + { + (yyval.elist).values[0] = (yyvsp[-16].triple); + (yyval.elist).values[1] = (yyvsp[-13].triple); + (yyval.elist).values[2] = (yyvsp[-10].triple); + (yyval.elist).values[3] = (yyvsp[-7].triple); + (yyval.elist).values[4] = (yyvsp[-4].triple); + (yyval.elist).values[5] = (yyvsp[-1].triple); + (yyval.elist).argCount = 6; } break; -case 119: + + case 120: #line 821 "sdfparse.yy" -{ - yyval.triple.triple[0].value = yyvsp[-4].floating; - yyval.triple.triple[0].valid = TRUE; - yyval.triple.triple[1] = yyvsp[-2].creal; - yyval.triple.triple[2] = yyvsp[0].creal; + { + (yyval.triple).triple[0].value = (yyvsp[-4].floating); + (yyval.triple).triple[0].valid = TRUE; + (yyval.triple).triple[1] = (yyvsp[-2].creal); + (yyval.triple).triple[2] = (yyvsp[0].creal); } break; -case 120: + + case 121: #line 828 "sdfparse.yy" -{ - yyval.triple.triple[0] = yyvsp[-4].creal; - yyval.triple.triple[1].value = yyvsp[-2].floating; - yyval.triple.triple[1].valid = TRUE; - yyval.triple.triple[2] = yyvsp[0].creal; + { + (yyval.triple).triple[0] = (yyvsp[-4].creal); + (yyval.triple).triple[1].value = (yyvsp[-2].floating); + (yyval.triple).triple[1].valid = TRUE; + (yyval.triple).triple[2] = (yyvsp[0].creal); } break; -case 121: + + case 122: #line 835 "sdfparse.yy" -{ - yyval.triple.triple[0] = yyvsp[-4].creal; - yyval.triple.triple[1] = yyvsp[-2].creal; - yyval.triple.triple[2].value = yyvsp[0].floating; - yyval.triple.triple[2].valid = TRUE; + { + (yyval.triple).triple[0] = (yyvsp[-4].creal); + (yyval.triple).triple[1] = (yyvsp[-2].creal); + (yyval.triple).triple[2].value = (yyvsp[0].floating); + (yyval.triple).triple[2].valid = TRUE; } break; -case 122: + + case 123: #line 842 "sdfparse.yy" -{ - yyval.triple.triple[0].valid = FALSE; - yyval.triple.triple[1].valid = FALSE; - yyval.triple.triple[2].valid = FALSE; + { + (yyval.triple).triple[0].valid = FALSE; + (yyval.triple).triple[1].valid = FALSE; + (yyval.triple).triple[2].valid = FALSE; } break; -case 123: + + case 124: #line 851 "sdfparse.yy" -{ - yyval.triple.triple[0].value = yyvsp[-4].floating; - yyval.triple.triple[0].valid = TRUE; - yyval.triple.triple[1] = yyvsp[-2].creal; - yyval.triple.triple[2] = yyvsp[0].creal; + { + (yyval.triple).triple[0].value = (yyvsp[-4].floating); + (yyval.triple).triple[0].valid = TRUE; + (yyval.triple).triple[1] = (yyvsp[-2].creal); + (yyval.triple).triple[2] = (yyvsp[0].creal); } break; -case 124: + + case 125: #line 858 "sdfparse.yy" -{ - yyval.triple.triple[0] = yyvsp[-4].creal; - yyval.triple.triple[1].value = yyvsp[-2].floating; - yyval.triple.triple[1].valid = TRUE; - yyval.triple.triple[2] = yyvsp[0].creal; + { + (yyval.triple).triple[0] = (yyvsp[-4].creal); + (yyval.triple).triple[1].value = (yyvsp[-2].floating); + (yyval.triple).triple[1].valid = TRUE; + (yyval.triple).triple[2] = (yyvsp[0].creal); } break; -case 125: + + case 126: #line 865 "sdfparse.yy" -{ - yyval.triple.triple[0] = yyvsp[-4].creal; - yyval.triple.triple[1] = yyvsp[-2].creal; - yyval.triple.triple[2].value = yyvsp[0].floating; - yyval.triple.triple[2].valid = TRUE; + { + (yyval.triple).triple[0] = (yyvsp[-4].creal); + (yyval.triple).triple[1] = (yyvsp[-2].creal); + (yyval.triple).triple[2].value = (yyvsp[0].floating); + (yyval.triple).triple[2].valid = TRUE; } break; -case 126: + + case 127: #line 872 "sdfparse.yy" -{ - yyval.triple.triple[0].valid = FALSE; - yyval.triple.triple[1].valid = FALSE; - yyval.triple.triple[2].valid = FALSE; + { + (yyval.triple).triple[0].valid = FALSE; + (yyval.triple).triple[1].valid = FALSE; + (yyval.triple).triple[2].valid = FALSE; } break; -case 128: + + case 129: #line 882 "sdfparse.yy" -{ yyval.floating = yyvsp[0].floating; } + { (yyval.floating) = (yyvsp[0].floating); } break; -case 129: + + case 130: #line 884 "sdfparse.yy" -{ yyval.floating = -yyvsp[0].floating; } + { (yyval.floating) = -(yyvsp[0].floating); } break; -case 131: + + case 132: #line 889 "sdfparse.yy" -{ yyval.floating = (double) yyvsp[0].integer; } + { (yyval.floating) = (double) (yyvsp[0].integer); } break; -case 132: + + case 133: #line 894 "sdfparse.yy" -{ - yyval.creal.value = yyvsp[0].floating; - yyval.creal.valid = TRUE; + { + (yyval.creal).value = (yyvsp[0].floating); + (yyval.creal).valid = TRUE; } break; -case 133: + + case 134: #line 899 "sdfparse.yy" -{ yyval.creal.valid = FALSE; } + { (yyval.creal).valid = FALSE; } break; -case 134: + + case 135: #line 904 "sdfparse.yy" -{ - yyval.creal.value = yyvsp[0].floating; - yyval.creal.valid = TRUE; + { + (yyval.creal).value = (yyvsp[0].floating); + (yyval.creal).valid = TRUE; } break; -case 135: + + case 136: #line 909 "sdfparse.yy" -{ yyval.creal.valid = FALSE; } + { (yyval.creal).valid = FALSE; } break; -case 137: + + case 138: #line 915 "sdfparse.yy" -{ yyval.ptr = ""; } + { (yyval.ptr) = ""; } break; -case 138: + + case 139: #line 924 "sdfparse.yy" -{ yyerrok; } + { yyerrok; } break; -case 139: + + case 140: #line 929 "sdfparse.yy" -{ yyerrok; } + { yyerrok; } break; -case 140: + + case 141: #line 931 "sdfparse.yy" -{ yyerrok; } + { yyerrok; } break; -} -#line 705 "/home/mdh/sourceforge/bison/share/bison/bison.simple" + } + +/* Line 1037 of yacc.c. */ +#line 2411 "sdfparse.cc" yyvsp -= yylen; yyssp -= yylen; -#if YYLSP_NEEDED - yylsp -= yylen; -#endif -#if YYDEBUG - if (yydebug) - { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); - } -#endif + + YY_STACK_PRINT (yyss, yyssp); *++yyvsp = yyval; -#if YYLSP_NEEDED - *++yylsp = yyloc; -#endif + /* Now `shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule @@ -2070,11 +2424,11 @@ case 140: yyn = yyr1[yyn]; - yystate = yypgoto[yyn - YYNTBASE] + *yyssp; - if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else - yystate = yydefgoto[yyn - YYNTBASE]; + yystate = yydefgoto[yyn - YYNTOKENS]; goto yynewstate; @@ -2087,155 +2441,159 @@ case 140: if (!yyerrstatus) { ++yynerrs; - -#ifdef YYERROR_VERBOSE +#if YYERROR_VERBOSE yyn = yypact[yystate]; - if (yyn > YYFLAG && yyn < YYLAST) + if (YYPACT_NINF < yyn && yyn < YYLAST) { YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + const char* yyprefix; char *yymsg; - int yyx, yycount; + int yyx; - yycount = 0; /* Start YYX at -YYN if negative to avoid negative indexes in YYCHECK. */ - for (yyx = yyn < 0 ? -yyn : 0; - yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) - if (yycheck[yyx + yyn] == yyx) - yysize += yystrlen (yytname[yyx]) + 15, yycount++; - yysize += yystrlen ("parse error, unexpected ") + 1; - yysize += yystrlen (yytname[YYTRANSLATE (yychar)]); + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 0; + + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); + yycount += 1; + if (yycount == 5) + { + yysize = 0; + break; + } + } + yysize += (sizeof ("syntax error, unexpected ") + + yystrlen (yytname[yytype])); yymsg = (char *) YYSTACK_ALLOC (yysize); if (yymsg != 0) { - char *yyp = yystpcpy (yymsg, "parse error, unexpected "); - yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]); + char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); if (yycount < 5) { - yycount = 0; - for (yyx = yyn < 0 ? -yyn : 0; - yyx < (int) (sizeof (yytname) / sizeof (char *)); - yyx++) - if (yycheck[yyx + yyn] == yyx) + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) { - const char *yyq = ! yycount ? ", expecting " : " or "; - yyp = yystpcpy (yyp, yyq); + yyp = yystpcpy (yyp, yyprefix); yyp = yystpcpy (yyp, yytname[yyx]); - yycount++; + yyprefix = " or "; } } yyerror (yymsg); YYSTACK_FREE (yymsg); } else - yyerror ("parse error; also virtual memory exhausted"); + yyerror ("syntax error; also virtual memory exhausted"); } else -#endif /* defined (YYERROR_VERBOSE) */ - yyerror ("parse error"); +#endif /* YYERROR_VERBOSE */ + yyerror ("syntax error"); } - goto yyerrlab1; -/*--------------------------------------------------. -| yyerrlab1 -- error raised explicitly by an action | -`--------------------------------------------------*/ -yyerrlab1: + if (yyerrstatus == 3) { - /* If just tried and failed to reuse lookahead token after an + /* If just tried and failed to reuse look-ahead token after an error, discard it. */ - /* return failure if at end of input */ - if (yychar == YYEOF) - YYABORT; - YYDPRINTF ((stderr, "Discarding token %d (%s).\n", - yychar, yytname[yychar1])); - yychar = YYEMPTY; + if (yychar <= YYEOF) + { + /* If at end of input, pop the error token, + then the rest of the stack, then return failure. */ + if (yychar == YYEOF) + for (;;) + { + + YYPOPSTACK; + if (yyssp == yyss) + YYABORT; + yydestruct ("Error: popping", + yystos[*yyssp], yyvsp); + } + } + else + { + yydestruct ("Error: discarding", yytoken, &yylval); + yychar = YYEMPTY; + } } - /* Else will try to reuse lookahead token after shifting the error + /* Else will try to reuse look-ahead token after shifting the error token. */ - - yyerrstatus = 3; /* Each real token shifted decrements this */ - - goto yyerrhandle; + goto yyerrlab1; -/*-------------------------------------------------------------------. -| yyerrdefault -- current state does not do anything special for the | -| error token. | -`-------------------------------------------------------------------*/ -yyerrdefault: -#if 0 - /* This is wrong; only states that explicitly want error tokens - should shift them. */ +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: - /* If its default is to accept any token, ok. Otherwise pop it. */ - yyn = yydefact[yystate]; - if (yyn) - goto yydefault; +#ifdef __GNUC__ + /* Pacify GCC when the user code never invokes YYERROR and the label + yyerrorlab therefore never appears in user code. */ + if (0) + goto yyerrorlab; #endif +yyvsp -= yylen; + yyssp -= yylen; + yystate = *yyssp; + goto yyerrlab1; -/*---------------------------------------------------------------. -| yyerrpop -- pop the current state because it cannot handle the | -| error token | -`---------------------------------------------------------------*/ -yyerrpop: - if (yyssp == yyss) - YYABORT; - yyvsp--; - yystate = *--yyssp; -#if YYLSP_NEEDED - yylsp--; -#endif -#if YYDEBUG - if (yydebug) +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "Error: state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); - } -#endif + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } -/*--------------. -| yyerrhandle. | -`--------------*/ -yyerrhandle: - yyn = yypact[yystate]; - if (yyn == YYFLAG) - goto yyerrdefault; + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; - yyn += YYTERROR; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) - goto yyerrdefault; - yyn = yytable[yyn]; - if (yyn < 0) - { - if (yyn == YYFLAG) - goto yyerrpop; - yyn = -yyn; - goto yyreduce; + yydestruct ("Error: popping", yystos[yystate], yyvsp); + YYPOPSTACK; + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); } - else if (yyn == 0) - goto yyerrpop; if (yyn == YYFINAL) YYACCEPT; - YYDPRINTF ((stderr, "Shifting error token, ")); - *++yyvsp = yylval; -#if YYLSP_NEEDED - *++yylsp = yylloc; -#endif + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); yystate = yyn; goto yynewstate; @@ -2252,16 +2610,21 @@ case 140: | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ yyabortlab: + yydestruct ("Error: discarding lookahead", + yytoken, &yylval); + yychar = YYEMPTY; yyresult = 1; goto yyreturn; -/*---------------------------------------------. -| yyoverflowab -- parser overflow comes here. | -`---------------------------------------------*/ +#ifndef yyoverflow +/*----------------------------------------------. +| yyoverflowlab -- parser overflow comes here. | +`----------------------------------------------*/ yyoverflowlab: yyerror ("parser stack overflow"); yyresult = 2; /* Fall through. */ +#endif yyreturn: #ifndef yyoverflow @@ -2270,6 +2633,9 @@ case 140: #endif return yyresult; } + + #line 934 "sdfparse.yy" + diff --git a/src/sdfparse.h b/src/sdfparse.h index b5de620..78016c4 100644 --- a/src/sdfparse.h +++ b/src/sdfparse.h @@ -1,8 +1,199 @@ -#ifndef BISON_SDFPARSE_H -# define BISON_SDFPARSE_H +/* A Bison parser, made by GNU Bison 2.0. */ -#ifndef YYSTYPE -typedef union { +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + IF = 258, + ELSE = 259, + OROR = 260, + ANDAND = 261, + ANDANDAND = 262, + XNOR = 263, + CASE_INEQUALITY = 264, + CASE_EQUALITY = 265, + LOGICAL_INEQUALITY = 266, + LOGICAL_EQUALITY = 267, + GE = 268, + GT = 269, + LE = 270, + LT = 271, + RIGHT_SHIFT = 272, + LEFT_SHIFT = 273, + REDUCTION_NOR = 274, + REDUCTION_NAND = 275, + UNARY = 276, + INTEGER = 277, + SCALAR_CONSTANT = 278, + FLOATING = 279, + QSTRING = 280, + IDENTIFIER = 281, + BLOB = 282, + POSEDGE = 283, + NEGEDGE = 284, + DELAYFILE = 285, + SDFVERSION = 286, + DESIGN = 287, + DATE = 288, + VENDOR = 289, + PROGRAM = 290, + VERSION_ = 291, + DIVIDER = 292, + VOLTAGE = 293, + PROCESS = 294, + TEMPERATURE = 295, + TIMESCALE = 296, + CELL = 297, + CELLTYPE = 298, + INSTANCE = 299, + DELAY = 300, + TIMINGCHECK = 301, + INCLUDE = 302, + ABSOLUTE = 303, + INCREMENT = 304, + USERDEF = 305, + PATHPULSE = 306, + GLOBALPATHPULSE = 307, + IOPATH = 308, + COND = 309, + PORT = 310, + INTERCONNECT = 311, + NETDELAY = 312, + DEVICE = 313, + SETUP = 314, + HOLD = 315, + SETUPHOLD = 316, + RECOVERY = 317, + SKEW = 318, + WIDTH = 319, + PERIOD = 320, + NOCHANGE = 321, + PATHCONSTRAINT = 322, + SUM = 323, + DIFF = 324, + SKEWCONSTRAINT = 325, + MICROSECOND = 326, + NANOSECOND = 327, + PICOSECOND = 328, + EDGE_01 = 329, + EDGE_10 = 330, + EDGE_0z = 331, + EDGE_1z = 332, + EDGE_z0 = 333, + EDGE_z1 = 334, + EOF_ = 335 + }; +#endif +#define IF 258 +#define ELSE 259 +#define OROR 260 +#define ANDAND 261 +#define ANDANDAND 262 +#define XNOR 263 +#define CASE_INEQUALITY 264 +#define CASE_EQUALITY 265 +#define LOGICAL_INEQUALITY 266 +#define LOGICAL_EQUALITY 267 +#define GE 268 +#define GT 269 +#define LE 270 +#define LT 271 +#define RIGHT_SHIFT 272 +#define LEFT_SHIFT 273 +#define REDUCTION_NOR 274 +#define REDUCTION_NAND 275 +#define UNARY 276 +#define INTEGER 277 +#define SCALAR_CONSTANT 278 +#define FLOATING 279 +#define QSTRING 280 +#define IDENTIFIER 281 +#define BLOB 282 +#define POSEDGE 283 +#define NEGEDGE 284 +#define DELAYFILE 285 +#define SDFVERSION 286 +#define DESIGN 287 +#define DATE 288 +#define VENDOR 289 +#define PROGRAM 290 +#define VERSION_ 291 +#define DIVIDER 292 +#define VOLTAGE 293 +#define PROCESS 294 +#define TEMPERATURE 295 +#define TIMESCALE 296 +#define CELL 297 +#define CELLTYPE 298 +#define INSTANCE 299 +#define DELAY 300 +#define TIMINGCHECK 301 +#define INCLUDE 302 +#define ABSOLUTE 303 +#define INCREMENT 304 +#define USERDEF 305 +#define PATHPULSE 306 +#define GLOBALPATHPULSE 307 +#define IOPATH 308 +#define COND 309 +#define PORT 310 +#define INTERCONNECT 311 +#define NETDELAY 312 +#define DEVICE 313 +#define SETUP 314 +#define HOLD 315 +#define SETUPHOLD 316 +#define RECOVERY 317 +#define SKEW 318 +#define WIDTH 319 +#define PERIOD 320 +#define NOCHANGE 321 +#define PATHCONSTRAINT 322 +#define SUM 323 +#define DIFF 324 +#define SKEWCONSTRAINT 325 +#define MICROSECOND 326 +#define NANOSECOND 327 +#define PICOSECOND 328 +#define EDGE_01 329 +#define EDGE_10 330 +#define EDGE_0z 331 +#define EDGE_1z 332 +#define EDGE_z0 333 +#define EDGE_z1 334 +#define EOF_ 335 + + + + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +#line 93 "sdfparse.yy" +typedef union YYSTYPE { int integer; double floating; char *ptr; @@ -15,88 +206,15 @@ typedef union { triple_t triple; elist_t elist; port_t port; -} yystype; -# define YYSTYPE yystype +} YYSTYPE; +/* Line 1318 of yacc.c. */ +#line 212 "sdfparse.h" +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 #endif -# define IF 257 -# define ELSE 258 -# define OROR 259 -# define ANDAND 260 -# define ANDANDAND 261 -# define XNOR 262 -# define LOGICAL_EQUALITY 263 -# define LOGICAL_INEQUALITY 264 -# define CASE_EQUALITY 265 -# define CASE_INEQUALITY 266 -# define LT 267 -# define LE 268 -# define GT 269 -# define GE 270 -# define LEFT_SHIFT 271 -# define RIGHT_SHIFT 272 -# define REDUCTION_NOR 273 -# define REDUCTION_NAND 274 -# define UNARY 275 -# define INTEGER 276 -# define SCALAR_CONSTANT 277 -# define FLOATING 278 -# define QSTRING 279 -# define IDENTIFIER 280 -# define BLOB 281 -# define POSEDGE 282 -# define NEGEDGE 283 -# define DELAYFILE 284 -# define SDFVERSION 285 -# define DESIGN 286 -# define DATE 287 -# define VENDOR 288 -# define PROGRAM 289 -# define VERSION_ 290 -# define DIVIDER 291 -# define VOLTAGE 292 -# define PROCESS 293 -# define TEMPERATURE 294 -# define TIMESCALE 295 -# define CELL 296 -# define CELLTYPE 297 -# define INSTANCE 298 -# define DELAY 299 -# define TIMINGCHECK 300 -# define INCLUDE 301 -# define ABSOLUTE 302 -# define INCREMENT 303 -# define USERDEF 304 -# define PATHPULSE 305 -# define GLOBALPATHPULSE 306 -# define IOPATH 307 -# define COND 308 -# define PORT 309 -# define INTERCONNECT 310 -# define NETDELAY 311 -# define DEVICE 312 -# define SETUP 313 -# define HOLD 314 -# define SETUPHOLD 315 -# define RECOVERY 316 -# define SKEW 317 -# define WIDTH 318 -# define PERIOD 319 -# define NOCHANGE 320 -# define PATHCONSTRAINT 321 -# define SUM 322 -# define DIFF 323 -# define SKEWCONSTRAINT 324 -# define MICROSECOND 325 -# define NANOSECOND 326 -# define PICOSECOND 327 -# define EDGE_01 328 -# define EDGE_10 329 -# define EDGE_0z 330 -# define EDGE_1z 331 -# define EDGE_z0 332 -# define EDGE_z1 333 -# define EOF_ 334 -#endif /* not BISON_SDFPARSE_H */ + + +