/* * $Log: yyparse.template,v $ * Revision 1.1.1.1 1997/03/12 23:09:29 nsl * changed dir struct * * Revision 1.1.1.1 1997/02/20 08:04:36 nsl * Importing pp * * Skeleton output parser for bison, Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* As a special exception, when this file is copied by Bison into a Bison output file, you may use that output file without restriction. This special exception was added by the Free Software Foundation in version 1.24 of Bison. */ /* This is a parser template file, in java, for running parsers generated by the GNU Bison parser generator. */ /**************************************************/ /**************************************************/ /* package patch.src; import java.util.*; import java.io.*; import patch.src.util.*; import pp.src.jbf.*; */ /**************************************************/ // PREFIX package patch.src; import java.util.*; import java.io.*; import patch.src.util.*; import pp.src.jbf.*; /**************************************************/ public class YYparse { // Set up the fake goto mechanism protected int Goto; protected static final int yynewstate = 0; protected static final int yybackup = 1; protected static final int yydefault = 2; protected static final int yyreduce = 3; protected static final int yyerrlab = 4; protected static final int yyerrlab1 = 5; protected static final int yyerrdefault = 6; protected static final int yyerrpop = 7; protected static final int yyerrhandle = 8; public static final int YYCONTINUE = 1; public static final int YYACCEPT = 0; public static final int YYABORT = -1; public static final int YYEOF = 0; protected static final int YYEMPTY = -2; protected static final int YYTERROR = 1; protected static final int YYTERRCODE = 256; // CONSTANTS public static final int YYFINAL = 102; public static final int YYFLAG = -32768; public static final int YYNTBASE = 38; public static final int YYLAST = 96; // TOKENTYPES public static final int ERROR = 258; public static final int SYMBOL = 259; public static final int FINAL = 260; public static final int SYNCHRONIZED = 261; public static final int PUBLIC = 262; public static final int ABSTRACT = 263; public static final int INTERFACE = 264; public static final int IMPLEMENTS = 265; public static final int EXTENDS = 266; public static final int CLASS = 267; public static final int PRIVATE = 268; public static final int PROTECTED = 269; public static final int STATIC = 270; public static final int TRANSIENT = 271; public static final int VOLATILE = 272; public static final int NATIVE = 273; public static final int BOOLEAN = 274; public static final int BYTE = 275; public static final int CHAR = 276; public static final int DOUBLE = 277; public static final int FLOAT = 278; public static final int VOID = 279; public static final int LONG = 280; public static final int STRING = 281; public static final int INT = 282; public static final int SHORT = 283; protected int yyreturn; // see ACTIONS switch protected int yystate; protected int yyn; protected int yylen; protected int yychar; /* the lookahead symbol */ protected int yychar1; /* lookahead token as an internal (translated) Token number */ protected int yynerrs; /* number of parse errors so far */ protected int yydebug; /* nonzero means print parse trace */ protected int yyerrstatus; /* number of tokens to shift before error messages enabled */ protected YYtoken yylval; /* the semantic value of the lookahead symbol*/ /*protected YYnode yyval; */ protected YYtoken yyval; /* the variable used to return semantic values from the action routines */ protected Int_Stack yyss; protected YYtoken_Stack yyvs; /* protected YYnode_Stack yyvs;*/ /* protected loc_stack yyls;*/ protected YYlex yylex; protected java.io.PrintStream yyout; // PROCS public static final int YYTRANSLATE(int x) { return ((x) <= 283 ? yytranslate[x] : 64);} public YYparse(YYlex yyl, java.io.PrintStream fout) { yyss = new Int_Stack(); /* yyvs = new YYnode_Stack();*/ yyvs = new YYtoken_Stack(); yylex = yyl; yydebug = 0; yyout = fout; } public YYparse(YYlex yyl) {this(yyl, System.out);} public int yyparse() throws Exception, IOException, EmptyStackException { int ok; yychar1 = 0; /* lookahead Token as an internal (translated) */ yystate = 0; yyerrstatus = 0; yynerrs = 0; yychar = YYEMPTY; /* Cause a Token to be read. */ yyval = null; /* Initialize stack pointers. Waste one element of value and location stack so that they stay on the same level as the state stack. The wasted elements are never initialized. */ yyss.clear(); yyvs.clear(); /* yyls.clear();*/ /* need to push a null value to match state 0 */ yyvs.push(yyval); if(yydebug > 0) yyout.print("Starting parse\n"); /* Push a new state, which is found in yystate . */ /* In all cases, when you get here, the value and location stacks have just been pushed. so pushing a state here evens the stacks. */ for(;;) { branch: switch (Goto) { case yynewstate: yyss.push(yystate); if (yydebug > 0) { yyout.print("Entering state "); yyout.print(yystate); yyout.print("\n"); } // {Goto = yybackup; break branch;} case yybackup: /* Do appropriate processing given the current state. */ /* Read a lookahead token if we need one and don't already have one. */ /* yyresume: */ /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; if (yyn == YYFLAG) {Goto = yydefault; break branch;} /* Not known => get a lookahead token if don't already have one. */ /* yychar is either YYEMPTY or YYEOF or a valid token in external form. */ if (yychar == YYEMPTY) { if(yydebug > 0) yyout.print("Reading a token: "); if((yylval = yylex.yylex()) == null) { yylval = new YYtoken(YYEOF,""); } yychar = yylval.tokentype; } /* Convert token to internal form (in yychar1) for indexing tables with */ if (yychar <= 0) /* This means end of input. */ { yychar1 = 0; yychar = YYEOF; /* Don't call YYLEX any more */ if(yydebug > 0) yyout.print("Now at end of input.\n"); } else { yychar1 = YYTRANSLATE(yychar); if (yydebug >= 10) { yyout.print("Next token is "); yyout.print(yychar); yyout.print(" ("); yyout.print(yytname[yychar1]); yyout.print(")\n"); } } yyn += yychar1; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) {Goto = yydefault; break branch;} yyn = yytable[yyn]; /* yyn is what to do for this token type in this state. Negative => reduce, -yyn is rule number. Positive => shift, yyn is new state. New state is final state => don't bother to shift, just return success. 0, or most negative number => error. */ if (yyn < 0) { if (yyn == YYFLAG) {Goto = yyerrlab; break branch;} yyn = -yyn; {Goto = yyreduce; break branch;} } else if (yyn == 0) {Goto = yyerrlab; break branch;} if (yyn == YYFINAL) return YYACCEPT; /* Shift the lookahead token. */ if (yydebug > 0) { yyout.print("Shifting token "); yyout.print(yychar); yyout.print(" ("); yyout.print(yytname[yychar1]); yyout.print("), "); } /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; yyvs.push(yylval); /* yyls.push(yylloc);*/ /* count tokens shifted since error; after three, turn off error status. */ if (yyerrstatus > 0) yyerrstatus--; yystate = yyn; {Goto = yynewstate; break branch;} /* Do the default action for the current state. */ case yydefault: yyn = yydefact[yystate]; if (yyn == 0) {Goto = yyerrlab; break branch;} /* Do a reduction. yyn is the number of a rule to reduce with. */ case yyreduce: yylen = yyr2[yyn]; if (yylen > 0) yyval = yyvs.tth(1-yylen); /* implement default value of the action */ if (yydebug > 0) { int i; yyout.print("Reducing via rule "); yyout.print(yyn); yyout.print(" (line "); yyout.print(yyrline[yyn]); yyout.print("), "); /* Print the symbols being reduced, and their result. */ for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) { yyout.print(yytname[yyrhs[i]]); yyout.print(" "); } yyout.print(" -> "); yyout.print(yytname[yyr1[yyn]]); yyout.print("\n"); } /*$*/ /* the action file gets copied in in place of this dollarsign */ /* Provide a way to avoid having return statements in the actions and so avoid "statement not reached" errors" */ yyreturn = YYCONTINUE; switch (yyn) { case 7: { // pat.startClass($3); nothing needed at this point ; break;} case 8: { // pat.startClass(new ClassNode($3, $4, $5));} // pat.startClass($3, $5); boolean addVar = true; // Add Var of Parent Class to current scope pat.parseClass(yyvs.tth(-1).text, addVar); ; break;} case 9: { // pat.endClass(); ; break;} case 10: { // pat.startClass($3, $5); boolean addVar = true; // Add Var of Parent Class to current scope pat.parseClass(yyvs.tth(0).text, addVar); ; break;} case 11: { // pat.endClass(); ; break;} case 20: { yyval = yyvs.tth(0); ; break;} case 21: { (yyvs.tth(-2)).text += ("."+(yyvs.tth(0)).text); yyval = yyvs.tth(-2);; break;} case 22: { // System.out.println($1.text); yyval = yyvs.tth(0) ; ; break;} case 33: { yyval = yyvs.tth(0); ; break;} case 34: { yyval = yyvs.tth(0); ; break;} case 35: { yyval = yyvs.tth(0); ; break;} case 36: { yyval = yyvs.tth(0); ; break;} case 37: { yyval = yyvs.tth(0); ; break;} case 38: { yyval = yyvs.tth(0); ; break;} case 39: { yyval = yyvs.tth(0); ; break;} case 40: { yyval = yyvs.tth(0); ; break;} case 41: { yyval = yyvs.tth(0); ; break;} case 42: { yyval = yyvs.tth(0); ; break;} case 47: { pat.addLocalVar((FormalNode)(yyvs.tth(-1))); ; break;} case 48: { yyval = (YYtoken) (new FormalNode(new TypeNode(yyvs.tth(-1)), yyvs.tth(0))); boolean addVar = false; pat.parseClass(yyvs.tth(-1).text, addVar); ; break;} case 49: { yyval = (YYtoken) (new FormalNode(new TypeNode(yyvs.tth(-1)), yyvs.tth(0))); boolean addVar = false; pat.parseClass(yyvs.tth(-1).text, addVar); ; break;} case 50: { yyval = (YYtoken) (new FormalNode(yyvs.tth(-1), yyvs.tth(0))); ; break;} case 51: { ((FormalNode)yyvs.tth(-2)).type.addDim(1); ; break;} case 52: { yyval = (YYtoken) (new TypeNode(TypeNode.BOOL, yyvs.tth(0))); ; break;} case 53: { yyval = (YYtoken) (new TypeNode(TypeNode.BYTE, yyvs.tth(0))); ; break;} case 54: { yyval = (YYtoken) (new TypeNode(TypeNode.CHAR, yyvs.tth(0))); ; break;} case 55: { yyval = (YYtoken) (new TypeNode(TypeNode.SHORT, yyvs.tth(0))); ; break;} case 56: { yyval = (YYtoken) (new TypeNode(TypeNode.INT, yyvs.tth(0))); ; break;} case 57: { yyval = (YYtoken) (new TypeNode(TypeNode.FLOAT, yyvs.tth(0))); ; break;} case 58: { yyval = (YYtoken) (new TypeNode(TypeNode.LONG, yyvs.tth(0))); ; break;} case 59: { yyval = (YYtoken) (new TypeNode(TypeNode.DOUBLE, yyvs.tth(0))); ; break;} case 60: { yyval = (YYtoken) (new TypeNode(TypeNode.STRING, yyvs.tth(0))); ; break;} case 61: { yyval = (YYtoken) (new TypeNode(TypeNode.VOID, yyvs.tth(0))); ; break;} case 71: { if (!(yyvs.tth(-3).text).equals("static")) { System.err.println("UnHandled Profiler Output in "+pat.modName+".tmp"); } ; break;} } if(yyreturn != YYCONTINUE) return yyreturn; yyvs.popn(yylen); yyss.popn(yylen); /* yyls.popn(yylen)*/ if (yydebug > 0) { stackdump("state stack now"); } yyvs.push(yyval); /* yylsp++;*/ if (yylen == 0) { /*remind: yyls.push(yylloc); yyls.last_line = (yylsp-1)->last_line; yyls.last_column = (yylsp-1)->last_column; yyls.text = 0; */ } else { /* remind: yylsp.last_line = (yylsp+yylen-1)->last_line; yylsp.last_column = (yylsp+yylen-1)->last_column; */ } /* Now "shift" the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ yyn = yyr1[yyn]; yystate = yypgoto[yyn - YYNTBASE] + yyss.peek(); if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == yyss.peek()) yystate = yytable[yystate]; else yystate = yydefgoto[yyn - YYNTBASE]; {Goto = yynewstate; break branch;} case yyerrlab: /* here on detecting error */ if (yyerrstatus == 0) /* If not already recovering from an error, report this error. */ { ++yynerrs; yyverror("parse error"); } // {Goto = yyerrlab1; break branch;} case yyerrlab1: /* here on error raised explicitly by an action */ if (yyerrstatus == 3) { /* if just tried and failed to reuse lookahead token after an error, discard it. */ /* return failure if at end of input */ if (yychar == YYEOF) return YYABORT; if (yydebug > 0) { yyout.print("Discarding token "); yyout.print(yychar); yyout.print(" ("); yyout.print(yytname[yychar1]); yyout.print(").\n"); } yychar = YYEMPTY; } /* Else will try to reuse lookahead token after shifting the error token. */ yyerrstatus = 3; /* Each real token shifted decrements this */ {Goto = yyerrhandle; break branch;} case yyerrdefault: /* current state does not do anything special for the error token. */ /* if 0 // This is wrong; only states that explicitly want error tokens // should shift them. yyn = yydefact[yystate]; // If its default is to accept any token, ok. Otherwise pop it. if (yyn) {Goto = yydefault; break branch;} */ case yyerrpop: /* pop the current state because it cannot handle the error token */ if (yyss.empty()) return YYABORT; yyvs.popn(1); yystate = yyss.pop(); /* yyls.popn(1);*/ if (yydebug > 0) { stackdump("Error: state stack now"); } case yyerrhandle: yyn = yypact[yystate]; if (yyn == YYFLAG) {Goto = yyerrdefault; break branch;} yyn += YYTERROR; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) {Goto = yyerrdefault; break branch;} yyn = yytable[yyn]; if (yyn < 0) { if (yyn == YYFLAG) {Goto = yyerrpop; break branch;} yyn = -yyn; {Goto = yyreduce; break branch;} } else if (yyn == 0) {Goto = yyerrpop; break branch;} if (yyn == YYFINAL) return YYACCEPT; if (yydebug > 0) {yyout.println("Shifting error token, ");} yyvs.push(yylval); /* yyls.push(yyloc);*/ yystate = yyn; // {Goto = yynewstate; break branch;} }//switch }//for(;;) } // parse protected void stackdump(String s) { int i; int x; int ssp1 = yyss.depth(); yyout.print(s); for(i=0;i YYFLAG && yyn < YYLAST) { int size = msg0.length(); StringBuffer msg; int yychar1; // a TRANSLATEd char value int count; count = 0; /* Start yychar1 at -yyn if nec to avoid negative indexes in yycheck.*/ for (yychar1 = (yyn < 0 ? -yyn : 0); (yyn+yychar1) < (yytname.length); yychar1++) { if((yyn+yychar1) < yycheck.length && yycheck[yyn+yychar1] == yychar1) { size += (yytname[yychar1].length()) + 15; count++; } } msg = new StringBuffer(size+15); msg.append(msg0); msg.append("(state " + Integer.toString(yystate) + ")"); yychar1 = (yyn < 0)? - yyn :0; for(count=0,yychar1 = (yyn < 0 ? -yyn : 0); (yyn+yychar1) < (yytname.length) && count < 5; yychar1++) { if((yyn+yychar1) < yycheck.length && yycheck[yyn+yychar1] == yychar1) { msg.append(count == 0 ? ", expecting `" : " or `"); msg.append(yytname[yychar1]); msg.append("'"); count++; } } return msg.toString(); } return msg0; } public void yyerror(String msg, boolean verbose, boolean dumpstack) throws ParseException { String s; if(verbose) { s = yyerror_verbose(msg); } else { s = msg; } yyout.print("yyerror: "); if(yylval.tokentype == YYEOF) { yyout.print("at end of file"); } else { yyout.print("line "); yyout.print(yylval.lineno()+1); yyout.print(" char "); yyout.print(yylval.charno()+1); } yyout.println(" ; " + s); if(dumpstack) { stackdump("yyerror: state stack"); } throw new ParseException(s); } public void yyerror(String s, boolean verbose) throws ParseException { yyerror(s,verbose,false); } public void yyerror(String s) throws ParseException { yyerror(s,false,false); } public void yyreturn(int t) {yyreturn = t;} public void setdebug(boolean i) {yydebug = i?1:0;} public void setdebug(int i) {yydebug = i>0?i:0;} // TABLES public static final int yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 34, 35, 2, 2, 30, 2, 31, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 29, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 36, 2, 37, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 32, 2, 33, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 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 }; public static final int yyprhs[] = { 0, 0, 2, 4, 6, 8, 11, 14, 18, 25, 27, 33, 35, 36, 39, 42, 45, 48, 49, 52, 56, 58, 62, 64, 67, 71, 75, 80, 82, 85, 88, 91, 94, 95, 98, 101, 104, 107, 110, 113, 116, 119, 122, 125, 128, 134, 139, 143, 146, 151, 154, 157, 161, 163, 165, 167, 169, 171, 173, 175, 177, 179, 181, 182, 184, 186, 190, 193, 195, 196, 200, 201 }; public static final int yyrhs[] = { 39, 0, 29, 0, 40, 0, 41, 0, 42, 43, 0, 44, 45, 0, 46, 12, 48, 0, 46, 12, 48, 11, 48, 47, 0, 50, 0, 46, 9, 49, 11, 48, 0, 50, 0, 0, 46, 5, 0, 46, 6, 0, 46, 7, 0, 46, 8, 0, 0, 10, 48, 0, 47, 30, 48, 0, 49, 0, 48, 31, 49, 0, 4, 0, 32, 33, 0, 32, 51, 33, 0, 32, 33, 29, 0, 32, 51, 33, 29, 0, 52, 0, 51, 52, 0, 63, 29, 0, 53, 54, 0, 53, 56, 0, 0, 53, 13, 0, 53, 7, 0, 53, 14, 0, 53, 15, 0, 53, 16, 0, 53, 17, 0, 53, 5, 0, 53, 18, 0, 53, 6, 0, 53, 8, 0, 55, 29, 0, 58, 48, 34, 59, 35, 0, 49, 34, 59, 35, 0, 55, 36, 37, 0, 57, 29, 0, 48, 31, 4, 49, 0, 49, 49, 0, 58, 49, 0, 57, 36, 37, 0, 19, 0, 20, 0, 21, 0, 28, 0, 27, 0, 23, 0, 25, 0, 22, 0, 26, 0, 24, 0, 0, 60, 0, 61, 0, 60, 30, 61, 0, 58, 62, 0, 48, 0, 0, 62, 36, 37, 0, 0, 53, 15, 32, 33, 0 }; public static final int yyrline[] = { 0, 21, 24, 25, 26, 29, 31, 34, 38, 47, 52, 59, 64, 65, 66, 67, 68, 71, 72, 73, 76, 78, 83, 88, 89, 90, 91, 94, 95, 98, 99, 100, 103, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 126, 129, 130, 131, 134, 140, 146, 152, 156, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 204, 205, 208, 209, 212, 213, 216, 217, 220, 221 }; public static final String yytname[] = { "$","error","$undefined.","ERROR", "SYMBOL","FINAL","SYNCHRONIZED","PUBLIC","ABSTRACT","INTERFACE","IMPLEMENTS", "EXTENDS","CLASS","PRIVATE","PROTECTED","STATIC","TRANSIENT","VOLATILE","NATIVE", "BOOLEAN","BYTE","CHAR","DOUBLE","FLOAT","VOID","LONG","STRING","INT","SHORT", "';'","','","'.'","'{'","'}'","'('","')'","'['","']'","compilationUnit","typeDeclaration", "classDeclaration","interfaceDeclaration","classDecl1","classDecl2","interfaceDecl1", "interfaceDecl2","classModifierList","interfaces","qualifiedSymbol","simpleSymbol", "classBlock","fieldList","field","modifierList","methodDeclaration","method", "variableDeclaration","variable","simpleType","optArgList","argList","arg","optArrayBounds", "ignore", null }; public static final int yyr1[] = { 0, 38, 39, 39, 39, 40, 41, 42, 42, 43, 44, 45, 46, 46, 46, 46, 46, 47, 47, 47, 48, 48, 49, 50, 50, 50, 50, 51, 51, 52, 52, 52, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 54, 55, 55, 55, 56, 57, 57, 57, 57, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 59, 59, 60, 60, 61, 61, 62, 62, 63, 63 }; public static final int yyr2[] = { 0, 1, 1, 1, 1, 2, 2, 3, 6, 1, 5, 1, 0, 2, 2, 2, 2, 0, 2, 3, 1, 3, 1, 2, 3, 3, 4, 1, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 5, 4, 3, 2, 4, 2, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 3, 2, 1, 0, 3, 0, 4 }; public static final int yydefact[] = { 12, 2, 1, 3, 4, 0, 0, 0, 32, 5, 9, 6, 11, 13, 14, 15, 16, 0, 0, 23, 32, 27, 0, 0, 22, 0, 7, 20, 25, 24, 28, 39, 41, 34, 42, 33, 35, 36, 37, 38, 40, 52, 53, 54, 59, 57, 61, 58, 60, 56, 55, 0, 20, 30, 0, 31, 0, 0, 29, 0, 0, 0, 26, 0, 0, 62, 49, 43, 0, 47, 0, 0, 20, 10, 17, 21, 71, 22, 67, 68, 0, 63, 64, 46, 51, 62, 0, 8, 48, 66, 45, 0, 0, 18, 0, 0, 65, 44, 19, 69, 0, 0, 0 }; public static final int yydefgoto[] = { 100, 2, 3, 4, 5, 9, 6, 11, 7, 87, 78, 27, 10, 20, 21, 22, 53, 54, 55, 56, 79, 80, 81, 82, 89, 23 }; public static final int yypact[] = { -16, -32768,-32768,-32768,-32768, -21, -21, 28, 15,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768, 11, 11, 0, 16, -32768, 65, 3,-32768, 17, -1,-32768,-32768, 23,-32768, -32768,-32768,-32768,-32768,-32768,-32768, 14,-32768,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 22, -3,-32768, -24,-32768, -22, 11,-32768, 11, 11, 11,-32768, 24, 51, -2,-32768,-32768, 19,-32768, 21, 20, -20, 29, -4,-32768,-32768, 11, 29,-32768, 26, 32,-32768,-32768,-32768, -2, 11, 34,-32768, 30,-32768, -2, 39, 29, 11, 38,-32768,-32768, 29,-32768, 59, 67,-32768 }; public static final int yypgoto[] = { -32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -18, -14, 71,-32768, 45,-32768,-32768,-32768,-32768,-32768, 72, 10,-32768, 5,-32768,-32768 }; public static final int yytable[] = { 26, 24, 24, 25, 51, 67, 86, 69, 52, -50, 60, 8, 68, 1, 70, 24, -50, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 61, 59, 28, 61, 65, 58, 13, 14, 15, 16, 17, 66, 71, 18, 73, 74, 72, -70, -70, 63, 75, 19, 29, 75, 61, 62, 64, 85, 77, 83, 76, 84, 101, 61, 90, 91, 88, 94, 30, 95, 102, 93, 24, 31, 32, 33, 34, 97, 99, 98, 12, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 57, 92, 96 }; public static final int yycheck[] = { 18, 4, 4, 17, 22, 29, 10, 29, 22, 29, 11, 32, 36, 29, 36, 4, 36, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31, 11, 29, 31, 34, 29, 5, 6, 7, 8, 9, 52, 57, 12, 59, 60, 57, 29, 29, 32, 61, 33, 33, 64, 31, 29, 31, 34, 4, 37, 33, 37, 0, 31, 35, 30, 77, 30, 20, 36, 0, 86, 4, 5, 6, 7, 8, 35, 37, 94, 6, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 22, 85, 91 }; // SUFFIX /* put suffix code here */ /* Override yyerror */ public void yyverror(String s) throws ParseException { yyerror(s, true); //throw new ParseException(s); } // protected Patch pat; protected npp.src.util.NslPreProcessor pat; public void init(npp.src.util.NslPreProcessor p) { pat = p; } /* init(npp.src.NPP p) { pat = p; } */ }; /*class*/