/* A Bison parser, made by GNU Bison 3.0.2. */ /* Skeleton implementation for Bison LALR(1) parsers in Java Copyright (C) 2007-2013 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, 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, see . */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work under terms of your choice, so long as that work isn't itself a parser generator using the skeleton or a modified version thereof as a parser skeleton. Alternatively, if you modify or redistribute the parser skeleton itself, you may (at your option) remove this special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception. This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ /* First part of user declarations. */ /* "YYParser.java":36 */ /* lalr1.java:91 */ /* "YYParser.java":38 */ /* lalr1.java:92 */ /** * A Bison parser, automatically generated from YYParser.y. * * @author LALR (1) parser skeleton written by Paolo Bonzini. */ class YYParser { /** Version number for the Bison executable that generated this parser. */ public static final String bisonVersion = "3.0.2"; /** Name of the skeleton that generated this parser. */ public static final String bisonSkeleton = "lalr1.java"; /** * Communication interface between the scanner and the Bison-generated * parser YYParser. */ public interface Lexer { /** Token returned by the scanner to signal the end of its input. */ public static final int EOF = 0; /* Tokens. */ /** Token number,to be returned by the scanner. */ static final int CAND = 258; /** Token number,to be returned by the scanner. */ static final int CHARACTERS = 259; /** Token number,to be returned by the scanner. */ static final int CONSTANTS = 260; /** Token number,to be returned by the scanner. */ static final int COR = 261; /** Token number,to be returned by the scanner. */ static final int DO = 262; /** Token number,to be returned by the scanner. */ static final int ELSE = 263; /** Token number,to be returned by the scanner. */ static final int ELSIF = 264; /** Token number,to be returned by the scanner. */ static final int END = 265; /** Token number,to be returned by the scanner. */ static final int ENUM = 266; /** Token number,to be returned by the scanner. */ static final int EXPORT = 267; /** Token number,to be returned by the scanner. */ static final int FI = 268; /** Token number,to be returned by the scanner. */ static final int FIELD = 269; /** Token number,to be returned by the scanner. */ static final int FUNC = 270; /** Token number,to be returned by the scanner. */ static final int HIDE = 271; /** Token number,to be returned by the scanner. */ static final int IF = 272; /** Token number,to be returned by the scanner. */ static final int IN = 273; /** Token number,to be returned by the scanner. */ static final int EXTEND = 274; /** Token number,to be returned by the scanner. */ static final int LET = 275; /** Token number,to be returned by the scanner. */ static final int NI = 276; /** Token number,to be returned by the scanner. */ static final int OD = 277; /** Token number,to be returned by the scanner. */ static final int READONLY = 278; /** Token number,to be returned by the scanner. */ static final int RECORD = 279; /** Token number,to be returned by the scanner. */ static final int THEN = 280; /** Token number,to be returned by the scanner. */ static final int TYPE = 281; /** Token number,to be returned by the scanner. */ static final int UNION = 282; /** Token number,to be returned by the scanner. */ static final int USE = 283; /** Token number,to be returned by the scanner. */ static final int VAL = 284; /** Token number,to be returned by the scanner. */ static final int VAR = 285; /** Token number,to be returned by the scanner. */ static final int WITH = 286; /** Token number,to be returned by the scanner. */ static final int RIGHT_ARROW = 287; /** Token number,to be returned by the scanner. */ static final int EQUALS_EQUALS = 288; /** Token number,to be returned by the scanner. */ static final int EQUALS_EQUALS_EQUALS = 289; /** Token number,to be returned by the scanner. */ static final int COLON = 290; /** Token number,to be returned by the scanner. */ static final int WORDID = 291; /** Token number,to be returned by the scanner. */ static final int OPID = 292; /** Token number,to be returned by the scanner. */ static final int PROD = 293; /** Token number,to be returned by the scanner. */ static final int QSTRING = 294; /** Token number,to be returned by the scanner. */ static final int UQSTRING = 295; /** Token number,to be returned by the scanner. */ static final int LEFT_ANGLE_BRACKET = 296; /** Token number,to be returned by the scanner. */ static final int RIGHT_ANGLE_BRACKET = 297; /** Token number,to be returned by the scanner. */ static final int EXTERN = 298; /** Token number,to be returned by the scanner. */ static final int SIGNATURE = 299; /** * Method to retrieve the semantic value of the last scanned token. * @return the semantic value of the last scanned token. */ Object getLVal (); /** * Entry point for the scanner. Returns the token identifier corresponding * to the next token and prepares to return the semantic value * of the token. * @return the token identifier corresponding to the next token. */ int yylex () throws java.io.IOException; /** * Entry point for error reporting. Emits an error * in a user-defined way. * * * @param msg The string for the error message. */ void yyerror (String msg); } /** * The object doing lexical analysis for us. */ private Lexer yylexer; /** * Instantiates the Bison-generated parser. * @param yylexer The scanner that will supply tokens to the parser. */ public YYParser (Lexer yylexer) { this.yylexer = yylexer; } private java.io.PrintStream yyDebugStream = System.err; /** * Return the PrintStream on which the debugging output is * printed. */ public final java.io.PrintStream getDebugStream () { return yyDebugStream; } /** * Set the PrintStream on which the debug output is printed. * @param s The stream that is used for debugging output. */ public final void setDebugStream(java.io.PrintStream s) { yyDebugStream = s; } private int yydebug = 0; /** * Answer the verbosity of the debugging output; 0 means that all kinds of * output from the parser are suppressed. */ public final int getDebugLevel() { return yydebug; } /** * Set the verbosity of the debugging output; 0 means that all kinds of * output from the parser are suppressed. * @param level The verbosity level for debugging output. */ public final void setDebugLevel(int level) { yydebug = level; } /** * Print an error message via the lexer. * * @param msg The error message. */ public final void yyerror (String msg) { yylexer.yyerror (msg); } protected final void yycdebug (String s) { if (yydebug > 0) yyDebugStream.println (s); } private final class YYStack { private int[] stateStack = new int[16]; private Object[] valueStack = new Object[16]; public int size = 16; public int height = -1; public final void push (int state, Object value) { height++; if (size == height) { int[] newStateStack = new int[size * 2]; System.arraycopy (stateStack, 0, newStateStack, 0, height); stateStack = newStateStack; Object[] newValueStack = new Object[size * 2]; System.arraycopy (valueStack, 0, newValueStack, 0, height); valueStack = newValueStack; size *= 2; } stateStack[height] = state; valueStack[height] = value; } public final void pop () { pop (1); } public final void pop (int num) { // Avoid memory leaks... garbage collection is a white lie! if (num > 0) { java.util.Arrays.fill (valueStack, height - num + 1, height + 1, null); } height -= num; } public final int stateAt (int i) { return stateStack[height - i]; } public final Object valueAt (int i) { return valueStack[height - i]; } // Print the state stack on the debug stream. public void print (java.io.PrintStream out) { out.print ("Stack now"); for (int i = 0; i <= height; i++) { out.print (' '); out.print (stateStack[i]); } out.println (); } } /** * Returned by a Bison action in order to stop the parsing process and * return success (true). */ public static final int YYACCEPT = 0; /** * Returned by a Bison action in order to stop the parsing process and * return failure (false). */ public static final int YYABORT = 1; /** * Returned by a Bison action in order to start error recovery without * printing an error message. */ public static final int YYERROR = 2; /** * Internal return codes that are not supported for user semantic * actions. */ private static final int YYERRLAB = 3; private static final int YYNEWSTATE = 4; private static final int YYDEFAULT = 5; private static final int YYREDUCE = 6; private static final int YYERRLAB1 = 7; private static final int YYRETURN = 8; private int yyerrstatus_ = 0; /** * Return whether error recovery is being done. In this state, the parser * reads token until it reaches a known state, and then restarts normal * operation. */ public final boolean recovering () { return yyerrstatus_ == 0; } /** Compute post-reduction state. * @param yystate the current state * @param yysym the nonterminal to push on the stack */ private int yy_lr_goto_state_ (int yystate, int yysym) { int yyr = yypgoto_[yysym - yyntokens_] + yystate; if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) return yytable_[yyr]; else return yydefgoto_[yysym - yyntokens_]; } private int yyaction (int yyn, YYStack yystack, int yylen) { Object yyval; Mine.write_action_line(yyn); Globals.actions_out.printf("yyn = %d yylen = %d\n",yyn,yylen); /* If YYLEN is nonzero, implement the default value of the action: '$$ = $1'. Otherwise, use the top of the stack. Otherwise, the following line sets YYVAL to garbage. This behavior is undocumented and Bison users should not rely upon it. */ if (yylen > 0) yyval = yystack.valueAt (yylen - 1); else yyval = yystack.valueAt (0); yy_reduce_print (yyn, yystack); switch (yyn) { case 2: if (yyn == 2) /* "YYParser.y":185 */ /* lalr1.java:489 */ { yyval = Globals.insrtptr; /* Remember original value */ }; break; /* "YYParser.java":395 */ /* lalr1.java:489 */ default: break; } yy_symbol_print ("-> $$ =", yyr1_[yyn], yyval); yystack.pop (yylen); yylen = 0; /* Shift the result of the reduction. */ int yystate = yy_lr_goto_state_ (yystack.stateAt (0), yyr1_[yyn]); yystack.push (yystate, yyval); return YYNEWSTATE; } /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ private void yy_symbol_print (String s, int yytype, Object yyvaluep ) { if (yydebug > 0) yycdebug (s + (yytype < yyntokens_ ? " token " : " nterm ") + yytname_[yytype] + " (" + (yyvaluep == null ? "(null)" : yyvaluep.toString ()) + ")"); } /** * Parse input from the scanner that was specified at object construction * time. Return whether the end of the input was reached successfully. * * @return true if the parsing succeeds. Note that this does not * imply that there were no syntax errors. */ public boolean parse () throws java.io.IOException { Mine.russinfo("Hello YYParser.parse() !!!"); /* Lookahead and lookahead in internal form. */ int yychar = yyempty_; int yytoken = 0; /* State. */ int yyn = 0; int yylen = 0; int yystate = 0; YYStack yystack = new YYStack (); int label = YYNEWSTATE; /* Error handling. */ int yynerrs_ = 0; /* Semantic value of the lookahead. */ Object yylval = null; yycdebug ("Starting parse\n"); yyerrstatus_ = 0; /* Initialize the stack. */ yystack.push (yystate, yylval ); for (;;) switch (label) { /* New state. Unlike in the C/C++ skeletons, the state is already pushed when we come here. */ case YYNEWSTATE: yycdebug ("Entering state " + yystate + "\n"); if (yydebug > 0) yystack.print (yyDebugStream); /* Accept? */ if (yystate == yyfinal_) return true; /* Take a decision. First try without lookahead. */ yyn = yypact_[yystate]; if (yy_pact_value_is_default_ (yyn)) { label = YYDEFAULT; break; } /* Read a lookahead token. */ if (yychar == yyempty_) { yycdebug ("Reading a token: "); Mine.russinfo("YYPArser before yylexer.yylex() !!!"); yychar = yylexer.yylex (); Mine.russinfo("YYPArser after yylexer.yylex() !!!"); yylval = yylexer.getLVal (); Mine.russinfo("YYPArser after yylexer.getLVal() !!!" + yylval.toString()); Globals.actions_out.printf("yychar = %d yylval = %s\n",yychar,yylval.toString()); } /* Convert token to internal form. */ if (yychar <= Lexer.EOF) { yychar = yytoken = Lexer.EOF; yycdebug ("Now at end of input.\n"); } else { yytoken = yytranslate_ (yychar); yy_symbol_print ("Next token is", yytoken, yylval); Globals.actions_out.printf("Next token is %d yylval %s\n", yytoken, yylval.toString()); } /* If the proper action on seeing token YYTOKEN is to reduce or to detect an error, take that action. */ yyn += yytoken; Globals.actions_out.printf("yyn + yytoken = %d\n",yyn); if (yyn >= 0 && yylast_ >= yyn) { Globals.actions_out.printf("yytable_[yyn] = %d\n",yytable_[yyn]); Globals.actions_out.printf("yycheck_[yyn] = %d\n",yycheck_[yyn]); } Globals.actions_out.printf("yyn = %d yylast_ = %d\n",yyn,yylast_); if (yyn < 0 && yylast_ < yyn) Globals.actions_out.printf("yycheck_[yyn] = %d yytoken = %d\n", yycheck_[yyn],yytoken); if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken) { label = YYDEFAULT; Globals.actions_out.printf("DEFAULT\n"); } /* <= 0 means reduce or error. */ else if ((yyn = yytable_[yyn]) <= 0) { Globals.actions_out.printf("ERROR OR REDUCE\n"); if (yy_table_value_is_error_ (yyn)) { Globals.actions_out.printf("ERROR\n"); label = YYERRLAB; } else { yyn = -yyn; Globals.actions_out.printf("REDUCE yyn = %d\n",yyn); label = YYREDUCE; } } else { /* Shift the lookahead token. */ Globals.actions_out.printf("SHIFT\n"); yy_symbol_print ("Shifting", yytoken, yylval); /* Discard the token being shifted. */ yychar = yyempty_; /* Count tokens shifted since error; after three, turn off error status. */ if (yyerrstatus_ > 0) --yyerrstatus_; yystate = yyn; yystack.push (yystate, yylval); label = YYNEWSTATE; } break; /*-----------------------------------------------------------. | yydefault -- do the default action for the current state. | `-----------------------------------------------------------*/ case YYDEFAULT: yyn = yydefact_[yystate]; Globals.actions_out.printf("AT YYDEFAULT yyn = %d if 0 error other REDUCE\n",yyn); if (yyn == 0) label = YYERRLAB; else label = YYREDUCE; break; /*-----------------------------. | yyreduce -- Do a reduction. | `-----------------------------*/ case YYREDUCE: yylen = yyr2_[yyn]; label = yyaction (yyn, yystack, yylen); yystate = yystack.stateAt (0); break; /*------------------------------------. | yyerrlab -- here on detecting error | `------------------------------------*/ case YYERRLAB: /* If not already recovering from an error, report this error. */ if (yyerrstatus_ == 0) { ++yynerrs_; if (yychar == yyempty_) yytoken = yyempty_; yyerror (yysyntax_error (yystate, yytoken)); } if (yyerrstatus_ == 3) { /* If just tried and failed to reuse lookahead token after an error, discard it. */ if (yychar <= Lexer.EOF) { /* Return failure if at end of input. */ if (yychar == Lexer.EOF) return false; } else yychar = yyempty_; } /* Else will try to reuse lookahead token after shifting the error token. */ label = YYERRLAB1; break; /*-------------------------------------------------. | errorlab -- error raised explicitly by YYERROR. | `-------------------------------------------------*/ case YYERROR: /* Do not reclaim the symbols of the rule which action triggered this YYERROR. */ yystack.pop (yylen); yylen = 0; yystate = yystack.stateAt (0); label = YYERRLAB1; break; /*-------------------------------------------------------------. | yyerrlab1 -- common code for both syntax error and YYERROR. | `-------------------------------------------------------------*/ case YYERRLAB1: yyerrstatus_ = 3; /* Each real token shifted decrements this. */ for (;;) { yyn = yypact_[yystate]; if (!yy_pact_value_is_default_ (yyn)) { yyn += yyterror_; if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_) { yyn = yytable_[yyn]; if (0 < yyn) break; } } /* Pop the current state because it cannot handle the * error token. */ if (yystack.height == 0) return false; yystack.pop (); yystate = yystack.stateAt (0); if (yydebug > 0) yystack.print (yyDebugStream); } if (label == YYABORT) /* Leave the switch. */ break; /* Shift the error token. */ yy_symbol_print ("Shifting", yystos_[yyn], yylval); yystate = yyn; yystack.push (yyn, yylval); label = YYNEWSTATE; break; /* Accept. */ case YYACCEPT: return true; /* Abort. */ case YYABORT: return false; } } // Generate an error message. private String yysyntax_error (int yystate, int tok) { return "syntax error"; } /** * Whether the given yypact_ value indicates a defaulted state. * @param yyvalue the value to check */ private static boolean yy_pact_value_is_default_ (int yyvalue) { return yyvalue == yypact_ninf_; } /** * Whether the given yytable_ * value indicates a syntax error. * @param yyvalue the value to check */ private static boolean yy_table_value_is_error_ (int yyvalue) { return yyvalue == yytable_ninf_; } private static final byte yypact_ninf_ = -1; private static final byte yytable_ninf_ = -1; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ private static final byte yypact_[] = yypact_init(); private static final byte[] yypact_init() { return new byte[] { -1, 0, -1 }; } /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. Performed when YYTABLE does not specify something else to do. Zero means the default is an error. */ private static final byte yydefact_[] = yydefact_init(); private static final byte[] yydefact_init() { return new byte[] { 2, 0, 1 }; } /* YYPGOTO[NTERM-NUM]. */ private static final byte yypgoto_[] = yypgoto_init(); private static final byte[] yypgoto_init() { return new byte[] { -1, -1 }; } /* YYDEFGOTO[NTERM-NUM]. */ private static final byte yydefgoto_[] = yydefgoto_init(); private static final byte[] yydefgoto_init() { return new byte[] { -1, 1 }; } /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule whose number is the opposite. If YYTABLE_NINF, syntax error. */ private static final int yytable_[] = yytable_init(); private static final int[] yytable_init() { return new int[] { 259, 3, 73, 4, 110, 91, 234, 136, 80, 143, 137, 266, 100, 97, 76, 78, 69, 97, 92, 173, 30, 134, 114, 94, 81, 123, 106, 190, 124, 100, 83, 68, 132, 110, 19, 20, 181, 142, 88, 184, 12, 4, 170, 89, 134, 19, 20, 97, 151, 212, 201, 201, 132, 1, 114, 212, 56, 201, 82, 132, 57, 61, 174, 99, 175, 201, 212, 99, 212, 81, 132, 201, 212, 132, 12, 203, 201, 137, 212, 134, 134, 114, 140, 53, 134, 134, 37, 134, 134, 127, 84, 202, 4, 97, 97, 12, 186, 19, 20, 232, 250, 98, 99, 134, 132, 252, 12, 97, 171, 132, 263, 243, 12, 193, 150, 213, 214, 216, 53, 101, 242, 261, 55, 53, 53, 268, 182, 53, 142, 99, 145, 240, 272, 149, 278, 134, 275, 134, 280, 277, 104, 279, 53, 169, 281, 167, 12, 114, 132, 132, 132, 62, 37, 96, 218, 253, 183, 55, 105, 132, 210, 12, 55, 55, 67, 132, 55, 134, 99, 134, 132, 28, 165, 166, 53, 121, 53, 122, 123, 124, 132, 55, 220, 200, 72, 221, 19, 20, 79, 132, 125, 126, 128, 123, 123, 192, 124, 124, 92, 134, 132, 135, 161, 94, 211, 162, 53, 185, 53, 26, 188, 132, 189, 55, 191, 55, 198, 19, 20, 19, 20, 249, 199, 19, 20, 28, 226, 217, 134, 151, 206, 209, 225, 134, 215, 88, 113, 172, 30, 136, 89, 143, 137, 228, 107, 55, 267, 55, 262, 136, 109, 143, 137, 270, 258, 90, 273, 4, 4, 233, 27, 4, 4, 26, 265, 28, 4, 19, 20, 142, 4, 99, 235, 4, 241, 4, 4, 99, 257, 142, 4, 99, 4, 4, 4, 4, 4, 244, 245, 90, 246, 251, 4, 4, 4, 4, 4, 194, 195, 4, 4, 134, 260, 26, 134, 134, 134, 134, 248, 134, 134, 134, 269, 134, 27, 134, 134, 134, 134, 134, 134, 134, 271, 134, 134, 32, 134, 134, 274, 28, 134, 134, 134, 134, 276, 134, 134, 134, 134, 134, 53, 134, 134, 53, 53, 53, 53, 41, 53, 94, 53, 94, 53, 5, 27, 53, 53, 53, 53, 53, 53, 88, 53, 53, 127, 53, 53, 26, 78, 28, 53, 53, 53, 48, 53, 53, 53, 53, 53, 55, 53, 53, 55, 55, 55, 55, 125, 55, 136, 55, 77, 55, 230, 187, 55, 55, 55, 55, 55, 55, 239, 55, 55, 86, 55, 55, 87, 26, 60, 55, 55, 55, 139, 55, 55, 55, 55, 55, 27, 55, 55, 1, 219, 19, 20, 50, 5, 168, 254, 6, 7, 51, 19, 20, 8, 22, 23, 256, 9, 208, 148, 10, 0, 11, 12, 0, 264, 0, 13, 0, 14, 15, 16, 17, 18, 0, 0, 0, 27, 1, 19, 20, 21, 22, 23, 0, 0, 24, 25, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 146, 5, 0, 0, 6, 7, 51, 0, 0, 8, 0, 0, 0, 9, 0, 0, 10, 0, 11, 12, 0, 0, 0, 13, 0, 14, 15, 16, 17, 18, 10, 1, 0, 0, 0, 19, 20, 21, 22, 23, 47, 5, 24, 25, 6, 7, 0, 0, 0, 8, 0, 51, 0, 9, 0, 0, 10, 0, 11, 12, 0, 0, 0, 13, 0, 14, 15, 16, 17, 18, 0, 153, 0, 0, 0, 19, 20, 21, 22, 23, 0, 10, 24, 25, 129, 0, 51, 0, 28, 0, 0, 0, 51, 0, 0, 51, 14, 0, 0, 17, 18, 0, 0, 0, 47, 5, 19, 20, 6, 7, 51, 0, 0, 8, 25, 0, 0, 9, 0, 0, 10, 0, 11, 12, 0, 0, 26, 13, 0, 14, 15, 16, 17, 18, 63, 0, 0, 0, 0, 19, 20, 21, 22, 23, 51, 5, 141, 25, 6, 7, 0, 0, 0, 8, 73, 0, 0, 9, 0, 0, 10, 0, 11, 12, 0, 0, 0, 13, 0, 14, 15, 16, 17, 18, 51, 0, 51, 27, 102, 19, 20, 21, 22, 23, 0, 22, 24, 25, 0, 73, 115, 0, 0, 0, 0, 73, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 73, 1, 1, 0, 0, 0, 1, 22, 1, 1, 1, 1, 1, 22, 0, 0, 22, 129, 1, 1, 1, 1, 1, 63, 0, 1, 1, 0, 0, 14, 176, 22, 17, 18, 10, 15, 0, 10, 10, 19, 20, 0, 10, 0, 0, 0, 10, 25, 0, 10, 17, 10, 10, 0, 130, 0, 10, 0, 10, 10, 10, 10, 10, 0, 0, 22, 73, 0, 10, 10, 10, 10, 10, 0, 0, 10, 10, 26, 0, 115, 0, 164, 0, 0, 17, 0, 10, 10, 0, 0, 0, 0, 0, 0, 0, 76, 10, 22, 63, 10, 51, 51, 10, 10, 0, 51, 0, 0, 0, 10, 10, 51, 0, 0, 51, 51, 17, 10, 51, 0, 0, 176, 0, 0, 0, 51, 51, 51, 27, 0, 5, 0, 0, 6, 7, 51, 0, 0, 8, 0, 0, 0, 9, 0, 176, 10, 0, 11, 12, 0, 0, 0, 13, 0, 0, 15, 16, 0, 0, 15, 0, 0, 0, 0, 19, 20, 21, 22, 23, 176, 229, 24, 231, 0, 44, 64, 10, 70, 70, 0, 176, 237, 0, 176, 70, 176, 0, 0, 10, 0, 0, 10, 10, 0, 0, 102, 102, 0, 10, 10, 0, 0, 247, 73, 73, 0, 10, 0, 73, 0, 0, 0, 0, 0, 129, 0, 0, 73, 73, 64, 103, 0, 231, 236, 0, 0, 14, 0, 0, 17, 18, 64, 119, 247, 22, 22, 19, 20, 0, 22, 44, 0, 0, 0, 25, 22, 0, 131, 22, 22, 0, 0, 22, 70, 138, 0, 0, 0, 70, 22, 15, 0, 0, 0, 0, 0, 152, 159, 160, 0, 0, 0, 15, 163, 131, 15, 15, 64, 0, 0, 0, 15, 15, 15, 177, 159, 0, 0, 159, 0, 15, 0, 0, 0, 5, 0, 0, 6, 7, 0, 0, 0, 8, 0, 0, 0, 9, 0, 0, 10, 0, 11, 12, 0, 0, 0, 13, 0, 0, 15, 16, 0, 77, 77, 159, 0, 0, 0, 19, 20, 21, 22, 23, 64, 29, 24, 70, 0, 52, 77, 0, 52, 0, 0, 0, 0, 0, 74, 0, 0, 0, 0, 64, 0, 222, 10, 0, 0, 74, 0, 0, 0, 0, 131, 159, 131, 0, 10, 0, 0, 10, 10, 0, 0, 131, 177, 0, 10, 10, 0, 159, 0, 0, 15, 15, 10, 0, 0, 0, 133, 0, 0, 108, 15, 0, 131, 15, 70, 177, 15, 15, 0, 0, 0, 159, 15, 15, 15, 222, 133, 0, 0, 0, 0, 15, 131, 133, 0, 0, 0, 0, 0, 70, 177, 0, 0, 131, 133, 143, 70, 133, 147, 70, 0, 177, 0, 0, 177, 0, 177, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 133, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 204, 205, 0, 0, 207, 0, 0, 0, 0, 133, 133, 133, 0, 0, 0, 0, 0, 0, 0, 0, 133, 0, 0, 0, 0, 0, 133, 0, 0, 0, 227, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 133, 0, 0, 0, 0, 0, 0, 0, 0, 133, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 133, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 133, }; // { // 2 // }; } private static final int yycheck_[] = yycheck_init(); private static final int[] yycheck_init() { return new int[] { 41, 0, 15, 2, 44, 36, 41, 35, 21, 35, 35, 41, 35, 59, 17, 18, 40, 59, 93, 41, 41, 59, 59, 93, 123, 123, 59, 138, 123, 35, 27, 123, 84, 44, 291, 292, 122, 35, 266, 125, 59, 40, 59, 271, 0, 291, 292, 59, 294, 59, 59, 59, 104, 256, 59, 59, 123, 59, 26, 111, 40, 123, 256, 59, 258, 59, 59, 59, 59, 123, 122, 59, 59, 125, 93, 161, 59, 90, 59, 35, 36, 59, 95, 0, 40, 41, 59, 125, 44, 41, 296, 93, 91, 59, 59, 59, 129, 291, 292, 93, 235, 280, 59, 59, 59, 93, 125, 59, 125, 161, 93, 222, 59, 125, 125, 125, 125, 125, 35, 287, 125, 125, 0, 40, 41, 260, 123, 44, 96, 125, 98, 217, 125, 101, 125, 91, 271, 93, 125, 274, 91, 276, 59, 115, 125, 113, 93, 125, 200, 201, 202, 256, 125, 123, 187, 241, 124, 35, 40, 211, 173, 125, 40, 41, 256, 217, 44, 123, 125, 125, 125, 2, 288, 289, 91, 123, 93, 123, 44, 273, 232, 59, 256, 155, 256, 259, 291, 292, 256, 241, 123, 294, 93, 291, 292, 294, 291, 292, 273, 256, 252, 256, 91, 273, 176, 125, 123, 125, 125, 40, 297, 263, 123, 91, 123, 93, 41, 291, 292, 291, 292, 234, 295, 291, 292, 2, 194, 91, 266, 294, 276, 294, 125, 271, 276, 266, 273, 259, 259, 267, 271, 267, 267, 41, 267, 123, 259, 125, 251, 277, 290, 277, 277, 266, 295, 286, 269, 256, 257, 294, 91, 260, 261, 40, 294, 2, 265, 291, 292, 267, 269, 277, 123, 272, 91, 274, 275, 273, 246, 277, 279, 273, 281, 282, 283, 284, 285, 125, 59, 287, 280, 268, 291, 292, 293, 294, 295, 262, 263, 298, 299, 257, 123, 40, 260, 261, 262, 263, 294, 265, 266, 267, 41, 269, 91, 271, 272, 273, 274, 275, 276, 277, 123, 279, 280, 91, 282, 283, 123, 2, 286, 287, 288, 289, 123, 291, 292, 293, 294, 295, 257, 297, 298, 260, 261, 262, 263, 123, 265, 273, 267, 93, 269, 0, 91, 272, 273, 274, 275, 276, 277, 287, 279, 280, 125, 282, 283, 40, 123, 2, 287, 288, 289, 268, 291, 292, 293, 294, 295, 257, 297, 298, 260, 261, 262, 263, 125, 265, 256, 267, 123, 269, 201, 129, 272, 273, 274, 275, 276, 277, 212, 279, 280, 34, 282, 283, 34, 40, 10, 287, 288, 289, 91, 291, 292, 293, 294, 295, 91, 297, 298, 2, 189, 291, 292, 256, 257, 114, 243, 260, 261, 262, 291, 292, 265, 294, 295, 245, 269, 170, 100, 272, -1, 274, 275, -1, 257, -1, 279, -1, 281, 282, 283, 284, 285, -1, -1, -1, 91, 40, 291, 292, 293, 294, 295, -1, -1, 298, 299, -1, -1, 2, -1, -1, -1, -1, -1, -1, -1, 256, 257, -1, -1, 260, 261, 262, -1, -1, 265, -1, -1, -1, 269, -1, -1, 272, -1, 274, 275, -1, -1, -1, 279, -1, 281, 282, 283, 284, 285, 40, 91, -1, -1, -1, 291, 292, 293, 294, 295, 256, 257, 298, 299, 260, 261, -1, -1, -1, 265, -1, 0, -1, 269, -1, -1, 272, -1, 274, 275, -1, -1, -1, 279, -1, 281, 282, 283, 284, 285, -1, 256, -1, -1, -1, 291, 292, 293, 294, 295, -1, 91, 298, 299, 269, -1, 35, -1, 2, -1, -1, -1, 41, -1, -1, 44, 281, -1, -1, 284, 285, -1, -1, -1, 256, 257, 291, 292, 260, 261, 59, -1, -1, 265, 299, -1, -1, 269, -1, -1, 272, -1, 274, 275, -1, -1, 40, 279, -1, 281, 282, 283, 284, 285, 12, -1, -1, -1, -1, 291, 292, 293, 294, 295, 93, 257, 298, 299, 260, 261, -1, -1, -1, 265, 0, -1, -1, 269, -1, -1, 272, -1, 274, 275, -1, -1, -1, 279, -1, 281, 282, 283, 284, 285, 123, -1, 125, 91, 56, 291, 292, 293, 294, 295, -1, 0, 298, 299, -1, 35, 68, -1, -1, -1, -1, 41, -1, 257, -1, -1, 260, 261, -1, -1, -1, 265, -1, -1, -1, 269, -1, -1, 272, 59, 274, 275, -1, -1, -1, 279, 35, 281, 282, 283, 284, 285, 41, -1, -1, 44, 269, 291, 292, 293, 294, 295, 114, -1, 298, 299, -1, -1, 281, 121, 59, 284, 285, 257, 44, -1, 260, 261, 291, 292, -1, 265, -1, -1, -1, 269, 299, -1, 272, 59, 274, 275, -1, 84, -1, 279, -1, 281, 282, 283, 284, 285, -1, -1, 93, 125, -1, 291, 292, 293, 294, 295, -1, -1, 298, 299, 40, -1, 170, -1, 111, -1, -1, 93, -1, 268, 269, -1, -1, -1, -1, -1, -1, -1, 123, 278, 125, 189, 281, 262, 263, 284, 285, -1, 267, -1, -1, -1, 291, 292, 273, -1, -1, 276, 277, 125, 299, 280, -1, -1, 212, -1, -1, -1, 287, 288, 289, 91, -1, 257, -1, -1, 260, 261, 297, -1, -1, 265, -1, -1, -1, 269, -1, 235, 272, -1, 274, 275, -1, -1, -1, 279, -1, -1, 282, 283, -1, -1, 44, -1, -1, -1, -1, 291, 292, 293, 294, 295, 260, 200, 298, 202, -1, 59, 12, 269, 14, 15, -1, 271, 211, -1, 274, 21, 276, -1, -1, 281, -1, -1, 284, 285, -1, -1, 288, 289, -1, 291, 292, -1, -1, 232, 262, 263, -1, 299, -1, 267, -1, -1, -1, -1, -1, 269, -1, -1, 276, 277, 56, 57, -1, 252, 278, -1, -1, 281, -1, -1, 284, 285, 68, 69, 263, 262, 263, 291, 292, -1, 267, 125, -1, -1, -1, 299, 273, -1, 84, 276, 277, -1, -1, 280, 90, 91, -1, -1, -1, 95, 287, 269, -1, -1, -1, -1, -1, 103, 104, 105, -1, -1, -1, 281, 110, 111, 284, 285, 114, -1, -1, -1, 290, 291, 292, 121, 122, -1, -1, 125, -1, 299, -1, -1, -1, 257, -1, -1, 260, 261, -1, -1, -1, 265, -1, -1, -1, 269, -1, -1, 272, -1, 274, 275, -1, -1, -1, 279, -1, -1, 282, 283, -1, 17, 18, 161, -1, -1, -1, 291, 292, 293, 294, 295, 170, 3, 298, 173, -1, 7, 34, -1, 10, -1, -1, -1, -1, -1, 16, -1, -1, -1, -1, 189, -1, 191, 269, -1, -1, 27, -1, -1, -1, -1, 200, 201, 202, -1, 281, -1, -1, 284, 285, -1, -1, 211, 212, -1, 291, 292, -1, 217, -1, -1, 268, 269, 299, -1, -1, -1, 84, -1, -1, 61, 278, -1, 232, 281, 234, 235, 284, 285, -1, -1, -1, 241, 290, 291, 292, 245, 104, -1, -1, -1, -1, 299, 252, 111, -1, -1, -1, -1, -1, 259, 260, -1, -1, 263, 122, 97, 266, 125, 100, 269, -1, 271, -1, -1, 274, -1, 276, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 123, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 161, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 165, 166, -1, -1, 169, -1, -1, -1, -1, 200, 201, 202, -1, -1, -1, -1, -1, -1, -1, -1, 211, -1, -1, -1, -1, -1, 217, -1, -1, -1, 195, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 232, -1, -1, -1, -1, -1, -1, -1, -1, 241, -1, -1, -1, -1, -1, -1, -1, -1, -1, 251, 252, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 263, }; // { // 0 // }; } /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ private static final byte yystos_[] = yystos_init(); private static final byte[] yystos_init() { return new byte[] { 0, 57, 0 }; } /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ private static final byte yyr1_[] = yyr1_init(); private static final byte[] yyr1_init() { return new byte[] { 0, 56, 57 }; } /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ private static final byte yyr2_[] = yyr2_init(); private static final byte[] yyr2_init() { return new byte[] { 0, 2, 0 }; } /* YYTOKEN_NUMBER[YYLEX-NUM] -- Internal symbol number corresponding to YYLEX-NUM. */ private static final short yytoken_number_[] = yytoken_number_init(); private static final short[] yytoken_number_init() { return new short[] { 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 59, 44, 40, 41, 123, 125, 91, 93, 2, 36, 35 }; } /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. First, the terminals, then, starting at \a yyntokens_, nonterminals. */ private static final String yytname_[] = yytname_init(); private static final String[] yytname_init() { return new String[] { "$end", "error", "$undefined", "CAND", "CHARACTERS", "CONSTANTS", "COR", "DO", "ELSE", "ELSIF", "END", "ENUM", "EXPORT", "FI", "FIELD", "FUNC", "HIDE", "IF", "IN", "EXTEND", "LET", "NI", "OD", "READONLY", "RECORD", "THEN", "TYPE", "UNION", "USE", "VAL", "VAR", "WITH", "RIGHT_ARROW", "EQUALS_EQUALS", "EQUALS_EQUALS_EQUALS", "COLON", "WORDID", "OPID", "PROD", "QSTRING", "UQSTRING", "LEFT_ANGLE_BRACKET", "RIGHT_ANGLE_BRACKET", "EXTERN", "SIGNATURE", "';'", "','", "'('", "')'", "'{'", "'}'", "'['", "']'", "'\\002'", "'$'", "'#'", "$accept", "Program", null }; } /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ private static final short yyrline_[] = yyrline_init(); private static final short[] yyrline_init() { return new short[] { 0, 185, 185 }; } // Report on the debug stream that the rule yyrule is going to be reduced. private void yy_reduce_print (int yyrule, YYStack yystack) { if (yydebug == 0) return; int yylno = yyrline_[yyrule]; int yynrhs = yyr2_[yyrule]; /* Print the symbols being reduced, and their result. */ yycdebug ("Reducing stack by rule " + (yyrule - 1) + " (line " + yylno + "), "); /* The symbols being reduced. */ for (int yyi = 0; yyi < yynrhs; yyi++) yy_symbol_print (" $" + (yyi + 1) + " =", yystos_[yystack.stateAt(yynrhs - (yyi + 1))], ((yystack.valueAt (yynrhs-(yyi + 1))))); } /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ private static final byte yytranslate_table_[] = yytranslate_table_init(); private static final byte[] yytranslate_table_init() { return new byte[] { 0, 2, 53, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 55, 54, 2, 2, 2, 47, 48, 2, 2, 46, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 45, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 51, 2, 52, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 49, 2, 50, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 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, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44 }; } private static final byte yytranslate_ (int t) { if (t >= 0 && t <= yyuser_token_number_max_) return yytranslate_table_[t]; else return yyundef_token_; } private static final int yylast_ = 1620; private static final int yynnts_ = 2; private static final int yyempty_ = -2; private static final int yyfinal_ = 2; private static final int yyterror_ = 1; private static final int yyerrcode_ = 256; private static final int yyntokens_ = 56; private static final int yyuser_token_number_max_ = 299; private static final int yyundef_token_ = 2; /* User implementation code. */ } /* "YYParser.y":1166 */ /* lalr1.java:1070 */ /* int in(int element,int list[]) */ /* { int i; */ /* i = 0; */ /* while (element != list[i] && list[i] != LIST_END) ++i; */ /* return (element == list[i]); */ /* } */ /* # ifdef DEBUG */ /* rec_on(c) */ /* int c; */ /* { */ /* if ( c < 0400 ) { */ /* dbgmsg ( "recovery attempted on %c\n", c); */ /* } */ /* else { */ /* dbgmsg ( "recovery attempted on token number %d\n", c); */ /* } */ /* } */ /* # endif */