Annotation of OpenXM_contrib2/asir2000/parse/ytab.c, Revision 1.5
1.5 ! noro 1: /* A Bison parser, made from parse.y
! 2: by GNU bison 1.35. */
! 3:
! 4: #define YYBISON 1 /* Identify Bison output. */
! 5:
! 6: # define STRUCT 257
! 7: # define POINT 258
! 8: # define NEWSTRUCT 259
! 9: # define ANS 260
! 10: # define FDEF 261
! 11: # define PFDEF 262
! 12: # define MODDEF 263
! 13: # define MODEND 264
! 14: # define GLOBAL 265
! 15: # define MGLOBAL 266
! 16: # define LOCAL 267
! 17: # define LOCALF 268
! 18: # define CMP 269
! 19: # define OR 270
! 20: # define AND 271
! 21: # define CAR 272
! 22: # define CDR 273
! 23: # define QUOTED 274
! 24: # define COLONCOLON 275
! 25: # define DO 276
! 26: # define WHILE 277
! 27: # define FOR 278
! 28: # define IF 279
! 29: # define ELSE 280
! 30: # define BREAK 281
! 31: # define RETURN 282
! 32: # define CONTINUE 283
! 33: # define PARIF 284
! 34: # define MAP 285
! 35: # define RECMAP 286
! 36: # define TIMER 287
! 37: # define GF2NGEN 288
! 38: # define GFPNGEN 289
! 39: # define GFSNGEN 290
! 40: # define GETOPT 291
! 41: # define FOP_AND 292
! 42: # define FOP_OR 293
! 43: # define FOP_IMPL 294
! 44: # define FOP_REPL 295
! 45: # define FOP_EQUIV 296
! 46: # define FOP_NOT 297
! 47: # define LOP 298
! 48: # define FORMULA 299
! 49: # define UCASE 300
! 50: # define LCASE 301
! 51: # define STR 302
! 52: # define SELF 303
! 53: # define BOPASS 304
! 54: # define PLUS 305
! 55: # define MINUS 306
! 56:
! 57: #line 50 "parse.y"
! 58:
1.1 noro 59: #define malloc(x) GC_malloc(x)
60: #define realloc(x,y) GC_realloc(x,y)
61: #define free(x) GC_free(x)
62:
63: #if defined(TOWNS)
64: #include <alloca.h>
65: #endif
66: #include <ctype.h>
67: #include "ca.h"
68: #include <sys/types.h>
69: #include <sys/stat.h>
70: #include "parse.h"
71:
72: #define NOPR (prresult=0)
73:
1.4 noro 74: extern int gdef,mgdef,ldef;
1.1 noro 75: extern SNODE parse_snode;
1.4 noro 76: extern int main_parser, allow_create_var;
1.1 noro 77:
78: int prresult;
79:
80: static int ind;
81: static FNODE t;
82: static NODE a,b;
83: static NODE2 a2;
84: static pointer val;
1.2 noro 85: static QUOTE quote;
1.1 noro 86: extern jmp_buf env;
1.5 ! noro 87:
1.2 noro 88: #line 83 "parse.y"
1.5 ! noro 89: #ifndef YYSTYPE
1.1 noro 90: typedef union {
91: FNODE f;
92: SNODE s;
93: NODE n;
94: NODE2 n2;
95: int i;
96: pointer p;
1.5 ! noro 97: } yystype;
! 98: # define YYSTYPE yystype
! 99: # define YYSTYPE_IS_TRIVIAL 1
! 100: #endif
! 101: #ifndef YYDEBUG
! 102: # define YYDEBUG 0
! 103: #endif
! 104:
! 105:
! 106:
! 107: #define YYFINAL 274
! 108: #define YYFLAG -32768
! 109: #define YYNTBASE 77
! 110:
! 111: /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
! 112: #define YYTRANSLATE(x) ((unsigned)(x) <= 306 ? yytranslate[x] : 102)
! 113:
! 114: /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
! 115: static const char yytranslate[] =
! 116: {
! 117: 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 118: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 119: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 120: 2, 2, 2, 64, 2, 2, 70, 56, 61, 2,
! 121: 67, 68, 53, 51, 71, 52, 2, 54, 2, 2,
! 122: 2, 2, 2, 2, 2, 2, 2, 2, 59, 69,
! 123: 75, 57, 76, 58, 2, 2, 2, 2, 2, 2,
! 124: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 125: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 126: 2, 73, 2, 74, 55, 2, 60, 2, 2, 2,
! 127: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 128: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 129: 2, 2, 2, 65, 72, 66, 2, 2, 2, 2,
! 130: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 131: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 132: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 133: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 134: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 135: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 136: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 137: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 138: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 139: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 140: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 141: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
! 142: 2, 2, 2, 2, 2, 2, 1, 3, 4, 5,
! 143: 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
! 144: 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
! 145: 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
! 146: 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
! 147: 46, 47, 48, 49, 50, 62, 63
! 148: };
! 149:
! 150: #if YYDEBUG
! 151: static const short yyprhs[] =
! 152: {
! 153: 0, 0, 2, 4, 5, 6, 12, 13, 14, 20,
! 154: 21, 22, 28, 32, 39, 42, 44, 47, 50, 53,
! 155: 57, 63, 71, 81, 87, 95, 104, 111, 112, 113,
! 156: 114, 127, 131, 134, 137, 139, 141, 142, 144, 148,
! 157: 150, 154, 156, 160, 162, 166, 167, 170, 171, 173,
! 158: 175, 179, 181, 185, 187, 189, 193, 195, 197, 199,
! 159: 201, 203, 205, 207, 212, 219, 226, 233, 241, 246,
! 160: 250, 259, 264, 271, 279, 284, 289, 293, 295, 300,
! 161: 304, 306, 312, 316, 320, 323, 326, 330, 333, 336,
! 162: 340, 344, 348, 352, 356, 360, 364, 367, 371, 375,
! 163: 378, 382, 386, 390, 394, 398, 402, 408, 412, 417,
! 164: 422
! 165: };
! 166: static const short yyrhs[] =
! 167: {
! 168: 78, 0, 88, 0, 0, 0, 11, 79, 93, 80,
! 169: 88, 0, 0, 0, 12, 81, 93, 82, 88, 0,
! 170: 0, 0, 13, 83, 93, 84, 88, 0, 14, 92,
! 171: 88, 0, 3, 98, 65, 91, 66, 88, 0, 101,
! 172: 88, 0, 90, 0, 27, 88, 0, 29, 88, 0,
! 173: 28, 88, 0, 28, 101, 88, 0, 25, 67, 95,
! 174: 68, 78, 0, 25, 67, 95, 68, 78, 26, 78,
! 175: 0, 24, 67, 95, 69, 95, 69, 95, 68, 78,
! 176: 0, 23, 67, 95, 68, 78, 0, 22, 78, 23,
! 177: 67, 95, 68, 88, 0, 47, 67, 95, 68, 59,
! 178: 57, 101, 88, 0, 8, 47, 67, 95, 68, 88,
! 179: 0, 0, 0, 0, 7, 47, 85, 67, 86, 95,
! 180: 87, 68, 89, 65, 94, 66, 0, 9, 47, 88,
! 181: 0, 10, 88, 0, 1, 88, 0, 69, 0, 70,
! 182: 0, 0, 48, 0, 65, 94, 66, 0, 98, 0,
! 183: 91, 71, 98, 0, 47, 0, 92, 71, 47, 0,
! 184: 46, 0, 93, 71, 46, 0, 0, 94, 78, 0,
! 185: 0, 96, 0, 101, 0, 96, 71, 101, 0, 99,
! 186: 0, 97, 71, 99, 0, 46, 0, 47, 0, 98,
! 187: 57, 101, 0, 48, 0, 45, 0, 6, 0, 34,
! 188: 0, 35, 0, 36, 0, 47, 0, 47, 67, 95,
! 189: 68, 0, 47, 67, 95, 72, 97, 68, 0, 31,
! 190: 67, 47, 71, 95, 68, 0, 32, 67, 47, 71,
! 191: 95, 68, 0, 47, 65, 95, 66, 67, 95, 68,
! 192: 0, 37, 67, 98, 68, 0, 37, 67, 68, 0,
! 193: 33, 67, 101, 71, 101, 71, 101, 68, 0, 30,
! 194: 67, 47, 68, 0, 30, 67, 47, 71, 95, 68,
! 195: 0, 67, 53, 101, 68, 67, 95, 68, 0, 18,
! 196: 67, 101, 68, 0, 19, 67, 101, 68, 0, 67,
! 197: 101, 68, 0, 46, 0, 100, 73, 101, 74, 0,
! 198: 100, 4, 98, 0, 100, 0, 67, 3, 98, 68,
! 199: 100, 0, 101, 57, 101, 0, 101, 50, 101, 0,
! 200: 101, 49, 0, 49, 101, 0, 73, 95, 74, 0,
! 201: 51, 101, 0, 52, 101, 0, 101, 51, 101, 0,
! 202: 101, 52, 101, 0, 101, 53, 101, 0, 101, 54,
! 203: 101, 0, 101, 56, 101, 0, 101, 55, 101, 0,
! 204: 101, 15, 101, 0, 64, 101, 0, 101, 16, 101,
! 205: 0, 101, 17, 101, 0, 43, 101, 0, 101, 38,
! 206: 101, 0, 101, 39, 101, 0, 101, 40, 101, 0,
! 207: 101, 41, 101, 0, 101, 42, 101, 0, 101, 44,
! 208: 101, 0, 101, 58, 101, 59, 101, 0, 75, 95,
! 209: 76, 0, 5, 67, 98, 68, 0, 20, 67, 101,
! 210: 68, 0, 60, 101, 0
1.1 noro 211: };
1.5 ! noro 212:
! 213: #endif
! 214:
! 215: #if YYDEBUG
! 216: /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
! 217: static const short yyrline[] =
! 218: {
! 219: 0, 130, 139, 141, 141, 141, 143, 143, 143, 145,
! 220: 145, 145, 147, 149, 151, 153, 155, 157, 159, 161,
! 221: 163, 165, 167, 169, 171, 173, 175, 177, 177, 177,
! 222: 177, 183, 185, 187, 190, 192, 195, 197, 200, 203,
! 223: 205, 208, 210, 213, 215, 218, 220, 223, 225, 228,
! 224: 230, 233, 235, 238, 240, 243, 246, 248, 250, 252,
! 225: 254, 256, 258, 285, 292, 299, 305, 311, 316, 320,
! 226: 324, 328, 335, 342, 346, 348, 350, 352, 365, 375,
! 227: 378, 380, 382, 384, 386, 388, 390, 392, 394, 396,
! 228: 398, 400, 402, 404, 406, 408, 410, 412, 414, 416,
! 229: 418, 420, 422, 424, 426, 428, 430, 432, 434, 436,
! 230: 438
1.1 noro 231: };
1.5 ! noro 232: #endif
! 233:
! 234:
! 235: #if (YYDEBUG) || defined YYERROR_VERBOSE
! 236:
! 237: /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
! 238: static const char *const yytname[] =
! 239: {
! 240: "$", "error", "$undefined.", "STRUCT", "POINT", "NEWSTRUCT", "ANS",
! 241: "FDEF", "PFDEF", "MODDEF", "MODEND", "GLOBAL", "MGLOBAL", "LOCAL",
! 242: "LOCALF", "CMP", "OR", "AND", "CAR", "CDR", "QUOTED", "COLONCOLON",
! 243: "DO", "WHILE", "FOR", "IF", "ELSE", "BREAK", "RETURN", "CONTINUE",
! 244: "PARIF", "MAP", "RECMAP", "TIMER", "GF2NGEN", "GFPNGEN", "GFSNGEN",
! 245: "GETOPT", "FOP_AND", "FOP_OR", "FOP_IMPL", "FOP_REPL", "FOP_EQUIV",
! 246: "FOP_NOT", "LOP", "FORMULA", "UCASE", "LCASE", "STR", "SELF", "BOPASS",
! 247: "'+'", "'-'", "'*'", "'/'", "'^'", "'%'", "'='", "'?'", "':'", "'`'",
! 248: "'&'", "PLUS", "MINUS", "'!'", "'{'", "'}'", "'('", "')'", "';'", "'$'",
! 249: "','", "'|'", "'['", "']'", "'<'", "'>'", "start", "stat", "@1", "@2",
! 250: "@3", "@4", "@5", "@6", "@7", "@8", "@9", "tail", "desc", "complex",
! 251: "members", "vars", "pvars", "stats", "node", "_node", "optlist",
! 252: "rawstr", "opt", "pexpr", "expr", 0
1.1 noro 253: };
1.5 ! noro 254: #endif
! 255:
! 256: /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
! 257: static const short yyr1[] =
! 258: {
! 259: 0, 77, 78, 79, 80, 78, 81, 82, 78, 83,
! 260: 84, 78, 78, 78, 78, 78, 78, 78, 78, 78,
! 261: 78, 78, 78, 78, 78, 78, 78, 85, 86, 87,
! 262: 78, 78, 78, 78, 88, 88, 89, 89, 90, 91,
! 263: 91, 92, 92, 93, 93, 94, 94, 95, 95, 96,
! 264: 96, 97, 97, 98, 98, 99, 100, 100, 100, 100,
! 265: 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
! 266: 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
! 267: 101, 101, 101, 101, 101, 101, 101, 101, 101, 101,
! 268: 101, 101, 101, 101, 101, 101, 101, 101, 101, 101,
! 269: 101, 101, 101, 101, 101, 101, 101, 101, 101, 101,
! 270: 101
1.1 noro 271: };
1.5 ! noro 272:
! 273: /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
! 274: static const short yyr2[] =
! 275: {
! 276: 0, 1, 1, 0, 0, 5, 0, 0, 5, 0,
! 277: 0, 5, 3, 6, 2, 1, 2, 2, 2, 3,
! 278: 5, 7, 9, 5, 7, 8, 6, 0, 0, 0,
! 279: 12, 3, 2, 2, 1, 1, 0, 1, 3, 1,
! 280: 3, 1, 3, 1, 3, 0, 2, 0, 1, 1,
! 281: 3, 1, 3, 1, 1, 3, 1, 1, 1, 1,
! 282: 1, 1, 1, 4, 6, 6, 6, 7, 4, 3,
! 283: 8, 4, 6, 7, 4, 4, 3, 1, 4, 3,
! 284: 1, 5, 3, 3, 2, 2, 3, 2, 2, 3,
! 285: 3, 3, 3, 3, 3, 3, 2, 3, 3, 2,
! 286: 3, 3, 3, 3, 3, 3, 5, 3, 4, 4,
! 287: 2
1.1 noro 288: };
1.5 ! noro 289:
! 290: /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
! 291: doesn't specify something else to do. Zero means the default is an
! 292: error. */
! 293: static const short yydefact[] =
! 294: {
! 295: 0, 0, 0, 0, 58, 0, 0, 0, 0, 3,
! 296: 6, 9, 0, 0, 0, 0, 0, 0, 0, 0,
! 297: 0, 0, 0, 0, 0, 0, 0, 59, 60, 61,
! 298: 0, 0, 57, 77, 62, 56, 0, 0, 0, 0,
! 299: 0, 45, 0, 34, 35, 47, 47, 1, 2, 15,
! 300: 80, 0, 33, 53, 54, 0, 0, 27, 0, 0,
! 301: 32, 0, 0, 0, 41, 0, 0, 0, 0, 0,
! 302: 47, 47, 47, 16, 62, 18, 0, 17, 0, 0,
! 303: 0, 0, 0, 99, 47, 47, 85, 87, 88, 110,
! 304: 96, 0, 0, 0, 0, 0, 48, 49, 0, 0,
! 305: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 306: 84, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 307: 14, 0, 0, 0, 47, 31, 43, 4, 7, 10,
! 308: 0, 12, 0, 0, 0, 0, 0, 0, 0, 47,
! 309: 19, 0, 0, 0, 0, 69, 0, 0, 0, 38,
! 310: 46, 0, 0, 76, 86, 0, 107, 79, 0, 95,
! 311: 97, 98, 100, 101, 102, 103, 104, 105, 83, 89,
! 312: 90, 91, 92, 94, 93, 82, 0, 0, 39, 108,
! 313: 28, 0, 0, 0, 0, 0, 42, 74, 75, 109,
! 314: 47, 0, 47, 0, 0, 71, 47, 47, 47, 0,
! 315: 68, 0, 63, 0, 0, 0, 50, 78, 0, 0,
! 316: 0, 47, 0, 44, 5, 8, 11, 0, 23, 0,
! 317: 20, 63, 0, 0, 0, 0, 47, 0, 0, 0,
! 318: 51, 0, 81, 47, 106, 13, 40, 29, 26, 0,
! 319: 47, 0, 72, 65, 66, 0, 0, 0, 64, 0,
! 320: 0, 0, 0, 24, 0, 21, 0, 67, 0, 52,
! 321: 55, 73, 36, 0, 70, 25, 37, 0, 22, 45,
! 322: 0, 30, 0, 0, 0
1.1 noro 323: };
1.5 ! noro 324:
! 325: static const short yydefgoto[] =
! 326: {
! 327: 272, 150, 61, 183, 62, 184, 63, 185, 123, 211,
! 328: 252, 48, 267, 49, 177, 65, 127, 91, 95, 96,
! 329: 228, 229, 230, 50, 97
1.1 noro 330: };
1.5 ! noro 331:
! 332: static const short yypact[] =
! 333: {
! 334: 454, -55, -19, -63,-32768, -28, -13, 17, -55,-32768,
! 335: -32768,-32768, 23, 15, 30, 31, 454, 32, 57, 59,
! 336: -55, 575, -55, 62, 69, 71, 72,-32768,-32768,-32768,
! 337: 78, 685,-32768,-32768, -32,-32768, 685, 685, 685, 685,
! 338: 685,-32768, 525,-32768,-32768, 685, 685,-32768,-32768,-32768,
! 339: -2, 811,-32768,-32768,-32768, 86, -19,-32768, 92, -55,
! 340: -32768, 116, 116, 116,-32768, 87, 685, 685, 685, 140,
! 341: 685, 685, 685,-32768, 12,-32768, 811,-32768, 125, 126,
! 342: 127, 685, -36, 181, 685, 685, 128, 88, 88, 181,
! 343: 128, 312, -19, 685, 855, 101, 105, 1071, 102, -19,
! 344: 685, 685, 685, 685, 685, 685, 685, 685, 685, 685,
! 345: -32768, 685, 685, 685, 685, 685, 685, 685, 685, 685,
! 346: -32768, -19, 115, 117, 685,-32768,-32768, 114, 114, 114,
! 347: 139,-32768, 886, 917, 948, 123, 135, 133, 136, 685,
! 348: -32768, -65, 124, 138, 723,-32768, 137, 141, 53,-32768,
! 349: -32768, 142, 979,-32768,-32768, 685,-32768,-32768, 240, 483,
! 350: 5, 252, 79, 1165, 1146, 1120, 1101, -8, 1071, 88,
! 351: 88, -26, -26, -26, -26, 1071, 1041, -53,-32768,-32768,
! 352: -32768, 143, 160, -55, -55, -55,-32768,-32768,-32768,-32768,
! 353: 685, 454, 685, 454, 82,-32768, 685, 685, 685, 685,
! 354: -32768, 145, 155, -19, 134, 150, 1071,-32768, 685, -55,
! 355: -19, 685, -55,-32768,-32768,-32768,-32768, 156,-32768, 149,
! 356: 200,-32768, 159, 161, 171, 767, 685, 183, -6, 187,
! 357: -32768, 635, -2, 685, 34,-32768,-32768,-32768,-32768, -55,
! 358: 685, 454,-32768,-32768,-32768, 685, 178, 685,-32768, -19,
! 359: 685, 180, 184,-32768, 185,-32768, 1010,-32768, 811,-32768,
! 360: 1071,-32768, 201, 454,-32768,-32768,-32768, 163,-32768,-32768,
! 361: 383,-32768, 251, 254,-32768
1.1 noro 362: };
1.5 ! noro 363:
! 364: static const short yypgoto[] =
! 365: {
! 366: -32768, 1,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
! 367: -32768, 4,-32768,-32768,-32768,-32768, -10, -11, 76,-32768,
! 368: -32768, 28, 10, 56, 0
1.1 noro 369: };
1.5 ! noro 370:
! 371:
! 372: #define YYLAST 1221
! 373:
! 374:
! 375: static const short yytable[] =
! 376: {
! 377: 51, 47, 99, 195, 56, 52, 196, 101, 102, 103,
! 378: 53, 54, 60, 209, 43, 44, 51, 69, 210, 57,
! 379: 101, 76, 103, 110, 73, 75, 77, 53, 54, 116,
! 380: 55, 83, 145, 84, 58, 85, 86, 87, 88, 89,
! 381: 90, 110, 94, 112, 113, 114, 115, 116, 117, 101,
! 382: 102, 103, 128, 129, 110, 120, 112, 113, 114, 115,
! 383: 116, 117, 248, 125, 59, 249, 132, 133, 134, 131,
! 384: 64, 100, 104, 105, 106, 107, 108, 84, 109, 139,
! 385: 140, 144, 66, 110, 122, 112, 113, 114, 115, 116,
! 386: 117, 51, 119, 152, 101, 102, 103, 67, 68, 70,
! 387: 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
! 388: 146, 168, 169, 170, 171, 172, 173, 174, 175, 176,
! 389: 151, 202, 98, 109, 71, 203, 72, 157, 110, 78,
! 390: 112, 113, 114, 115, 116, 117, 79, 110, 80, 81,
! 391: 4, 114, 115, 116, 117, 82, 136, 137, 138, 178,
! 392: 221, 121, 13, 14, 203, 206, 43, 44, 130, 124,
! 393: 147, 148, 126, 135, 23, 24, 25, 26, 27, 28,
! 394: 29, 30, 141, 142, 143, 154, 155, 110, 156, 32,
! 395: 33, 74, 35, 179, 180, 182, 186, 214, 215, 216,
! 396: 190, 51, 218, 51, 220, 197, 101, 102, 103, 225,
! 397: 181, 231, 192, 191, 193, 200, 213, 201, 234, 198,
! 398: 204, 212, 226, 235, 227, 194, 238, 233, 240, 104,
! 399: 105, 106, 107, 108, 239, 109, 241, 242, 269, 243,
! 400: 110, 94, 112, 113, 114, 115, 116, 117, 236, 244,
! 401: 247, 51, 255, 253, 250, 256, 257, 258, 261, 266,
! 402: 260, 273, 262, 263, 274, 101, 102, 103, 270, 259,
! 403: 232, 0, 265, 51, 268, 0, 217, 101, 219, 0,
! 404: 51, 0, 222, 223, 224, 0, 0, 0, 104, 105,
! 405: 106, 107, 108, 0, 109, 0, 0, 237, 0, 110,
! 406: 111, 112, 113, 114, 115, 116, 117, 118, 119, 0,
! 407: 0, 110, 246, 112, 113, 114, 115, 116, 117, 251,
! 408: 0, 0, 0, 1, 207, 2, 254, 3, 4, 5,
! 409: 6, 7, 8, 9, 10, 11, 12, 0, 0, 0,
! 410: 13, 14, 15, 0, 16, 17, 18, 19, 0, 20,
! 411: 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
! 412: 0, 0, 0, 0, 0, 31, 0, 32, 33, 34,
! 413: 35, 36, 0, 37, 38, 0, 0, 0, 0, 0,
! 414: 0, 0, 39, 0, 0, 0, 40, 41, 149, 42,
! 415: 0, 43, 44, 0, 1, 45, 2, 46, 3, 4,
! 416: 5, 6, 7, 8, 9, 10, 11, 12, 0, 0,
! 417: 0, 13, 14, 15, 0, 16, 17, 18, 19, 0,
! 418: 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
! 419: 30, 0, 0, 0, 0, 0, 31, 0, 32, 33,
! 420: 34, 35, 36, 0, 37, 38, 0, 0, 0, 0,
! 421: 0, 0, 0, 39, 0, 0, 0, 40, 41, 271,
! 422: 42, 0, 43, 44, 0, 1, 45, 2, 46, 3,
! 423: 4, 5, 6, 7, 8, 9, 10, 11, 12, 0,
! 424: 0, 0, 13, 14, 15, 0, 16, 17, 18, 19,
! 425: 0, 20, 21, 22, 23, 24, 25, 26, 27, 28,
! 426: 29, 30, 0, 0, 0, 0, 0, 31, 0, 32,
! 427: 33, 34, 35, 36, 0, 37, 38, 0, 0, 0,
! 428: 0, 0, 0, 0, 39, 0, 0, 0, 40, 41,
! 429: 0, 42, 0, 43, 44, 0, 0, 45, 92, 46,
! 430: 3, 4, 110, 0, 112, 113, 114, 115, 116, 117,
! 431: 0, 0, 0, 13, 14, 15, 0, 0, 0, 0,
! 432: 0, 0, 0, 0, 0, 23, 24, 25, 26, 27,
! 433: 28, 29, 30, 0, 0, 0, 0, 0, 31, 0,
! 434: 32, 33, 74, 35, 36, 0, 37, 38, 93, 0,
! 435: 3, 4, 0, 0, 0, 39, 0, 0, 0, 40,
! 436: 0, 0, 42, 13, 14, 15, 0, 0, 45, 0,
! 437: 46, 0, 0, 0, 0, 23, 24, 25, 26, 27,
! 438: 28, 29, 30, 0, 0, 0, 0, 0, 31, 0,
! 439: 32, 33, 74, 35, 36, 0, 37, 38, 0, 0,
! 440: 0, 0, 0, 0, 0, 39, 0, 0, 0, 40,
! 441: 3, 4, 42, 0, 43, 44, 0, 0, 45, 0,
! 442: 46, 0, 0, 13, 14, 15, 0, 0, 0, 0,
! 443: 0, 0, 0, 0, 0, 23, 24, 25, 26, 27,
! 444: 28, 29, 30, 0, 0, 0, 0, 0, 31, 0,
! 445: 32, 33, 74, 35, 36, 0, 37, 38, 93, 0,
! 446: 3, 4, 0, 0, 0, 39, 0, 0, 0, 40,
! 447: 0, 0, 42, 13, 14, 15, 0, 0, 45, 0,
! 448: 46, 0, 0, 0, 0, 23, 24, 25, 26, 27,
! 449: 28, 29, 30, 0, 0, 0, 0, 0, 31, 0,
! 450: 32, 33, 74, 35, 36, 0, 37, 38, 101, 102,
! 451: 103, 0, 0, 0, 0, 39, 0, 0, 0, 40,
! 452: 0, 0, 42, 0, 0, 0, 0, 0, 45, 0,
! 453: 46, 104, 105, 106, 107, 108, 0, 109, 0, 0,
! 454: 0, 0, 110, 111, 112, 113, 114, 115, 116, 117,
! 455: 118, 119, 101, 102, 103, 0, 0, 0, 0, 0,
! 456: 0, 0, 0, 0, 199, 0, 0, 0, 0, 0,
! 457: 0, 0, 0, 0, 0, 104, 105, 106, 107, 108,
! 458: 0, 109, 0, 0, 0, 0, 110, 111, 112, 113,
! 459: 114, 115, 116, 117, 118, 119, 101, 102, 103, 0,
! 460: 0, 0, 0, 0, 0, 0, 0, 0, 245, 0,
! 461: 0, 0, 0, 0, 0, 0, 0, 0, 0, 104,
! 462: 105, 106, 107, 108, 0, 109, 0, 0, 0, 0,
! 463: 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
! 464: 101, 102, 103, 0, 0, 0, 0, 0, 0, 0,
! 465: 43, 44, 0, 0, 0, 0, 0, 0, 0, 0,
! 466: 0, 0, 0, 104, 105, 106, 107, 108, 0, 109,
! 467: 0, 101, 102, 103, 110, 111, 112, 113, 114, 115,
! 468: 116, 117, 118, 119, 0, 0, 0, 0, 0, 0,
! 469: 0, 0, 0, 153, 104, 105, 106, 107, 108, 0,
! 470: 109, 0, 101, 102, 103, 110, 111, 112, 113, 114,
! 471: 115, 116, 117, 118, 119, 0, 0, 0, 0, 0,
! 472: 0, 0, 0, 0, 187, 104, 105, 106, 107, 108,
! 473: 0, 109, 0, 101, 102, 103, 110, 111, 112, 113,
! 474: 114, 115, 116, 117, 118, 119, 0, 0, 0, 0,
! 475: 0, 0, 0, 0, 0, 188, 104, 105, 106, 107,
! 476: 108, 0, 109, 0, 101, 102, 103, 110, 111, 112,
! 477: 113, 114, 115, 116, 117, 118, 119, 0, 0, 0,
! 478: 0, 0, 0, 0, 0, 0, 189, 104, 105, 106,
! 479: 107, 108, 0, 109, 0, 101, 102, 103, 110, 111,
! 480: 112, 113, 114, 115, 116, 117, 118, 119, 0, 0,
! 481: 0, 0, 0, 0, 0, 0, 0, 205, 104, 105,
! 482: 106, 107, 108, 0, 109, 0, 101, 102, 103, 110,
! 483: 111, 112, 113, 114, 115, 116, 117, 118, 119, 0,
! 484: 0, 0, 0, 0, 0, 0, 0, 0, 264, 104,
! 485: 105, 106, 107, 108, 0, 109, 101, 102, 103, 0,
! 486: 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
! 487: 208, 0, 0, 0, 0, 0, 0, 0, 0, 104,
! 488: 105, 106, 107, 108, 0, 109, 101, 102, 103, 0,
! 489: 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
! 490: 0, 0, 0, 0, 0, 101, 102, 103, 0, 104,
! 491: 105, 106, 107, 0, 0, 109, 0, 0, 0, 0,
! 492: 110, 0, 112, 113, 114, 115, 116, 117, 104, 105,
! 493: 106, 101, 102, 103, 109, 0, 0, 0, 0, 110,
! 494: 0, 112, 113, 114, 115, 116, 117, 0, 0, 0,
! 495: 101, 102, 103, 0, 104, 105, 0, 0, 0, 0,
! 496: 109, 0, 0, 0, 0, 110, 0, 112, 113, 114,
! 497: 115, 116, 117, 104, 0, 0, 0, 0, 0, 109,
! 498: 0, 0, 0, 0, 110, 0, 112, 113, 114, 115,
! 499: 116, 117
! 500: };
! 501:
! 502: static const short yycheck[] =
! 503: {
! 504: 0, 0, 4, 68, 67, 1, 71, 15, 16, 17,
! 505: 46, 47, 8, 66, 69, 70, 16, 16, 71, 47,
! 506: 15, 21, 17, 49, 20, 21, 22, 46, 47, 55,
! 507: 2, 31, 68, 65, 47, 67, 36, 37, 38, 39,
! 508: 40, 49, 42, 51, 52, 53, 54, 55, 56, 15,
! 509: 16, 17, 62, 63, 49, 51, 51, 52, 53, 54,
! 510: 55, 56, 68, 59, 47, 71, 66, 67, 68, 65,
! 511: 47, 73, 38, 39, 40, 41, 42, 65, 44, 67,
! 512: 76, 81, 67, 49, 56, 51, 52, 53, 54, 55,
! 513: 56, 91, 58, 93, 15, 16, 17, 67, 67, 67,
! 514: 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
! 515: 82, 111, 112, 113, 114, 115, 116, 117, 118, 119,
! 516: 92, 68, 46, 44, 67, 72, 67, 99, 49, 67,
! 517: 51, 52, 53, 54, 55, 56, 67, 49, 67, 67,
! 518: 6, 53, 54, 55, 56, 67, 70, 71, 72, 121,
! 519: 68, 65, 18, 19, 72, 155, 69, 70, 71, 67,
! 520: 84, 85, 46, 23, 30, 31, 32, 33, 34, 35,
! 521: 36, 37, 47, 47, 47, 74, 71, 49, 76, 45,
! 522: 46, 47, 48, 68, 67, 71, 47, 183, 184, 185,
! 523: 67, 191, 191, 193, 193, 71, 15, 16, 17, 199,
! 524: 124, 67, 69, 68, 68, 68, 46, 66, 208, 71,
! 525: 68, 68, 67, 209, 59, 139, 212, 67, 69, 38,
! 526: 39, 40, 41, 42, 68, 44, 26, 68, 65, 68,
! 527: 49, 231, 51, 52, 53, 54, 55, 56, 210, 68,
! 528: 57, 241, 241, 239, 57, 245, 68, 247, 68, 48,
! 529: 250, 0, 68, 68, 0, 15, 16, 17, 269, 249,
! 530: 204, -1, 258, 263, 263, -1, 190, 15, 192, -1,
! 531: 270, -1, 196, 197, 198, -1, -1, -1, 38, 39,
! 532: 40, 41, 42, -1, 44, -1, -1, 211, -1, 49,
! 533: 50, 51, 52, 53, 54, 55, 56, 57, 58, -1,
! 534: -1, 49, 226, 51, 52, 53, 54, 55, 56, 233,
! 535: -1, -1, -1, 1, 74, 3, 240, 5, 6, 7,
! 536: 8, 9, 10, 11, 12, 13, 14, -1, -1, -1,
! 537: 18, 19, 20, -1, 22, 23, 24, 25, -1, 27,
! 538: 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
! 539: -1, -1, -1, -1, -1, 43, -1, 45, 46, 47,
! 540: 48, 49, -1, 51, 52, -1, -1, -1, -1, -1,
! 541: -1, -1, 60, -1, -1, -1, 64, 65, 66, 67,
! 542: -1, 69, 70, -1, 1, 73, 3, 75, 5, 6,
! 543: 7, 8, 9, 10, 11, 12, 13, 14, -1, -1,
! 544: -1, 18, 19, 20, -1, 22, 23, 24, 25, -1,
! 545: 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
! 546: 37, -1, -1, -1, -1, -1, 43, -1, 45, 46,
! 547: 47, 48, 49, -1, 51, 52, -1, -1, -1, -1,
! 548: -1, -1, -1, 60, -1, -1, -1, 64, 65, 66,
! 549: 67, -1, 69, 70, -1, 1, 73, 3, 75, 5,
! 550: 6, 7, 8, 9, 10, 11, 12, 13, 14, -1,
! 551: -1, -1, 18, 19, 20, -1, 22, 23, 24, 25,
! 552: -1, 27, 28, 29, 30, 31, 32, 33, 34, 35,
! 553: 36, 37, -1, -1, -1, -1, -1, 43, -1, 45,
! 554: 46, 47, 48, 49, -1, 51, 52, -1, -1, -1,
! 555: -1, -1, -1, -1, 60, -1, -1, -1, 64, 65,
! 556: -1, 67, -1, 69, 70, -1, -1, 73, 3, 75,
! 557: 5, 6, 49, -1, 51, 52, 53, 54, 55, 56,
! 558: -1, -1, -1, 18, 19, 20, -1, -1, -1, -1,
! 559: -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
! 560: 35, 36, 37, -1, -1, -1, -1, -1, 43, -1,
! 561: 45, 46, 47, 48, 49, -1, 51, 52, 53, -1,
! 562: 5, 6, -1, -1, -1, 60, -1, -1, -1, 64,
! 563: -1, -1, 67, 18, 19, 20, -1, -1, 73, -1,
! 564: 75, -1, -1, -1, -1, 30, 31, 32, 33, 34,
! 565: 35, 36, 37, -1, -1, -1, -1, -1, 43, -1,
! 566: 45, 46, 47, 48, 49, -1, 51, 52, -1, -1,
! 567: -1, -1, -1, -1, -1, 60, -1, -1, -1, 64,
! 568: 5, 6, 67, -1, 69, 70, -1, -1, 73, -1,
! 569: 75, -1, -1, 18, 19, 20, -1, -1, -1, -1,
! 570: -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
! 571: 35, 36, 37, -1, -1, -1, -1, -1, 43, -1,
! 572: 45, 46, 47, 48, 49, -1, 51, 52, 53, -1,
! 573: 5, 6, -1, -1, -1, 60, -1, -1, -1, 64,
! 574: -1, -1, 67, 18, 19, 20, -1, -1, 73, -1,
! 575: 75, -1, -1, -1, -1, 30, 31, 32, 33, 34,
! 576: 35, 36, 37, -1, -1, -1, -1, -1, 43, -1,
! 577: 45, 46, 47, 48, 49, -1, 51, 52, 15, 16,
! 578: 17, -1, -1, -1, -1, 60, -1, -1, -1, 64,
! 579: -1, -1, 67, -1, -1, -1, -1, -1, 73, -1,
! 580: 75, 38, 39, 40, 41, 42, -1, 44, -1, -1,
! 581: -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
! 582: 57, 58, 15, 16, 17, -1, -1, -1, -1, -1,
! 583: -1, -1, -1, -1, 71, -1, -1, -1, -1, -1,
! 584: -1, -1, -1, -1, -1, 38, 39, 40, 41, 42,
! 585: -1, 44, -1, -1, -1, -1, 49, 50, 51, 52,
! 586: 53, 54, 55, 56, 57, 58, 15, 16, 17, -1,
! 587: -1, -1, -1, -1, -1, -1, -1, -1, 71, -1,
! 588: -1, -1, -1, -1, -1, -1, -1, -1, -1, 38,
! 589: 39, 40, 41, 42, -1, 44, -1, -1, -1, -1,
! 590: 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
! 591: 15, 16, 17, -1, -1, -1, -1, -1, -1, -1,
! 592: 69, 70, -1, -1, -1, -1, -1, -1, -1, -1,
! 593: -1, -1, -1, 38, 39, 40, 41, 42, -1, 44,
! 594: -1, 15, 16, 17, 49, 50, 51, 52, 53, 54,
! 595: 55, 56, 57, 58, -1, -1, -1, -1, -1, -1,
! 596: -1, -1, -1, 68, 38, 39, 40, 41, 42, -1,
! 597: 44, -1, 15, 16, 17, 49, 50, 51, 52, 53,
! 598: 54, 55, 56, 57, 58, -1, -1, -1, -1, -1,
! 599: -1, -1, -1, -1, 68, 38, 39, 40, 41, 42,
! 600: -1, 44, -1, 15, 16, 17, 49, 50, 51, 52,
! 601: 53, 54, 55, 56, 57, 58, -1, -1, -1, -1,
! 602: -1, -1, -1, -1, -1, 68, 38, 39, 40, 41,
! 603: 42, -1, 44, -1, 15, 16, 17, 49, 50, 51,
! 604: 52, 53, 54, 55, 56, 57, 58, -1, -1, -1,
! 605: -1, -1, -1, -1, -1, -1, 68, 38, 39, 40,
! 606: 41, 42, -1, 44, -1, 15, 16, 17, 49, 50,
! 607: 51, 52, 53, 54, 55, 56, 57, 58, -1, -1,
! 608: -1, -1, -1, -1, -1, -1, -1, 68, 38, 39,
! 609: 40, 41, 42, -1, 44, -1, 15, 16, 17, 49,
! 610: 50, 51, 52, 53, 54, 55, 56, 57, 58, -1,
! 611: -1, -1, -1, -1, -1, -1, -1, -1, 68, 38,
! 612: 39, 40, 41, 42, -1, 44, 15, 16, 17, -1,
! 613: 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
! 614: 59, -1, -1, -1, -1, -1, -1, -1, -1, 38,
! 615: 39, 40, 41, 42, -1, 44, 15, 16, 17, -1,
! 616: 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
! 617: -1, -1, -1, -1, -1, 15, 16, 17, -1, 38,
! 618: 39, 40, 41, -1, -1, 44, -1, -1, -1, -1,
! 619: 49, -1, 51, 52, 53, 54, 55, 56, 38, 39,
! 620: 40, 15, 16, 17, 44, -1, -1, -1, -1, 49,
! 621: -1, 51, 52, 53, 54, 55, 56, -1, -1, -1,
! 622: 15, 16, 17, -1, 38, 39, -1, -1, -1, -1,
! 623: 44, -1, -1, -1, -1, 49, -1, 51, 52, 53,
! 624: 54, 55, 56, 38, -1, -1, -1, -1, -1, 44,
! 625: -1, -1, -1, -1, 49, -1, 51, 52, 53, 54,
! 626: 55, 56
1.1 noro 627: };
1.5 ! noro 628: /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
! 629: #line 3 "/usr/share/bison/bison.simple"
! 630:
! 631: /* Skeleton output parser for bison,
! 632:
! 633: Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
! 634: Foundation, Inc.
! 635:
! 636: This program is free software; you can redistribute it and/or modify
! 637: it under the terms of the GNU General Public License as published by
! 638: the Free Software Foundation; either version 2, or (at your option)
! 639: any later version.
! 640:
! 641: This program is distributed in the hope that it will be useful,
! 642: but WITHOUT ANY WARRANTY; without even the implied warranty of
! 643: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 644: GNU General Public License for more details.
! 645:
! 646: You should have received a copy of the GNU General Public License
! 647: along with this program; if not, write to the Free Software
! 648: Foundation, Inc., 59 Temple Place - Suite 330,
! 649: Boston, MA 02111-1307, USA. */
! 650:
! 651: /* As a special exception, when this file is copied by Bison into a
! 652: Bison output file, you may use that output file without restriction.
! 653: This special exception was added by the Free Software Foundation
! 654: in version 1.24 of Bison. */
! 655:
! 656: /* This is the parser code that is written into each bison parser when
! 657: the %semantic_parser declaration is not specified in the grammar.
! 658: It was written by Richard Stallman by simplifying the hairy parser
! 659: used when %semantic_parser is specified. */
! 660:
! 661: /* All symbols defined below should begin with yy or YY, to avoid
! 662: infringing on user name space. This should be done even for local
! 663: variables, as they might otherwise be expanded by user macros.
! 664: There are some unavoidable exceptions within include files to
! 665: define necessary library symbols; they are noted "INFRINGES ON
! 666: USER NAME SPACE" below. */
! 667:
! 668: #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
! 669:
! 670: /* The parser invokes alloca or malloc; define the necessary symbols. */
! 671:
! 672: # if YYSTACK_USE_ALLOCA
! 673: # define YYSTACK_ALLOC alloca
! 674: # else
! 675: # ifndef YYSTACK_USE_ALLOCA
! 676: # if defined (alloca) || defined (_ALLOCA_H)
! 677: # define YYSTACK_ALLOC alloca
! 678: # else
! 679: # ifdef __GNUC__
! 680: # define YYSTACK_ALLOC __builtin_alloca
! 681: # endif
! 682: # endif
! 683: # endif
! 684: # endif
! 685:
! 686: # ifdef YYSTACK_ALLOC
! 687: /* Pacify GCC's `empty if-body' warning. */
! 688: # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
! 689: # else
! 690: # if defined (__STDC__) || defined (__cplusplus)
! 691: # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
! 692: # define YYSIZE_T size_t
! 693: # endif
! 694: # define YYSTACK_ALLOC malloc
! 695: # define YYSTACK_FREE free
! 696: # endif
! 697: #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
! 698:
! 699:
! 700: #if (! defined (yyoverflow) \
! 701: && (! defined (__cplusplus) \
! 702: || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
! 703:
! 704: /* A type that is properly aligned for any stack member. */
! 705: union yyalloc
! 706: {
! 707: short yyss;
! 708: YYSTYPE yyvs;
! 709: # if YYLSP_NEEDED
! 710: YYLTYPE yyls;
! 711: # endif
1.1 noro 712: };
1.5 ! noro 713:
! 714: /* The size of the maximum gap between one aligned stack and the next. */
! 715: # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
! 716:
! 717: /* The size of an array large to enough to hold all stacks, each with
! 718: N elements. */
! 719: # if YYLSP_NEEDED
! 720: # define YYSTACK_BYTES(N) \
! 721: ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
! 722: + 2 * YYSTACK_GAP_MAX)
! 723: # else
! 724: # define YYSTACK_BYTES(N) \
! 725: ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
! 726: + YYSTACK_GAP_MAX)
! 727: # endif
! 728:
! 729: /* Copy COUNT objects from FROM to TO. The source and destination do
! 730: not overlap. */
! 731: # ifndef YYCOPY
! 732: # if 1 < __GNUC__
! 733: # define YYCOPY(To, From, Count) \
! 734: __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
! 735: # else
! 736: # define YYCOPY(To, From, Count) \
! 737: do \
! 738: { \
! 739: register YYSIZE_T yyi; \
! 740: for (yyi = 0; yyi < (Count); yyi++) \
! 741: (To)[yyi] = (From)[yyi]; \
! 742: } \
! 743: while (0)
! 744: # endif
! 745: # endif
! 746:
! 747: /* Relocate STACK from its old location to the new one. The
! 748: local variables YYSIZE and YYSTACKSIZE give the old and new number of
! 749: elements in the stack, and YYPTR gives the new location of the
! 750: stack. Advance YYPTR to a properly aligned location for the next
! 751: stack. */
! 752: # define YYSTACK_RELOCATE(Stack) \
! 753: do \
! 754: { \
! 755: YYSIZE_T yynewbytes; \
! 756: YYCOPY (&yyptr->Stack, Stack, yysize); \
! 757: Stack = &yyptr->Stack; \
! 758: yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \
! 759: yyptr += yynewbytes / sizeof (*yyptr); \
! 760: } \
! 761: while (0)
! 762:
! 763: #endif
! 764:
! 765:
! 766: #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
! 767: # define YYSIZE_T __SIZE_TYPE__
! 768: #endif
! 769: #if ! defined (YYSIZE_T) && defined (size_t)
! 770: # define YYSIZE_T size_t
1.1 noro 771: #endif
1.5 ! noro 772: #if ! defined (YYSIZE_T)
! 773: # if defined (__STDC__) || defined (__cplusplus)
! 774: # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
! 775: # define YYSIZE_T size_t
! 776: # endif
! 777: #endif
! 778: #if ! defined (YYSIZE_T)
! 779: # define YYSIZE_T unsigned int
! 780: #endif
! 781:
! 782: #define yyerrok (yyerrstatus = 0)
! 783: #define yyclearin (yychar = YYEMPTY)
! 784: #define YYEMPTY -2
! 785: #define YYEOF 0
! 786: #define YYACCEPT goto yyacceptlab
! 787: #define YYABORT goto yyabortlab
! 788: #define YYERROR goto yyerrlab1
! 789: /* Like YYERROR except do call yyerror. This remains here temporarily
! 790: to ease the transition to the new meaning of YYERROR, for GCC.
! 791: Once GCC version 2 has supplanted version 1, this can go. */
! 792: #define YYFAIL goto yyerrlab
! 793: #define YYRECOVERING() (!!yyerrstatus)
! 794: #define YYBACKUP(Token, Value) \
! 795: do \
! 796: if (yychar == YYEMPTY && yylen == 1) \
! 797: { \
! 798: yychar = (Token); \
! 799: yylval = (Value); \
! 800: yychar1 = YYTRANSLATE (yychar); \
! 801: YYPOPSTACK; \
! 802: goto yybackup; \
! 803: } \
! 804: else \
! 805: { \
! 806: yyerror ("syntax error: cannot back up"); \
! 807: YYERROR; \
! 808: } \
! 809: while (0)
! 810:
! 811: #define YYTERROR 1
! 812: #define YYERRCODE 256
! 813:
! 814:
! 815: /* YYLLOC_DEFAULT -- Compute the default location (before the actions
! 816: are run).
! 817:
! 818: When YYLLOC_DEFAULT is run, CURRENT is set the location of the
! 819: first token. By default, to implement support for ranges, extend
! 820: its range to the last symbol. */
! 821:
! 822: #ifndef YYLLOC_DEFAULT
! 823: # define YYLLOC_DEFAULT(Current, Rhs, N) \
! 824: Current.last_line = Rhs[N].last_line; \
! 825: Current.last_column = Rhs[N].last_column;
! 826: #endif
! 827:
! 828:
! 829: /* YYLEX -- calling `yylex' with the right arguments. */
! 830:
! 831: #if YYPURE
! 832: # if YYLSP_NEEDED
! 833: # ifdef YYLEX_PARAM
! 834: # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
! 835: # else
! 836: # define YYLEX yylex (&yylval, &yylloc)
! 837: # endif
! 838: # else /* !YYLSP_NEEDED */
! 839: # ifdef YYLEX_PARAM
! 840: # define YYLEX yylex (&yylval, YYLEX_PARAM)
! 841: # else
! 842: # define YYLEX yylex (&yylval)
! 843: # endif
! 844: # endif /* !YYLSP_NEEDED */
! 845: #else /* !YYPURE */
! 846: # define YYLEX yylex ()
! 847: #endif /* !YYPURE */
! 848:
! 849:
! 850: /* Enable debugging if requested. */
1.1 noro 851: #if YYDEBUG
1.5 ! noro 852:
! 853: # ifndef YYFPRINTF
! 854: # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
! 855: # define YYFPRINTF fprintf
! 856: # endif
! 857:
! 858: # define YYDPRINTF(Args) \
! 859: do { \
! 860: if (yydebug) \
! 861: YYFPRINTF Args; \
! 862: } while (0)
! 863: /* Nonzero means print parse trace. It is left uninitialized so that
! 864: multiple parsers can coexist. */
! 865: int yydebug;
! 866: #else /* !YYDEBUG */
! 867: # define YYDPRINTF(Args)
! 868: #endif /* !YYDEBUG */
! 869:
! 870: /* YYINITDEPTH -- initial size of the parser's stacks. */
! 871: #ifndef YYINITDEPTH
! 872: # define YYINITDEPTH 200
! 873: #endif
! 874:
! 875: /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
! 876: if the built-in stack extension method is used).
! 877:
! 878: Do not make this value too large; the results are undefined if
! 879: SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
! 880: evaluated with infinite-precision integer arithmetic. */
! 881:
! 882: #if YYMAXDEPTH == 0
! 883: # undef YYMAXDEPTH
! 884: #endif
! 885:
! 886: #ifndef YYMAXDEPTH
! 887: # define YYMAXDEPTH 10000
1.1 noro 888: #endif
1.5 ! noro 889:
! 890: #ifdef YYERROR_VERBOSE
! 891:
! 892: # ifndef yystrlen
! 893: # if defined (__GLIBC__) && defined (_STRING_H)
! 894: # define yystrlen strlen
! 895: # else
! 896: /* Return the length of YYSTR. */
! 897: static YYSIZE_T
! 898: # if defined (__STDC__) || defined (__cplusplus)
! 899: yystrlen (const char *yystr)
! 900: # else
! 901: yystrlen (yystr)
! 902: const char *yystr;
! 903: # endif
! 904: {
! 905: register const char *yys = yystr;
! 906:
! 907: while (*yys++ != '\0')
! 908: continue;
! 909:
! 910: return yys - yystr - 1;
! 911: }
! 912: # endif
! 913: # endif
! 914:
! 915: # ifndef yystpcpy
! 916: # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
! 917: # define yystpcpy stpcpy
! 918: # else
! 919: /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
! 920: YYDEST. */
! 921: static char *
! 922: # if defined (__STDC__) || defined (__cplusplus)
! 923: yystpcpy (char *yydest, const char *yysrc)
! 924: # else
! 925: yystpcpy (yydest, yysrc)
! 926: char *yydest;
! 927: const char *yysrc;
! 928: # endif
! 929: {
! 930: register char *yyd = yydest;
! 931: register const char *yys = yysrc;
! 932:
! 933: while ((*yyd++ = *yys++) != '\0')
! 934: continue;
! 935:
! 936: return yyd - 1;
! 937: }
! 938: # endif
! 939: # endif
1.1 noro 940: #endif
1.5 ! noro 941:
! 942: #line 315 "/usr/share/bison/bison.simple"
! 943:
! 944:
! 945: /* The user can define YYPARSE_PARAM as the name of an argument to be passed
! 946: into yyparse. The argument should have type void *.
! 947: It should actually point to an object.
! 948: Grammar actions can access the variable by casting it
! 949: to the proper pointer type. */
! 950:
! 951: #ifdef YYPARSE_PARAM
! 952: # if defined (__STDC__) || defined (__cplusplus)
! 953: # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
! 954: # define YYPARSE_PARAM_DECL
! 955: # else
! 956: # define YYPARSE_PARAM_ARG YYPARSE_PARAM
! 957: # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
! 958: # endif
! 959: #else /* !YYPARSE_PARAM */
! 960: # define YYPARSE_PARAM_ARG
! 961: # define YYPARSE_PARAM_DECL
! 962: #endif /* !YYPARSE_PARAM */
! 963:
! 964: /* Prevent warning if -Wstrict-prototypes. */
! 965: #ifdef __GNUC__
! 966: # ifdef YYPARSE_PARAM
! 967: int yyparse (void *);
! 968: # else
! 969: int yyparse (void);
! 970: # endif
1.1 noro 971: #endif
1.5 ! noro 972:
! 973: /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
! 974: variables are global, or local to YYPARSE. */
! 975:
! 976: #define YY_DECL_NON_LSP_VARIABLES \
! 977: /* The lookahead symbol. */ \
! 978: int yychar; \
! 979: \
! 980: /* The semantic value of the lookahead symbol. */ \
! 981: YYSTYPE yylval; \
! 982: \
! 983: /* Number of parse errors so far. */ \
1.1 noro 984: int yynerrs;
985:
1.5 ! noro 986: #if YYLSP_NEEDED
! 987: # define YY_DECL_VARIABLES \
! 988: YY_DECL_NON_LSP_VARIABLES \
! 989: \
! 990: /* Location data for the lookahead symbol. */ \
! 991: YYLTYPE yylloc;
! 992: #else
! 993: # define YY_DECL_VARIABLES \
! 994: YY_DECL_NON_LSP_VARIABLES
! 995: #endif
! 996:
! 997:
! 998: /* If nonreentrant, generate the variables here. */
! 999:
! 1000: #if !YYPURE
! 1001: YY_DECL_VARIABLES
! 1002: #endif /* !YYPURE */
1.1 noro 1003:
1004: int
1005: yyparse (YYPARSE_PARAM_ARG)
1.5 ! noro 1006: YYPARSE_PARAM_DECL
1.1 noro 1007: {
1.5 ! noro 1008: /* If reentrant, generate the variables here. */
! 1009: #if YYPURE
! 1010: YY_DECL_VARIABLES
! 1011: #endif /* !YYPURE */
! 1012:
! 1013: register int yystate;
! 1014: register int yyn;
! 1015: int yyresult;
! 1016: /* Number of tokens to shift before error messages enabled. */
! 1017: int yyerrstatus;
! 1018: /* Lookahead token as an internal (translated) token number. */
! 1019: int yychar1 = 0;
! 1020:
! 1021: /* Three stacks and their tools:
! 1022: `yyss': related to states,
! 1023: `yyvs': related to semantic values,
! 1024: `yyls': related to locations.
! 1025:
! 1026: Refer to the stacks thru separate pointers, to allow yyoverflow
! 1027: to reallocate them elsewhere. */
! 1028:
! 1029: /* The state stack. */
! 1030: short yyssa[YYINITDEPTH];
! 1031: short *yyss = yyssa;
! 1032: register short *yyssp;
! 1033:
! 1034: /* The semantic value stack. */
! 1035: YYSTYPE yyvsa[YYINITDEPTH];
! 1036: YYSTYPE *yyvs = yyvsa;
! 1037: register YYSTYPE *yyvsp;
! 1038:
! 1039: #if YYLSP_NEEDED
! 1040: /* The location stack. */
! 1041: YYLTYPE yylsa[YYINITDEPTH];
! 1042: YYLTYPE *yyls = yylsa;
! 1043: YYLTYPE *yylsp;
! 1044: #endif
! 1045:
! 1046: #if YYLSP_NEEDED
! 1047: # define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
! 1048: #else
! 1049: # define YYPOPSTACK (yyvsp--, yyssp--)
! 1050: #endif
! 1051:
! 1052: YYSIZE_T yystacksize = YYINITDEPTH;
! 1053:
! 1054:
! 1055: /* The variables used to return semantic value and location from the
! 1056: action routines. */
! 1057: YYSTYPE yyval;
! 1058: #if YYLSP_NEEDED
! 1059: YYLTYPE yyloc;
! 1060: #endif
! 1061:
! 1062: /* When reducing, the number of symbols on the RHS of the reduced
! 1063: rule. */
! 1064: int yylen;
! 1065:
! 1066: YYDPRINTF ((stderr, "Starting parse\n"));
! 1067:
! 1068: yystate = 0;
! 1069: yyerrstatus = 0;
! 1070: yynerrs = 0;
! 1071: yychar = YYEMPTY; /* Cause a token to be read. */
! 1072:
! 1073: /* Initialize stack pointers.
! 1074: Waste one element of value and location stack
! 1075: so that they stay on the same level as the state stack.
! 1076: The wasted elements are never initialized. */
1.1 noro 1077:
1.5 ! noro 1078: yyssp = yyss;
! 1079: yyvsp = yyvs;
! 1080: #if YYLSP_NEEDED
! 1081: yylsp = yyls;
1.1 noro 1082: #endif
1.5 ! noro 1083: goto yysetstate;
! 1084:
! 1085: /*------------------------------------------------------------.
! 1086: | yynewstate -- Push a new state, which is found in yystate. |
! 1087: `------------------------------------------------------------*/
! 1088: yynewstate:
! 1089: /* In all cases, when you get here, the value and location stacks
! 1090: have just been pushed. so pushing a state here evens the stacks.
! 1091: */
! 1092: yyssp++;
1.1 noro 1093:
1.5 ! noro 1094: yysetstate:
! 1095: *yyssp = yystate;
! 1096:
! 1097: if (yyssp >= yyss + yystacksize - 1)
1.1 noro 1098: {
1.5 ! noro 1099: /* Get the current used size of the three stacks, in elements. */
! 1100: YYSIZE_T yysize = yyssp - yyss + 1;
! 1101:
! 1102: #ifdef yyoverflow
! 1103: {
! 1104: /* Give user a chance to reallocate the stack. Use copies of
! 1105: these so that the &'s don't force the real ones into
! 1106: memory. */
! 1107: YYSTYPE *yyvs1 = yyvs;
! 1108: short *yyss1 = yyss;
! 1109:
! 1110: /* Each stack pointer address is followed by the size of the
! 1111: data in use in that stack, in bytes. */
! 1112: # if YYLSP_NEEDED
! 1113: YYLTYPE *yyls1 = yyls;
! 1114: /* This used to be a conditional around just the two extra args,
! 1115: but that might be undefined if yyoverflow is a macro. */
! 1116: yyoverflow ("parser stack overflow",
! 1117: &yyss1, yysize * sizeof (*yyssp),
! 1118: &yyvs1, yysize * sizeof (*yyvsp),
! 1119: &yyls1, yysize * sizeof (*yylsp),
! 1120: &yystacksize);
! 1121: yyls = yyls1;
! 1122: # else
! 1123: yyoverflow ("parser stack overflow",
! 1124: &yyss1, yysize * sizeof (*yyssp),
! 1125: &yyvs1, yysize * sizeof (*yyvsp),
! 1126: &yystacksize);
! 1127: # endif
! 1128: yyss = yyss1;
! 1129: yyvs = yyvs1;
! 1130: }
! 1131: #else /* no yyoverflow */
! 1132: # ifndef YYSTACK_RELOCATE
! 1133: goto yyoverflowlab;
! 1134: # else
! 1135: /* Extend the stack our own way. */
! 1136: if (yystacksize >= YYMAXDEPTH)
! 1137: goto yyoverflowlab;
! 1138: yystacksize *= 2;
! 1139: if (yystacksize > YYMAXDEPTH)
! 1140: yystacksize = YYMAXDEPTH;
! 1141:
! 1142: {
! 1143: short *yyss1 = yyss;
! 1144: union yyalloc *yyptr =
! 1145: (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
! 1146: if (! yyptr)
! 1147: goto yyoverflowlab;
! 1148: YYSTACK_RELOCATE (yyss);
! 1149: YYSTACK_RELOCATE (yyvs);
! 1150: # if YYLSP_NEEDED
! 1151: YYSTACK_RELOCATE (yyls);
! 1152: # endif
! 1153: # undef YYSTACK_RELOCATE
! 1154: if (yyss1 != yyssa)
! 1155: YYSTACK_FREE (yyss1);
! 1156: }
! 1157: # endif
! 1158: #endif /* no yyoverflow */
! 1159:
! 1160: yyssp = yyss + yysize - 1;
! 1161: yyvsp = yyvs + yysize - 1;
! 1162: #if YYLSP_NEEDED
! 1163: yylsp = yyls + yysize - 1;
1.1 noro 1164: #endif
1.5 ! noro 1165:
! 1166: YYDPRINTF ((stderr, "Stack size increased to %lu\n",
! 1167: (unsigned long int) yystacksize));
! 1168:
! 1169: if (yyssp >= yyss + yystacksize - 1)
! 1170: YYABORT;
1.1 noro 1171: }
1.5 ! noro 1172:
! 1173: YYDPRINTF ((stderr, "Entering state %d\n", yystate));
! 1174:
! 1175: goto yybackup;
! 1176:
! 1177:
! 1178: /*-----------.
! 1179: | yybackup. |
! 1180: `-----------*/
! 1181: yybackup:
! 1182:
! 1183: /* Do appropriate processing given the current state. */
! 1184: /* Read a lookahead token if we need one and don't already have one. */
! 1185: /* yyresume: */
! 1186:
! 1187: /* First try to decide what to do without reference to lookahead token. */
! 1188:
! 1189: yyn = yypact[yystate];
! 1190: if (yyn == YYFLAG)
! 1191: goto yydefault;
! 1192:
! 1193: /* Not known => get a lookahead token if don't already have one. */
! 1194:
! 1195: /* yychar is either YYEMPTY or YYEOF
! 1196: or a valid token in external form. */
! 1197:
! 1198: if (yychar == YYEMPTY)
1.1 noro 1199: {
1.5 ! noro 1200: YYDPRINTF ((stderr, "Reading a token: "));
! 1201: yychar = YYLEX;
1.1 noro 1202: }
1.5 ! noro 1203:
! 1204: /* Convert token to internal form (in yychar1) for indexing tables with */
! 1205:
! 1206: if (yychar <= 0) /* This means end of input. */
1.1 noro 1207: {
1.5 ! noro 1208: yychar1 = 0;
! 1209: yychar = YYEOF; /* Don't call YYLEX any more */
! 1210:
! 1211: YYDPRINTF ((stderr, "Now at end of input.\n"));
1.1 noro 1212: }
1.5 ! noro 1213: else
1.1 noro 1214: {
1.5 ! noro 1215: yychar1 = YYTRANSLATE (yychar);
! 1216:
1.1 noro 1217: #if YYDEBUG
1.5 ! noro 1218: /* We have to keep this `#if YYDEBUG', since we use variables
! 1219: which are defined only if `YYDEBUG' is set. */
! 1220: if (yydebug)
! 1221: {
! 1222: YYFPRINTF (stderr, "Next token is %d (%s",
! 1223: yychar, yytname[yychar1]);
! 1224: /* Give the individual parser a way to print the precise
! 1225: meaning of a token, for further debugging info. */
! 1226: # ifdef YYPRINT
! 1227: YYPRINT (stderr, yychar, yylval);
! 1228: # endif
! 1229: YYFPRINTF (stderr, ")\n");
! 1230: }
! 1231: #endif
1.1 noro 1232: }
1.5 ! noro 1233:
! 1234: yyn += yychar1;
! 1235: if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
! 1236: goto yydefault;
! 1237:
! 1238: yyn = yytable[yyn];
! 1239:
! 1240: /* yyn is what to do for this token type in this state.
! 1241: Negative => reduce, -yyn is rule number.
! 1242: Positive => shift, yyn is new state.
! 1243: New state is final state => don't bother to shift,
! 1244: just return success.
! 1245: 0, or most negative number => error. */
! 1246:
! 1247: if (yyn < 0)
1.1 noro 1248: {
1.5 ! noro 1249: if (yyn == YYFLAG)
! 1250: goto yyerrlab;
! 1251: yyn = -yyn;
! 1252: goto yyreduce;
! 1253: }
! 1254: else if (yyn == 0)
! 1255: goto yyerrlab;
! 1256:
! 1257: if (yyn == YYFINAL)
! 1258: YYACCEPT;
! 1259:
! 1260: /* Shift the lookahead token. */
! 1261: YYDPRINTF ((stderr, "Shifting token %d (%s), ",
! 1262: yychar, yytname[yychar1]));
! 1263:
! 1264: /* Discard the token being shifted unless it is eof. */
! 1265: if (yychar != YYEOF)
! 1266: yychar = YYEMPTY;
! 1267:
! 1268: *++yyvsp = yylval;
! 1269: #if YYLSP_NEEDED
! 1270: *++yylsp = yylloc;
1.1 noro 1271: #endif
1.5 ! noro 1272:
! 1273: /* Count tokens shifted since error; after three, turn off error
! 1274: status. */
! 1275: if (yyerrstatus)
! 1276: yyerrstatus--;
! 1277:
! 1278: yystate = yyn;
! 1279: goto yynewstate;
! 1280:
! 1281:
! 1282: /*-----------------------------------------------------------.
! 1283: | yydefault -- do the default action for the current state. |
! 1284: `-----------------------------------------------------------*/
! 1285: yydefault:
! 1286: yyn = yydefact[yystate];
! 1287: if (yyn == 0)
! 1288: goto yyerrlab;
! 1289: goto yyreduce;
! 1290:
! 1291:
! 1292: /*-----------------------------.
! 1293: | yyreduce -- Do a reduction. |
! 1294: `-----------------------------*/
1.1 noro 1295: yyreduce:
1.5 ! noro 1296: /* yyn is the number of a rule to reduce with. */
! 1297: yylen = yyr2[yyn];
! 1298:
! 1299: /* If YYLEN is nonzero, implement the default value of the action:
! 1300: `$$ = $1'.
! 1301:
! 1302: Otherwise, the following line sets YYVAL to the semantic value of
! 1303: the lookahead token. This behavior is undocumented and Bison
! 1304: users should not rely upon it. Assigning to YYVAL
! 1305: unconditionally makes the parser a bit smaller, and it avoids a
! 1306: GCC warning that YYVAL may be used uninitialized. */
! 1307: yyval = yyvsp[1-yylen];
! 1308:
! 1309: #if YYLSP_NEEDED
! 1310: /* Similarly for the default location. Let the user run additional
! 1311: commands if for instance locations are ranges. */
! 1312: yyloc = yylsp[1-yylen];
! 1313: YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
! 1314: #endif
! 1315:
1.1 noro 1316: #if YYDEBUG
1.5 ! noro 1317: /* We have to keep this `#if YYDEBUG', since we use variables which
! 1318: are defined only if `YYDEBUG' is set. */
! 1319: if (yydebug)
1.1 noro 1320: {
1.5 ! noro 1321: int yyi;
! 1322:
! 1323: YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
! 1324: yyn, yyrline[yyn]);
! 1325:
! 1326: /* Print the symbols being reduced, and their result. */
! 1327: for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
! 1328: YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
! 1329: YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
! 1330: }
! 1331: #endif
! 1332:
! 1333: switch (yyn) {
! 1334:
1.1 noro 1335: case 1:
1.4 noro 1336: #line 131 "parse.y"
1.5 ! noro 1337: {
! 1338: parse_snode = yyvsp[0].s;
! 1339: if ( yychar >= 0 )
! 1340: fprintf(stderr,
! 1341: "Warning: a token was wasted after an 'if' statement without 'else'.\n");
! 1342: YYACCEPT;
! 1343: }
! 1344: break;
1.1 noro 1345: case 2:
1.5 ! noro 1346: #line 140 "parse.y"
1.1 noro 1347: { yyval.s = 0; }
1.5 ! noro 1348: break;
1.1 noro 1349: case 3:
1.5 ! noro 1350: #line 141 "parse.y"
1.1 noro 1351: { gdef=1; }
1.5 ! noro 1352: break;
1.1 noro 1353: case 4:
1.5 ! noro 1354: #line 141 "parse.y"
1.1 noro 1355: { gdef=0; }
1.5 ! noro 1356: break;
1.1 noro 1357: case 5:
1.5 ! noro 1358: #line 142 "parse.y"
1.4 noro 1359: { yyval.s = 0; NOPR; }
1.5 ! noro 1360: break;
1.1 noro 1361: case 6:
1.5 ! noro 1362: #line 143 "parse.y"
1.4 noro 1363: { mgdef=1; }
1.5 ! noro 1364: break;
1.1 noro 1365: case 7:
1.5 ! noro 1366: #line 143 "parse.y"
1.4 noro 1367: { mgdef=0; }
1.5 ! noro 1368: break;
1.1 noro 1369: case 8:
1.5 ! noro 1370: #line 144 "parse.y"
1.4 noro 1371: { yyval.s = 0; NOPR; }
1.5 ! noro 1372: break;
1.1 noro 1373: case 9:
1.5 ! noro 1374: #line 145 "parse.y"
1.4 noro 1375: { ldef=1; }
1.5 ! noro 1376: break;
1.1 noro 1377: case 10:
1.5 ! noro 1378: #line 145 "parse.y"
1.4 noro 1379: { ldef=0; }
1.5 ! noro 1380: break;
1.1 noro 1381: case 11:
1.5 ! noro 1382: #line 146 "parse.y"
1.4 noro 1383: { yyval.s = 0; NOPR; }
1.5 ! noro 1384: break;
1.1 noro 1385: case 12:
1.5 ! noro 1386: #line 148 "parse.y"
1.4 noro 1387: { appenduflist(yyvsp[-1].n); yyval.s = 0; NOPR; }
1.5 ! noro 1388: break;
1.1 noro 1389: case 13:
1.5 ! noro 1390: #line 150 "parse.y"
1.4 noro 1391: { structdef(yyvsp[-4].p,yyvsp[-2].n); yyval.s = 0; NOPR; }
1.5 ! noro 1392: break;
1.1 noro 1393: case 14:
1.5 ! noro 1394: #line 152 "parse.y"
1.4 noro 1395: { yyval.s = mksnode(1,S_SINGLE,yyvsp[-1].f); }
1.5 ! noro 1396: break;
1.1 noro 1397: case 15:
1.5 ! noro 1398: #line 154 "parse.y"
1.4 noro 1399: { yyval.s = yyvsp[0].s; }
1.5 ! noro 1400: break;
1.1 noro 1401: case 16:
1.5 ! noro 1402: #line 156 "parse.y"
1.4 noro 1403: { yyval.s = mksnode(0,S_BREAK); }
1.5 ! noro 1404: break;
1.1 noro 1405: case 17:
1.5 ! noro 1406: #line 158 "parse.y"
1.4 noro 1407: { yyval.s = mksnode(0,S_CONTINUE); }
1.5 ! noro 1408: break;
1.1 noro 1409: case 18:
1.5 ! noro 1410: #line 160 "parse.y"
1.4 noro 1411: { yyval.s = mksnode(1,S_RETURN,0); }
1.5 ! noro 1412: break;
1.1 noro 1413: case 19:
1.5 ! noro 1414: #line 162 "parse.y"
1.4 noro 1415: { yyval.s = mksnode(1,S_RETURN,yyvsp[-1].f); }
1.5 ! noro 1416: break;
1.1 noro 1417: case 20:
1.5 ! noro 1418: #line 164 "parse.y"
1.4 noro 1419: { yyval.s = mksnode(4,S_IFELSE,yyvsp[-4].i,yyvsp[-2].n,yyvsp[0].s,0); yyvsp[0].s?yyval.s->ln=yyvsp[0].s->ln:0; NOPR; }
1.5 ! noro 1420: break;
1.1 noro 1421: case 21:
1.5 ! noro 1422: #line 166 "parse.y"
1.4 noro 1423: { yyval.s = mksnode(4,S_IFELSE,yyvsp[-6].i,yyvsp[-4].n,yyvsp[-2].s,yyvsp[0].s); yyvsp[0].s?yyval.s->ln=yyvsp[0].s->ln:0; NOPR; }
1.5 ! noro 1424: break;
1.4 noro 1425: case 22:
1.5 ! noro 1426: #line 168 "parse.y"
1.4 noro 1427: { yyval.s = mksnode(5,S_FOR,yyvsp[-8].i,yyvsp[-6].n,yyvsp[-4].n?yyvsp[-4].n:ONENODE,yyvsp[-2].n,yyvsp[0].s); yyvsp[0].s?yyval.s->ln=yyvsp[0].s->ln:0; NOPR; }
1.5 ! noro 1428: break;
1.4 noro 1429: case 23:
1.5 ! noro 1430: #line 170 "parse.y"
1.4 noro 1431: { yyval.s = mksnode(5,S_FOR,yyvsp[-4].i,0,yyvsp[-2].n,0,yyvsp[0].s); yyvsp[0].s?yyval.s->ln=yyvsp[0].s->ln:0; NOPR; }
1.5 ! noro 1432: break;
1.4 noro 1433: case 24:
1.5 ! noro 1434: #line 172 "parse.y"
1.4 noro 1435: { yyval.s = mksnode(3,S_DO,yyvsp[-6].i,yyvsp[-5].s,yyvsp[-2].n); }
1.5 ! noro 1436: break;
1.4 noro 1437: case 25:
1.5 ! noro 1438: #line 174 "parse.y"
1.4 noro 1439: { yyval.s = mksnode(3,S_PFDEF,yyvsp[-7].p,yyvsp[-5].n,yyvsp[-1].f); NOPR; }
1.5 ! noro 1440: break;
1.4 noro 1441: case 26:
1.5 ! noro 1442: #line 176 "parse.y"
1.4 noro 1443: { yyval.s = mksnode(3,S_PFDEF,yyvsp[-4].p,yyvsp[-2].n,0); NOPR; }
1.5 ! noro 1444: break;
1.4 noro 1445: case 27:
1.5 ! noro 1446: #line 177 "parse.y"
1.4 noro 1447: { mkpvs(yyvsp[0].p); }
1.5 ! noro 1448: break;
1.4 noro 1449: case 28:
1.5 ! noro 1450: #line 177 "parse.y"
1.4 noro 1451: { ldef = 1; }
1.5 ! noro 1452: break;
1.4 noro 1453: case 29:
1.5 ! noro 1454: #line 177 "parse.y"
1.4 noro 1455: { ldef = -1; }
1.5 ! noro 1456: break;
1.4 noro 1457: case 30:
1.5 ! noro 1458: #line 178 "parse.y"
1.1 noro 1459: {
1.4 noro 1460: mkuf(yyvsp[-10].p,asir_infile->name,yyvsp[-6].n,
1461: mksnode(1,S_CPLX,yyvsp[-1].n),yyvsp[-11].i,asir_infile->ln,yyvsp[-3].p,CUR_MODULE);
1.1 noro 1462: yyval.s = 0; NOPR;
1463: }
1.5 ! noro 1464: break;
1.4 noro 1465: case 31:
1.5 ! noro 1466: #line 184 "parse.y"
1.4 noro 1467: { CUR_MODULE = mkmodule(yyvsp[-1].p); MPVS = CUR_MODULE->pvs; yyval.s = 0; NOPR; }
1.5 ! noro 1468: break;
1.4 noro 1469: case 32:
1.5 ! noro 1470: #line 186 "parse.y"
1.4 noro 1471: { CUR_MODULE = 0; MPVS = 0; yyval.s = 0; NOPR; }
1.5 ! noro 1472: break;
1.4 noro 1473: case 33:
1.5 ! noro 1474: #line 188 "parse.y"
1.1 noro 1475: { yyerrok; yyval.s = 0; }
1.5 ! noro 1476: break;
1.4 noro 1477: case 34:
1.5 ! noro 1478: #line 191 "parse.y"
1.1 noro 1479: { if ( main_parser ) prresult = 1; }
1.5 ! noro 1480: break;
1.4 noro 1481: case 35:
1.5 ! noro 1482: #line 193 "parse.y"
1.1 noro 1483: { if ( main_parser ) prresult = 0; }
1.5 ! noro 1484: break;
1.4 noro 1485: case 36:
1.5 ! noro 1486: #line 196 "parse.y"
1.1 noro 1487: { yyval.p = 0; }
1.5 ! noro 1488: break;
1.4 noro 1489: case 37:
1.5 ! noro 1490: #line 198 "parse.y"
1.1 noro 1491: { yyval.p = yyvsp[0].p; }
1.5 ! noro 1492: break;
1.4 noro 1493: case 38:
1.5 ! noro 1494: #line 201 "parse.y"
1.1 noro 1495: { yyval.s = mksnode(1,S_CPLX,yyvsp[-1].n); }
1.5 ! noro 1496: break;
1.4 noro 1497: case 39:
1.5 ! noro 1498: #line 204 "parse.y"
1.4 noro 1499: { MKNODE(yyval.n,yyvsp[0].p,0); }
1.5 ! noro 1500: break;
1.4 noro 1501: case 40:
1.5 ! noro 1502: #line 206 "parse.y"
1.4 noro 1503: { appendtonode(yyvsp[-2].n,yyvsp[0].p,&yyval.n); }
1.5 ! noro 1504: break;
1.4 noro 1505: case 41:
1.5 ! noro 1506: #line 209 "parse.y"
1.1 noro 1507: { MKNODE(yyval.n,yyvsp[0].p,0); }
1.5 ! noro 1508: break;
1.4 noro 1509: case 42:
1.5 ! noro 1510: #line 211 "parse.y"
1.1 noro 1511: { appendtonode(yyvsp[-2].n,yyvsp[0].p,&yyval.n); }
1.5 ! noro 1512: break;
1.4 noro 1513: case 43:
1.5 ! noro 1514: #line 214 "parse.y"
1.1 noro 1515: { val = (pointer)makepvar(yyvsp[0].p); MKNODE(yyval.n,val,0); }
1.5 ! noro 1516: break;
1.4 noro 1517: case 44:
1.5 ! noro 1518: #line 216 "parse.y"
1.1 noro 1519: { appendtonode(yyvsp[-2].n,(pointer)makepvar(yyvsp[0].p),&yyval.n); }
1.5 ! noro 1520: break;
1.4 noro 1521: case 45:
1.5 ! noro 1522: #line 219 "parse.y"
1.1 noro 1523: { yyval.n = 0; }
1.5 ! noro 1524: break;
1.4 noro 1525: case 46:
1.5 ! noro 1526: #line 221 "parse.y"
1.1 noro 1527: { appendtonode(yyvsp[-1].n,(pointer)yyvsp[0].s,&yyval.n); }
1.5 ! noro 1528: break;
1.4 noro 1529: case 47:
1.5 ! noro 1530: #line 224 "parse.y"
1.1 noro 1531: { yyval.n = 0; }
1.5 ! noro 1532: break;
1.4 noro 1533: case 48:
1.5 ! noro 1534: #line 226 "parse.y"
1.1 noro 1535: { yyval.n = yyvsp[0].n; }
1.5 ! noro 1536: break;
1.4 noro 1537: case 49:
1.5 ! noro 1538: #line 229 "parse.y"
1.1 noro 1539: { MKNODE(yyval.n,yyvsp[0].f,0); }
1.5 ! noro 1540: break;
1.4 noro 1541: case 50:
1.5 ! noro 1542: #line 231 "parse.y"
1.1 noro 1543: { appendtonode(yyvsp[-2].n,(pointer)yyvsp[0].f,&yyval.n); }
1.5 ! noro 1544: break;
1.4 noro 1545: case 51:
1.5 ! noro 1546: #line 234 "parse.y"
1.1 noro 1547: { MKNODE(yyval.n,yyvsp[0].f,0); }
1.5 ! noro 1548: break;
1.4 noro 1549: case 52:
1.5 ! noro 1550: #line 236 "parse.y"
1.1 noro 1551: { appendtonode(yyvsp[-2].n,(pointer)yyvsp[0].f,&yyval.n); }
1.5 ! noro 1552: break;
1.4 noro 1553: case 53:
1.5 ! noro 1554: #line 239 "parse.y"
1.1 noro 1555: { yyval.p = yyvsp[0].p; }
1.5 ! noro 1556: break;
1.4 noro 1557: case 54:
1.5 ! noro 1558: #line 241 "parse.y"
1.1 noro 1559: { yyval.p = yyvsp[0].p; }
1.5 ! noro 1560: break;
1.4 noro 1561: case 55:
1.5 ! noro 1562: #line 244 "parse.y"
1.1 noro 1563: { yyval.f = mkfnode(2,I_OPT,yyvsp[-2].p,yyvsp[0].f); }
1.5 ! noro 1564: break;
1.4 noro 1565: case 56:
1.5 ! noro 1566: #line 247 "parse.y"
1.1 noro 1567: { yyval.f = mkfnode(1,I_STR,yyvsp[0].p); }
1.5 ! noro 1568: break;
1.4 noro 1569: case 57:
1.5 ! noro 1570: #line 249 "parse.y"
1.1 noro 1571: { yyval.f = mkfnode(1,I_FORMULA,yyvsp[0].p); }
1.5 ! noro 1572: break;
1.4 noro 1573: case 58:
1.5 ! noro 1574: #line 251 "parse.y"
1.1 noro 1575: { yyval.f = mkfnode(1,I_ANS,yyvsp[0].i); }
1.5 ! noro 1576: break;
1.4 noro 1577: case 59:
1.5 ! noro 1578: #line 253 "parse.y"
1.1 noro 1579: { yyval.f = mkfnode(0,I_GF2NGEN); }
1.5 ! noro 1580: break;
1.4 noro 1581: case 60:
1.5 ! noro 1582: #line 255 "parse.y"
1.1 noro 1583: { yyval.f = mkfnode(0,I_GFPNGEN); }
1.5 ! noro 1584: break;
1.4 noro 1585: case 61:
1.5 ! noro 1586: #line 257 "parse.y"
1.3 noro 1587: { yyval.f = mkfnode(0,I_GFSNGEN); }
1.5 ! noro 1588: break;
1.4 noro 1589: case 62:
1.5 ! noro 1590: #line 259 "parse.y"
1.1 noro 1591: {
1592: FUNC f;
1593:
1594: searchf(noargsysf,yyvsp[0].p,&f);
1595: if ( f )
1596: yyval.f = mkfnode(2,I_FUNC,f,0);
1597: else {
1598: searchc(yyvsp[0].p,&f);
1599: if ( f )
1600: yyval.f = mkfnode(2,I_FUNC,f,mkfnode(1,I_LIST,0));
1601: else {
1602: searchf(sysf,yyvsp[0].p,&f);
1603: if ( !f )
1604: searchf(ubinf,yyvsp[0].p,&f);
1605: if ( !f )
1606: searchpf(yyvsp[0].p,&f);
1607: if ( !f )
1608: searchf(usrf,yyvsp[0].p,&f);
1609: if ( f )
1610: makesrvar(f,(P *)&val);
1611: else
1612: makevar(yyvsp[0].p,(P *)&val);
1613: yyval.f = mkfnode(1,I_FORMULA,val);
1614: }
1615: }
1616: }
1.5 ! noro 1617: break;
1.4 noro 1618: case 63:
1.5 ! noro 1619: #line 286 "parse.y"
1.1 noro 1620: {
1.3 noro 1621: gen_searchf(yyvsp[-3].p,(FUNC *)&val);
1.4 noro 1622: print_crossref(val);
1.1 noro 1623: yyval.f = mkfnode(2,I_FUNC,val,mkfnode(1,I_LIST,yyvsp[-1].n));
1624: }
1.5 ! noro 1625: break;
1.4 noro 1626: case 64:
1.5 ! noro 1627: #line 293 "parse.y"
1.1 noro 1628: {
1.3 noro 1629: gen_searchf(yyvsp[-5].p,(FUNC *)&val);
1.4 noro 1630: print_crossref(val);
1.1 noro 1631: yyval.f = mkfnode(3,I_FUNC_OPT,val,
1632: mkfnode(1,I_LIST,yyvsp[-3].n),mkfnode(1,I_LIST,yyvsp[-1].n));
1633: }
1.5 ! noro 1634: break;
1.4 noro 1635: case 65:
1.5 ! noro 1636: #line 300 "parse.y"
1.3 noro 1637: {
1638: gen_searchf(yyvsp[-3].p,(FUNC *)&val);
1.4 noro 1639: print_crossref(val);
1.3 noro 1640: yyval.f = mkfnode(2,I_MAP,val,mkfnode(1,I_LIST,yyvsp[-1].n));
1641: }
1.5 ! noro 1642: break;
1.4 noro 1643: case 66:
1.5 ! noro 1644: #line 306 "parse.y"
1.3 noro 1645: {
1646: gen_searchf(yyvsp[-3].p,(FUNC *)&val);
1.4 noro 1647: print_crossref(val);
1.3 noro 1648: yyval.f = mkfnode(2,I_RECMAP,val,mkfnode(1,I_LIST,yyvsp[-1].n));
1649: }
1.5 ! noro 1650: break;
1.4 noro 1651: case 67:
1.5 ! noro 1652: #line 312 "parse.y"
1.1 noro 1653: {
1654: searchpf(yyvsp[-6].p,(FUNC *)&val);
1655: yyval.f = mkfnode(2,I_PFDERIV,val,mkfnode(1,I_LIST,yyvsp[-1].n),mkfnode(1,I_LIST,yyvsp[-4].n));
1656: }
1.5 ! noro 1657: break;
1.4 noro 1658: case 68:
1.5 ! noro 1659: #line 317 "parse.y"
1.3 noro 1660: {
1661: yyval.f = mkfnode(2,I_GETOPT,yyvsp[-1].p);
1662: }
1.5 ! noro 1663: break;
1.4 noro 1664: case 69:
1.5 ! noro 1665: #line 321 "parse.y"
1.1 noro 1666: {
1.3 noro 1667: yyval.f = mkfnode(2,I_GETOPT,0);
1.1 noro 1668: }
1.5 ! noro 1669: break;
1.4 noro 1670: case 70:
1.5 ! noro 1671: #line 325 "parse.y"
1.1 noro 1672: {
1.3 noro 1673: yyval.f = mkfnode(3,I_TIMER,yyvsp[-5].f,yyvsp[-3].f,yyvsp[-1].f);
1.1 noro 1674: }
1.5 ! noro 1675: break;
1.4 noro 1676: case 71:
1.5 ! noro 1677: #line 329 "parse.y"
1.1 noro 1678: {
1.3 noro 1679: searchf(parif,yyvsp[-1].p,(FUNC *)&val);
1680: if ( !val )
1681: mkparif(yyvsp[-1].p,(FUNC *)&val);
1682: yyval.f = mkfnode(2,I_FUNC,val,0);
1.1 noro 1683: }
1.5 ! noro 1684: break;
1.4 noro 1685: case 72:
1.5 ! noro 1686: #line 336 "parse.y"
1.1 noro 1687: {
1688: searchf(parif,yyvsp[-3].p,(FUNC *)&val);
1689: if ( !val )
1690: mkparif(yyvsp[-3].p,(FUNC *)&val);
1691: yyval.f = mkfnode(2,I_FUNC,val,mkfnode(1,I_LIST,yyvsp[-1].n));
1692: }
1.5 ! noro 1693: break;
1.4 noro 1694: case 73:
1.5 ! noro 1695: #line 343 "parse.y"
1.1 noro 1696: {
1697: yyval.f = mkfnode(2,I_IFUNC,yyvsp[-4].f,mkfnode(1,I_LIST,yyvsp[-1].n));
1698: }
1.5 ! noro 1699: break;
1.4 noro 1700: case 74:
1.5 ! noro 1701: #line 347 "parse.y"
1.1 noro 1702: { yyval.f = mkfnode(1,I_CAR,yyvsp[-1].f); }
1.5 ! noro 1703: break;
1.4 noro 1704: case 75:
1.5 ! noro 1705: #line 349 "parse.y"
1.1 noro 1706: { yyval.f = mkfnode(1,I_CDR,yyvsp[-1].f); }
1.5 ! noro 1707: break;
1.4 noro 1708: case 76:
1.5 ! noro 1709: #line 351 "parse.y"
1.3 noro 1710: { yyval.f = mkfnode(1,I_PAREN,yyvsp[-1].f); }
1.5 ! noro 1711: break;
1.4 noro 1712: case 77:
1.5 ! noro 1713: #line 353 "parse.y"
1.1 noro 1714: {
1.4 noro 1715: if ( main_parser || allow_create_var )
1.1 noro 1716: yyval.f = mkfnode(2,I_PVAR,makepvar(yyvsp[0].p),0);
1717: else {
1718: ind = searchpvar(yyvsp[0].p);
1719: if ( ind == -1 ) {
1720: fprintf(stderr,"%s : no such variable.\n",yyvsp[0].p);
1721: YYABORT;
1722: } else
1723: yyval.f = mkfnode(2,I_PVAR,ind,0);
1724: }
1725: }
1.5 ! noro 1726: break;
1.4 noro 1727: case 78:
1.5 ! noro 1728: #line 366 "parse.y"
1.1 noro 1729: {
1730: if ( yyvsp[-3].f->id == I_PVAR || yyvsp[-3].f->id == I_INDEX ) {
1731: appendtonode((NODE)yyvsp[-3].f->arg[1],(pointer)yyvsp[-1].f,&a);
1732: yyvsp[-3].f->arg[1] = (pointer)a; yyval.f = yyvsp[-3].f;
1733: } else {
1734: MKNODE(a,yyvsp[-1].f,0);
1735: yyval.f = mkfnode(2,I_INDEX,(pointer)yyvsp[-3].f,a);
1736: }
1737: }
1.5 ! noro 1738: break;
1.4 noro 1739: case 79:
1.5 ! noro 1740: #line 376 "parse.y"
1.1 noro 1741: { yyval.f = mkfnode(2,I_POINT,yyvsp[-2].f,yyvsp[0].p); }
1.5 ! noro 1742: break;
1.4 noro 1743: case 80:
1.5 ! noro 1744: #line 379 "parse.y"
1.3 noro 1745: { yyval.f = yyvsp[0].f; }
1.5 ! noro 1746: break;
1.4 noro 1747: case 81:
1.5 ! noro 1748: #line 381 "parse.y"
1.3 noro 1749: { yyval.f = mkfnode(3,I_CAST,structtoindex(yyvsp[-2].p),yyvsp[0].f,0); }
1.5 ! noro 1750: break;
1.4 noro 1751: case 82:
1.5 ! noro 1752: #line 383 "parse.y"
1.3 noro 1753: { yyval.f = mkfnode(2,I_ASSPVAR,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1754: break;
1.4 noro 1755: case 83:
1.5 ! noro 1756: #line 385 "parse.y"
1.3 noro 1757: { yyval.f = mkfnode(2,I_ASSPVAR,yyvsp[-2].f,mkfnode(3,I_BOP,yyvsp[-1].p,yyvsp[-2].f,yyvsp[0].f)); }
1.5 ! noro 1758: break;
1.4 noro 1759: case 84:
1.5 ! noro 1760: #line 387 "parse.y"
1.3 noro 1761: { yyval.f = mkfnode(2,I_POSTSELF,yyvsp[0].p,yyvsp[-1].f); }
1.5 ! noro 1762: break;
1.4 noro 1763: case 85:
1.5 ! noro 1764: #line 389 "parse.y"
1.3 noro 1765: { yyval.f = mkfnode(2,I_PRESELF,yyvsp[-1].p,yyvsp[0].f); }
1.5 ! noro 1766: break;
1.4 noro 1767: case 86:
1.5 ! noro 1768: #line 391 "parse.y"
1.3 noro 1769: { yyval.f = mkfnode(1,I_LIST,yyvsp[-1].n); }
1.5 ! noro 1770: break;
1.4 noro 1771: case 87:
1.5 ! noro 1772: #line 393 "parse.y"
1.3 noro 1773: { yyval.f = yyvsp[0].f; }
1.5 ! noro 1774: break;
1.4 noro 1775: case 88:
1.5 ! noro 1776: #line 395 "parse.y"
1.3 noro 1777: { yyval.f = mkfnode(1,I_MINUS,yyvsp[0].f); }
1.5 ! noro 1778: break;
1.4 noro 1779: case 89:
1.5 ! noro 1780: #line 397 "parse.y"
1.3 noro 1781: { yyval.f = mkfnode(3,I_BOP,yyvsp[-1].p,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1782: break;
1.4 noro 1783: case 90:
1.5 ! noro 1784: #line 399 "parse.y"
1.3 noro 1785: { yyval.f = mkfnode(3,I_BOP,yyvsp[-1].p,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1786: break;
1.4 noro 1787: case 91:
1.5 ! noro 1788: #line 401 "parse.y"
1.3 noro 1789: { yyval.f = mkfnode(3,I_BOP,yyvsp[-1].p,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1790: break;
1.4 noro 1791: case 92:
1.5 ! noro 1792: #line 403 "parse.y"
1.1 noro 1793: { yyval.f = mkfnode(3,I_BOP,yyvsp[-1].p,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1794: break;
1.4 noro 1795: case 93:
1.5 ! noro 1796: #line 405 "parse.y"
1.1 noro 1797: { yyval.f = mkfnode(3,I_BOP,yyvsp[-1].p,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1798: break;
1.4 noro 1799: case 94:
1.5 ! noro 1800: #line 407 "parse.y"
1.1 noro 1801: { yyval.f = mkfnode(3,I_BOP,yyvsp[-1].p,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1802: break;
1.4 noro 1803: case 95:
1.5 ! noro 1804: #line 409 "parse.y"
1.3 noro 1805: { yyval.f = mkfnode(3,I_COP,yyvsp[-1].i,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1806: break;
1.4 noro 1807: case 96:
1.5 ! noro 1808: #line 411 "parse.y"
1.3 noro 1809: { yyval.f = mkfnode(1,I_NOT,yyvsp[0].f); }
1.5 ! noro 1810: break;
1.4 noro 1811: case 97:
1.5 ! noro 1812: #line 413 "parse.y"
1.3 noro 1813: { yyval.f = mkfnode(2,I_OR,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1814: break;
1.4 noro 1815: case 98:
1.5 ! noro 1816: #line 415 "parse.y"
1.3 noro 1817: { yyval.f = mkfnode(2,I_AND,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1818: break;
1.4 noro 1819: case 99:
1.5 ! noro 1820: #line 417 "parse.y"
1.3 noro 1821: { yyval.f = mkfnode(3,I_LOP,yyvsp[-1].i,yyvsp[0].f,0); }
1.5 ! noro 1822: break;
1.4 noro 1823: case 100:
1.5 ! noro 1824: #line 419 "parse.y"
1.3 noro 1825: { yyval.f = mkfnode(3,I_LOP,yyvsp[-1].i,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1826: break;
1.4 noro 1827: case 101:
1.5 ! noro 1828: #line 421 "parse.y"
1.3 noro 1829: { yyval.f = mkfnode(3,I_LOP,yyvsp[-1].i,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1830: break;
1.4 noro 1831: case 102:
1.5 ! noro 1832: #line 423 "parse.y"
1.3 noro 1833: { yyval.f = mkfnode(3,I_LOP,yyvsp[-1].i,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1834: break;
1.4 noro 1835: case 103:
1.5 ! noro 1836: #line 425 "parse.y"
1.1 noro 1837: { yyval.f = mkfnode(3,I_LOP,yyvsp[-1].i,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1838: break;
1.4 noro 1839: case 104:
1.5 ! noro 1840: #line 427 "parse.y"
1.1 noro 1841: { yyval.f = mkfnode(3,I_LOP,yyvsp[-1].i,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1842: break;
1.4 noro 1843: case 105:
1.5 ! noro 1844: #line 429 "parse.y"
1.1 noro 1845: { yyval.f = mkfnode(3,I_LOP,yyvsp[-1].i,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1846: break;
1.4 noro 1847: case 106:
1.5 ! noro 1848: #line 431 "parse.y"
1.3 noro 1849: { yyval.f = mkfnode(3,I_CE,yyvsp[-4].f,yyvsp[-2].f,yyvsp[0].f); }
1.5 ! noro 1850: break;
1.4 noro 1851: case 107:
1.5 ! noro 1852: #line 433 "parse.y"
1.3 noro 1853: { yyval.f = mkfnode(1,I_EV,yyvsp[-1].n); }
1.5 ! noro 1854: break;
1.4 noro 1855: case 108:
1.5 ! noro 1856: #line 435 "parse.y"
1.3 noro 1857: { yyval.f = mkfnode(1,I_NEWCOMP,(int)structtoindex(yyvsp[-1].p)); }
1.5 ! noro 1858: break;
1.4 noro 1859: case 109:
1.5 ! noro 1860: #line 437 "parse.y"
1.2 noro 1861: { MKQUOTE(quote,yyvsp[-1].f); yyval.f = mkfnode(1,I_FORMULA,(pointer)quote); }
1.5 ! noro 1862: break;
1.4 noro 1863: case 110:
1.5 ! noro 1864: #line 439 "parse.y"
1.4 noro 1865: { MKQUOTE(quote,yyvsp[0].f); yyval.f = mkfnode(1,I_FORMULA,(pointer)quote); }
1.5 ! noro 1866: break;
! 1867: }
! 1868:
! 1869: #line 705 "/usr/share/bison/bison.simple"
! 1870:
! 1871:
! 1872: yyvsp -= yylen;
! 1873: yyssp -= yylen;
! 1874: #if YYLSP_NEEDED
! 1875: yylsp -= yylen;
! 1876: #endif
! 1877:
! 1878: #if YYDEBUG
! 1879: if (yydebug)
! 1880: {
! 1881: short *yyssp1 = yyss - 1;
! 1882: YYFPRINTF (stderr, "state stack now");
! 1883: while (yyssp1 != yyssp)
! 1884: YYFPRINTF (stderr, " %d", *++yyssp1);
! 1885: YYFPRINTF (stderr, "\n");
1.1 noro 1886: }
1.5 ! noro 1887: #endif
! 1888:
! 1889: *++yyvsp = yyval;
! 1890: #if YYLSP_NEEDED
! 1891: *++yylsp = yyloc;
! 1892: #endif
! 1893:
! 1894: /* Now `shift' the result of the reduction. Determine what state
! 1895: that goes to, based on the state we popped back to and the rule
! 1896: number reduced by. */
! 1897:
! 1898: yyn = yyr1[yyn];
! 1899:
! 1900: yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
! 1901: if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
! 1902: yystate = yytable[yystate];
! 1903: else
! 1904: yystate = yydefgoto[yyn - YYNTBASE];
! 1905:
! 1906: goto yynewstate;
! 1907:
! 1908:
! 1909: /*------------------------------------.
! 1910: | yyerrlab -- here on detecting error |
! 1911: `------------------------------------*/
! 1912: yyerrlab:
! 1913: /* If not already recovering from an error, report this error. */
! 1914: if (!yyerrstatus)
! 1915: {
! 1916: ++yynerrs;
! 1917:
! 1918: #ifdef YYERROR_VERBOSE
! 1919: yyn = yypact[yystate];
! 1920:
! 1921: if (yyn > YYFLAG && yyn < YYLAST)
! 1922: {
! 1923: YYSIZE_T yysize = 0;
! 1924: char *yymsg;
! 1925: int yyx, yycount;
! 1926:
! 1927: yycount = 0;
! 1928: /* Start YYX at -YYN if negative to avoid negative indexes in
! 1929: YYCHECK. */
! 1930: for (yyx = yyn < 0 ? -yyn : 0;
! 1931: yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
! 1932: if (yycheck[yyx + yyn] == yyx)
! 1933: yysize += yystrlen (yytname[yyx]) + 15, yycount++;
! 1934: yysize += yystrlen ("parse error, unexpected ") + 1;
! 1935: yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
! 1936: yymsg = (char *) YYSTACK_ALLOC (yysize);
! 1937: if (yymsg != 0)
! 1938: {
! 1939: char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
! 1940: yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
! 1941:
! 1942: if (yycount < 5)
! 1943: {
! 1944: yycount = 0;
! 1945: for (yyx = yyn < 0 ? -yyn : 0;
! 1946: yyx < (int) (sizeof (yytname) / sizeof (char *));
! 1947: yyx++)
! 1948: if (yycheck[yyx + yyn] == yyx)
! 1949: {
! 1950: const char *yyq = ! yycount ? ", expecting " : " or ";
! 1951: yyp = yystpcpy (yyp, yyq);
! 1952: yyp = yystpcpy (yyp, yytname[yyx]);
! 1953: yycount++;
! 1954: }
! 1955: }
! 1956: yyerror (yymsg);
! 1957: YYSTACK_FREE (yymsg);
! 1958: }
! 1959: else
! 1960: yyerror ("parse error; also virtual memory exhausted");
! 1961: }
! 1962: else
! 1963: #endif /* defined (YYERROR_VERBOSE) */
! 1964: yyerror ("parse error");
! 1965: }
! 1966: goto yyerrlab1;
! 1967:
! 1968:
! 1969: /*--------------------------------------------------.
! 1970: | yyerrlab1 -- error raised explicitly by an action |
! 1971: `--------------------------------------------------*/
! 1972: yyerrlab1:
! 1973: if (yyerrstatus == 3)
1.1 noro 1974: {
1.5 ! noro 1975: /* If just tried and failed to reuse lookahead token after an
! 1976: error, discard it. */
! 1977:
! 1978: /* return failure if at end of input */
! 1979: if (yychar == YYEOF)
! 1980: YYABORT;
! 1981: YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
! 1982: yychar, yytname[yychar1]));
! 1983: yychar = YYEMPTY;
! 1984: }
! 1985:
! 1986: /* Else will try to reuse lookahead token after shifting the error
! 1987: token. */
! 1988:
! 1989: yyerrstatus = 3; /* Each real token shifted decrements this */
! 1990:
! 1991: goto yyerrhandle;
! 1992:
! 1993:
! 1994: /*-------------------------------------------------------------------.
! 1995: | yyerrdefault -- current state does not do anything special for the |
! 1996: | error token. |
! 1997: `-------------------------------------------------------------------*/
! 1998: yyerrdefault:
! 1999: #if 0
! 2000: /* This is wrong; only states that explicitly want error tokens
! 2001: should shift them. */
! 2002:
! 2003: /* If its default is to accept any token, ok. Otherwise pop it. */
! 2004: yyn = yydefact[yystate];
! 2005: if (yyn)
! 2006: goto yydefault;
! 2007: #endif
! 2008:
! 2009:
! 2010: /*---------------------------------------------------------------.
! 2011: | yyerrpop -- pop the current state because it cannot handle the |
! 2012: | error token |
! 2013: `---------------------------------------------------------------*/
! 2014: yyerrpop:
! 2015: if (yyssp == yyss)
! 2016: YYABORT;
! 2017: yyvsp--;
! 2018: yystate = *--yyssp;
! 2019: #if YYLSP_NEEDED
! 2020: yylsp--;
! 2021: #endif
! 2022:
1.1 noro 2023: #if YYDEBUG
1.5 ! noro 2024: if (yydebug)
! 2025: {
! 2026: short *yyssp1 = yyss - 1;
! 2027: YYFPRINTF (stderr, "Error: state stack now");
! 2028: while (yyssp1 != yyssp)
! 2029: YYFPRINTF (stderr, " %d", *++yyssp1);
! 2030: YYFPRINTF (stderr, "\n");
1.1 noro 2031: }
2032: #endif
1.5 ! noro 2033:
! 2034: /*--------------.
! 2035: | yyerrhandle. |
! 2036: `--------------*/
! 2037: yyerrhandle:
! 2038: yyn = yypact[yystate];
! 2039: if (yyn == YYFLAG)
! 2040: goto yyerrdefault;
! 2041:
! 2042: yyn += YYTERROR;
! 2043: if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
! 2044: goto yyerrdefault;
! 2045:
! 2046: yyn = yytable[yyn];
! 2047: if (yyn < 0)
1.1 noro 2048: {
1.5 ! noro 2049: if (yyn == YYFLAG)
! 2050: goto yyerrpop;
! 2051: yyn = -yyn;
! 2052: goto yyreduce;
1.1 noro 2053: }
1.5 ! noro 2054: else if (yyn == 0)
! 2055: goto yyerrpop;
! 2056:
! 2057: if (yyn == YYFINAL)
! 2058: YYACCEPT;
! 2059:
! 2060: YYDPRINTF ((stderr, "Shifting error token, "));
! 2061:
! 2062: *++yyvsp = yylval;
! 2063: #if YYLSP_NEEDED
! 2064: *++yylsp = yylloc;
! 2065: #endif
! 2066:
! 2067: yystate = yyn;
! 2068: goto yynewstate;
! 2069:
! 2070:
! 2071: /*-------------------------------------.
! 2072: | yyacceptlab -- YYACCEPT comes here. |
! 2073: `-------------------------------------*/
! 2074: yyacceptlab:
! 2075: yyresult = 0;
! 2076: goto yyreturn;
! 2077:
! 2078: /*-----------------------------------.
! 2079: | yyabortlab -- YYABORT comes here. |
! 2080: `-----------------------------------*/
! 2081: yyabortlab:
! 2082: yyresult = 1;
! 2083: goto yyreturn;
! 2084:
! 2085: /*---------------------------------------------.
! 2086: | yyoverflowab -- parser overflow comes here. |
! 2087: `---------------------------------------------*/
! 2088: yyoverflowlab:
! 2089: yyerror ("parser stack overflow");
! 2090: yyresult = 2;
! 2091: /* Fall through. */
! 2092:
! 2093: yyreturn:
! 2094: #ifndef yyoverflow
! 2095: if (yyss != yyssa)
! 2096: YYSTACK_FREE (yyss);
! 2097: #endif
! 2098: return yyresult;
1.1 noro 2099: }
1.5 ! noro 2100: #line 441 "parse.y"
! 2101:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ytab.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / parse