aboutsummaryrefslogtreecommitdiff
path: root/gcc-1.40/c-parse.tab.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc-1.40/c-parse.tab.c')
-rw-r--r--gcc-1.40/c-parse.tab.c4280
1 files changed, 4280 insertions, 0 deletions
diff --git a/gcc-1.40/c-parse.tab.c b/gcc-1.40/c-parse.tab.c
new file mode 100644
index 0000000..f29a995
--- /dev/null
+++ b/gcc-1.40/c-parse.tab.c
@@ -0,0 +1,4280 @@
+
+/* A Bison parser, made from ccdir/c-parse.y */
+
+#define IDENTIFIER 258
+#define TYPENAME 259
+#define SCSPEC 260
+#define TYPESPEC 261
+#define TYPE_QUAL 262
+#define CONSTANT 263
+#define STRING 264
+#define ELLIPSIS 265
+#define SIZEOF 266
+#define ENUM 267
+#define STRUCT 268
+#define UNION 269
+#define IF 270
+#define ELSE 271
+#define WHILE 272
+#define DO 273
+#define FOR 274
+#define SWITCH 275
+#define CASE 276
+#define DEFAULT 277
+#define BREAK 278
+#define CONTINUE 279
+#define RETURN 280
+#define GOTO 281
+#define ASM 282
+#define TYPEOF 283
+#define ALIGNOF 284
+#define ATTRIBUTE 285
+#define ASSIGN 286
+#define OROR 287
+#define ANDAND 288
+#define EQCOMPARE 289
+#define ARITHCOMPARE 290
+#define LSHIFT 291
+#define RSHIFT 292
+#define UNARY 293
+#define PLUSPLUS 294
+#define MINUSMINUS 295
+#define HYPERUNARY 296
+#define POINTSAT 297
+
+#line 39 "ccdir/c-parse.y"
+
+#include "config.h"
+#include "tree.h"
+#include "input.h"
+#include "c-parse.h"
+#include "c-tree.h"
+
+#include <stdio.h>
+#include <errno.h>
+
+#ifndef errno
+extern int errno;
+#endif
+
+void yyerror ();
+
+/* Cause the `yydebug' variable to be defined. */
+#define YYDEBUG 1
+
+#line 61 "ccdir/c-parse.y"
+typedef union {long itype; tree ttype; enum tree_code code; } YYSTYPE;
+#line 154 "ccdir/c-parse.y"
+
+/* the declaration found for the last IDENTIFIER token read in.
+ yylex must look this up to detect typedefs, which get token type TYPENAME,
+ so it is left around in case the identifier is not a typedef but is
+ used in a context which makes it a reference to a variable. */
+static tree lastiddecl;
+
+static tree make_pointer_declarator ();
+static tree combine_strings ();
+static void reinit_parse_for_function ();
+
+/* List of types and structure classes of the current declaration. */
+tree current_declspecs;
+
+/* Stack of saved values of current_declspecs. */
+tree declspec_stack;
+
+int undeclared_variable_notice; /* 1 if we explained undeclared var errors. */
+
+static int yylex ();
+
+#ifndef YYLTYPE
+typedef
+ struct yyltype
+ {
+ int timestamp;
+ int first_line;
+ int first_column;
+ int last_line;
+ int last_column;
+ char *text;
+ }
+ yyltype;
+
+#define YYLTYPE yyltype
+#endif
+
+#include <stdio.h>
+
+#ifndef __STDC__
+#define const
+#endif
+
+
+
+#define YYFINAL 515
+#define YYFLAG -32768
+#define YYNTBASE 65
+
+#define YYTRANSLATE(x) ((unsigned)(x) <= 297 ? yytranslate[x] : 172)
+
+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, 61, 2, 2, 2, 48, 39, 2, 55,
+ 57, 46, 44, 62, 45, 54, 47, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 34, 58, 2,
+ 32, 2, 33, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 56, 2, 64, 38, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 63, 37, 59, 60, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 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, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+ 26, 27, 28, 29, 30, 31, 35, 36, 40, 41,
+ 42, 43, 49, 50, 51, 52, 53
+};
+
+static const short yyprhs[] = { 0,
+ 0, 1, 3, 4, 7, 8, 12, 14, 16, 22,
+ 26, 31, 36, 39, 42, 45, 48, 50, 51, 52,
+ 60, 65, 66, 67, 75, 80, 81, 82, 89, 93,
+ 95, 97, 99, 101, 103, 105, 107, 109, 111, 113,
+ 114, 116, 118, 122, 124, 127, 130, 133, 138, 141,
+ 146, 148, 153, 161, 163, 167, 171, 175, 179, 183,
+ 187, 191, 195, 199, 203, 207, 211, 215, 219, 225,
+ 229, 233, 235, 237, 239, 243, 247, 248, 253, 258,
+ 263, 267, 271, 274, 277, 279, 282, 283, 285, 287,
+ 289, 292, 295, 296, 301, 306, 309, 312, 315, 319,
+ 320, 323, 326, 328, 330, 333, 336, 339, 343, 344,
+ 347, 349, 351, 353, 358, 363, 365, 367, 369, 371,
+ 375, 377, 381, 382, 387, 388, 395, 399, 400, 407,
+ 411, 412, 419, 421, 425, 427, 432, 437, 439, 442,
+ 446, 451, 453, 455, 459, 461, 463, 467, 471, 476,
+ 480, 484, 486, 490, 495, 499, 503, 505, 509, 513,
+ 517, 522, 526, 528, 529, 536, 541, 544, 545, 552,
+ 557, 560, 561, 569, 570, 577, 580, 581, 583, 584,
+ 586, 588, 591, 592, 596, 599, 603, 607, 609, 610,
+ 612, 616, 619, 624, 627, 629, 633, 635, 639, 642,
+ 645, 646, 648, 650, 653, 654, 657, 661, 665, 668,
+ 672, 677, 681, 684, 688, 691, 693, 696, 699, 700,
+ 702, 705, 706, 708, 711, 714, 720, 725, 730, 731,
+ 738, 740, 743, 744, 749, 751, 752, 753, 761, 762,
+ 763, 773, 774, 775, 776, 789, 790, 797, 798, 804,
+ 805, 810, 813, 816, 819, 823, 830, 839, 850, 863,
+ 867, 868, 873, 875, 876, 878, 879, 881, 882, 884,
+ 886, 890, 895, 897, 901, 902, 905, 906, 909, 912,
+ 915, 918, 921, 924, 925, 927, 931, 933, 937, 940,
+ 943, 946, 949, 952, 954
+};
+
+static const short yyrhs[] = { -1,
+ 66, 0, 0, 67, 69, 0, 0, 66, 68, 69,
+ 0, 71, 0, 70, 0, 27, 55, 88, 57, 58,
+ 0, 91, 101, 58, 0, 95, 91, 101, 58, 0,
+ 93, 91, 100, 58, 0, 95, 58, 0, 93, 58,
+ 0, 1, 58, 0, 1, 59, 0, 58, 0, 0,
+ 0, 93, 91, 112, 72, 89, 73, 139, 0, 93,
+ 91, 112, 1, 0, 0, 0, 95, 91, 115, 74,
+ 89, 75, 139, 0, 95, 91, 115, 1, 0, 0,
+ 0, 91, 115, 76, 89, 77, 139, 0, 91, 115,
+ 1, 0, 3, 0, 4, 0, 39, 0, 45, 0,
+ 44, 0, 50, 0, 51, 0, 60, 0, 61, 0,
+ 82, 0, 0, 82, 0, 85, 0, 82, 62, 85,
+ 0, 86, 0, 46, 84, 0, 79, 84, 0, 11,
+ 83, 0, 11, 55, 130, 57, 0, 29, 83, 0,
+ 29, 55, 130, 57, 0, 83, 0, 55, 130, 57,
+ 84, 0, 55, 130, 57, 63, 111, 121, 59, 0,
+ 84, 0, 85, 44, 85, 0, 85, 45, 85, 0,
+ 85, 46, 85, 0, 85, 47, 85, 0, 85, 48,
+ 85, 0, 85, 42, 85, 0, 85, 43, 85, 0,
+ 85, 41, 85, 0, 85, 40, 85, 0, 85, 39,
+ 85, 0, 85, 37, 85, 0, 85, 38, 85, 0,
+ 85, 36, 85, 0, 85, 35, 85, 0, 85, 33,
+ 157, 34, 85, 0, 85, 32, 85, 0, 85, 31,
+ 85, 0, 3, 0, 8, 0, 88, 0, 55, 80,
+ 57, 0, 55, 1, 57, 0, 0, 55, 87, 140,
+ 57, 0, 86, 55, 81, 57, 0, 86, 56, 80,
+ 64, 0, 86, 54, 78, 0, 86, 53, 78, 0,
+ 86, 50, 0, 86, 51, 0, 9, 0, 88, 9,
+ 0, 0, 90, 0, 92, 0, 137, 0, 90, 92,
+ 0, 92, 137, 0, 0, 93, 91, 100, 58, 0,
+ 95, 91, 101, 58, 0, 93, 58, 0, 95, 58,
+ 0, 98, 94, 0, 95, 98, 94, 0, 0, 94,
+ 99, 0, 94, 5, 0, 7, 0, 5, 0, 95,
+ 7, 0, 95, 5, 0, 98, 97, 0, 132, 98,
+ 97, 0, 0, 97, 99, 0, 6, 0, 116, 0,
+ 4, 0, 28, 55, 80, 57, 0, 28, 55, 130,
+ 57, 0, 6, 0, 7, 0, 116, 0, 103, 0,
+ 100, 62, 103, 0, 105, 0, 101, 62, 103, 0,
+ 0, 27, 55, 88, 57, 0, 0, 112, 102, 107,
+ 32, 104, 110, 0, 112, 102, 107, 0, 0, 115,
+ 102, 107, 32, 106, 110, 0, 115, 102, 107, 0,
+ 0, 30, 55, 55, 108, 57, 57, 0, 109, 0,
+ 108, 62, 109, 0, 3, 0, 3, 55, 8, 57,
+ 0, 3, 55, 171, 57, 0, 85, 0, 63, 59,
+ 0, 63, 111, 59, 0, 63, 111, 62, 59, 0,
+ 1, 0, 110, 0, 111, 62, 110, 0, 113, 0,
+ 115, 0, 55, 113, 57, 0, 113, 55, 164, 0,
+ 113, 56, 80, 64, 0, 113, 56, 64, 0, 46,
+ 133, 113, 0, 4, 0, 114, 55, 164, 0, 114,
+ 56, 80, 64, 0, 114, 56, 64, 0, 46, 133,
+ 114, 0, 4, 0, 115, 55, 164, 0, 55, 115,
+ 57, 0, 46, 133, 115, 0, 115, 56, 80, 64,
+ 0, 115, 56, 64, 0, 3, 0, 0, 13, 78,
+ 63, 117, 123, 59, 0, 13, 63, 123, 59, 0,
+ 13, 78, 0, 0, 14, 78, 63, 118, 123, 59,
+ 0, 14, 63, 123, 59, 0, 14, 78, 0, 0,
+ 12, 78, 63, 119, 128, 122, 59, 0, 0, 12,
+ 63, 120, 128, 122, 59, 0, 12, 78, 0, 0,
+ 62, 0, 0, 62, 0, 124, 0, 124, 125, 0,
+ 0, 124, 125, 58, 0, 124, 58, 0, 96, 91,
+ 126, 0, 132, 91, 126, 0, 1, 0, 0, 127,
+ 0, 126, 62, 127, 0, 112, 107, 0, 112, 34,
+ 85, 107, 0, 34, 85, 0, 129, 0, 128, 62,
+ 129, 0, 78, 0, 78, 32, 85, 0, 96, 131,
+ 0, 132, 131, 0, 0, 134, 0, 7, 0, 132,
+ 7, 0, 0, 133, 7, 0, 55, 134, 57, 0,
+ 46, 133, 134, 0, 46, 133, 0, 134, 55, 162,
+ 0, 134, 56, 80, 64, 0, 134, 56, 64, 0,
+ 55, 162, 0, 56, 80, 64, 0, 56, 64, 0,
+ 143, 0, 135, 143, 0, 135, 137, 0, 0, 135,
+ 0, 1, 58, 0, 0, 140, 0, 1, 140, 0,
+ 63, 59, 0, 63, 138, 90, 136, 59, 0, 63,
+ 138, 1, 59, 0, 63, 138, 135, 59, 0, 0,
+ 15, 55, 80, 57, 142, 143, 0, 140, 0, 80,
+ 58, 0, 0, 141, 16, 144, 143, 0, 141, 0,
+ 0, 0, 17, 145, 55, 80, 57, 146, 143, 0,
+ 0, 0, 18, 147, 143, 17, 148, 55, 80, 57,
+ 58, 0, 0, 0, 0, 19, 55, 157, 58, 149,
+ 157, 58, 150, 157, 57, 151, 143, 0, 0, 20,
+ 55, 80, 57, 152, 143, 0, 0, 21, 80, 34,
+ 153, 143, 0, 0, 22, 34, 154, 143, 0, 23,
+ 58, 0, 24, 58, 0, 25, 58, 0, 25, 80,
+ 58, 0, 27, 156, 55, 88, 57, 58, 0, 27,
+ 156, 55, 88, 34, 158, 57, 58, 0, 27, 156,
+ 55, 88, 34, 158, 34, 158, 57, 58, 0, 27,
+ 156, 55, 88, 34, 158, 34, 158, 34, 161, 57,
+ 58, 0, 26, 78, 58, 0, 0, 78, 34, 155,
+ 143, 0, 58, 0, 0, 7, 0, 0, 80, 0,
+ 0, 159, 0, 160, 0, 159, 62, 160, 0, 9,
+ 55, 80, 57, 0, 88, 0, 161, 62, 88, 0,
+ 0, 163, 167, 0, 0, 165, 166, 0, 168, 57,
+ 0, 171, 57, 0, 1, 57, 0, 168, 57, 0,
+ 1, 57, 0, 0, 169, 0, 169, 62, 10, 0,
+ 170, 0, 169, 62, 170, 0, 93, 114, 0, 93,
+ 115, 0, 93, 131, 0, 95, 115, 0, 95, 131,
+ 0, 3, 0, 171, 62, 3, 0
+};
+
+#if YYDEBUG != 0
+static const short yyrline[] = { 0,
+ 177, 178, 185, 187, 187, 188, 190, 192, 193, 200,
+ 206, 208, 210, 212, 214, 215, 216, 221, 227, 229,
+ 230, 232, 237, 239, 240, 242, 247, 249, 250, 254,
+ 256, 259, 261, 263, 265, 267, 269, 271, 275, 279,
+ 282, 285, 288, 292, 294, 296, 298, 311, 313, 346,
+ 350, 352, 355, 369, 371, 373, 375, 377, 379, 381,
+ 383, 385, 387, 389, 391, 393, 395, 397, 399, 401,
+ 403, 407, 456, 457, 459, 461, 463, 471, 483, 485,
+ 487, 489, 491, 493, 498, 500, 504, 506, 509, 511,
+ 512, 513, 520, 527, 532, 536, 538, 546, 549, 553,
+ 555, 557, 565, 568, 570, 572, 581, 584, 588, 590,
+ 598, 599, 600, 601, 605, 613, 614, 615, 618, 620,
+ 623, 625, 628, 631, 639, 644, 645, 650, 655, 656,
+ 662, 665, 670, 671, 675, 679, 687, 693, 695, 699,
+ 701, 703, 709, 712, 719, 721, 726, 729, 734, 736,
+ 738, 740, 748, 754, 756, 758, 760, 766, 772, 774,
+ 776, 778, 780, 783, 788, 792, 795, 797, 799, 801,
+ 804, 806, 809, 812, 815, 818, 822, 824, 827, 829,
+ 833, 836, 841, 843, 845, 859, 865, 870, 874, 879,
+ 880, 884, 887, 889, 898, 900, 905, 908, 912, 915,
+ 919, 922, 925, 928, 932, 935, 939, 943, 945, 947,
+ 949, 951, 953, 955, 957, 965, 967, 968, 971, 973,
+ 976, 979, 988, 991, 994, 996, 1000, 1004, 1010, 1015,
+ 1017, 1019, 1029, 1032, 1033, 1035, 1039, 1043, 1044, 1048,
+ 1050, 1055, 1061, 1065, 1071, 1077, 1084, 1086, 1118, 1118,
+ 1129, 1129, 1133, 1137, 1140, 1143, 1148, 1155, 1162, 1169,
+ 1175, 1181, 1181, 1186, 1191, 1197, 1200, 1205, 1207, 1210,
+ 1212, 1216, 1221, 1224, 1230, 1234, 1241, 1245, 1250, 1252,
+ 1254, 1258, 1260, 1266, 1268, 1270, 1274, 1277, 1283, 1286,
+ 1288, 1290, 1292, 1297, 1300
+};
+
+static const char * const yytname[] = { "$",
+"error","$illegal.","IDENTIFIER","TYPENAME","SCSPEC","TYPESPEC","TYPE_QUAL","CONSTANT","STRING","ELLIPSIS",
+"SIZEOF","ENUM","STRUCT","UNION","IF","ELSE","WHILE","DO","FOR","SWITCH",
+"CASE","DEFAULT","BREAK","CONTINUE","RETURN","GOTO","ASM","TYPEOF","ALIGNOF","ATTRIBUTE",
+"ASSIGN","'='","'?'","':'","OROR","ANDAND","'|'","'^'","'&'","EQCOMPARE",
+"ARITHCOMPARE","LSHIFT","RSHIFT","'+'","'-'","'*'","'/'","'%'","UNARY","PLUSPLUS",
+"MINUSMINUS","HYPERUNARY","POINTSAT","'.'","'('","'['","')'","';'","'}'","'~'",
+"'!'","','","'{'","']'","program","extdefs","@1","@2","extdef","datadef",
+"fndef","@3","@4","@5","@6","@7","@8","identifier","unop","expr",
+"exprlist","nonnull_exprlist","unary_expr","cast_expr","expr_no_commas","primary","@9","string","xdecls","decls",
+"setspecs","decl","typed_declspecs","reserved_declspecs","declmods","typed_typespecs","reserved_typespecquals","typespec","typespecqual_reserved","initdecls",
+"notype_initdecls","maybeasm","initdcl","@10","notype_initdcl","@11","maybe_attribute","attribute_list","attrib","init",
+"initlist","declarator","after_type_declarator","parm_declarator","notype_declarator","structsp","@12","@13","@14","@15",
+"maybecomma","maybecomma_warn","component_decl_list","component_decl_list2","component_decl","components","component_declarator","enumlist","enumerator","typename",
+"absdcl","nonempty_type_quals","type_quals","absdcl1","stmts","xstmts","errstmt","pushlevel","compstmt_or_error","compstmt",
+"simple_if","@16","stmt","@17","@18","@19","@20","@21","@22","@23",
+"@24","@25","@26","@27","@28","maybe_type_qual","xexpr","asm_operands","nonnull_asm_operands","asm_operand",
+"asm_clobbers","parmlist","@29","parmlist_or_identifiers","@30","parmlist_or_identifiers_1","parmlist_1","parmlist_2","parms","parm",
+"identifiers",""
+};
+#endif
+
+static const short yyr1[] = { 0,
+ 65, 65, 67, 66, 68, 66, 69, 69, 69, 70,
+ 70, 70, 70, 70, 70, 70, 70, 72, 73, 71,
+ 71, 74, 75, 71, 71, 76, 77, 71, 71, 78,
+ 78, 79, 79, 79, 79, 79, 79, 79, 80, 81,
+ 81, 82, 82, 83, 83, 83, 83, 83, 83, 83,
+ 84, 84, 84, 85, 85, 85, 85, 85, 85, 85,
+ 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
+ 85, 86, 86, 86, 86, 86, 87, 86, 86, 86,
+ 86, 86, 86, 86, 88, 88, 89, 89, 90, 90,
+ 90, 90, 91, 92, 92, 92, 92, 93, 93, 94,
+ 94, 94, 95, 95, 95, 95, 96, 96, 97, 97,
+ 98, 98, 98, 98, 98, 99, 99, 99, 100, 100,
+ 101, 101, 102, 102, 104, 103, 103, 106, 105, 105,
+ 107, 107, 108, 108, 109, 109, 109, 110, 110, 110,
+ 110, 110, 111, 111, 112, 112, 113, 113, 113, 113,
+ 113, 113, 114, 114, 114, 114, 114, 115, 115, 115,
+ 115, 115, 115, 117, 116, 116, 116, 118, 116, 116,
+ 116, 119, 116, 120, 116, 116, 121, 121, 122, 122,
+ 123, 123, 124, 124, 124, 125, 125, 125, 126, 126,
+ 126, 127, 127, 127, 128, 128, 129, 129, 130, 130,
+ 131, 131, 132, 132, 133, 133, 134, 134, 134, 134,
+ 134, 134, 134, 134, 134, 135, 135, 135, 136, 136,
+ 137, 138, 139, 139, 140, 140, 140, 140, 142, 141,
+ 143, 143, 144, 143, 143, 145, 146, 143, 147, 148,
+ 143, 149, 150, 151, 143, 152, 143, 153, 143, 154,
+ 143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
+ 155, 143, 143, 156, 156, 157, 157, 158, 158, 159,
+ 159, 160, 161, 161, 163, 162, 165, 164, 166, 166,
+ 166, 167, 167, 168, 168, 168, 169, 169, 170, 170,
+ 170, 170, 170, 171, 171
+};
+
+static const short yyr2[] = { 0,
+ 0, 1, 0, 2, 0, 3, 1, 1, 5, 3,
+ 4, 4, 2, 2, 2, 2, 1, 0, 0, 7,
+ 4, 0, 0, 7, 4, 0, 0, 6, 3, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 3, 1, 2, 2, 2, 4, 2, 4,
+ 1, 4, 7, 1, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 5, 3,
+ 3, 1, 1, 1, 3, 3, 0, 4, 4, 4,
+ 3, 3, 2, 2, 1, 2, 0, 1, 1, 1,
+ 2, 2, 0, 4, 4, 2, 2, 2, 3, 0,
+ 2, 2, 1, 1, 2, 2, 2, 3, 0, 2,
+ 1, 1, 1, 4, 4, 1, 1, 1, 1, 3,
+ 1, 3, 0, 4, 0, 6, 3, 0, 6, 3,
+ 0, 6, 1, 3, 1, 4, 4, 1, 2, 3,
+ 4, 1, 1, 3, 1, 1, 3, 3, 4, 3,
+ 3, 1, 3, 4, 3, 3, 1, 3, 3, 3,
+ 4, 3, 1, 0, 6, 4, 2, 0, 6, 4,
+ 2, 0, 7, 0, 6, 2, 0, 1, 0, 1,
+ 1, 2, 0, 3, 2, 3, 3, 1, 0, 1,
+ 3, 2, 4, 2, 1, 3, 1, 3, 2, 2,
+ 0, 1, 1, 2, 0, 2, 3, 3, 2, 3,
+ 4, 3, 2, 3, 2, 1, 2, 2, 0, 1,
+ 2, 0, 1, 2, 2, 5, 4, 4, 0, 6,
+ 1, 2, 0, 4, 1, 0, 0, 7, 0, 0,
+ 9, 0, 0, 0, 12, 0, 6, 0, 5, 0,
+ 4, 2, 2, 2, 3, 6, 8, 10, 12, 3,
+ 0, 4, 1, 0, 1, 0, 1, 0, 1, 1,
+ 3, 4, 1, 3, 0, 2, 0, 2, 2, 2,
+ 2, 2, 2, 0, 1, 3, 1, 3, 2, 2,
+ 2, 2, 2, 1, 3
+};
+
+static const short yydefact[] = { 3,
+ 5, 0, 0, 0, 113, 104, 111, 103, 0, 0,
+ 0, 0, 0, 17, 4, 8, 7, 0, 93, 93,
+ 100, 112, 6, 15, 16, 30, 31, 174, 176, 183,
+ 167, 183, 171, 0, 0, 163, 205, 0, 0, 121,
+ 0, 14, 0, 106, 105, 13, 0, 100, 98, 0,
+ 172, 0, 0, 164, 0, 168, 85, 0, 72, 203,
+ 73, 0, 0, 32, 34, 33, 0, 35, 36, 0,
+ 37, 38, 0, 0, 39, 51, 54, 42, 44, 74,
+ 201, 109, 0, 201, 0, 0, 10, 0, 29, 0,
+ 277, 0, 0, 131, 152, 205, 0, 0, 119, 0,
+ 145, 146, 0, 0, 99, 102, 116, 117, 101, 118,
+ 197, 179, 195, 0, 166, 188, 185, 93, 182, 93,
+ 183, 170, 183, 86, 0, 0, 47, 0, 49, 45,
+ 0, 0, 0, 0, 46, 114, 0, 0, 0, 266,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 83, 84, 0, 0, 40, 0,
+ 205, 275, 0, 199, 202, 107, 115, 204, 109, 200,
+ 206, 160, 159, 122, 123, 0, 158, 0, 162, 0,
+ 0, 27, 88, 0, 93, 93, 90, 0, 130, 0,
+ 0, 12, 0, 21, 0, 131, 277, 0, 11, 25,
+ 0, 0, 180, 0, 179, 189, 184, 189, 0, 0,
+ 9, 0, 0, 76, 75, 222, 0, 0, 43, 71,
+ 70, 267, 0, 68, 67, 65, 66, 64, 63, 62,
+ 60, 61, 55, 56, 57, 58, 59, 82, 81, 0,
+ 41, 0, 209, 0, 213, 0, 215, 0, 275, 0,
+ 110, 108, 0, 0, 294, 201, 201, 278, 0, 285,
+ 287, 0, 161, 221, 0, 91, 92, 96, 0, 97,
+ 0, 0, 128, 151, 147, 120, 19, 127, 148, 150,
+ 0, 23, 198, 196, 175, 0, 0, 131, 186, 190,
+ 187, 165, 169, 48, 50, 225, 0, 78, 0, 52,
+ 0, 79, 80, 208, 207, 0, 276, 0, 214, 210,
+ 212, 0, 124, 281, 157, 205, 275, 289, 290, 291,
+ 205, 292, 293, 279, 0, 280, 0, 0, 28, 223,
+ 0, 0, 123, 0, 0, 0, 125, 149, 0, 173,
+ 194, 0, 192, 0, 0, 72, 113, 0, 236, 239,
+ 0, 0, 0, 0, 0, 0, 0, 0, 264, 263,
+ 0, 0, 219, 0, 231, 235, 216, 142, 0, 138,
+ 143, 177, 69, 283, 282, 211, 209, 277, 0, 209,
+ 286, 288, 295, 224, 94, 95, 135, 0, 133, 129,
+ 20, 0, 24, 131, 191, 227, 0, 0, 0, 266,
+ 0, 0, 250, 252, 253, 254, 0, 0, 265, 0,
+ 261, 232, 0, 0, 228, 218, 217, 233, 139, 0,
+ 0, 0, 156, 153, 155, 0, 0, 0, 0, 126,
+ 193, 0, 0, 0, 0, 0, 248, 0, 255, 260,
+ 0, 0, 226, 0, 140, 0, 144, 53, 154, 0,
+ 0, 132, 134, 229, 0, 240, 242, 246, 0, 251,
+ 0, 262, 234, 141, 136, 137, 0, 237, 0, 266,
+ 0, 249, 268, 0, 230, 0, 0, 0, 247, 0,
+ 0, 269, 270, 256, 238, 0, 243, 0, 268, 0,
+ 0, 0, 266, 0, 0, 257, 271, 241, 0, 272,
+ 0, 0, 244, 273, 0, 258, 0, 0, 0, 245,
+ 259, 274, 0, 0, 0
+};
+
+static const short yydefgoto[] = { 513,
+ 1, 2, 3, 15, 16, 17, 195, 336, 201, 339,
+ 93, 265, 361, 73, 362, 240, 75, 76, 77, 78,
+ 79, 133, 80, 182, 183, 18, 184, 185, 49, 186,
+ 81, 166, 21, 109, 98, 39, 94, 99, 392, 40,
+ 335, 189, 388, 389, 371, 372, 175, 101, 318, 102,
+ 22, 121, 123, 114, 50, 422, 204, 52, 53, 119,
+ 289, 290, 112, 113, 83, 164, 84, 85, 165, 364,
+ 414, 187, 297, 329, 365, 366, 467, 367, 444, 398,
+ 476, 399, 469, 470, 493, 507, 471, 459, 438, 442,
+ 410, 223, 481, 482, 483, 505, 245, 246, 177, 178,
+ 258, 307, 259, 260, 261, 262
+};
+
+static const short yypact[] = { 61,
+ 71, 1439, 1439, 210,-32768,-32768,-32768,-32768, 35, 37,
+ 39, 79, 109,-32768,-32768,-32768,-32768, 86, 36, 131,
+-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 53,-32768,
+ 63,-32768, 84, 163, 1292,-32768,-32768, 86, 19,-32768,
+ 731,-32768, 267,-32768,-32768,-32768, 86,-32768, 467, 338,
+-32768, 116, 389,-32768, 122,-32768,-32768, 76,-32768,-32768,
+-32768, 1359, 1372,-32768,-32768,-32768, 1426,-32768,-32768, 369,
+-32768,-32768, 1426, 135, 158,-32768,-32768, 1495, 844, 227,
+ 124,-32768, 187, 1450, 273, 190,-32768, 267,-32768, 220,
+-32768, 947, 51, 223,-32768,-32768, 267, 26,-32768, 932,
+ 306, 310, 29, 768, 467,-32768,-32768,-32768,-32768,-32768,
+ 245, 217,-32768, 338,-32768,-32768,-32768,-32768, 229, 515,
+-32768,-32768,-32768,-32768, 240, 369,-32768, 369,-32768,-32768,
+ 247, 264, 239, 266,-32768,-32768, 1426, 1426, 1426, 1426,
+ 1426, 1426, 1426, 1426, 1426, 1426, 1426, 1426, 1426, 1426,
+ 1426, 1426, 1426, 1426,-32768,-32768, 338, 338, 1426, 1426,
+-32768, 124, 970,-32768, 349, 154,-32768,-32768,-32768,-32768,
+-32768, 310,-32768,-32768, 308, 163,-32768, 302,-32768, 261,
+ 287,-32768, 457, 487, 292, 260,-32768, 314, 325, 46,
+ 298,-32768, 267,-32768, 51, 223,-32768, 1015,-32768,-32768,
+ 51, 1426, 338, 312, 217, 182,-32768, 182, 315, 328,
+-32768, 334, 337,-32768,-32768, 347, 361, 1231, 1495, 1495,
+ 1495,-32768, 382, 1524, 832, 1535, 707, 538, 598, 923,
+ 237, 237, 246, 246,-32768,-32768,-32768,-32768,-32768, 366,
+ 158, 363, 102, 329,-32768, 699,-32768, 364,-32768, 1038,
+-32768, 154, 112, 368,-32768, 100, 806,-32768, 374, 376,
+-32768, 10,-32768,-32768, 33,-32768,-32768,-32768, 267,-32768,
+ 86, 385,-32768, 306,-32768,-32768,-32768, 413,-32768,-32768,
+ 386,-32768, 1495,-32768,-32768, 387, 1426, 189, 390,-32768,
+ 390,-32768,-32768,-32768,-32768,-32768, 548,-32768, 880,-32768,
+ 1426,-32768,-32768, 349,-32768, 394,-32768, 396,-32768,-32768,
+-32768, 392,-32768,-32768,-32768,-32768, 107, 354, 310,-32768,
+-32768, 310,-32768,-32768, 429,-32768, 451, 239,-32768,-32768,
+ 193, 198, 27, 455, 880, 33,-32768,-32768, 33,-32768,
+ 1495, 1426,-32768, 182, 353, 425, 431, 411,-32768,-32768,
+ 421, 422, 1426, 434, 424, 426, 1305, 338, 476,-32768,
+ 452, 439, 1145, 609,-32768, 471,-32768,-32768, 288, 1495,
+-32768, 427, 1511,-32768,-32768,-32768, 333,-32768, 1083, 255,
+-32768,-32768,-32768,-32768,-32768,-32768, 462, 92,-32768,-32768,
+-32768, 880,-32768, 1477,-32768,-32768, 1426, 463, 1206, 1426,
+ 1426, 486,-32768,-32768,-32768,-32768, 465, 466,-32768, 470,
+-32768,-32768, 670, 475,-32768,-32768,-32768,-32768,-32768, -11,
+ 796, 477, 354,-32768,-32768, 480, 219, 473, 455,-32768,
+-32768, 478, 1426, 522, 482, 484,-32768, 1206,-32768,-32768,
+ 163, 1206,-32768, 1206,-32768, 857,-32768,-32768,-32768, 501,
+ 176,-32768,-32768,-32768, 507,-32768,-32768,-32768, 1206,-32768,
+ 65,-32768,-32768,-32768,-32768,-32768, 1206,-32768, 533, 1426,
+ 1206,-32768, 580, 532,-32768, 1206, 1426, 537,-32768, 536,
+ 12, 534,-32768,-32768,-32768, 540,-32768, 1426, 580, 542,
+ 580, 543, 1426, 545, 13,-32768,-32768,-32768, 547,-32768,
+ 163, 549,-32768, 227, 186,-32768, 1206, 556, 163,-32768,
+-32768, 227, 605, 615,-32768
+};
+
+static const short yypgoto[] = {-32768,
+-32768,-32768,-32768, 613,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768,-32768, -6,-32768, -33,-32768, 460, 359, -41, 57,
+-32768,-32768, -34, -135, 324, 5, -148, 4, 574, 6,
+ 570, 456, -8, -147, 378, -30, -64, -65,-32768,-32768,
+-32768, -182,-32768, 208, -306, 280, -32, -66, 274, -17,
+ -27,-32768,-32768,-32768,-32768,-32768, 445, -4,-32768,-32768,
+ 444, 313, 544, 453, 3, -69, 608, -86, -146, 299,
+-32768, -171,-32768, -110, -115,-32768,-32768, -181,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768, -380, 174,-32768, 175,-32768, 416,-32768, -164,-32768,
+-32768,-32768, 430,-32768, 350, 250
+};
+
+
+#define YYLAST 1583
+
+
+static const short yytable[] = { 58,
+ 41, 74, 29, 31, 33, 19, 19, 20, 20, 190,
+ 100, 48, 267, 278, 170, 244, 103, 217, 251, 435,
+ 86, 110, 174, 43, 47, 130, 82, 55, 390, 104,
+ 191, 135, 279, 328, 266, 196, 132, 26, 27, 26,
+ 27, 26, 27, 111, 82, 489, 501, 445, 36, 95,
+ 446, 181, 171, 90, 5, 6, 7, 8, 180, 277,
+ -1, 82, 9, 10, 11, 282, 326, 172, 490, 502,
+ -2, 327, 134, 124, 243, 169, 87, 110, 13, 86,
+ 88, 91, 92, 192, 124, 430, 199, 193, 36, 478,
+ 88, 96, 132, 42, 132, 216, 304, 28, 473, 30,
+ 97, 32, 36, 315, 251, 343, 222, 111, 171, 36,
+ 196, 169, 499, -87, 447, 51, 209, 82, 210, 82,
+ 124, 474, 206, 274, 208, 54, 242, 276, 212, 248,
+ 213, 37, 125, 34, 5, 44, 7, 45, 110, 447,
+ 38, 253, 9, 10, 11, 316, 56, 161, 428, 330,
+ 238, 239, 321, 429, 317, 163, 162, 163, 13, 107,
+ 108, 317, 163, 35, 281, 9, 10, 11, 313, 161,
+ 244, 57, 172, 288, 115, 288, 300, 48, 162, 163,
+ 122, 256, 417, 257, 36, 95, 320, 323, 46, 269,
+ 271, 136, 416, 219, 220, 221, 111, 224, 225, 226,
+ 227, 228, 229, 230, 231, 232, 233, 234, 235, 236,
+ 237, 431, 384, 424, 266, 287, 312, 434, 188, 137,
+ 330, 255, 342, 330, 110, 391, 450, 96, 393, 377,
+ 304, 417, 466, 304, 380, 124, 97, 327, 319, 322,
+ 332, 416, 508, 167, 91, 92, 173, 509, 48, 256,
+ 385, 257, 188, 333, 193, 386, 460, 36, 283, 88,
+ 462, 171, 463, 5, 44, 7, 45, 24, 25, 36,
+ 95, 9, 10, 11, 176, 36, 202, 472, 203, 171,
+ 150, 151, 152, 153, 154, 475, 207, 13, 368, 479,
+ 59, 152, 153, 154, 485, 61, 57, 211, 62, 86,
+ 321, 216, 254, 214, 255, 5, 6, 7, 8, 317,
+ 163, 288, 96, 9, 10, 11, 63, 270, 37, 402,
+ 215, 97, 218, 407, 263, 510, 64, 38, 256, 13,
+ 257, 65, 66, 67, 90, 36, 315, 68, 69, 171,
+ 26, 27, 70, 341, 264, 426, 419, 71, 72, 268,
+ 369, 408, 197, 198, 275, 370, 273, 373, -284, 172,
+ 197, 198, 172, 432, 91, 92, 222, 436, 272, 131,
+ 285, 59, 5, 292, 7, 60, 61, 57, 316, 62,
+ 9, 10, 11, 249, 250, 305, 293, 317, 163, 116,
+ 294, 370, 5, 295, 7, 60, 13, 63, 394, 455,
+ 9, 10, 11, 249, 250, 296, 461, 64, 378, 379,
+ 264, 396, 65, 66, 67, 301, 13, 298, 68, 69,
+ 127, 129, 302, 70, 314, 370, 303, 309, 71, 72,
+ 324, -77, 5, 6, 7, 8, 222, 325, 381, 334,
+ 9, 10, 11, 486, 337, 340, 117, -181, 370, 338,
+ 374, 344, 375, 383, 494, 376, 13, 387, -30, 222,
+ 5, 6, 7, 8, -31, 397, 504, 403, 9, 10,
+ 11, 106, 107, 108, 512, 400, 401, 370, 9, 10,
+ 11, 404, 409, 405, 13, 411, 418, 181, 421, -89,
+ -89, -89, -89, -89, -89, -89, 412, -89, -89, -89,
+ -89, -89, 370, -89, -89, -89, -89, -89, -89, -89,
+ -89, -89, -89, -89, -89, -89, 427, 433, 5, 437,
+ 7, 168, 439, 440, 441, -89, 9, 10, 11, 452,
+ -89, -89, -89, 443, 454, 448, -89, -89, 456, 457,
+ 458, -89, 13, 449, -89, -89, -89, -89, 345, -89,
+ 346, 347, 6, 7, 8, 61, 57, 465, 62, 9,
+ 10, 11, 348, 468, 349, 350, 351, 352, 353, 354,
+ 355, 356, 357, 358, 359, 13, 63, 146, 147, 148,
+ 149, 150, 151, 152, 153, 154, 64, 477, 480, 484,
+ 488, 65, 66, 67, 487, 491, 492, 68, 69, 496,
+ 498, 500, 70, 503, 514, 360, 506, 71, 72, 181,
+ 216, 346, 27, 511, 515, 23, 61, 57, 241, 62,
+ 363, 105, 118, 348, 252, 349, 350, 351, 352, 353,
+ 354, 355, 356, 357, 358, 359, 453, 63, 147, 148,
+ 149, 150, 151, 152, 153, 154, 331, 64, 420, 286,
+ 423, 291, 65, 66, 67, 284, 395, 205, 68, 69,
+ 120, 413, 495, 70, 310, 497, 360, 415, 71, 72,
+ 181, 216, 346, 27, 382, 308, 451, 61, 57, 0,
+ 62, 0, 0, 0, 348, 0, 349, 350, 351, 352,
+ 353, 354, 355, 356, 357, 358, 359, 0, 63, 306,
+ 0, 0, 5, 6, 7, 8, 0, 0, 64, 0,
+ 9, 10, 11, 65, 66, 67, 0, 0, 0, 68,
+ 69, 0, 0, 0, 70, 0, 13, 360, -220, 71,
+ 72, 89, 216, 0, -26, -26, -26, -26, 0, 0,
+ 0, 0, -26, -26, -26, 145, 146, 147, 148, 149,
+ 150, 151, 152, 153, 154, -284, 0, 90, -26, 0,
+ -123, 0, -123, 0, 0, 0, 0, 0, 200, 0,
+ 0, -22, -22, -22, -22, 0, 0, 0, 0, -22,
+ -22, -22, 0, 0, 0, 91, 92, 0, -123, 0,
+ 0, 0, -123, -26, 90, -22, 368, -123, 59, -123,
+ 0, 0, 0, 61, 57, 0, 62, 0, 36, 5,
+ 44, 7, 45, 0, 0, 0, 0, 9, 10, 11,
+ 0, 0, 91, 92, 63, -123, 0, 0, 0, -123,
+ -22, 0, 0, 13, 64, 0, 0, 0, 0, 65,
+ 66, 67, 0, 0, 0, 68, 69, 0, 0, 0,
+ 70, 321, 0, 0, -178, 71, 72, 368, 369, 59,
+ 317, 163, 0, 0, 61, 57, 0, 62, 143, 144,
+ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
+ 368, 0, 59, 0, 0, 63, 0, 61, 57, 0,
+ 62, 0, 0, 155, 156, 64, 157, 158, 159, 160,
+ 65, 66, 67, 0, 0, 0, 68, 69, 63, 0,
+ 0, 70, 0, 0, 0, 464, 71, 72, 64, 369,
+ 0, 0, 0, 65, 66, 67, 0, 0, 0, 68,
+ 69, 0, 194, 0, 70, -18, -18, -18, -18, 71,
+ 72, 0, 369, -18, -18, -18, 0, 0, 0, 59,
+ 0, 0, 0, 0, 61, 57, 0, 62, 90, -18,
+ 0, -123, 0, -123, 148, 149, 150, 151, 152, 153,
+ 154, 0, 59, 0, 0, 63, 0, 61, 57, 0,
+ 62, 0, 0, 0, 0, 64, 0, 0, 0, -123,
+ 65, 66, 67, -123, -18, 0, 68, 69, 63, 0,
+ 0, 70, 0, 0, 0, 0, 71, 72, 64, 0,
+ 179, 0, 0, 65, 66, 67, 0, 59, 0, 68,
+ 69, 0, 61, 57, 70, 62, 0, 0, 0, 71,
+ 72, 0, 0, 247, 0, 0, 0, 0, 0, 0,
+ 59, 0, 0, 63, 0, 61, 57, 0, 62, 0,
+ 0, 0, 0, 64, 0, 0, 0, 0, 65, 66,
+ 67, 0, 0, 0, 68, 69, 63, 0, 0, 70,
+ 0, 0, 0, 0, 71, 72, 64, 0, 280, 0,
+ 0, 65, 66, 67, 0, 59, 0, 68, 69, 0,
+ 61, 57, 70, 62, 0, 0, 0, 71, 72, 0,
+ 0, 311, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 63, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 64, 0, 0, 0, 0, 65, 66, 67, 0,
+ 0, 0, 68, 69, 0, 0, 0, 70, 0, 0,
+ 0, 0, 71, 72, 0, 0, 425, 346, 347, 6,
+ 7, 8, 61, 57, 0, 62, 9, 10, 11, 348,
+ 0, 349, 350, 351, 352, 353, 354, 355, 356, 357,
+ 358, 359, 13, 63, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 64, 0, 0, 0, 0, 65, 66,
+ 67, 0, 0, 0, 68, 69, 0, 0, 0, 70,
+ 0, 0, 360, 0, 71, 72, 0, 216, 346, 27,
+ 0, 0, 0, 61, 57, 0, 62, 0, 0, 0,
+ 348, 0, 349, 350, 351, 352, 353, 354, 355, 356,
+ 357, 358, 359, 59, 63, 0, 0, 0, 61, 57,
+ 0, 62, 0, 0, 64, 0, 0, 0, 0, 65,
+ 66, 67, 0, 0, 0, 68, 69, 0, 0, 63,
+ 70, 0, 0, 360, 0, 71, 72, 0, 216, 64,
+ 0, 0, 0, 0, 65, 66, 67, 0, 0, 0,
+ 68, 69, 0, 0, 0, 70, 0, 0, 0, 0,
+ 71, 72, 0, 299, 59, 5, 0, 7, 60, 61,
+ 57, 0, 62, 9, 10, 11, 0, 59, 0, 0,
+ 0, 0, 61, 57, 0, 62, 0, 0, 0, 13,
+ 63, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 64, 0, 0, 63, 0, 65, 66, 67, 0, 0,
+ 0, 68, 69, 64, 0, 0, 70, 0, 65, 66,
+ 67, 71, 72, 0, 68, 69, 0, 0, 0, 70,
+ 0, 59, 406, 0, 71, 72, 61, 57, 0, 62,
+ 0, 0, 0, 0, 59, 0, 0, 0, 0, 61,
+ 57, 0, 62, 0, 0, 0, 0, 63, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 64, 0, 0,
+ 63, 0, 65, 66, 67, 0, 0, 0, 68, 69,
+ 64, 0, 0, 126, 0, 65, 66, 67, 71, 72,
+ 0, 68, 69, 0, 0, 0, 128, 0, 59, 0,
+ 0, 71, 72, 61, 57, 0, 62, 0, 0, 4,
+ 0, -93, 5, 6, 7, 8, 0, 0, 0, 0,
+ 9, 10, 11, 5, 63, 7, 168, 0, 0, 0,
+ 0, 9, 10, 11, 64, 12, 13, 0, 0, 65,
+ 66, 67, 0, 0, 0, 68, 69, 13, 0, 0,
+ 70, 0, 0, 0, -93, 71, 72, 0, 0, 0,
+ 0, 0, 0, -93, 0, 161, 14, 0, 0, 0,
+ 0, 0, 0, 0, 162, 163, 188, 138, 139, 140,
+ 0, 141, 142, 143, 144, 145, 146, 147, 148, 149,
+ 150, 151, 152, 153, 154, 138, 139, 140, 0, 141,
+ 142, 143, 144, 145, 146, 147, 148, 149, 150, 151,
+ 152, 153, 154, 140, 0, 141, 142, 143, 144, 145,
+ 146, 147, 148, 149, 150, 151, 152, 153, 154, 142,
+ 143, 144, 145, 146, 147, 148, 149, 150, 151, 152,
+ 153, 154, 144, 145, 146, 147, 148, 149, 150, 151,
+ 152, 153, 154
+};
+
+static const short yycheck[] = { 34,
+ 18, 35, 9, 10, 11, 2, 3, 2, 3, 96,
+ 43, 20, 184, 196, 84, 162, 47, 133, 166, 400,
+ 38, 49, 88, 19, 20, 67, 35, 32, 335, 47,
+ 97, 73, 197, 1, 183, 100, 70, 3, 4, 3,
+ 4, 3, 4, 50, 53, 34, 34, 59, 3, 4,
+ 62, 1, 7, 27, 4, 5, 6, 7, 92, 195,
+ 0, 70, 12, 13, 14, 201, 57, 85, 57, 57,
+ 0, 62, 70, 9, 161, 84, 58, 105, 28, 97,
+ 62, 55, 56, 58, 9, 392, 58, 62, 3, 470,
+ 62, 46, 126, 58, 128, 63, 243, 63, 34, 63,
+ 55, 63, 3, 4, 252, 288, 140, 114, 7, 3,
+ 175, 120, 493, 63, 421, 63, 121, 126, 123, 128,
+ 9, 57, 118, 190, 120, 63, 160, 193, 126, 163,
+ 128, 46, 57, 55, 4, 5, 6, 7, 166, 446,
+ 55, 176, 12, 13, 14, 46, 63, 46, 57, 265,
+ 157, 158, 46, 62, 55, 56, 55, 56, 28, 6,
+ 7, 55, 56, 55, 198, 12, 13, 14, 57, 46,
+ 317, 9, 190, 206, 59, 208, 218, 186, 55, 56,
+ 59, 178, 364, 178, 3, 4, 256, 257, 58, 185,
+ 186, 57, 364, 137, 138, 139, 203, 141, 142, 143,
+ 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
+ 154, 394, 328, 378, 363, 34, 250, 399, 30, 62,
+ 336, 3, 34, 339, 252, 336, 8, 46, 339, 316,
+ 377, 413, 57, 380, 321, 9, 55, 62, 256, 257,
+ 271, 413, 57, 57, 55, 56, 57, 62, 257, 246,
+ 58, 246, 30, 271, 62, 58, 438, 3, 202, 62,
+ 442, 7, 444, 4, 5, 6, 7, 58, 59, 3,
+ 4, 12, 13, 14, 55, 3, 32, 459, 62, 7,
+ 44, 45, 46, 47, 48, 467, 58, 28, 1, 471,
+ 3, 46, 47, 48, 476, 8, 9, 58, 11, 317,
+ 46, 63, 1, 57, 3, 4, 5, 6, 7, 55,
+ 56, 344, 46, 12, 13, 14, 29, 58, 46, 353,
+ 57, 55, 57, 357, 64, 507, 39, 55, 325, 28,
+ 325, 44, 45, 46, 27, 3, 4, 50, 51, 7,
+ 3, 4, 55, 287, 58, 379, 59, 60, 61, 58,
+ 63, 358, 55, 56, 57, 299, 32, 301, 57, 377,
+ 55, 56, 380, 397, 55, 56, 400, 401, 55, 1,
+ 59, 3, 4, 59, 6, 7, 8, 9, 46, 11,
+ 12, 13, 14, 55, 56, 57, 59, 55, 56, 1,
+ 57, 335, 4, 57, 6, 7, 28, 29, 342, 433,
+ 12, 13, 14, 55, 56, 59, 441, 39, 55, 56,
+ 58, 59, 44, 45, 46, 34, 28, 57, 50, 51,
+ 62, 63, 57, 55, 57, 369, 64, 64, 60, 61,
+ 57, 63, 4, 5, 6, 7, 470, 62, 10, 55,
+ 12, 13, 14, 477, 32, 59, 58, 59, 392, 64,
+ 57, 62, 57, 3, 488, 64, 28, 3, 34, 493,
+ 4, 5, 6, 7, 34, 55, 501, 34, 12, 13,
+ 14, 5, 6, 7, 509, 55, 55, 421, 12, 13,
+ 14, 58, 7, 58, 28, 34, 16, 1, 62, 3,
+ 4, 5, 6, 7, 8, 9, 58, 11, 12, 13,
+ 14, 15, 446, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, 26, 27, 28, 29, 55, 55, 4, 34,
+ 6, 7, 58, 58, 55, 39, 12, 13, 14, 57,
+ 44, 45, 46, 59, 57, 59, 50, 51, 17, 58,
+ 57, 55, 28, 64, 58, 59, 60, 61, 1, 63,
+ 3, 4, 5, 6, 7, 8, 9, 57, 11, 12,
+ 13, 14, 15, 57, 17, 18, 19, 20, 21, 22,
+ 23, 24, 25, 26, 27, 28, 29, 40, 41, 42,
+ 43, 44, 45, 46, 47, 48, 39, 55, 9, 58,
+ 55, 44, 45, 46, 58, 62, 57, 50, 51, 58,
+ 58, 57, 55, 57, 0, 58, 58, 60, 61, 1,
+ 63, 3, 4, 58, 0, 3, 8, 9, 159, 11,
+ 297, 48, 53, 15, 169, 17, 18, 19, 20, 21,
+ 22, 23, 24, 25, 26, 27, 429, 29, 41, 42,
+ 43, 44, 45, 46, 47, 48, 269, 39, 369, 205,
+ 377, 208, 44, 45, 46, 203, 344, 114, 50, 51,
+ 53, 363, 489, 55, 249, 491, 58, 59, 60, 61,
+ 1, 63, 3, 4, 325, 246, 427, 8, 9, -1,
+ 11, -1, -1, -1, 15, -1, 17, 18, 19, 20,
+ 21, 22, 23, 24, 25, 26, 27, -1, 29, 1,
+ -1, -1, 4, 5, 6, 7, -1, -1, 39, -1,
+ 12, 13, 14, 44, 45, 46, -1, -1, -1, 50,
+ 51, -1, -1, -1, 55, -1, 28, 58, 59, 60,
+ 61, 1, 63, -1, 4, 5, 6, 7, -1, -1,
+ -1, -1, 12, 13, 14, 39, 40, 41, 42, 43,
+ 44, 45, 46, 47, 48, 57, -1, 27, 28, -1,
+ 30, -1, 32, -1, -1, -1, -1, -1, 1, -1,
+ -1, 4, 5, 6, 7, -1, -1, -1, -1, 12,
+ 13, 14, -1, -1, -1, 55, 56, -1, 58, -1,
+ -1, -1, 62, 63, 27, 28, 1, 30, 3, 32,
+ -1, -1, -1, 8, 9, -1, 11, -1, 3, 4,
+ 5, 6, 7, -1, -1, -1, -1, 12, 13, 14,
+ -1, -1, 55, 56, 29, 58, -1, -1, -1, 62,
+ 63, -1, -1, 28, 39, -1, -1, -1, -1, 44,
+ 45, 46, -1, -1, -1, 50, 51, -1, -1, -1,
+ 55, 46, -1, -1, 59, 60, 61, 1, 63, 3,
+ 55, 56, -1, -1, 8, 9, -1, 11, 37, 38,
+ 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+ 1, -1, 3, -1, -1, 29, -1, 8, 9, -1,
+ 11, -1, -1, 50, 51, 39, 53, 54, 55, 56,
+ 44, 45, 46, -1, -1, -1, 50, 51, 29, -1,
+ -1, 55, -1, -1, -1, 59, 60, 61, 39, 63,
+ -1, -1, -1, 44, 45, 46, -1, -1, -1, 50,
+ 51, -1, 1, -1, 55, 4, 5, 6, 7, 60,
+ 61, -1, 63, 12, 13, 14, -1, -1, -1, 3,
+ -1, -1, -1, -1, 8, 9, -1, 11, 27, 28,
+ -1, 30, -1, 32, 42, 43, 44, 45, 46, 47,
+ 48, -1, 3, -1, -1, 29, -1, 8, 9, -1,
+ 11, -1, -1, -1, -1, 39, -1, -1, -1, 58,
+ 44, 45, 46, 62, 63, -1, 50, 51, 29, -1,
+ -1, 55, -1, -1, -1, -1, 60, 61, 39, -1,
+ 64, -1, -1, 44, 45, 46, -1, 3, -1, 50,
+ 51, -1, 8, 9, 55, 11, -1, -1, -1, 60,
+ 61, -1, -1, 64, -1, -1, -1, -1, -1, -1,
+ 3, -1, -1, 29, -1, 8, 9, -1, 11, -1,
+ -1, -1, -1, 39, -1, -1, -1, -1, 44, 45,
+ 46, -1, -1, -1, 50, 51, 29, -1, -1, 55,
+ -1, -1, -1, -1, 60, 61, 39, -1, 64, -1,
+ -1, 44, 45, 46, -1, 3, -1, 50, 51, -1,
+ 8, 9, 55, 11, -1, -1, -1, 60, 61, -1,
+ -1, 64, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 29, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 39, -1, -1, -1, -1, 44, 45, 46, -1,
+ -1, -1, 50, 51, -1, -1, -1, 55, -1, -1,
+ -1, -1, 60, 61, -1, -1, 64, 3, 4, 5,
+ 6, 7, 8, 9, -1, 11, 12, 13, 14, 15,
+ -1, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+ 26, 27, 28, 29, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 39, -1, -1, -1, -1, 44, 45,
+ 46, -1, -1, -1, 50, 51, -1, -1, -1, 55,
+ -1, -1, 58, -1, 60, 61, -1, 63, 3, 4,
+ -1, -1, -1, 8, 9, -1, 11, -1, -1, -1,
+ 15, -1, 17, 18, 19, 20, 21, 22, 23, 24,
+ 25, 26, 27, 3, 29, -1, -1, -1, 8, 9,
+ -1, 11, -1, -1, 39, -1, -1, -1, -1, 44,
+ 45, 46, -1, -1, -1, 50, 51, -1, -1, 29,
+ 55, -1, -1, 58, -1, 60, 61, -1, 63, 39,
+ -1, -1, -1, -1, 44, 45, 46, -1, -1, -1,
+ 50, 51, -1, -1, -1, 55, -1, -1, -1, -1,
+ 60, 61, -1, 63, 3, 4, -1, 6, 7, 8,
+ 9, -1, 11, 12, 13, 14, -1, 3, -1, -1,
+ -1, -1, 8, 9, -1, 11, -1, -1, -1, 28,
+ 29, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 39, -1, -1, 29, -1, 44, 45, 46, -1, -1,
+ -1, 50, 51, 39, -1, -1, 55, -1, 44, 45,
+ 46, 60, 61, -1, 50, 51, -1, -1, -1, 55,
+ -1, 3, 58, -1, 60, 61, 8, 9, -1, 11,
+ -1, -1, -1, -1, 3, -1, -1, -1, -1, 8,
+ 9, -1, 11, -1, -1, -1, -1, 29, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 39, -1, -1,
+ 29, -1, 44, 45, 46, -1, -1, -1, 50, 51,
+ 39, -1, -1, 55, -1, 44, 45, 46, 60, 61,
+ -1, 50, 51, -1, -1, -1, 55, -1, 3, -1,
+ -1, 60, 61, 8, 9, -1, 11, -1, -1, 1,
+ -1, 3, 4, 5, 6, 7, -1, -1, -1, -1,
+ 12, 13, 14, 4, 29, 6, 7, -1, -1, -1,
+ -1, 12, 13, 14, 39, 27, 28, -1, -1, 44,
+ 45, 46, -1, -1, -1, 50, 51, 28, -1, -1,
+ 55, -1, -1, -1, 46, 60, 61, -1, -1, -1,
+ -1, -1, -1, 55, -1, 46, 58, -1, -1, -1,
+ -1, -1, -1, -1, 55, 56, 30, 31, 32, 33,
+ -1, 35, 36, 37, 38, 39, 40, 41, 42, 43,
+ 44, 45, 46, 47, 48, 31, 32, 33, -1, 35,
+ 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
+ 46, 47, 48, 33, -1, 35, 36, 37, 38, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47, 48, 36,
+ 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
+ 47, 48, 38, 39, 40, 41, 42, 43, 44, 45,
+ 46, 47, 48
+};
+/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
+#line 3 "bison.simple"
+
+/* Skeleton output parser for bison,
+ Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
+
+ 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 1, 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+
+#ifndef alloca
+#ifdef __GNUC__
+#define alloca __builtin_alloca
+#else /* Not GNU C. */
+#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
+#include <alloca.h>
+#endif /* Sparc. */
+#endif /* Not GNU C. */
+#endif /* alloca not defined. */
+
+/* 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. */
+
+/* Note: there must be only one dollar sign in this file.
+ It is replaced by the list of actions, each action
+ as one case of the switch. */
+
+#define yyerrok (yyerrstatus = 0)
+#define yyclearin (yychar = YYEMPTY)
+#define YYEMPTY -2
+#define YYEOF 0
+#define YYACCEPT return(0)
+#define YYABORT return(1)
+#define YYERROR goto yyerrlab1
+/* 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); \
+ YYPOPSTACK; \
+ goto yybackup; \
+ } \
+ else \
+ { yyerror ("syntax error: cannot back up"); YYERROR; } \
+while (0)
+
+#define YYTERROR 1
+#define YYERRCODE 256
+
+#ifndef YYPURE
+#define YYLEX yylex()
+#endif
+
+#ifdef YYPURE
+#ifdef YYLSP_NEEDED
+#define YYLEX yylex(&yylval, &yylloc)
+#else
+#define YYLEX yylex(&yylval)
+#endif
+#endif
+
+/* If nonreentrant, generate the variables here */
+
+#ifndef YYPURE
+
+int yychar; /* the lookahead symbol */
+YYSTYPE yylval; /* the semantic value of the */
+ /* lookahead symbol */
+
+#ifdef YYLSP_NEEDED
+YYLTYPE yylloc; /* location data for the lookahead */
+ /* symbol */
+#endif
+
+int yynerrs; /* number of parse errors so far */
+#endif /* not YYPURE */
+
+#if YYDEBUG != 0
+int yydebug; /* nonzero means print parse trace */
+/* Since this is uninitialized, it does not stop multiple parsers
+ from coexisting. */
+#endif
+
+/* YYINITDEPTH indicates the initial size of the parser's stacks */
+
+#ifndef YYINITDEPTH
+#define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH is the maximum size the stacks can grow to
+ (effective only if the built-in stack extension method is used). */
+
+#if YYMAXDEPTH == 0
+#undef YYMAXDEPTH
+#endif
+
+#ifndef YYMAXDEPTH
+#define YYMAXDEPTH 10000
+#endif
+
+#ifndef __cplusplus
+
+/* This is the most reliable way to avoid incompatibilities
+ in available built-in functions on various systems. */
+static void
+__yy_bcopy (from, to, count)
+ char *from;
+ char *to;
+ int count;
+{
+ register char *f = from;
+ register char *t = to;
+ register int i = count;
+
+ while (i-- > 0)
+ *t++ = *f++;
+}
+
+#else /* __cplusplus */
+
+/* This is the most reliable way to avoid incompatibilities
+ in available built-in functions on various systems. */
+static void
+__yy_bcopy (char *from, char *to, int count)
+{
+ register char *f = from;
+ register char *t = to;
+ register int i = count;
+
+ while (i-- > 0)
+ *t++ = *f++;
+}
+
+#endif
+
+#line 156 "bison.simple"
+int
+yyparse()
+{
+ register int yystate;
+ register int yyn;
+ register short *yyssp;
+ register YYSTYPE *yyvsp;
+ int yyerrstatus; /* number of tokens to shift before error messages enabled */
+ int yychar1; /* lookahead token as an internal (translated) token number */
+
+ short yyssa[YYINITDEPTH]; /* the state stack */
+ YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
+
+ short *yyss = yyssa; /* refer to the stacks thru separate pointers */
+ YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
+
+#ifdef YYLSP_NEEDED
+ YYLTYPE *yyls = yylsa;
+ YYLTYPE *yylsp;
+ YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
+
+#define YYPOPSTACK (yyvsp--, yysp--, yylsp--)
+#else
+#define YYPOPSTACK (yyvsp--, yysp--)
+#endif
+
+ int yystacksize = YYINITDEPTH;
+
+#ifdef YYPURE
+ int yychar;
+ YYSTYPE yylval;
+ int yynerrs;
+#ifdef YYLSP_NEEDED
+ YYLTYPE yylloc;
+#endif
+#endif
+
+ YYSTYPE yyval; /* the variable used to return */
+ /* semantic values from the action */
+ /* routines */
+
+ int yylen;
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Starting parse\n");
+#endif
+
+ yystate = 0;
+ yyerrstatus = 0;
+ yynerrs = 0;
+ yychar = YYEMPTY; /* Cause a token to be read. */
+
+ /* Initialize stack pointers.
+ Waste one element of value and location stack
+ so that they stay on the same level as the state stack. */
+
+ yyssp = yyss - 1;
+ yyvsp = yyvs;
+#ifdef YYLSP_NEEDED
+ yylsp = yyls;
+#endif
+
+/* Push a new state, which is found in yystate . */
+/* In all cases, when you get here, the value and location stacks
+ have just been pushed. so pushing a state here evens the stacks. */
+yynewstate:
+
+ *++yyssp = yystate;
+
+ if (yyssp >= yyss + yystacksize - 1)
+ {
+ /* Give user a chance to reallocate the stack */
+ /* Use copies of these so that the &'s don't force the real ones into memory. */
+ YYSTYPE *yyvs1 = yyvs;
+ short *yyss1 = yyss;
+#ifdef YYLSP_NEEDED
+ YYLTYPE *yyls1 = yyls;
+#endif
+
+ /* Get the current used size of the three stacks, in elements. */
+ int size = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+ /* Each stack pointer address is followed by the size of
+ the data in use in that stack, in bytes. */
+ yyoverflow("parser stack overflow",
+ &yyss1, size * sizeof (*yyssp),
+ &yyvs1, size * sizeof (*yyvsp),
+#ifdef YYLSP_NEEDED
+ &yyls1, size * sizeof (*yylsp),
+#endif
+ &yystacksize);
+
+ yyss = yyss1; yyvs = yyvs1;
+#ifdef YYLSP_NEEDED
+ yyls = yyls1;
+#endif
+#else /* no yyoverflow */
+ /* Extend the stack our own way. */
+ if (yystacksize >= YYMAXDEPTH)
+ {
+ yyerror("parser stack overflow");
+ return 2;
+ }
+ yystacksize *= 2;
+ if (yystacksize > YYMAXDEPTH)
+ yystacksize = YYMAXDEPTH;
+ yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
+ __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
+ yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
+ __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
+#ifdef YYLSP_NEEDED
+ yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
+ __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
+#endif
+#endif /* no yyoverflow */
+
+ yyssp = yyss + size - 1;
+ yyvsp = yyvs + size - 1;
+#ifdef YYLSP_NEEDED
+ yylsp = yyls + size - 1;
+#endif
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Stack size increased to %d\n", yystacksize);
+#endif
+
+ if (yyssp >= yyss + yystacksize - 1)
+ YYABORT;
+ }
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Entering state %d\n", yystate);
+#endif
+
+ yybackup:
+
+/* Do appropriate processing given the current state. */
+/* Read a lookahead token if we need one and don't already have one. */
+/* yyresume: */
+
+ /* First try to decide what to do without reference to lookahead token. */
+
+ yyn = yypact[yystate];
+ if (yyn == YYFLAG)
+ 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. */
+
+ if (yychar == YYEMPTY)
+ {
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Reading a token: ");
+#endif
+ yychar = YYLEX;
+ }
+
+ /* Convert token to internal form (in yychar1) for indexing tables with */
+
+ if (yychar <= 0) /* This means end of input. */
+ {
+ yychar1 = 0;
+ yychar = YYEOF; /* Don't call YYLEX any more */
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Now at end of input.\n");
+#endif
+ }
+ else
+ {
+ yychar1 = YYTRANSLATE(yychar);
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
+#endif
+ }
+
+ yyn += yychar1;
+ if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+ 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 == YYFLAG)
+ goto yyerrlab;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+ else if (yyn == 0)
+ goto yyerrlab;
+
+ if (yyn == YYFINAL)
+ YYACCEPT;
+
+ /* Shift the lookahead token. */
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
+#endif
+
+ /* Discard the token being shifted unless it is eof. */
+ if (yychar != YYEOF)
+ yychar = YYEMPTY;
+
+ *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+ *++yylsp = yylloc;
+#endif
+
+ /* count tokens shifted since error; after three, turn off error status. */
+ if (yyerrstatus) yyerrstatus--;
+
+ yystate = yyn;
+ goto yynewstate;
+
+/* Do the default action for the current state. */
+yydefault:
+
+ yyn = yydefact[yystate];
+ if (yyn == 0)
+ goto yyerrlab;
+
+/* Do a reduction. yyn is the number of a rule to reduce with. */
+yyreduce:
+ yylen = yyr2[yyn];
+ yyval = yyvsp[1-yylen]; /* implement default value of the action */
+
+#if YYDEBUG != 0
+ if (yydebug)
+ {
+ int i;
+
+ fprintf (stderr, "Reducing via rule %d (line %d), ",
+ yyn, yyrline[yyn]);
+
+ /* Print the symboles being reduced, and their result. */
+ for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
+ fprintf (stderr, "%s ", yytname[yyrhs[i]]);
+ fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+ }
+#endif
+
+
+ switch (yyn) {
+
+case 3:
+#line 186 "ccdir/c-parse.y"
+{yyval.ttype = NULL_TREE; ;
+ break;}
+case 5:
+#line 187 "ccdir/c-parse.y"
+{yyval.ttype = NULL_TREE; ;
+ break;}
+case 9:
+#line 194 "ccdir/c-parse.y"
+{ if (pedantic)
+ warning ("ANSI C forbids use of `asm' keyword");
+ if (TREE_CHAIN (yyvsp[-2].ttype)) yyvsp[-2].ttype = combine_strings (yyvsp[-2].ttype);
+ assemble_asm (yyvsp[-2].ttype); ;
+ break;}
+case 10:
+#line 202 "ccdir/c-parse.y"
+{ if (pedantic)
+ error ("ANSI C forbids data definition lacking type or storage class");
+ else if (!flag_traditional)
+ warning ("data definition lacks type or storage class"); ;
+ break;}
+case 11:
+#line 207 "ccdir/c-parse.y"
+{;
+ break;}
+case 12:
+#line 209 "ccdir/c-parse.y"
+{;
+ break;}
+case 13:
+#line 211 "ccdir/c-parse.y"
+{ error ("empty declaration"); ;
+ break;}
+case 14:
+#line 213 "ccdir/c-parse.y"
+{ shadow_tag (yyvsp[-1].ttype); ;
+ break;}
+case 17:
+#line 217 "ccdir/c-parse.y"
+{ if (pedantic)
+ warning ("ANSI C does not allow extra `;' outside of a function"); ;
+ break;}
+case 18:
+#line 223 "ccdir/c-parse.y"
+{ if (! start_function (yyvsp[-2].ttype, yyvsp[0].ttype))
+ YYFAIL;
+ reinit_parse_for_function (); ;
+ break;}
+case 19:
+#line 227 "ccdir/c-parse.y"
+{ store_parm_decls (); ;
+ break;}
+case 20:
+#line 229 "ccdir/c-parse.y"
+{ finish_function (lineno); ;
+ break;}
+case 21:
+#line 231 "ccdir/c-parse.y"
+{ ;
+ break;}
+case 22:
+#line 233 "ccdir/c-parse.y"
+{ if (! start_function (yyvsp[-2].ttype, yyvsp[0].ttype))
+ YYFAIL;
+ reinit_parse_for_function (); ;
+ break;}
+case 23:
+#line 237 "ccdir/c-parse.y"
+{ store_parm_decls (); ;
+ break;}
+case 24:
+#line 239 "ccdir/c-parse.y"
+{ finish_function (lineno); ;
+ break;}
+case 25:
+#line 241 "ccdir/c-parse.y"
+{ ;
+ break;}
+case 26:
+#line 243 "ccdir/c-parse.y"
+{ if (! start_function (0, yyvsp[0].ttype))
+ YYFAIL;
+ reinit_parse_for_function (); ;
+ break;}
+case 27:
+#line 247 "ccdir/c-parse.y"
+{ store_parm_decls (); ;
+ break;}
+case 28:
+#line 249 "ccdir/c-parse.y"
+{ finish_function (lineno); ;
+ break;}
+case 29:
+#line 251 "ccdir/c-parse.y"
+{ ;
+ break;}
+case 32:
+#line 260 "ccdir/c-parse.y"
+{ yyval.code = ADDR_EXPR; ;
+ break;}
+case 33:
+#line 262 "ccdir/c-parse.y"
+{ yyval.code = NEGATE_EXPR; ;
+ break;}
+case 34:
+#line 264 "ccdir/c-parse.y"
+{ yyval.code = CONVERT_EXPR; ;
+ break;}
+case 35:
+#line 266 "ccdir/c-parse.y"
+{ yyval.code = PREINCREMENT_EXPR; ;
+ break;}
+case 36:
+#line 268 "ccdir/c-parse.y"
+{ yyval.code = PREDECREMENT_EXPR; ;
+ break;}
+case 37:
+#line 270 "ccdir/c-parse.y"
+{ yyval.code = BIT_NOT_EXPR; ;
+ break;}
+case 38:
+#line 272 "ccdir/c-parse.y"
+{ yyval.code = TRUTH_NOT_EXPR; ;
+ break;}
+case 39:
+#line 276 "ccdir/c-parse.y"
+{ yyval.ttype = build_compound_expr (yyvsp[0].ttype); ;
+ break;}
+case 40:
+#line 281 "ccdir/c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+ break;}
+case 42:
+#line 287 "ccdir/c-parse.y"
+{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ;
+ break;}
+case 43:
+#line 289 "ccdir/c-parse.y"
+{ chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
+ break;}
+case 45:
+#line 295 "ccdir/c-parse.y"
+{ yyval.ttype = build_indirect_ref (yyvsp[0].ttype, "unary *"); ;
+ break;}
+case 46:
+#line 297 "ccdir/c-parse.y"
+{ yyval.ttype = build_unary_op (yyvsp[-1].code, yyvsp[0].ttype, 0); ;
+ break;}
+case 47:
+#line 299 "ccdir/c-parse.y"
+{ if (TREE_CODE (yyvsp[0].ttype) == COMPONENT_REF
+ && TREE_PACKED (TREE_OPERAND (yyvsp[0].ttype, 1)))
+ error ("`sizeof' applied to a bit-field");
+ /* ANSI says arrays and functions are converted inside comma.
+ But we can't really convert them in build_compound_expr
+ because that would break commas in lvalues.
+ So do the conversion here if operand was a comma. */
+ if (TREE_CODE (yyvsp[0].ttype) == COMPOUND_EXPR
+ && (TREE_CODE (TREE_TYPE (yyvsp[0].ttype)) == ARRAY_TYPE
+ || TREE_CODE (TREE_TYPE (yyvsp[0].ttype)) == FUNCTION_TYPE))
+ yyvsp[0].ttype = default_conversion (yyvsp[0].ttype);
+ yyval.ttype = c_sizeof (TREE_TYPE (yyvsp[0].ttype)); ;
+ break;}
+case 48:
+#line 312 "ccdir/c-parse.y"
+{ yyval.ttype = c_sizeof (groktypename (yyvsp[-1].ttype)); ;
+ break;}
+case 49:
+#line 314 "ccdir/c-parse.y"
+{ if (TREE_CODE (yyvsp[0].ttype) == COMPONENT_REF
+ && TREE_PACKED (TREE_OPERAND (yyvsp[0].ttype, 1)))
+ error ("`__alignof' applied to a bit-field");
+ if (TREE_CODE (yyvsp[0].ttype) == INDIRECT_REF)
+ {
+ tree t = TREE_OPERAND (yyvsp[0].ttype, 0);
+ tree best = t;
+ int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
+ while (TREE_CODE (t) == NOP_EXPR
+ && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
+ {
+ int thisalign;
+ t = TREE_OPERAND (t, 0);
+ thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
+ if (thisalign > bestalign)
+ best = t, bestalign = thisalign;
+ }
+ yyval.ttype = c_alignof (TREE_TYPE (TREE_TYPE (best)));
+ }
+ else
+ {
+ /* ANSI says arrays and fns are converted inside comma.
+ But we can't convert them in build_compound_expr
+ because that would break commas in lvalues.
+ So do the conversion here if operand was a comma. */
+ if (TREE_CODE (yyvsp[0].ttype) == COMPOUND_EXPR
+ && (TREE_CODE (TREE_TYPE (yyvsp[0].ttype)) == ARRAY_TYPE
+ || TREE_CODE (TREE_TYPE (yyvsp[0].ttype)) == FUNCTION_TYPE))
+ yyvsp[0].ttype = default_conversion (yyvsp[0].ttype);
+ yyval.ttype = c_alignof (TREE_TYPE (yyvsp[0].ttype));
+ }
+ ;
+ break;}
+case 50:
+#line 347 "ccdir/c-parse.y"
+{ yyval.ttype = c_alignof (groktypename (yyvsp[-1].ttype)); ;
+ break;}
+case 52:
+#line 353 "ccdir/c-parse.y"
+{ tree type = groktypename (yyvsp[-2].ttype);
+ yyval.ttype = build_c_cast (type, yyvsp[0].ttype); ;
+ break;}
+case 53:
+#line 356 "ccdir/c-parse.y"
+{ tree type = groktypename (yyvsp[-5].ttype);
+ if (pedantic)
+ warning ("ANSI C forbids constructor expressions");
+ yyval.ttype = digest_init (type, build_nt (CONSTRUCTOR, NULL_TREE, nreverse (yyvsp[-2].ttype)), 0);
+ if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
+ {
+ int failure = complete_array_type (type, yyval.ttype, 1);
+ if (failure)
+ abort ();
+ }
+ ;
+ break;}
+case 55:
+#line 372 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 56:
+#line 374 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 57:
+#line 376 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 58:
+#line 378 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 59:
+#line 380 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 60:
+#line 382 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 61:
+#line 384 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 62:
+#line 386 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 63:
+#line 388 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 64:
+#line 390 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 65:
+#line 392 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 66:
+#line 394 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 67:
+#line 396 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (TRUTH_ANDIF_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 68:
+#line 398 "ccdir/c-parse.y"
+{ yyval.ttype = build_binary_op (TRUTH_ORIF_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 69:
+#line 400 "ccdir/c-parse.y"
+{ yyval.ttype = build_conditional_expr (yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 70:
+#line 402 "ccdir/c-parse.y"
+{ yyval.ttype = build_modify_expr (yyvsp[-2].ttype, NOP_EXPR, yyvsp[0].ttype); ;
+ break;}
+case 71:
+#line 404 "ccdir/c-parse.y"
+{ yyval.ttype = build_modify_expr (yyvsp[-2].ttype, yyvsp[-1].code, yyvsp[0].ttype); ;
+ break;}
+case 72:
+#line 409 "ccdir/c-parse.y"
+{ yyval.ttype = lastiddecl;
+ if (!yyval.ttype || yyval.ttype == error_mark_node)
+ {
+ if (yychar == YYEMPTY)
+ yychar = YYLEX;
+ if (yychar == '(')
+ {
+ yyval.ttype = implicitly_declare (yyvsp[0].ttype);
+ assemble_external (yyval.ttype);
+ TREE_USED (yyval.ttype) = 1;
+ }
+ else if (current_function_decl == 0)
+ {
+ error ("`%s' undeclared, outside of functions",
+ IDENTIFIER_POINTER (yyvsp[0].ttype));
+ yyval.ttype = error_mark_node;
+ }
+ else
+ {
+ if (IDENTIFIER_GLOBAL_VALUE (yyvsp[0].ttype) != error_mark_node
+ || IDENTIFIER_ERROR_LOCUS (yyvsp[0].ttype) != current_function_decl)
+ {
+ error ("`%s' undeclared (first use this function)",
+ IDENTIFIER_POINTER (yyvsp[0].ttype));
+
+ if (! undeclared_variable_notice)
+ {
+ error ("(Each undeclared identifier is reported only once");
+ error ("for each function it appears in.)");
+ undeclared_variable_notice = 1;
+ }
+ }
+ yyval.ttype = error_mark_node;
+ /* Prevent repeated error messages. */
+ IDENTIFIER_GLOBAL_VALUE (yyvsp[0].ttype) = error_mark_node;
+ IDENTIFIER_ERROR_LOCUS (yyvsp[0].ttype) = current_function_decl;
+ }
+ }
+ else if (! TREE_USED (yyval.ttype))
+ {
+ if (TREE_EXTERNAL (yyval.ttype))
+ assemble_external (yyval.ttype);
+ TREE_USED (yyval.ttype) = 1;
+ }
+ if (TREE_CODE (yyval.ttype) == CONST_DECL)
+ yyval.ttype = DECL_INITIAL (yyval.ttype);
+ ;
+ break;}
+case 74:
+#line 458 "ccdir/c-parse.y"
+{ yyval.ttype = combine_strings (yyvsp[0].ttype); ;
+ break;}
+case 75:
+#line 460 "ccdir/c-parse.y"
+{ yyval.ttype = yyvsp[-1].ttype; ;
+ break;}
+case 76:
+#line 462 "ccdir/c-parse.y"
+{ yyval.ttype = error_mark_node; ;
+ break;}
+case 77:
+#line 464 "ccdir/c-parse.y"
+{ if (current_function_decl == 0)
+ {
+ error ("braced-group within expression allowed only inside a function");
+ YYFAIL;
+ }
+ keep_next_level ();
+ yyval.ttype = expand_start_stmt_expr (); ;
+ break;}
+case 78:
+#line 472 "ccdir/c-parse.y"
+{ tree rtl_exp;
+ if (pedantic)
+ warning ("ANSI C forbids braced-groups within expressions");
+ rtl_exp = expand_end_stmt_expr (yyvsp[-2].ttype);
+ yyval.ttype = yyvsp[-1].ttype;
+ TREE_USED (yyval.ttype) = 0;
+ /* Since the statements have side effects,
+ consider this volatile. */
+ TREE_VOLATILE (yyval.ttype) = 1;
+ TREE_TYPE (yyval.ttype) = TREE_TYPE (rtl_exp);
+ STMT_BODY (yyval.ttype) = rtl_exp; ;
+ break;}
+case 79:
+#line 484 "ccdir/c-parse.y"
+{ yyval.ttype = build_function_call (yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 80:
+#line 486 "ccdir/c-parse.y"
+{ yyval.ttype = build_array_ref (yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 81:
+#line 488 "ccdir/c-parse.y"
+{ yyval.ttype = build_component_ref (yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 82:
+#line 490 "ccdir/c-parse.y"
+{ yyval.ttype = build_component_ref (build_indirect_ref (yyvsp[-2].ttype, "->"), yyvsp[0].ttype); ;
+ break;}
+case 83:
+#line 492 "ccdir/c-parse.y"
+{ yyval.ttype = build_unary_op (POSTINCREMENT_EXPR, yyvsp[-1].ttype, 0); ;
+ break;}
+case 84:
+#line 494 "ccdir/c-parse.y"
+{ yyval.ttype = build_unary_op (POSTDECREMENT_EXPR, yyvsp[-1].ttype, 0); ;
+ break;}
+case 86:
+#line 501 "ccdir/c-parse.y"
+{ yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+ break;}
+case 93:
+#line 521 "ccdir/c-parse.y"
+{ yyval.itype = suspend_momentary ();
+ declspec_stack = tree_cons (0, current_declspecs,
+ declspec_stack);
+ current_declspecs = yyvsp[0].ttype; ;
+ break;}
+case 94:
+#line 529 "ccdir/c-parse.y"
+{ current_declspecs = TREE_VALUE (declspec_stack);
+ declspec_stack = TREE_CHAIN (declspec_stack);
+ resume_momentary (yyvsp[-2].itype); ;
+ break;}
+case 95:
+#line 533 "ccdir/c-parse.y"
+{ current_declspecs = TREE_VALUE (declspec_stack);
+ declspec_stack = TREE_CHAIN (declspec_stack);
+ resume_momentary (yyvsp[-2].itype); ;
+ break;}
+case 96:
+#line 537 "ccdir/c-parse.y"
+{ shadow_tag (yyvsp[-1].ttype); ;
+ break;}
+case 97:
+#line 539 "ccdir/c-parse.y"
+{ warning ("empty declaration"); ;
+ break;}
+case 98:
+#line 548 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[0].ttype); ;
+ break;}
+case 99:
+#line 550 "ccdir/c-parse.y"
+{ yyval.ttype = chainon (yyvsp[0].ttype, tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[-2].ttype)); ;
+ break;}
+case 100:
+#line 554 "ccdir/c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+ break;}
+case 101:
+#line 556 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 102:
+#line 558 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 103:
+#line 567 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, NULL_TREE); ;
+ break;}
+case 104:
+#line 569 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, NULL_TREE); ;
+ break;}
+case 105:
+#line 571 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 106:
+#line 573 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 107:
+#line 583 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[0].ttype); ;
+ break;}
+case 108:
+#line 585 "ccdir/c-parse.y"
+{ yyval.ttype = chainon (yyvsp[0].ttype, tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[-2].ttype)); ;
+ break;}
+case 109:
+#line 589 "ccdir/c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+ break;}
+case 110:
+#line 591 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 114:
+#line 602 "ccdir/c-parse.y"
+{ yyval.ttype = TREE_TYPE (yyvsp[-1].ttype);
+ if (pedantic)
+ warning ("ANSI C forbids `typeof'"); ;
+ break;}
+case 115:
+#line 606 "ccdir/c-parse.y"
+{ yyval.ttype = groktypename (yyvsp[-1].ttype);
+ if (pedantic)
+ warning ("ANSI C forbids `typeof'"); ;
+ break;}
+case 123:
+#line 630 "ccdir/c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+ break;}
+case 124:
+#line 632 "ccdir/c-parse.y"
+{ if (TREE_CHAIN (yyvsp[-1].ttype)) yyvsp[-1].ttype = combine_strings (yyvsp[-1].ttype);
+ yyval.ttype = yyvsp[-1].ttype;
+ if (pedantic)
+ warning ("ANSI C forbids use of `asm' keyword");
+ ;
+ break;}
+case 125:
+#line 641 "ccdir/c-parse.y"
+{ yyval.ttype = start_decl (yyvsp[-3].ttype, current_declspecs, 1); ;
+ break;}
+case 126:
+#line 644 "ccdir/c-parse.y"
+{ finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype); ;
+ break;}
+case 127:
+#line 646 "ccdir/c-parse.y"
+{ tree d = start_decl (yyvsp[-2].ttype, current_declspecs, 0);
+ finish_decl (d, NULL_TREE, yyvsp[-1].ttype); ;
+ break;}
+case 128:
+#line 652 "ccdir/c-parse.y"
+{ yyval.ttype = start_decl (yyvsp[-3].ttype, current_declspecs, 1); ;
+ break;}
+case 129:
+#line 655 "ccdir/c-parse.y"
+{ finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype); ;
+ break;}
+case 130:
+#line 657 "ccdir/c-parse.y"
+{ tree d = start_decl (yyvsp[-2].ttype, current_declspecs, 0);
+ finish_decl (d, NULL_TREE, yyvsp[-1].ttype); ;
+ break;}
+case 131:
+#line 664 "ccdir/c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+ break;}
+case 132:
+#line 666 "ccdir/c-parse.y"
+{ yyval.ttype = yyvsp[-2].ttype; ;
+ break;}
+case 135:
+#line 676 "ccdir/c-parse.y"
+{ warning ("`%s' attribute directive ignored",
+ IDENTIFIER_POINTER (yyvsp[0].ttype));
+ yyval.ttype = yyvsp[0].ttype; ;
+ break;}
+case 136:
+#line 680 "ccdir/c-parse.y"
+{ /* if not "aligned(1)", then issue warning */
+ if (strcmp (IDENTIFIER_POINTER (yyvsp[-3].ttype), "aligned") != 0
+ || TREE_CODE (yyvsp[-1].ttype) != INTEGER_CST
+ || TREE_INT_CST_LOW (yyvsp[-1].ttype) != 1)
+ warning ("`%s' attribute directive ignored",
+ IDENTIFIER_POINTER (yyvsp[-3].ttype));
+ yyval.ttype = yyvsp[-3].ttype; ;
+ break;}
+case 137:
+#line 688 "ccdir/c-parse.y"
+{ warning ("`%s' attribute directive ignored",
+ IDENTIFIER_POINTER (yyvsp[-3].ttype));
+ yyval.ttype = yyvsp[-3].ttype; ;
+ break;}
+case 139:
+#line 696 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE);
+ if (pedantic)
+ warning ("ANSI C forbids empty initializer braces"); ;
+ break;}
+case 140:
+#line 700 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (yyvsp[-1].ttype)); ;
+ break;}
+case 141:
+#line 702 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (yyvsp[-2].ttype)); ;
+ break;}
+case 142:
+#line 704 "ccdir/c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+ break;}
+case 143:
+#line 711 "ccdir/c-parse.y"
+{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ;
+ break;}
+case 144:
+#line 713 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-2].ttype); ;
+ break;}
+case 147:
+#line 728 "ccdir/c-parse.y"
+{ yyval.ttype = yyvsp[-1].ttype; ;
+ break;}
+case 148:
+#line 730 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (CALL_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE); ;
+ break;}
+case 149:
+#line 735 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 150:
+#line 737 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-2].ttype, NULL_TREE); ;
+ break;}
+case 151:
+#line 739 "ccdir/c-parse.y"
+{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+ break;}
+case 153:
+#line 750 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (CALL_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE); ;
+ break;}
+case 154:
+#line 755 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 155:
+#line 757 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-2].ttype, NULL_TREE); ;
+ break;}
+case 156:
+#line 759 "ccdir/c-parse.y"
+{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+ break;}
+case 158:
+#line 768 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (CALL_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE); ;
+ break;}
+case 159:
+#line 773 "ccdir/c-parse.y"
+{ yyval.ttype = yyvsp[-1].ttype; ;
+ break;}
+case 160:
+#line 775 "ccdir/c-parse.y"
+{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+ break;}
+case 161:
+#line 777 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 162:
+#line 779 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-2].ttype, NULL_TREE); ;
+ break;}
+case 164:
+#line 785 "ccdir/c-parse.y"
+{ yyval.ttype = start_struct (RECORD_TYPE, yyvsp[-1].ttype);
+ /* Start scope of tag before parsing components. */
+ ;
+ break;}
+case 165:
+#line 789 "ccdir/c-parse.y"
+{ yyval.ttype = finish_struct (yyvsp[-2].ttype, yyvsp[-1].ttype);
+ /* Really define the structure. */
+ ;
+ break;}
+case 166:
+#line 793 "ccdir/c-parse.y"
+{ yyval.ttype = finish_struct (start_struct (RECORD_TYPE, NULL_TREE),
+ yyvsp[-1].ttype); ;
+ break;}
+case 167:
+#line 796 "ccdir/c-parse.y"
+{ yyval.ttype = xref_tag (RECORD_TYPE, yyvsp[0].ttype); ;
+ break;}
+case 168:
+#line 798 "ccdir/c-parse.y"
+{ yyval.ttype = start_struct (UNION_TYPE, yyvsp[-1].ttype); ;
+ break;}
+case 169:
+#line 800 "ccdir/c-parse.y"
+{ yyval.ttype = finish_struct (yyvsp[-2].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 170:
+#line 802 "ccdir/c-parse.y"
+{ yyval.ttype = finish_struct (start_struct (UNION_TYPE, NULL_TREE),
+ yyvsp[-1].ttype); ;
+ break;}
+case 171:
+#line 805 "ccdir/c-parse.y"
+{ yyval.ttype = xref_tag (UNION_TYPE, yyvsp[0].ttype); ;
+ break;}
+case 172:
+#line 807 "ccdir/c-parse.y"
+{ yyvsp[0].itype = suspend_momentary ();
+ yyval.ttype = start_enum (yyvsp[-1].ttype); ;
+ break;}
+case 173:
+#line 810 "ccdir/c-parse.y"
+{ yyval.ttype = finish_enum (yyvsp[-3].ttype, nreverse (yyvsp[-2].ttype));
+ resume_momentary (yyvsp[-4].itype); ;
+ break;}
+case 174:
+#line 813 "ccdir/c-parse.y"
+{ yyvsp[0].itype = suspend_momentary ();
+ yyval.ttype = start_enum (NULL_TREE); ;
+ break;}
+case 175:
+#line 816 "ccdir/c-parse.y"
+{ yyval.ttype = finish_enum (yyvsp[-3].ttype, nreverse (yyvsp[-2].ttype));
+ resume_momentary (yyvsp[-4].itype); ;
+ break;}
+case 176:
+#line 819 "ccdir/c-parse.y"
+{ yyval.ttype = xref_tag (ENUMERAL_TYPE, yyvsp[0].ttype); ;
+ break;}
+case 180:
+#line 830 "ccdir/c-parse.y"
+{ if (pedantic) warning ("comma at end of enumerator list"); ;
+ break;}
+case 181:
+#line 835 "ccdir/c-parse.y"
+{ yyval.ttype = yyvsp[0].ttype; ;
+ break;}
+case 182:
+#line 837 "ccdir/c-parse.y"
+{ yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype);
+ warning ("no semicolon at end of struct or union"); ;
+ break;}
+case 183:
+#line 842 "ccdir/c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+ break;}
+case 184:
+#line 844 "ccdir/c-parse.y"
+{ yyval.ttype = chainon (yyvsp[-2].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 185:
+#line 846 "ccdir/c-parse.y"
+{ if (pedantic)
+ warning ("extra semicolon in struct or union specified"); ;
+ break;}
+case 186:
+#line 861 "ccdir/c-parse.y"
+{ yyval.ttype = yyvsp[0].ttype;
+ current_declspecs = TREE_VALUE (declspec_stack);
+ declspec_stack = TREE_CHAIN (declspec_stack);
+ resume_momentary (yyvsp[-1].itype); ;
+ break;}
+case 187:
+#line 866 "ccdir/c-parse.y"
+{ yyval.ttype = yyvsp[0].ttype;
+ current_declspecs = TREE_VALUE (declspec_stack);
+ declspec_stack = TREE_CHAIN (declspec_stack);
+ resume_momentary (yyvsp[-1].itype); ;
+ break;}
+case 188:
+#line 871 "ccdir/c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+ break;}
+case 189:
+#line 876 "ccdir/c-parse.y"
+{ if (pedantic)
+ warning ("ANSI C forbids member declarations with no members");
+ yyval.ttype = NULL_TREE; ;
+ break;}
+case 191:
+#line 881 "ccdir/c-parse.y"
+{ yyval.ttype = chainon (yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 192:
+#line 886 "ccdir/c-parse.y"
+{ yyval.ttype = grokfield (input_filename, lineno, yyvsp[-1].ttype, current_declspecs, NULL_TREE); ;
+ break;}
+case 193:
+#line 888 "ccdir/c-parse.y"
+{ yyval.ttype = grokfield (input_filename, lineno, yyvsp[-3].ttype, current_declspecs, yyvsp[-1].ttype); ;
+ break;}
+case 194:
+#line 890 "ccdir/c-parse.y"
+{ yyval.ttype = grokfield (input_filename, lineno, NULL_TREE, current_declspecs, yyvsp[0].ttype); ;
+ break;}
+case 196:
+#line 901 "ccdir/c-parse.y"
+{ yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-2].ttype); ;
+ break;}
+case 197:
+#line 907 "ccdir/c-parse.y"
+{ yyval.ttype = build_enumerator (yyvsp[0].ttype, NULL_TREE); ;
+ break;}
+case 198:
+#line 909 "ccdir/c-parse.y"
+{ yyval.ttype = build_enumerator (yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 199:
+#line 914 "ccdir/c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+ break;}
+case 200:
+#line 916 "ccdir/c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+ break;}
+case 201:
+#line 921 "ccdir/c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+ break;}
+case 203:
+#line 927 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, NULL_TREE); ;
+ break;}
+case 204:
+#line 929 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 205:
+#line 934 "ccdir/c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+ break;}
+case 206:
+#line 936 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 207:
+#line 941 "ccdir/c-parse.y"
+{ yyval.ttype = yyvsp[-1].ttype; ;
+ break;}
+case 208:
+#line 944 "ccdir/c-parse.y"
+{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+ break;}
+case 209:
+#line 946 "ccdir/c-parse.y"
+{ yyval.ttype = make_pointer_declarator (yyvsp[0].ttype, NULL_TREE); ;
+ break;}
+case 210:
+#line 948 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (CALL_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE); ;
+ break;}
+case 211:
+#line 950 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 212:
+#line 952 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-2].ttype, NULL_TREE); ;
+ break;}
+case 213:
+#line 954 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (CALL_EXPR, NULL_TREE, yyvsp[0].ttype, NULL_TREE); ;
+ break;}
+case 214:
+#line 956 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, NULL_TREE, yyvsp[-1].ttype); ;
+ break;}
+case 215:
+#line 958 "ccdir/c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, NULL_TREE, NULL_TREE); ;
+ break;}
+case 222:
+#line 980 "ccdir/c-parse.y"
+{ pushlevel (0);
+ clear_last_expr ();
+ push_momentary ();
+ expand_start_bindings (0); ;
+ break;}
+case 223:
+#line 990 "ccdir/c-parse.y"
+{;
+ break;}
+case 225:
+#line 995 "ccdir/c-parse.y"
+{ yyval.ttype = 0; ;
+ break;}
+case 226:
+#line 997 "ccdir/c-parse.y"
+{ expand_end_bindings (getdecls (), 1, 0);
+ yyval.ttype = poplevel (1, 1, 0);
+ pop_momentary (); ;
+ break;}
+case 227:
+#line 1001 "ccdir/c-parse.y"
+{ expand_end_bindings (getdecls (), kept_level_p (), 0);
+ yyval.ttype = poplevel (kept_level_p (), 0, 0);
+ pop_momentary (); ;
+ break;}
+case 228:
+#line 1005 "ccdir/c-parse.y"
+{ expand_end_bindings (getdecls (), kept_level_p (), 0);
+ yyval.ttype = poplevel (kept_level_p (), 0, 0);
+ pop_momentary (); ;
+ break;}
+case 229:
+#line 1012 "ccdir/c-parse.y"
+{ emit_line_note (input_filename, lineno);
+ expand_start_cond (truthvalue_conversion (yyvsp[-1].ttype), 0); ;
+ break;}
+case 231:
+#line 1018 "ccdir/c-parse.y"
+{;
+ break;}
+case 232:
+#line 1020 "ccdir/c-parse.y"
+{ emit_line_note (input_filename, lineno);
+ /* Do default conversion if safe and possibly important,
+ in case within ({...}). */
+ if ((TREE_CODE (TREE_TYPE (yyvsp[-1].ttype)) == ARRAY_TYPE
+ && lvalue_p (yyvsp[-1].ttype))
+ || TREE_CODE (TREE_TYPE (yyvsp[-1].ttype)) == FUNCTION_TYPE)
+ yyvsp[-1].ttype = default_conversion (yyvsp[-1].ttype);
+ expand_expr_stmt (yyvsp[-1].ttype);
+ clear_momentary (); ;
+ break;}
+case 233:
+#line 1030 "ccdir/c-parse.y"
+{ expand_start_else (); ;
+ break;}
+case 234:
+#line 1032 "ccdir/c-parse.y"
+{ expand_end_else (); ;
+ break;}
+case 235:
+#line 1034 "ccdir/c-parse.y"
+{ expand_end_cond (); ;
+ break;}
+case 236:
+#line 1036 "ccdir/c-parse.y"
+{ emit_nop ();
+ emit_line_note (input_filename, lineno);
+ expand_start_loop (1); ;
+ break;}
+case 237:
+#line 1040 "ccdir/c-parse.y"
+{ emit_line_note (input_filename, lineno);
+ expand_exit_loop_if_false (truthvalue_conversion (yyvsp[-1].ttype)); ;
+ break;}
+case 238:
+#line 1043 "ccdir/c-parse.y"
+{ expand_end_loop (); ;
+ break;}
+case 239:
+#line 1045 "ccdir/c-parse.y"
+{ emit_nop ();
+ emit_line_note (input_filename, lineno);
+ expand_start_loop_continue_elsewhere (1); ;
+ break;}
+case 240:
+#line 1049 "ccdir/c-parse.y"
+{ expand_loop_continue_here (); ;
+ break;}
+case 241:
+#line 1051 "ccdir/c-parse.y"
+{ emit_line_note (input_filename, lineno);
+ expand_exit_loop_if_false (truthvalue_conversion (yyvsp[-2].ttype));
+ expand_end_loop ();
+ clear_momentary (); ;
+ break;}
+case 242:
+#line 1057 "ccdir/c-parse.y"
+{ emit_nop ();
+ emit_line_note (input_filename, lineno);
+ if (yyvsp[-1].ttype) expand_expr_stmt (yyvsp[-1].ttype);
+ expand_start_loop_continue_elsewhere (1); ;
+ break;}
+case 243:
+#line 1062 "ccdir/c-parse.y"
+{ emit_line_note (input_filename, lineno);
+ if (yyvsp[-1].ttype)
+ expand_exit_loop_if_false (truthvalue_conversion (yyvsp[-1].ttype)); ;
+ break;}
+case 244:
+#line 1068 "ccdir/c-parse.y"
+{ push_momentary ();
+ yyvsp[0].itype = lineno; ;
+ break;}
+case 245:
+#line 1071 "ccdir/c-parse.y"
+{ emit_line_note (input_filename, yyvsp[-2].itype);
+ expand_loop_continue_here ();
+ if (yyvsp[-3].ttype)
+ expand_expr_stmt (yyvsp[-3].ttype);
+ pop_momentary ();
+ expand_end_loop (); ;
+ break;}
+case 246:
+#line 1078 "ccdir/c-parse.y"
+{ emit_line_note (input_filename, lineno);
+ c_expand_start_case (yyvsp[-1].ttype);
+ /* Don't let the tree nodes for $3 be discarded by
+ clear_momentary during the parsing of the next stmt. */
+ push_momentary (); ;
+ break;}
+case 247:
+#line 1084 "ccdir/c-parse.y"
+{ expand_end_case (yyvsp[-3].ttype);
+ pop_momentary (); ;
+ break;}
+case 248:
+#line 1087 "ccdir/c-parse.y"
+{ register tree value = fold (yyvsp[-1].ttype);
+ register tree label
+ = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
+
+ /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
+ Strip such NOP_EXPRs. */
+ if (TREE_CODE (value) == NOP_EXPR
+ && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
+ value = TREE_OPERAND (value, 0);
+
+ if (TREE_CODE (value) != INTEGER_CST
+ && value != error_mark_node)
+ {
+ error ("case label does not reduce to an integer constant");
+ value = error_mark_node;
+ }
+ else
+ /* Promote char or short to int. */
+ value = default_conversion (value);
+ if (value != error_mark_node)
+ {
+ int success = pushcase (value, label);
+ if (success == 1)
+ error ("case label not within a switch statement");
+ else if (success == 2)
+ error ("duplicate case value");
+ else if (success == 3)
+ warning ("case value out of range");
+ }
+ ;
+ break;}
+case 250:
+#line 1119 "ccdir/c-parse.y"
+{
+ register tree label
+ = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
+ int success = pushcase (NULL_TREE, label);
+ if (success == 1)
+ error ("default label not within a switch statement");
+ else if (success == 2)
+ error ("multiple default labels in one switch");
+ ;
+ break;}
+case 252:
+#line 1130 "ccdir/c-parse.y"
+{ emit_line_note (input_filename, lineno);
+ if ( ! expand_exit_something ())
+ error ("break statement not within loop or switch"); ;
+ break;}
+case 253:
+#line 1134 "ccdir/c-parse.y"
+{ emit_line_note (input_filename, lineno);
+ if (! expand_continue_loop ())
+ error ("continue statement not within a loop"); ;
+ break;}
+case 254:
+#line 1138 "ccdir/c-parse.y"
+{ emit_line_note (input_filename, lineno);
+ c_expand_return (NULL_TREE); ;
+ break;}
+case 255:
+#line 1141 "ccdir/c-parse.y"
+{ emit_line_note (input_filename, lineno);
+ c_expand_return (yyvsp[-1].ttype); ;
+ break;}
+case 256:
+#line 1144 "ccdir/c-parse.y"
+{ if (TREE_CHAIN (yyvsp[-2].ttype)) yyvsp[-2].ttype = combine_strings (yyvsp[-2].ttype);
+ emit_line_note (input_filename, lineno);
+ expand_asm (yyvsp[-2].ttype); ;
+ break;}
+case 257:
+#line 1149 "ccdir/c-parse.y"
+{ if (TREE_CHAIN (yyvsp[-4].ttype)) yyvsp[-4].ttype = combine_strings (yyvsp[-4].ttype);
+ emit_line_note (input_filename, lineno);
+ c_expand_asm_operands (yyvsp[-4].ttype, yyvsp[-2].ttype, NULL_TREE, NULL_TREE,
+ yyvsp[-6].ttype == ridpointers[(int)RID_VOLATILE],
+ input_filename, lineno); ;
+ break;}
+case 258:
+#line 1156 "ccdir/c-parse.y"
+{ if (TREE_CHAIN (yyvsp[-6].ttype)) yyvsp[-6].ttype = combine_strings (yyvsp[-6].ttype);
+ emit_line_note (input_filename, lineno);
+ c_expand_asm_operands (yyvsp[-6].ttype, yyvsp[-4].ttype, yyvsp[-2].ttype, NULL_TREE,
+ yyvsp[-8].ttype == ridpointers[(int)RID_VOLATILE],
+ input_filename, lineno); ;
+ break;}
+case 259:
+#line 1164 "ccdir/c-parse.y"
+{ if (TREE_CHAIN (yyvsp[-8].ttype)) yyvsp[-8].ttype = combine_strings (yyvsp[-8].ttype);
+ emit_line_note (input_filename, lineno);
+ c_expand_asm_operands (yyvsp[-8].ttype, yyvsp[-6].ttype, yyvsp[-4].ttype, yyvsp[-2].ttype,
+ yyvsp[-10].ttype == ridpointers[(int)RID_VOLATILE],
+ input_filename, lineno); ;
+ break;}
+case 260:
+#line 1170 "ccdir/c-parse.y"
+{ tree decl;
+ emit_line_note (input_filename, lineno);
+ decl = lookup_label (yyvsp[-1].ttype);
+ TREE_USED (decl) = 1;
+ expand_goto (decl); ;
+ break;}
+case 261:
+#line 1176 "ccdir/c-parse.y"
+{ tree label = define_label (input_filename, lineno, yyvsp[-1].ttype);
+ emit_nop ();
+ if (label)
+ expand_label (label); ;
+ break;}
+case 264:
+#line 1188 "ccdir/c-parse.y"
+{ if (pedantic)
+ warning ("ANSI C forbids use of `asm' keyword");
+ emit_line_note (input_filename, lineno); ;
+ break;}
+case 265:
+#line 1192 "ccdir/c-parse.y"
+{ if (pedantic)
+ warning ("ANSI C forbids use of `asm' keyword");
+ emit_line_note (input_filename, lineno); ;
+ break;}
+case 266:
+#line 1199 "ccdir/c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+ break;}
+case 268:
+#line 1206 "ccdir/c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+ break;}
+case 271:
+#line 1213 "ccdir/c-parse.y"
+{ yyval.ttype = chainon (yyvsp[-2].ttype, yyvsp[0].ttype); ;
+ break;}
+case 272:
+#line 1218 "ccdir/c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+ break;}
+case 273:
+#line 1223 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, combine_strings (yyvsp[0].ttype), NULL_TREE); ;
+ break;}
+case 274:
+#line 1225 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, combine_strings (yyvsp[0].ttype), yyvsp[-2].ttype); ;
+ break;}
+case 275:
+#line 1231 "ccdir/c-parse.y"
+{ pushlevel (0);
+ declare_parm_level (); ;
+ break;}
+case 276:
+#line 1234 "ccdir/c-parse.y"
+{ yyval.ttype = yyvsp[0].ttype;
+ parmlist_tags_warning ();
+ poplevel (0, 0, 0); ;
+ break;}
+case 277:
+#line 1242 "ccdir/c-parse.y"
+{ pushlevel (0);
+ declare_parm_level (); ;
+ break;}
+case 278:
+#line 1245 "ccdir/c-parse.y"
+{ yyval.ttype = yyvsp[0].ttype;
+ parmlist_tags_warning ();
+ poplevel (0, 0, 0); ;
+ break;}
+case 280:
+#line 1253 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, NULL_TREE, yyvsp[-1].ttype); ;
+ break;}
+case 281:
+#line 1255 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); ;
+ break;}
+case 283:
+#line 1261 "ccdir/c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); ;
+ break;}
+case 284:
+#line 1267 "ccdir/c-parse.y"
+{ yyval.ttype = get_parm_info (0); ;
+ break;}
+case 285:
+#line 1269 "ccdir/c-parse.y"
+{ yyval.ttype = get_parm_info (1); ;
+ break;}
+case 286:
+#line 1271 "ccdir/c-parse.y"
+{ yyval.ttype = get_parm_info (0); ;
+ break;}
+case 287:
+#line 1276 "ccdir/c-parse.y"
+{ push_parm_decl (yyvsp[0].ttype); ;
+ break;}
+case 288:
+#line 1278 "ccdir/c-parse.y"
+{ push_parm_decl (yyvsp[0].ttype); ;
+ break;}
+case 289:
+#line 1285 "ccdir/c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype) ; ;
+ break;}
+case 290:
+#line 1287 "ccdir/c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype) ; ;
+ break;}
+case 291:
+#line 1289 "ccdir/c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+ break;}
+case 292:
+#line 1291 "ccdir/c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype) ; ;
+ break;}
+case 293:
+#line 1293 "ccdir/c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+ break;}
+case 294:
+#line 1299 "ccdir/c-parse.y"
+{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ;
+ break;}
+case 295:
+#line 1301 "ccdir/c-parse.y"
+{ yyval.ttype = chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
+ break;}
+}
+ /* the action file gets copied in in place of this dollarsign */
+#line 419 "bison.simple"
+
+ yyvsp -= yylen;
+ yyssp -= yylen;
+#ifdef YYLSP_NEEDED
+ yylsp -= yylen;
+#endif
+
+#if YYDEBUG != 0
+ if (yydebug)
+ {
+ short *ssp1 = yyss - 1;
+ fprintf (stderr, "state stack now");
+ while (ssp1 != yyssp)
+ fprintf (stderr, " %d", *++ssp1);
+ fprintf (stderr, "\n");
+ }
+#endif
+
+ *++yyvsp = yyval;
+
+#ifdef YYLSP_NEEDED
+ yylsp++;
+ if (yylen == 0)
+ {
+ yylsp->first_line = yylloc.first_line;
+ yylsp->first_column = yylloc.first_column;
+ yylsp->last_line = (yylsp-1)->last_line;
+ yylsp->last_column = (yylsp-1)->last_column;
+ yylsp->text = 0;
+ }
+ else
+ {
+ yylsp->last_line = (yylsp+yylen-1)->last_line;
+ yylsp->last_column = (yylsp+yylen-1)->last_column;
+ }
+#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 number reduced by. */
+
+ yyn = yyr1[yyn];
+
+ yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+ if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+ yystate = yytable[yystate];
+ else
+ yystate = yydefgoto[yyn - YYNTBASE];
+
+ goto yynewstate;
+
+yyerrlab: /* here on detecting error */
+
+ if (! yyerrstatus)
+ /* If not already recovering from an error, report this error. */
+ {
+ ++yynerrs;
+
+#ifdef YYERROR_VERBOSE
+ yyn = yypact[yystate];
+
+ if (yyn > YYFLAG && yyn < YYLAST)
+ {
+ int size = 0;
+ char *msg;
+ int x, count;
+
+ count = 0;
+ for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
+ if (yycheck[x + yyn] == x)
+ size += strlen(yytname[x]) + 15, count++;
+ msg = (char *) xmalloc(size + 15);
+ strcpy(msg, "parse error");
+
+ if (count < 5)
+ {
+ count = 0;
+ for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
+ if (yycheck[x + yyn] == x)
+ {
+ strcat(msg, count == 0 ? ", expecting `" : " or `");
+ strcat(msg, yytname[x]);
+ strcat(msg, "'");
+ count++;
+ }
+ }
+ yyerror(msg);
+ free(msg);
+ }
+ else
+#endif /* YYERROR_VERBOSE */
+ yyerror("parse error");
+ }
+
+yyerrlab1: /* here on error raised explicitly by an action */
+
+ if (yyerrstatus == 3)
+ {
+ /* if just tried and failed to reuse lookahead token after an error, discard it. */
+
+ /* return failure if at end of input */
+ if (yychar == YYEOF)
+ YYABORT;
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+#endif
+
+ yychar = YYEMPTY;
+ }
+
+ /* Else will try to reuse lookahead token
+ after shifting the error token. */
+
+ yyerrstatus = 3; /* Each real token shifted decrements this */
+
+ goto yyerrhandle;
+
+yyerrdefault: /* current state does not do anything special for the error token. */
+
+#if 0
+ /* This is wrong; only states that explicitly want error tokens
+ should shift them. */
+ yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
+ if (yyn) goto yydefault;
+#endif
+
+yyerrpop: /* pop the current state because it cannot handle the error token */
+
+ if (yyssp == yyss) YYABORT;
+ yyvsp--;
+ yystate = *--yyssp;
+#ifdef YYLSP_NEEDED
+ yylsp--;
+#endif
+
+#if YYDEBUG != 0
+ if (yydebug)
+ {
+ short *ssp1 = yyss - 1;
+ fprintf (stderr, "Error: state stack now");
+ while (ssp1 != yyssp)
+ fprintf (stderr, " %d", *++ssp1);
+ fprintf (stderr, "\n");
+ }
+#endif
+
+yyerrhandle:
+
+ yyn = yypact[yystate];
+ if (yyn == YYFLAG)
+ goto yyerrdefault;
+
+ 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;
+ }
+ else if (yyn == 0)
+ goto yyerrpop;
+
+ if (yyn == YYFINAL)
+ YYACCEPT;
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Shifting error token, ");
+#endif
+
+ *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+ *++yylsp = yylloc;
+#endif
+
+ yystate = yyn;
+ goto yynewstate;
+}
+#line 1303 "ccdir/c-parse.y"
+
+
+/* Return something to represent absolute declarators containing a *.
+ TARGET is the absolute declarator that the * contains.
+ TYPE_QUALS is a list of modifiers such as const or volatile
+ to apply to the pointer type, represented as identifiers.
+
+ We return an INDIRECT_REF whose "contents" are TARGET
+ and whose type is the modifier list. */
+
+static tree
+make_pointer_declarator (type_quals, target)
+ tree type_quals, target;
+{
+ return build (INDIRECT_REF, type_quals, target);
+}
+
+/* Given a chain of STRING_CST nodes,
+ concatenate them into one STRING_CST
+ and give it a suitable array-of-chars data type. */
+
+static tree
+combine_strings (strings)
+ tree strings;
+{
+ register tree value, t;
+ register int length = 1;
+ int wide_length = 0;
+ int wide_flag = 0;
+ int nchars;
+
+ if (TREE_CHAIN (strings))
+ {
+ /* More than one in the chain, so concatenate. */
+ register char *p, *q;
+
+ /* Don't include the \0 at the end of each substring,
+ except for the last one.
+ Count wide strings and ordinary strings separately. */
+ for (t = strings; t; t = TREE_CHAIN (t))
+ {
+ if (TREE_TYPE (t) == int_array_type_node)
+ {
+ wide_length += (TREE_STRING_LENGTH (t) - UNITS_PER_WORD);
+ wide_flag = 1;
+ }
+ else
+ length += (TREE_STRING_LENGTH (t) - 1);
+ }
+
+ /* If anything is wide, the non-wides will be converted,
+ which makes them take more space. */
+ if (wide_flag)
+ length = length * UNITS_PER_WORD + wide_length;
+
+ p = (char *) savealloc (length);
+
+ /* Copy the individual strings into the new combined string.
+ If the combined string is wide, convert the chars to ints
+ for any individual strings that are not wide. */
+
+ q = p;
+ for (t = strings; t; t = TREE_CHAIN (t))
+ {
+ int len = (TREE_STRING_LENGTH (t)
+ - ((TREE_TYPE (t) == int_array_type_node)
+ ? UNITS_PER_WORD : 1));
+ if ((TREE_TYPE (t) == int_array_type_node) == wide_flag)
+ {
+ bcopy (TREE_STRING_POINTER (t), q, len);
+ q += len;
+ }
+ else
+ {
+ int i;
+ for (i = 0; i < len; i++)
+ ((int *) q)[i] = TREE_STRING_POINTER (t)[i];
+ q += len * UNITS_PER_WORD;
+ }
+ }
+ if (wide_flag)
+ {
+ int i;
+ for (i = 0; i < UNITS_PER_WORD; i++)
+ *q++ = 0;
+ }
+ else
+ *q = 0;
+
+ value = make_node (STRING_CST);
+ TREE_STRING_POINTER (value) = p;
+ TREE_STRING_LENGTH (value) = length;
+ TREE_LITERAL (value) = 1;
+ }
+ else
+ {
+ value = strings;
+ length = TREE_STRING_LENGTH (value);
+ if (TREE_TYPE (value) == int_array_type_node)
+ wide_flag = 1;
+ }
+
+ /* Compute the number of elements, for the array type. */
+ nchars = wide_flag ? length / UNITS_PER_WORD : length;
+
+ /* Create the array type for the string constant.
+ -Wwrite-strings says make the string constant an array of const char
+ so that copying it to a non-const pointer will get a warning. */
+ if (warn_write_strings)
+ {
+ tree elements
+ = build_type_variant (wide_flag ? integer_type_node : char_type_node,
+ 1, 0);
+ TREE_TYPE (value)
+ = build_array_type (elements,
+ build_index_type (build_int_2 (nchars - 1, 0)));
+ }
+ else
+ TREE_TYPE (value)
+ = build_array_type (wide_flag ? integer_type_node : char_type_node,
+ build_index_type (build_int_2 (nchars - 1, 0)));
+ TREE_LITERAL (value) = 1;
+ TREE_STATIC (value) = 1;
+ return value;
+}
+
+FILE *finput; /* input file.
+ Normally a pipe from the preprocessor. */
+
+/* lexical analyzer */
+
+static int maxtoken; /* Current nominal length of token buffer. */
+static char *token_buffer; /* Pointer to token buffer.
+ Actual allocated length is maxtoken + 2. */
+static int max_wide; /* Current nominal length of wide_buffer. */
+static int *wide_buffer; /* Pointer to wide-string buffer.
+ Actual allocated length is max_wide + 1. */
+
+/* Nonzero if end-of-file has been seen on input. */
+static int end_of_file;
+
+/* Data type that represents the GNU C reserved words. */
+struct resword { char *name; short token; enum rid rid; };
+
+#define MIN_WORD_LENGTH 2 /* minimum size for C keyword */
+#define MAX_WORD_LENGTH 13 /* maximum size for C keyword */
+#define MIN_HASH_VALUE 7 /* range of the hash keys values */
+#define MAX_HASH_VALUE 91 /* for the perfect hash generator */
+#define NORID RID_UNUSED
+
+/* This function performs the minimum-perfect hash mapping from input
+ string to reswords table index. It only looks at the first and
+ last characters in the string, thus assuring the O(1) lookup time
+ (this keeps our constant down to an insignificant amount!). Compiling
+ the following 2 functions as inline removes all overhead of the
+ function calls. */
+
+#ifdef __GNUC__
+__inline
+#endif
+static int
+hash (str, len)
+ register char *str;
+ register int len;
+{
+/* This table is used to build the hash table index that recognizes
+ reserved words in 0(1) steps. It is larger than strictly necessary,
+ but I'm trading off the space for the time-saving luxury of avoiding
+ subtraction of an offset. All those ``91's'' (actually just a
+ short-hand for MAX_HASH_VALUE #defined above) are used to speed up
+ the search when the string found on the input stream doesn't have a
+ first or last character that is part of the set of alphabetic
+ characters that comprise the first or last characters in C
+ reserved words. */
+
+ static int hash_table[] =
+ {
+ 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
+ 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
+ 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
+ 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
+ 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
+ 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
+ 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
+ 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
+ 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
+ 91, 91, 91, 91, 91, 1, 91, 2, 1, 32,
+ 7, 5, 18, 20, 1, 17, 91, 1, 18, 1,
+ 28, 1, 23, 91, 12, 20, 1, 41, 7, 15,
+ 91, 91, 10, 91, 91, 91, 91, 91,
+ };
+ register int hval = len ;
+
+ switch (hval)
+ {
+ default:
+ case 3:
+ hval += hash_table[str[2]];
+ case 2:
+ case 1:
+ return hval + hash_table[str[0]] + hash_table[str[len - 1]];
+ }
+}
+
+/* This routine attempts to match the string found in the reswords table
+ with the one from the input stream. If all the relevant details
+ match then an actual strcmp comparison is performed and the address of
+ correct struct resword entry is returned. Otherwise, a NULL
+ pointer is returned. */
+
+#ifdef __GNUC__
+__inline
+#endif
+struct resword *
+is_reserved_word (str, len)
+ register char *str;
+ register int len;
+{
+ /* This is the hash table of keywords.
+ The order of keywords has been chosen for perfect hashing.
+ Therefore, this table cannot be updated by hand.
+ Use the program ``gperf,'' available with the latest libg++
+ distribution, to generate an updated table. A file called
+ c-parse.gperf, distributed with GNU C, contains the keyword file. */
+
+ static struct resword reswords[] =
+ {
+ { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", },
+ {"asm", ASM, NORID },
+ {"auto", SCSPEC, RID_AUTO },
+ {"__asm", ASM, NORID },
+ {"do", DO, NORID },
+ {"__asm__", ASM, NORID },
+ {"break", BREAK, NORID },
+ {"__typeof__", TYPEOF, NORID },
+ { "", },
+ {"__alignof__", ALIGNOF, NORID },
+ { "", },
+ {"__attribute__", ATTRIBUTE, NORID },
+ { "", },
+ {"__attribute", ATTRIBUTE, NORID },
+ { "", },
+ {"__volatile__", TYPE_QUAL, RID_VOLATILE },
+ {"int", TYPESPEC, RID_INT },
+ {"__volatile", TYPE_QUAL, RID_VOLATILE },
+ { "", },
+ {"float", TYPESPEC, RID_FLOAT },
+ {"goto", GOTO, NORID },
+ {"short", TYPESPEC, RID_SHORT },
+ {"__typeof", TYPEOF, NORID },
+ {"__inline__", SCSPEC, RID_INLINE },
+ {"__alignof", ALIGNOF, NORID },
+ {"__inline", SCSPEC, RID_INLINE },
+ {"__signed__", TYPESPEC, RID_SIGNED },
+ {"default", DEFAULT, NORID },
+ {"else", ELSE, NORID },
+ {"void", TYPESPEC, RID_VOID },
+ {"__signed", TYPESPEC, RID_SIGNED },
+ {"if", IF, NORID },
+ {"volatile", TYPE_QUAL, RID_VOLATILE },
+ {"struct", STRUCT, NORID },
+ {"extern", SCSPEC, RID_EXTERN },
+ {"__const", TYPE_QUAL, RID_CONST },
+ {"while", WHILE, NORID },
+ {"__const__", TYPE_QUAL, RID_CONST },
+ {"switch", SWITCH, NORID },
+ {"for", FOR, NORID },
+ {"inline", SCSPEC, RID_INLINE },
+ {"return", RETURN, NORID },
+ {"typeof", TYPEOF, NORID },
+ {"typedef", SCSPEC, RID_TYPEDEF },
+ {"char", TYPESPEC, RID_CHAR },
+ {"enum", ENUM, NORID },
+ {"register", SCSPEC, RID_REGISTER },
+ {"signed", TYPESPEC, RID_SIGNED },
+ {"sizeof", SIZEOF, NORID },
+ { "", }, { "", }, { "", }, { "", },
+ {"double", TYPESPEC, RID_DOUBLE },
+ {"static", SCSPEC, RID_STATIC },
+ {"case", CASE, NORID },
+ { "", }, { "", }, { "", }, { "", },
+ {"const", TYPE_QUAL, RID_CONST },
+ { "", }, { "", }, { "", },
+ {"long", TYPESPEC, RID_LONG },
+ { "", }, { "", },
+ {"continue", CONTINUE, NORID },
+ { "", }, { "", },
+ {"unsigned", TYPESPEC, RID_UNSIGNED },
+ { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", },
+ { "", }, { "", }, { "", }, { "", }, { "", },
+ {"union", UNION, NORID },
+ };
+
+ if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+ {
+ register int key = hash (str, len);
+
+ if (key <= MAX_HASH_VALUE)
+ {
+ register char *s = reswords[key].name;
+
+ if (*s == *str && !strcmp (str + 1, s + 1))
+ return &reswords[key];
+ }
+ }
+ return 0;
+}
+
+/* The elements of `ridpointers' are identifier nodes
+ for the reserved type names and storage classes.
+ It is indexed by a RID_... value. */
+
+tree ridpointers[(int) RID_MAX];
+
+int check_newline ();
+
+void
+init_lex ()
+{
+ /* Start it at 0, because check_newline is called at the very beginning
+ and will increment it to 1. */
+ lineno = 0;
+
+ maxtoken = 40;
+ token_buffer = (char *) xmalloc (maxtoken + 2);
+ max_wide = 40;
+ wide_buffer = (int *) xmalloc ((max_wide + 1) * UNITS_PER_WORD);
+
+ ridpointers[(int) RID_INT] = get_identifier ("int");
+ ridpointers[(int) RID_CHAR] = get_identifier ("char");
+ ridpointers[(int) RID_VOID] = get_identifier ("void");
+ ridpointers[(int) RID_FLOAT] = get_identifier ("float");
+ ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
+ ridpointers[(int) RID_SHORT] = get_identifier ("short");
+ ridpointers[(int) RID_LONG] = get_identifier ("long");
+ ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
+ ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
+ ridpointers[(int) RID_INLINE] = get_identifier ("inline");
+ ridpointers[(int) RID_CONST] = get_identifier ("const");
+ ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
+ ridpointers[(int) RID_AUTO] = get_identifier ("auto");
+ ridpointers[(int) RID_STATIC] = get_identifier ("static");
+ ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
+ ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
+ ridpointers[(int) RID_REGISTER] = get_identifier ("register");
+}
+
+static void
+reinit_parse_for_function ()
+{
+}
+
+/* If C is not whitespace, return C.
+ Otherwise skip whitespace and return first nonwhite char read. */
+
+static int
+skip_white_space (c)
+ register int c;
+{
+#if 0
+ register int inside;
+#endif
+
+ for (;;)
+ {
+ switch (c)
+ {
+ /* Don't recognize comments in cc1: all comments are removed by cpp,
+ and cpp output can include / and * consecutively as operators. */
+#if 0
+ case '/':
+ c = getc (finput);
+ if (c != '*')
+ {
+ ungetc (c, finput);
+ return '/';
+ }
+
+ c = getc (finput);
+
+ inside = 1;
+ while (inside)
+ {
+ if (c == '*')
+ {
+ while (c == '*')
+ c = getc (finput);
+
+ if (c == '/')
+ {
+ inside = 0;
+ c = getc (finput);
+ }
+ }
+ else if (c == '\n')
+ {
+ lineno++;
+ c = getc (finput);
+ }
+ else if (c == EOF)
+ {
+ error ("unterminated comment");
+ break;
+ }
+ else
+ c = getc (finput);
+ }
+
+ break;
+#endif
+
+ case '\n':
+ c = check_newline ();
+ break;
+
+ case ' ':
+ case '\t':
+ case '\f':
+ case '\r':
+ case '\v':
+ case '\b':
+ c = getc (finput);
+ break;
+
+ case '\\':
+ c = getc (finput);
+ if (c == '\n')
+ lineno++;
+ else
+ error ("stray '\\' in program");
+ c = getc (finput);
+ break;
+
+ default:
+ return (c);
+ }
+ }
+}
+
+
+
+/* Make the token buffer longer, preserving the data in it.
+ P should point to just beyond the last valid character in the old buffer.
+ The value we return is a pointer to the new buffer
+ at a place corresponding to P. */
+
+static char *
+extend_token_buffer (p)
+ char *p;
+{
+ int offset = p - token_buffer;
+
+ maxtoken = maxtoken * 2 + 10;
+ token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
+
+ return token_buffer + offset;
+}
+
+/* At the beginning of a line, increment the line number
+ and process any #-directive on this line.
+ If the line is a #-directive, read the entire line and return a newline.
+ Otherwise, return the line's first non-whitespace character. */
+
+int
+check_newline ()
+{
+ register int c;
+ register int token;
+
+ lineno++;
+
+ /* Read first nonwhite char on the line. */
+
+ c = getc (finput);
+ while (c == ' ' || c == '\t')
+ c = getc (finput);
+
+ if (c != '#')
+ {
+ /* If not #, return it so caller will use it. */
+ return c;
+ }
+
+ /* Read first nonwhite char after the `#'. */
+
+ c = getc (finput);
+ while (c == ' ' || c == '\t')
+ c = getc (finput);
+
+ /* If a letter follows, then if the word here is `line', skip
+ it and ignore it; otherwise, ignore the line, with an error
+ if the word isn't `pragma'. */
+
+ if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
+ {
+ if (c == 'p')
+ {
+ if (getc (finput) == 'r'
+ && getc (finput) == 'a'
+ && getc (finput) == 'g'
+ && getc (finput) == 'm'
+ && getc (finput) == 'a'
+ && ((c = getc (finput)) == ' ' || c == '\t' || c == '\n'))
+ goto skipline;
+ }
+
+ else if (c == 'l')
+ {
+ if (getc (finput) == 'i'
+ && getc (finput) == 'n'
+ && getc (finput) == 'e'
+ && ((c = getc (finput)) == ' ' || c == '\t'))
+ goto linenum;
+ }
+ else if (c == 'i')
+ {
+ if (getc (finput) == 'd'
+ && getc (finput) == 'e'
+ && getc (finput) == 'n'
+ && getc (finput) == 't'
+ && ((c = getc (finput)) == ' ' || c == '\t'))
+ {
+ extern FILE *asm_out_file;
+
+ if (pedantic)
+ error ("ANSI C does not allow #ident");
+
+ /* Here we have just seen `#ident '.
+ A string constant should follow. */
+
+ while (c == ' ' || c == '\t')
+ c = getc (finput);
+
+ /* If no argument, ignore the line. */
+ if (c == '\n')
+ return c;
+
+ ungetc (c, finput);
+ token = yylex ();
+ if (token != STRING
+ || TREE_CODE (yylval.ttype) != STRING_CST)
+ {
+ error ("invalid #ident");
+ goto skipline;
+ }
+
+#ifdef ASM_OUTPUT_IDENT
+ ASM_OUTPUT_IDENT (asm_out_file, TREE_STRING_POINTER (yylval.ttype));
+#endif
+
+ /* Skip the rest of this line. */
+ goto skipline;
+ }
+ }
+
+ error ("undefined or invalid # directive");
+ goto skipline;
+ }
+
+linenum:
+ /* Here we have either `#line' or `# <nonletter>'.
+ In either case, it should be a line number; a digit should follow. */
+
+ while (c == ' ' || c == '\t')
+ c = getc (finput);
+
+ /* If the # is the only nonwhite char on the line,
+ just ignore it. Check the new newline. */
+ if (c == '\n')
+ return c;
+
+ /* Something follows the #; read a token. */
+
+ ungetc (c, finput);
+ token = yylex ();
+
+ if (token == CONSTANT
+ && TREE_CODE (yylval.ttype) == INTEGER_CST)
+ {
+ int old_lineno = lineno;
+ /* subtract one, because it is the following line that
+ gets the specified number */
+
+ int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
+
+ /* Is this the last nonwhite stuff on the line? */
+ c = getc (finput);
+ while (c == ' ' || c == '\t')
+ c = getc (finput);
+ if (c == '\n')
+ {
+ /* No more: store the line number and check following line. */
+ lineno = l;
+ return c;
+ }
+ ungetc (c, finput);
+
+ /* More follows: it must be a string constant (filename). */
+
+ token = yylex ();
+ if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
+ {
+ error ("invalid #line");
+ goto skipline;
+ }
+
+ input_filename
+ = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
+ strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
+ lineno = l;
+
+ if (main_input_filename == 0)
+ main_input_filename = input_filename;
+
+ /* Is this the last nonwhite stuff on the line? */
+ c = getc (finput);
+ while (c == ' ' || c == '\t')
+ c = getc (finput);
+ if (c == '\n')
+ return c;
+ ungetc (c, finput);
+
+ token = yylex ();
+
+ /* `1' after file name means entering new file.
+ `2' after file name means just left a file. */
+
+ if (token == CONSTANT
+ && TREE_CODE (yylval.ttype) == INTEGER_CST)
+ {
+ if (TREE_INT_CST_LOW (yylval.ttype) == 1)
+ {
+ struct file_stack *p
+ = (struct file_stack *) xmalloc (sizeof (struct file_stack));
+ input_file_stack->line = old_lineno;
+ p->next = input_file_stack;
+ p->name = input_filename;
+ input_file_stack = p;
+ input_file_stack_tick++;
+ }
+ else if (input_file_stack->next)
+ {
+ struct file_stack *p = input_file_stack;
+ input_file_stack = p->next;
+ free (p);
+ input_file_stack_tick++;
+ }
+ else
+ error ("#-lines for entering and leaving files don't match");
+ }
+ }
+ else
+ error ("invalid #-line");
+
+ /* skip the rest of this line. */
+ skipline:
+ if (c == '\n')
+ return c;
+ while ((c = getc (finput)) != EOF && c != '\n');
+ return c;
+}
+
+#define isalnum(char) ((char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9'))
+#define isdigit(char) (char >= '0' && char <= '9')
+#define ENDFILE -1 /* token that represents end-of-file */
+
+
+static int
+readescape ()
+{
+ register int c = getc (finput);
+ register int count, code;
+ int firstdig;
+
+ switch (c)
+ {
+ case 'x':
+ code = 0;
+ count = 0;
+ while (1)
+ {
+ c = getc (finput);
+ if (!(c >= 'a' && c <= 'f')
+ && !(c >= 'A' && c <= 'F')
+ && !(c >= '0' && c <= '9'))
+ {
+ ungetc (c, finput);
+ break;
+ }
+ code *= 16;
+ if (c >= 'a' && c <= 'f')
+ code += c - 'a' + 10;
+ if (c >= 'A' && c <= 'F')
+ code += c - 'A' + 10;
+ if (c >= '0' && c <= '9')
+ code += c - '0';
+ if (count == 0)
+ firstdig = code;
+ count++;
+ }
+ if (count == 0)
+ error ("\\x used with no following hex digits");
+ else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
+ || (count > 1
+ && ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
+ <= firstdig)))
+ warning ("hex escape out of range");
+ return code;
+
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7':
+ code = 0;
+ count = 0;
+ while ((c <= '7') && (c >= '0') && (count++ < 3))
+ {
+ code = (code * 8) + (c - '0');
+ c = getc (finput);
+ }
+ ungetc (c, finput);
+ return code;
+
+ case '\\': case '\'': case '"':
+ return c;
+
+ case '\n':
+ lineno++;
+ return -1;
+
+ case 'n':
+ return TARGET_NEWLINE;
+
+ case 't':
+ return TARGET_TAB;
+
+ case 'r':
+ return TARGET_CR;
+
+ case 'f':
+ return TARGET_FF;
+
+ case 'b':
+ return TARGET_BS;
+
+ case 'a':
+ return TARGET_BELL;
+
+ case 'v':
+ return TARGET_VT;
+
+ case 'E':
+ return 033;
+
+ case '?':
+ /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
+ case '(':
+ case '{':
+ case '[':
+ return c;
+ }
+ if (c >= 040 && c <= 0177)
+ warning ("unknown escape sequence `\\%c'", c);
+ else
+ warning ("unknown escape sequence: `\\' followed by char code 0x%x", c);
+ return c;
+}
+
+void
+yyerror (string)
+ char *string;
+{
+ char buf[200];
+
+ strcpy (buf, string);
+
+ /* We can't print string and character constants well
+ because the token_buffer contains the result of processing escapes. */
+ if (end_of_file)
+ strcat (buf, " at end of input");
+ else if (token_buffer[0] == 0)
+ strcat (buf, " at null character");
+ else if (token_buffer[0] == '"')
+ strcat (buf, " before string constant");
+ else if (token_buffer[0] == '\'')
+ strcat (buf, " before character constant");
+ else if (token_buffer[0] < 040 || token_buffer[0] >= 0177)
+ sprintf (buf + strlen (buf), " before character 0%o", token_buffer[0]);
+ else
+ strcat (buf, " before `%s'");
+
+ error (buf, token_buffer);
+}
+
+static int nextchar = -1;
+
+static int
+yylex ()
+{
+ register int c;
+ register char *p;
+ register int value;
+ int wide_flag = 0;
+
+ if (nextchar >= 0)
+ c = nextchar, nextchar = -1;
+ else
+ c = getc (finput);
+
+ /* Effectively do c = skip_white_space (c)
+ but do it faster in the usual cases. */
+ while (1)
+ switch (c)
+ {
+ case ' ':
+ case '\t':
+ case '\f':
+ case '\r':
+ case '\v':
+ case '\b':
+ c = getc (finput);
+ break;
+
+ case '\n':
+ case '/':
+ case '\\':
+ c = skip_white_space (c);
+ default:
+ goto found_nonwhite;
+ }
+ found_nonwhite:
+
+ token_buffer[0] = c;
+ token_buffer[1] = 0;
+
+/* yylloc.first_line = lineno; */
+
+ switch (c)
+ {
+ case EOF:
+ end_of_file = 1;
+ token_buffer[0] = 0;
+ value = ENDFILE;
+ break;
+
+ case '$':
+ if (dollars_in_ident)
+ goto letter;
+ return '$';
+
+ case 'L':
+ /* Capital L may start a wide-string or wide-character constant. */
+ {
+ register int c = getc (finput);
+ if (c == '\'')
+ {
+ wide_flag = 1;
+ goto char_constant;
+ }
+ if (c == '"')
+ {
+ wide_flag = 1;
+ goto string_constant;
+ }
+ ungetc (c, finput);
+ }
+
+ case 'A': case 'B': case 'C': case 'D': case 'E':
+ case 'F': case 'G': case 'H': case 'I': case 'J':
+ case 'K': case 'M': case 'N': case 'O':
+ case 'P': case 'Q': case 'R': case 'S': case 'T':
+ case 'U': case 'V': case 'W': case 'X': case 'Y':
+ case 'Z':
+ case 'a': case 'b': case 'c': case 'd': case 'e':
+ case 'f': case 'g': case 'h': case 'i': case 'j':
+ case 'k': case 'l': case 'm': case 'n': case 'o':
+ case 'p': case 'q': case 'r': case 's': case 't':
+ case 'u': case 'v': case 'w': case 'x': case 'y':
+ case 'z':
+ case '_':
+ letter:
+ p = token_buffer;
+ while (isalnum (c) || c == '_' || c == '$')
+ {
+ if (p >= token_buffer + maxtoken)
+ p = extend_token_buffer (p);
+ if (c == '$' && ! dollars_in_ident)
+ break;
+
+ *p++ = c;
+ c = getc (finput);
+ }
+
+ *p = 0;
+ nextchar = c;
+
+ value = IDENTIFIER;
+ yylval.itype = 0;
+
+ /* Try to recognize a keyword. Uses minimum-perfect hash function */
+
+ {
+ register struct resword *ptr;
+
+ if (ptr = is_reserved_word (token_buffer, p - token_buffer))
+ {
+ if (ptr->rid)
+ yylval.ttype = ridpointers[(int) ptr->rid];
+ if ((! flag_no_asm
+ /* -fno-asm means don't recognize the non-ANSI keywords. */
+ || ((int) ptr->token != ASM
+ && (int) ptr->token != TYPEOF
+ && ptr->rid != RID_INLINE)
+ /* Recognize __asm and __inline despite -fno-asm. */
+ || token_buffer[0] == '_')
+ /* -ftraditional means don't recognize nontraditional keywords
+ typeof, const, volatile, signed or inline. */
+ && (! flag_traditional
+ || ((int) ptr->token != TYPE_QUAL
+ && (int) ptr->token != TYPEOF
+ && ptr->rid != RID_SIGNED
+ && ptr->rid != RID_INLINE)
+ /* Recognize __inline, etc. despite -ftraditional. */
+ || token_buffer[0] == '_'))
+ value = (int) ptr->token;
+ }
+ }
+
+ /* If we did not find a keyword, look for an identifier
+ (or a typename). */
+
+ if (value == IDENTIFIER)
+ {
+ yylval.ttype = get_identifier (token_buffer);
+ lastiddecl = lookup_name (yylval.ttype);
+
+ if (lastiddecl != 0 && TREE_CODE (lastiddecl) == TYPE_DECL)
+ value = TYPENAME;
+ }
+
+ break;
+
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ case '.':
+ {
+ int base = 10;
+ int count = 0;
+ int largest_digit = 0;
+ int numdigits = 0;
+ /* for multi-precision arithmetic,
+ we store only 8 live bits in each short,
+ giving us 64 bits of reliable precision */
+ short shorts[8];
+ int overflow = 0;
+
+ enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
+ = NOT_FLOAT;
+
+ for (count = 0; count < 8; count++)
+ shorts[count] = 0;
+
+ p = token_buffer;
+ *p++ = c;
+
+ if (c == '0')
+ {
+ *p++ = (c = getc (finput));
+ if ((c == 'x') || (c == 'X'))
+ {
+ base = 16;
+ *p++ = (c = getc (finput));
+ }
+ else
+ {
+ base = 8;
+ numdigits++;
+ }
+ }
+
+ /* Read all the digits-and-decimal-points. */
+
+ while (c == '.'
+ || (isalnum (c) && (c != 'l') && (c != 'L')
+ && (c != 'u') && (c != 'U')
+ && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
+ {
+ if (c == '.')
+ {
+ if (base == 16)
+ error ("floating constant may not be in radix 16");
+ if (floatflag == AFTER_POINT)
+ {
+ error ("malformed floating constant");
+ floatflag = TOO_MANY_POINTS;
+ }
+ else
+ floatflag = AFTER_POINT;
+
+ base = 10;
+ *p++ = c = getc (finput);
+ /* Accept '.' as the start of a floating-point number
+ only when it is followed by a digit.
+ Otherwise, unread the following non-digit
+ and use the '.' as a structural token. */
+ if (p == token_buffer + 2 && !isdigit (c))
+ {
+ if (c == '.')
+ {
+ c = getc (finput);
+ if (c == '.')
+ {
+ *p++ = c;
+ *p = 0;
+ return ELLIPSIS;
+ }
+ error ("parse error at `..'");
+ }
+ ungetc (c, finput);
+ token_buffer[1] = 0;
+ value = '.';
+ goto done;
+ }
+ }
+ else
+ {
+ /* It is not a decimal point.
+ It should be a digit (perhaps a hex digit). */
+
+ if (isdigit (c))
+ {
+ c = c - '0';
+ }
+ else if (base <= 10)
+ {
+ if ((c&~040) == 'E')
+ {
+ base = 10;
+ floatflag = AFTER_POINT;
+ break; /* start of exponent */
+ }
+ error ("nondigits in number and not hexadecimal");
+ c = 0;
+ }
+ else if (c >= 'a')
+ {
+ c = c - 'a' + 10;
+ }
+ else
+ {
+ c = c - 'A' + 10;
+ }
+ if (c >= largest_digit)
+ largest_digit = c;
+ numdigits++;
+
+ for (count = 0; count < 8; count++)
+ {
+ shorts[count] *= base;
+ if (count)
+ {
+ shorts[count] += (shorts[count-1] >> 8);
+ shorts[count-1] &= (1<<8)-1;
+ }
+ else shorts[0] += c;
+ }
+
+ if (shorts[7] >= 1<<8
+ || shorts[7] < - (1 << 8))
+ overflow = TRUE;
+
+ if (p >= token_buffer + maxtoken - 3)
+ p = extend_token_buffer (p);
+ *p++ = (c = getc (finput));
+ }
+ }
+
+ if (numdigits == 0)
+ error ("numeric constant with no digits");
+
+ if (largest_digit >= base)
+ error ("numeric constant contains digits beyond the radix");
+
+ /* Remove terminating char from the token buffer and delimit the string */
+ *--p = 0;
+
+ if (floatflag != NOT_FLOAT)
+ {
+ tree type = double_type_node;
+ char f_seen = 0;
+ char l_seen = 0;
+ REAL_VALUE_TYPE value;
+
+ /* Read explicit exponent if any, and put it in tokenbuf. */
+
+ if ((c == 'e') || (c == 'E'))
+ {
+ if (p >= token_buffer + maxtoken - 3)
+ p = extend_token_buffer (p);
+ *p++ = c;
+ c = getc (finput);
+ if ((c == '+') || (c == '-'))
+ {
+ *p++ = c;
+ c = getc (finput);
+ }
+ if (! isdigit (c))
+ error ("floating constant exponent has no digits");
+ while (isdigit (c))
+ {
+ if (p >= token_buffer + maxtoken - 3)
+ p = extend_token_buffer (p);
+ *p++ = c;
+ c = getc (finput);
+ }
+ }
+
+ *p = 0;
+ errno = 0;
+ value = REAL_VALUE_ATOF (token_buffer);
+#ifdef ERANGE
+ if (errno == ERANGE && !flag_traditional)
+ {
+ char *p1 = token_buffer;
+ /* Check for "0.0" and variants;
+ Sunos 4 spuriously returns ERANGE for them. */
+ while (*p1 == '0') p1++;
+ if (*p1 == '.')
+ {
+ p1++;
+ while (*p1 == '0') p1++;
+ }
+ if (*p1 == 'e' || *p1 == 'E')
+ {
+ /* with significand==0, ignore the exponent */
+ p1++;
+ while (*p1 != 0) p1++;
+ }
+ /* ERANGE is also reported for underflow,
+ so test the value to distinguish overflow from that. */
+ if (*p1 != 0 && (value > 1.0 || value < -1.0))
+ warning ("floating point number exceeds range of `double'");
+ }
+#endif
+
+ /* Read the suffixes to choose a data type. */
+ while (1)
+ {
+ if (c == 'f' || c == 'F')
+ {
+ float floater;
+ if (f_seen)
+ error ("two `f's in floating constant");
+ f_seen = 1;
+ type = float_type_node;
+ floater = value;
+ value = floater;
+ }
+ else if (c == 'l' || c == 'L')
+ {
+ if (l_seen)
+ error ("two `l's in floating constant");
+ l_seen = 1;
+ type = long_double_type_node;
+ }
+ else
+ {
+ if (isalnum (c))
+ {
+ error ("garbage at end of number");
+ while (isalnum (c))
+ {
+ if (p >= token_buffer + maxtoken - 3)
+ p = extend_token_buffer (p);
+ *p++ = c;
+ c = getc (finput);
+ }
+ }
+ break;
+ }
+ if (p >= token_buffer + maxtoken - 3)
+ p = extend_token_buffer (p);
+ *p++ = c;
+ c = getc (finput);
+ }
+
+ /* Create a node with determined type and value. */
+ yylval.ttype = build_real (type, value);
+
+ ungetc (c, finput);
+ *p = 0;
+ }
+ else
+ {
+ tree type;
+ int spec_unsigned = 0;
+ int spec_long = 0;
+ int spec_long_long = 0;
+
+ while (1)
+ {
+ if (c == 'u' || c == 'U')
+ {
+ if (spec_unsigned)
+ error ("two `u's in integer constant");
+ spec_unsigned = 1;
+ }
+ else if (c == 'l' || c == 'L')
+ {
+ if (spec_long)
+ {
+ if (spec_long_long)
+ error ("three `l's in integer constant");
+ else if (pedantic)
+ warning ("ANSI C forbids long long integer constants");
+ spec_long_long = 1;
+ }
+ spec_long = 1;
+ }
+ else
+ {
+ if (isalnum (c))
+ {
+ error ("garbage at end of number");
+ while (isalnum (c))
+ {
+ if (p >= token_buffer + maxtoken - 3)
+ p = extend_token_buffer (p);
+ *p++ = c;
+ c = getc (finput);
+ }
+ }
+ break;
+ }
+ if (p >= token_buffer + maxtoken - 3)
+ p = extend_token_buffer (p);
+ *p++ = c;
+ c = getc (finput);
+ }
+
+ ungetc (c, finput);
+
+ if ((overflow || shorts[7] || shorts[6] || shorts[5] || shorts[4])
+ && !spec_long_long)
+ warning ("integer constant out of range");
+
+ /* If it won't fit in a signed long long, make it unsigned.
+ We can't distinguish based on the tree node because
+ any integer constant fits any long long type. */
+ if (shorts[7] >= (1<<8))
+ spec_unsigned = 1;
+
+ /* This is simplified by the fact that our constant
+ is always positive. */
+ yylval.ttype
+ = (build_int_2
+ ((shorts[3]<<24) + (shorts[2]<<16) + (shorts[1]<<8) + shorts[0],
+ (spec_long_long
+ ? (shorts[7]<<24) + (shorts[6]<<16) + (shorts[5]<<8) + shorts[4]
+ : 0)));
+
+ if (!spec_long && !spec_unsigned
+ && int_fits_type_p (yylval.ttype, integer_type_node))
+ type = integer_type_node;
+
+ else if (!spec_long && (base != 10 || spec_unsigned)
+ && int_fits_type_p (yylval.ttype, unsigned_type_node))
+ type = unsigned_type_node;
+
+ else if (!spec_unsigned && !spec_long_long
+ && int_fits_type_p (yylval.ttype, long_integer_type_node))
+ type = long_integer_type_node;
+
+ else if (! spec_long_long
+ && int_fits_type_p (yylval.ttype,
+ long_unsigned_type_node))
+ type = long_unsigned_type_node;
+
+ else if (! spec_unsigned
+ && int_fits_type_p (yylval.ttype,
+ long_long_integer_type_node))
+ type = long_long_integer_type_node;
+
+ else if (int_fits_type_p (yylval.ttype,
+ long_long_unsigned_type_node))
+ type = long_long_unsigned_type_node;
+
+ else
+ {
+ type = long_long_integer_type_node;
+ warning ("integer constant out of range");
+ }
+
+ TREE_TYPE (yylval.ttype) = type;
+ *p = 0;
+ }
+
+ value = CONSTANT; break;
+ }
+
+ case '\'':
+ char_constant:
+ {
+ register int result = 0;
+ register num_chars = 0;
+ int width = TYPE_PRECISION (char_type_node);
+ int max_chars;
+
+ if (wide_flag) width = TYPE_PRECISION (integer_type_node);
+
+ max_chars = TYPE_PRECISION (integer_type_node) / width;
+
+ while (1)
+ {
+ tryagain:
+
+ c = getc (finput);
+
+ if (c == '\'' || c == EOF)
+ break;
+
+ if (c == '\\')
+ {
+ c = readescape ();
+ if (c < 0)
+ goto tryagain;
+ if (width < HOST_BITS_PER_INT
+ && (unsigned) c >= (1 << width))
+ warning ("escape sequence out of range for character");
+ }
+ else if (c == '\n')
+ {
+ if (pedantic)
+ warning ("ANSI C forbids newline in character constant");
+ lineno++;
+ }
+
+ num_chars++;
+ if (num_chars > maxtoken - 4)
+ extend_token_buffer (token_buffer);
+
+ token_buffer[num_chars] = c;
+
+ /* Merge character into result; ignore excess chars. */
+ if (num_chars < max_chars + 1)
+ {
+ if (width < HOST_BITS_PER_INT)
+ result = (result << width) | (c & ((1 << width) - 1));
+ else
+ result = c;
+ }
+ }
+
+ token_buffer[num_chars + 1] = '\'';
+ token_buffer[num_chars + 2] = 0;
+
+ if (c != '\'')
+ error ("malformatted character constant");
+ else if (num_chars == 0)
+ error ("empty character constant");
+ else if (num_chars > max_chars)
+ {
+ num_chars = max_chars;
+ error ("character constant too long");
+ }
+ else if (num_chars != 1 && ! flag_traditional)
+ warning ("multi-character character constant");
+
+ /* If char type is signed, sign-extend the constant. */
+ if (! wide_flag)
+ {
+ int num_bits = num_chars * width;
+ if (TREE_UNSIGNED (char_type_node)
+ || ((result >> (num_bits - 1)) & 1) == 0)
+ yylval.ttype
+ = build_int_2 (result & ((unsigned) ~0
+ >> (HOST_BITS_PER_INT - num_bits)),
+ 0);
+ else
+ yylval.ttype
+ = build_int_2 (result | ~((unsigned) ~0
+ >> (HOST_BITS_PER_INT - num_bits)),
+ -1);
+ }
+ else
+ yylval.ttype = build_int_2 (result, 0);
+
+ TREE_TYPE (yylval.ttype) = integer_type_node;
+ value = CONSTANT; break;
+ }
+
+ case '"':
+ string_constant:
+ {
+ int *widep;
+
+ c = getc (finput);
+ p = token_buffer + 1;
+
+ if (wide_flag)
+ widep = wide_buffer;
+
+ while (c != '"' && c >= 0)
+ {
+ if (c == '\\')
+ {
+ c = readescape ();
+ if (c < 0)
+ goto skipnewline;
+ if (!wide_flag && c >= (1 << TYPE_PRECISION (char_type_node)))
+ warning ("escape sequence out of range for character");
+ }
+ else if (c == '\n')
+ {
+ if (pedantic)
+ warning ("ANSI C forbids newline in string constant");
+ lineno++;
+ }
+
+ /* Store the char in C into the appropriate buffer. */
+
+ if (wide_flag)
+ {
+ if (widep == wide_buffer + max_wide)
+ {
+ int n = widep - wide_buffer;
+ max_wide *= 2;
+ wide_buffer
+ = (int *) xrealloc (wide_buffer,
+ (max_wide + 1) * UNITS_PER_WORD);
+ widep = wide_buffer + n;
+ }
+ *widep++ = c;
+ }
+ else
+ {
+ if (p == token_buffer + maxtoken)
+ p = extend_token_buffer (p);
+ *p++ = c;
+ }
+
+ skipnewline:
+ c = getc (finput);
+ }
+
+ /* We have read the entire constant.
+ Construct a STRING_CST for the result. */
+
+ if (wide_flag)
+ {
+ /* If this is a L"..." wide-string, make a vector
+ of the ints in wide_buffer. */
+ *widep = 0;
+ /* We have not implemented the case where `int'
+ on the target and on the execution machine differ in size. */
+ if (TYPE_PRECISION (integer_type_node)
+ != sizeof (int) * BITS_PER_UNIT)
+ abort ();
+ yylval.ttype
+ = build_string ((widep - wide_buffer + 1) * sizeof (int),
+ wide_buffer);
+ TREE_TYPE (yylval.ttype) = int_array_type_node;
+ }
+ else
+ {
+ *p = 0;
+ yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
+ TREE_TYPE (yylval.ttype) = char_array_type_node;
+ }
+
+ *p++ = '"';
+ *p = 0;
+
+ value = STRING; break;
+ }
+
+ case '+':
+ case '-':
+ case '&':
+ case '|':
+ case '<':
+ case '>':
+ case '*':
+ case '/':
+ case '%':
+ case '^':
+ case '!':
+ case '=':
+ {
+ register int c1;
+
+ combine:
+
+ switch (c)
+ {
+ case '+':
+ yylval.code = PLUS_EXPR; break;
+ case '-':
+ yylval.code = MINUS_EXPR; break;
+ case '&':
+ yylval.code = BIT_AND_EXPR; break;
+ case '|':
+ yylval.code = BIT_IOR_EXPR; break;
+ case '*':
+ yylval.code = MULT_EXPR; break;
+ case '/':
+ yylval.code = TRUNC_DIV_EXPR; break;
+ case '%':
+ yylval.code = TRUNC_MOD_EXPR; break;
+ case '^':
+ yylval.code = BIT_XOR_EXPR; break;
+ case LSHIFT:
+ yylval.code = LSHIFT_EXPR; break;
+ case RSHIFT:
+ yylval.code = RSHIFT_EXPR; break;
+ case '<':
+ yylval.code = LT_EXPR; break;
+ case '>':
+ yylval.code = GT_EXPR; break;
+ }
+
+ token_buffer[1] = c1 = getc (finput);
+ token_buffer[2] = 0;
+
+ if (c1 == '=')
+ {
+ switch (c)
+ {
+ case '<':
+ value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
+ case '>':
+ value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
+ case '!':
+ value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
+ case '=':
+ value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
+ }
+ value = ASSIGN; goto done;
+ }
+ else if (c == c1)
+ switch (c)
+ {
+ case '+':
+ value = PLUSPLUS; goto done;
+ case '-':
+ value = MINUSMINUS; goto done;
+ case '&':
+ value = ANDAND; goto done;
+ case '|':
+ value = OROR; goto done;
+ case '<':
+ c = LSHIFT;
+ goto combine;
+ case '>':
+ c = RSHIFT;
+ goto combine;
+ }
+ else if ((c == '-') && (c1 == '>'))
+ { value = POINTSAT; goto done; }
+ ungetc (c1, finput);
+ token_buffer[1] = 0;
+
+ if ((c == '<') || (c == '>'))
+ value = ARITHCOMPARE;
+ else value = c;
+ goto done;
+ }
+
+ case 0:
+ /* Don't make yyparse think this is eof. */
+ value = 1;
+ break;
+
+ default:
+ value = c;
+ }
+
+done:
+/* yylloc.last_line = lineno; */
+
+ return value;
+}
generated by cgit v1.2.3 (git 2.46.0) at 2026-06-03 22:48:29 +0000