PredicateParser.java Source File

00001 package edu.ksu.cis.bandera.abstraction.predicate.parser;
00002 
00003 /* Generated By:JJTree&JavaCC: Do not edit this line. PredicateParser.java */
00004 import java.util.*;
00005 import java.io.*;
00006 
00007 public class PredicateParser/*@bgen(jjtree)*/implements PredicateParserTreeConstants, PredicateParserConstants {/*@bgen(jjtree)*/
00008   protected JJTPredicateParserState jjtree = new JJTPredicateParserState();
00009   public PredicateParserTokenManager token_source;
00010   ASCII_UCodeESC_CharStream jj_input_stream;
00011   public Token token, jj_nt;
00012   private int jj_ntk;
00013   private Token jj_scanpos, jj_lastpos;
00014   private int jj_la;
00015   public boolean lookingAhead = false;
00016   private boolean jj_semLA;
00017   private int jj_gen;
00018   final private int[] jj_la1 = new int[36];
00019   final private int[] jj_la1_0 = {0x80000000,0x80000000,0x10000000,0x26ae000,0x0,0x26ae000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfeee000,0x0,0xd840000,0x0,0xd840000,0x0,0x0,0x0,0x0,0x8840000,0x0,0x26ae000,};
00020   final private int[] jj_la1_1 = {0x4000,0x4000,0x0,0x4000,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x80000000,0x0,0x18000000,0x18000000,0x0,0x0,0x0,0x0,0x0,0x0,0x60000000,0x240d1,0x60000000,0x600240d1,0x20000,0x200d1,0x4000,0x2200000,0x2200000,0x2000000,0xd1,0x1000000,0x4000,};
00021   final private int[] jj_la1_2 = {0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x8,0x10,0x1000,0x2000,0x800,0x4,0x4,0x0,0x3,0x3,0x38000,0x38000,0x180,0x180,0x4600,0x4600,0x180,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
00022   final private JJCalls[] jj_2_rtns = new JJCalls[6];
00023   private boolean jj_rescan = false;
00024   private int jj_gc = 0;
00025 
00026   private java.util.Vector jj_expentries = new java.util.Vector();
00027   private int[] jj_expentry;
00028   private int jj_kind = -1;
00029   private int[] jj_lasttokens = new int[100];
00030   private int jj_endpos;
00031 
00032   static final class JJCalls {
00033     int gen;
00034     Token first;
00035     int arg;
00036     JJCalls next;
00037   }
00038 
00039   public PredicateParser(PredicateParserTokenManager tm) {
00040     token_source = tm;
00041     token = new Token();
00042     jj_ntk = -1;
00043     jj_gen = 0;
00044     for (int i = 0; i < 36; i++) jj_la1[i] = -1;
00045     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
00046   }  
00047   public PredicateParser(java.io.InputStream stream) {
00048     jj_input_stream = new ASCII_UCodeESC_CharStream(stream, 1, 1);
00049     token_source = new PredicateParserTokenManager(jj_input_stream);
00050     token = new Token();
00051     jj_ntk = -1;
00052     jj_gen = 0;
00053     for (int i = 0; i < 36; i++) jj_la1[i] = -1;
00054     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
00055   }  
00056   public PredicateParser(java.io.Reader stream) {
00057     jj_input_stream = new ASCII_UCodeESC_CharStream(stream, 1, 1);
00058     token_source = new PredicateParserTokenManager(jj_input_stream);
00059     token = new Token();
00060     jj_ntk = -1;
00061     jj_gen = 0;
00062     for (int i = 0; i < 36; i++) jj_la1[i] = -1;
00063     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
00064   }  
00065   final public SimpleNode AddSubExpr() throws ParseException {
00066  /*@bgen(jjtree) AddSubExpr */
00067   ASTAddSubExpr jjtn000 = (ASTAddSubExpr)ASTAddSubExpr.jjtCreate(this, JJTADDSUBEXPR);
00068   boolean jjtc000 = true;
00069   jjtree.openNodeScope(jjtn000);LinkedList tl = new LinkedList();
00070   LinkedList el = new LinkedList();
00071   Token t;
00072   SimpleNode n;
00073     try {
00074       n = MulDivExpr();
00075                      el.addLast(n);
00076       label_11:
00077       while (true) {
00078         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00079         case PLUS:
00080         case MINUS:
00081           ;
00082           break;
00083         default:
00084           jj_la1[19] = jj_gen;
00085           break label_11;
00086         }
00087         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00088         case PLUS:
00089           t = jj_consume_token(PLUS);
00090           break;
00091         case MINUS:
00092           t = jj_consume_token(MINUS);
00093           break;
00094         default:
00095           jj_la1[20] = jj_gen;
00096           jj_consume_token(-1);
00097           throw new ParseException();
00098         }
00099                                                                 tl.addLast(t.image);
00100         n = MulDivExpr();
00101                      el.addLast(n);
00102       }
00103     jjtree.closeNodeScope(jjtn000, true);
00104     jjtc000 = false;
00105     if (!tl.isEmpty())
00106     {
00107       jjtn000.setExprList(el);
00108       jjtn000.setTokenList(tl);
00109       {if (true) return jjtn000;}
00110     } else {if (true) return n;}  // Skip pass-thru
00111 
00112     } catch (Throwable jjte000) {
00113     if (jjtc000) {
00114       jjtree.clearNodeScope(jjtn000);
00115       jjtc000 = false;
00116     } else {
00117       jjtree.popNode();
00118     }
00119     if (jjte000 instanceof RuntimeException) {
00120       {if (true) throw (RuntimeException)jjte000;}
00121     }
00122     if (jjte000 instanceof ParseException) {
00123       {if (true) throw (ParseException)jjte000;}
00124     }
00125     {if (true) throw (Error)jjte000;}
00126     } finally {
00127     if (jjtc000) {
00128       jjtree.closeNodeScope(jjtn000, true);
00129     }
00130     }
00131     throw new Error("Missing return statement in function");
00132   }  
00133   final public SimpleNode AndExpr() throws ParseException {
00134  /*@bgen(jjtree) AndExpr */
00135   ASTAndExpr jjtn000 = (ASTAndExpr)ASTAndExpr.jjtCreate(this, JJTANDEXPR);
00136   boolean jjtc000 = true;
00137   jjtree.openNodeScope(jjtn000);LinkedList el = new LinkedList();
00138   SimpleNode n;
00139     try {
00140       n = BitOrExpr();
00141                     el.addLast(n);
00142       label_5:
00143       while (true) {
00144         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00145         case SC_AND:
00146           ;
00147           break;
00148         default:
00149           jj_la1[8] = jj_gen;
00150           break label_5;
00151         }
00152         jj_consume_token(SC_AND);
00153         n = BitOrExpr();
00154                                                               el.addLast(n);
00155       }
00156     jjtree.closeNodeScope(jjtn000, true);
00157     jjtc000 = false;
00158      if (el.size() > 1)
00159      {
00160         jjtn000.setExprList(el);
00161         jjtn000.setToken("&&");
00162         {if (true) return jjtn000;}
00163      } else {if (true) return n;}  // Skip pass-thru
00164 
00165     } catch (Throwable jjte000) {
00166     if (jjtc000) {
00167       jjtree.clearNodeScope(jjtn000);
00168       jjtc000 = false;
00169     } else {
00170       jjtree.popNode();
00171     }
00172     if (jjte000 instanceof RuntimeException) {
00173       {if (true) throw (RuntimeException)jjte000;}
00174     }
00175     if (jjte000 instanceof ParseException) {
00176       {if (true) throw (ParseException)jjte000;}
00177     }
00178     {if (true) throw (Error)jjte000;}
00179     } finally {
00180     if (jjtc000) {
00181       jjtree.closeNodeScope(jjtn000, true);
00182     }
00183     }
00184     throw new Error("Missing return statement in function");
00185   }  
00186   final public ASTArguments Arguments() throws ParseException {
00187  /*@bgen(jjtree) Arguments */
00188   ASTArguments jjtn000 = (ASTArguments)ASTArguments.jjtCreate(this, JJTARGUMENTS);
00189   boolean jjtc000 = true;
00190   jjtree.openNodeScope(jjtn000);LinkedList ll = new LinkedList();
00191   SimpleNode n;
00192     try {
00193       jj_consume_token(LPAREN);
00194       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00195       case BOOLEAN:
00196       case BYTE:
00197       case CHAR:
00198       case DOUBLE:
00199       case FLOAT:
00200       case INT:
00201       case LONG:
00202       case SHORT:
00203       case IDENTIFIER:
00204         n = Type();
00205                      ll.addLast(n);
00206         label_14:
00207         while (true) {
00208           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00209           case COMMA:
00210             ;
00211             break;
00212           default:
00213             jj_la1[34] = jj_gen;
00214             break label_14;
00215           }
00216           jj_consume_token(COMMA);
00217           n = Type();
00218                                                          ll.addLast(n);
00219         }
00220         break;
00221       default:
00222         jj_la1[35] = jj_gen;
00223         ;
00224       }
00225       jj_consume_token(RPAREN);
00226     jjtree.closeNodeScope(jjtn000, true);
00227     jjtc000 = false;
00228     jjtn000.setArguments(ll);
00229     {if (true) return jjtn000;}
00230     } catch (Throwable jjte000) {
00231     if (jjtc000) {
00232       jjtree.clearNodeScope(jjtn000);
00233       jjtc000 = false;
00234     } else {
00235       jjtree.popNode();
00236     }
00237     if (jjte000 instanceof RuntimeException) {
00238       {if (true) throw (RuntimeException)jjte000;}
00239     }
00240     if (jjte000 instanceof ParseException) {
00241       {if (true) throw (ParseException)jjte000;}
00242     }
00243     {if (true) throw (Error)jjte000;}
00244     } finally {
00245     if (jjtc000) {
00246       jjtree.closeNodeScope(jjtn000, true);
00247     }
00248     }
00249     throw new Error("Missing return statement in function");
00250   }  
00251   final public ASTArrayExpr ArrayExpr() throws ParseException {
00252  /*@bgen(jjtree) ArrayExpr */
00253   ASTArrayExpr jjtn000 = (ASTArrayExpr)ASTArrayExpr.jjtCreate(this, JJTARRAYEXPR);
00254   boolean jjtc000 = true;
00255   jjtree.openNodeScope(jjtn000);SimpleNode n;
00256     try {
00257       jj_consume_token(LBRACKET);
00258       n = CondExpr();
00259       jj_consume_token(RBRACKET);
00260      jjtree.closeNodeScope(jjtn000, true);
00261      jjtc000 = false;
00262      jjtn000.setExpr(n);
00263      {if (true) return jjtn000;}
00264     } catch (Throwable jjte000) {
00265      if (jjtc000) {
00266        jjtree.clearNodeScope(jjtn000);
00267        jjtc000 = false;
00268      } else {
00269        jjtree.popNode();
00270      }
00271      if (jjte000 instanceof RuntimeException) {
00272        {if (true) throw (RuntimeException)jjte000;}
00273      }
00274      if (jjte000 instanceof ParseException) {
00275        {if (true) throw (ParseException)jjte000;}
00276      }
00277      {if (true) throw (Error)jjte000;}
00278     } finally {
00279      if (jjtc000) {
00280        jjtree.closeNodeScope(jjtn000, true);
00281      }
00282     }
00283     throw new Error("Missing return statement in function");
00284   }  
00285   final public SimpleNode BitAndExpr() throws ParseException {
00286  /*@bgen(jjtree) BitAndExpr */
00287   ASTBitAndExpr jjtn000 = (ASTBitAndExpr)ASTBitAndExpr.jjtCreate(this, JJTBITANDEXPR);
00288   boolean jjtc000 = true;
00289   jjtree.openNodeScope(jjtn000);LinkedList el = new LinkedList();
00290   SimpleNode n;
00291     try {
00292       n = EqExpr();
00293                  el.addLast(n);
00294       label_8:
00295       while (true) {
00296         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00297         case BIT_AND:
00298           ;
00299           break;
00300         default:
00301           jj_la1[11] = jj_gen;
00302           break label_8;
00303         }
00304         jj_consume_token(BIT_AND);
00305         n = EqExpr();
00306                                                        el.addLast(n);
00307       }
00308     jjtree.closeNodeScope(jjtn000, true);
00309     jjtc000 = false;
00310      if (el.size() > 1)
00311      {
00312         jjtn000.setExprList(el);
00313         jjtn000.setToken("&");
00314         {if (true) return jjtn000;}
00315      } else {if (true) return n;}  // Skip pass-thru
00316 
00317     } catch (Throwable jjte000) {
00318     if (jjtc000) {
00319       jjtree.clearNodeScope(jjtn000);
00320       jjtc000 = false;
00321     } else {
00322       jjtree.popNode();
00323     }
00324     if (jjte000 instanceof RuntimeException) {
00325       {if (true) throw (RuntimeException)jjte000;}
00326     }
00327     if (jjte000 instanceof ParseException) {
00328       {if (true) throw (ParseException)jjte000;}
00329     }
00330     {if (true) throw (Error)jjte000;}
00331     } finally {
00332     if (jjtc000) {
00333       jjtree.closeNodeScope(jjtn000, true);
00334     }
00335     }
00336     throw new Error("Missing return statement in function");
00337   }  
00338   final public SimpleNode BitOrExpr() throws ParseException {
00339  /*@bgen(jjtree) BitOrExpr */
00340   ASTBitOrExpr jjtn000 = (ASTBitOrExpr)ASTBitOrExpr.jjtCreate(this, JJTBITOREXPR);
00341   boolean jjtc000 = true;
00342   jjtree.openNodeScope(jjtn000);LinkedList el = new LinkedList();
00343   SimpleNode n;
00344     try {
00345       n = BitXorExpr();
00346                      el.addLast(n);
00347       label_6:
00348       while (true) {
00349         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00350         case BIT_OR:
00351           ;
00352           break;
00353         default:
00354           jj_la1[9] = jj_gen;
00355           break label_6;
00356         }
00357         jj_consume_token(BIT_OR);
00358         n = BitXorExpr();
00359                                                                el.addLast(n);
00360       }
00361     jjtree.closeNodeScope(jjtn000, true);
00362     jjtc000 = false;
00363      if (el.size() > 1)
00364      {
00365         jjtn000.setExprList(el);
00366         jjtn000.setToken("|");
00367         {if (true) return jjtn000;}
00368      } else {if (true) return n;}  // Skip pass-thru
00369 
00370     } catch (Throwable jjte000) {
00371     if (jjtc000) {
00372       jjtree.clearNodeScope(jjtn000);
00373       jjtc000 = false;
00374     } else {
00375       jjtree.popNode();
00376     }
00377     if (jjte000 instanceof RuntimeException) {
00378       {if (true) throw (RuntimeException)jjte000;}
00379     }
00380     if (jjte000 instanceof ParseException) {
00381       {if (true) throw (ParseException)jjte000;}
00382     }
00383     {if (true) throw (Error)jjte000;}
00384     } finally {
00385     if (jjtc000) {
00386       jjtree.closeNodeScope(jjtn000, true);
00387     }
00388     }
00389     throw new Error("Missing return statement in function");
00390   }  
00391   final public SimpleNode BitXorExpr() throws ParseException {
00392  /*@bgen(jjtree) BitXorExpr */
00393   ASTBitXorExpr jjtn000 = (ASTBitXorExpr)ASTBitXorExpr.jjtCreate(this, JJTBITXOREXPR);
00394   boolean jjtc000 = true;
00395   jjtree.openNodeScope(jjtn000);LinkedList el = new LinkedList();
00396   SimpleNode n;
00397     try {
00398       n = BitAndExpr();
00399                      el.addLast(n);
00400       label_7:
00401       while (true) {
00402         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00403         case XOR:
00404           ;
00405           break;
00406         default:
00407           jj_la1[10] = jj_gen;
00408           break label_7;
00409         }
00410         jj_consume_token(XOR);
00411         n = BitAndExpr();
00412                                                                el.addLast(n);
00413       }
00414     jjtree.closeNodeScope(jjtn000, true);
00415     jjtc000 = false;
00416      if (el.size() > 1)
00417      {
00418         jjtn000.setExprList(el);
00419         jjtn000.setToken("^");
00420         {if (true) return jjtn000;}
00421      } else {if (true) return n;}  // Skip pass-thru
00422 
00423     } catch (Throwable jjte000) {
00424     if (jjtc000) {
00425       jjtree.clearNodeScope(jjtn000);
00426       jjtc000 = false;
00427     } else {
00428       jjtree.popNode();
00429     }
00430     if (jjte000 instanceof RuntimeException) {
00431       {if (true) throw (RuntimeException)jjte000;}
00432     }
00433     if (jjte000 instanceof ParseException) {
00434       {if (true) throw (ParseException)jjte000;}
00435     }
00436     {if (true) throw (Error)jjte000;}
00437     } finally {
00438     if (jjtc000) {
00439       jjtree.closeNodeScope(jjtn000, true);
00440     }
00441     }
00442     throw new Error("Missing return statement in function");
00443   }  
00444   final public ASTCastExpr CastExpr() throws ParseException {
00445  /*@bgen(jjtree) CastExpr */
00446   ASTCastExpr jjtn000 = (ASTCastExpr)ASTCastExpr.jjtCreate(this, JJTCASTEXPR);
00447   boolean jjtc000 = true;
00448   jjtree.openNodeScope(jjtn000);SimpleNode n;
00449     try {
00450       jj_consume_token(LPAREN);
00451       n = Type();
00452       jj_consume_token(RPAREN);
00453                          jjtn000.setType(n);
00454       n = UnaryExpr();
00455     jjtree.closeNodeScope(jjtn000, true);
00456     jjtc000 = false;
00457      jjtn000.setExpr(n);
00458      {if (true) return jjtn000;}
00459     } catch (Throwable jjte000) {
00460     if (jjtc000) {
00461       jjtree.clearNodeScope(jjtn000);
00462       jjtc000 = false;
00463     } else {
00464       jjtree.popNode();
00465     }
00466     if (jjte000 instanceof RuntimeException) {
00467       {if (true) throw (RuntimeException)jjte000;}
00468     }
00469     if (jjte000 instanceof ParseException) {
00470       {if (true) throw (ParseException)jjte000;}
00471     }
00472     {if (true) throw (Error)jjte000;}
00473     } finally {
00474     if (jjtc000) {
00475       jjtree.closeNodeScope(jjtn000, true);
00476     }
00477     }
00478     throw new Error("Missing return statement in function");
00479   }  
00480 // This production is to determine lookahead only.  The LOOKAHEAD specifications
00481 // below are not used, but they are there just to indicate that we know about
00482 // this.
00483   final public void CastLookahead() throws ParseException {
00484  /*@bgen(jjtree) CastLookahead */
00485   ASTCastLookahead jjtn000 = (ASTCastLookahead)ASTCastLookahead.jjtCreate(this, JJTCASTLOOKAHEAD);
00486   boolean jjtc000 = true;
00487   jjtree.openNodeScope(jjtn000);
00488     try {
00489       if (jj_2_3(2)) {
00490         jj_consume_token(LPAREN);
00491         PrimitiveType();
00492       } else if (jj_2_4(2147483647)) {
00493         jj_consume_token(LPAREN);
00494         Name();
00495         jj_consume_token(LBRACKET);
00496         jj_consume_token(RBRACKET);
00497       } else {
00498         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00499         case LPAREN:
00500           jj_consume_token(LPAREN);
00501           Name();
00502           jj_consume_token(RPAREN);
00503           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00504           case TILDE:
00505             jj_consume_token(TILDE);
00506             break;
00507           case BANG:
00508             jj_consume_token(BANG);
00509             break;
00510           case LPAREN:
00511             jj_consume_token(LPAREN);
00512             break;
00513           case IDENTIFIER:
00514             jj_consume_token(IDENTIFIER);
00515             break;
00516           case FALSE:
00517           case NULL:
00518           case TRUE:
00519           case INTEGER_LITERAL:
00520           case FLOATING_POINT_LITERAL:
00521           case CHARACTER_LITERAL:
00522           case STRING_LITERAL:
00523             Literal();
00524             break;
00525           case THIS:
00526             jj_consume_token(THIS);
00527             break;
00528           case SUPER:
00529             jj_consume_token(SUPER);
00530             break;
00531           default:
00532             jj_la1[26] = jj_gen;
00533             jj_consume_token(-1);
00534             throw new ParseException();
00535           }
00536           break;
00537         default:
00538           jj_la1[27] = jj_gen;
00539           jj_consume_token(-1);
00540           throw new ParseException();
00541         }
00542       }
00543     } catch (Throwable jjte000) {
00544     if (jjtc000) {
00545       jjtree.clearNodeScope(jjtn000);
00546       jjtc000 = false;
00547     } else {
00548       jjtree.popNode();
00549     }
00550     if (jjte000 instanceof RuntimeException) {
00551       {if (true) throw (RuntimeException)jjte000;}
00552     }
00553     if (jjte000 instanceof ParseException) {
00554       {if (true) throw (ParseException)jjte000;}
00555     }
00556     {if (true) throw (Error)jjte000;}
00557     } finally {
00558     if (jjtc000) {
00559       jjtree.closeNodeScope(jjtn000, true);
00560     }
00561     }
00562   }  
00563 /*****************************************
00564  * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
00565  *****************************************/
00566 
00567 /*
00568  * Program structuring syntax follows.
00569  */
00570   final public ASTCompilationUnit CompilationUnit() throws ParseException {
00571  /*@bgen(jjtree) CompilationUnit */
00572   ASTCompilationUnit jjtn000 = (ASTCompilationUnit)ASTCompilationUnit.jjtCreate(this, JJTCOMPILATIONUNIT);
00573   boolean jjtc000 = true;
00574   jjtree.openNodeScope(jjtn000);SimpleNode n;
00575   PredicateImpl p = new PredicateImpl();
00576   Token t;
00577     try {
00578       label_1:
00579       while (true) {
00580         jj_consume_token(PREDICATE);
00581         t = jj_consume_token(IDENTIFIER);
00582                                    p.setName(t.image);
00583         jj_consume_token(LBRACE);
00584         jj_consume_token(CLASS);
00585         jj_consume_token(ASSIGN);
00586         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00587         case GLOBAL:
00588           jj_consume_token(GLOBAL);
00589           jj_consume_token(SEMICOLON);
00590           break;
00591         case IDENTIFIER:
00592           n = Name();
00593           jj_consume_token(SEMICOLON);
00594                                                      p.setClassContext(n.getTag());
00595           jj_consume_token(METHOD);
00596           jj_consume_token(ASSIGN);
00597           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00598           case GLOBAL:
00599             jj_consume_token(GLOBAL);
00600             jj_consume_token(SEMICOLON);
00601             break;
00602           case IDENTIFIER:
00603             t = jj_consume_token(IDENTIFIER);
00604             n = Arguments();
00605             jj_consume_token(SEMICOLON);
00606                                       p.setMethodContext(t.image,((ASTArguments) n).getArguments());
00607             break;
00608           default:
00609             jj_la1[0] = jj_gen;
00610             jj_consume_token(-1);
00611             throw new ParseException();
00612           }
00613           break;
00614         default:
00615           jj_la1[1] = jj_gen;
00616           jj_consume_token(-1);
00617           throw new ParseException();
00618         }
00619         jj_consume_token(EXPR);
00620         jj_consume_token(ASSIGN);
00621         n = CondExpr();
00622                                     p.setExprAST(n);
00623         jj_consume_token(SEMICOLON);
00624         jj_consume_token(RBRACE);
00625       jjtn000.addPredicate(p);
00626       p = new PredicateImpl();
00627         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00628         case PREDICATE:
00629           ;
00630           break;
00631         default:
00632           jj_la1[2] = jj_gen;
00633           break label_1;
00634         }
00635       }
00636       jj_consume_token(0);
00637     jjtree.closeNodeScope(jjtn000, true);
00638     jjtc000 = false;
00639      {if (true) return jjtn000;}
00640     } catch (Throwable jjte000) {
00641     if (jjtc000) {
00642       jjtree.clearNodeScope(jjtn000);
00643       jjtc000 = false;
00644     } else {
00645       jjtree.popNode();
00646     }
00647     if (jjte000 instanceof RuntimeException) {
00648       {if (true) throw (RuntimeException)jjte000;}
00649     }
00650     if (jjte000 instanceof ParseException) {
00651       {if (true) throw (ParseException)jjte000;}
00652     }
00653     {if (true) throw (Error)jjte000;}
00654     } finally {
00655     if (jjtc000) {
00656       jjtree.closeNodeScope(jjtn000, true);
00657     }
00658     }
00659     throw new Error("Missing return statement in function");
00660   }  
00661 /*
00662  * Expr syntax follows.
00663  */
00664   final public SimpleNode CondExpr() throws ParseException {
00665  /*@bgen(jjtree) CondExpr */
00666   ASTCondExpr jjtn000 = (ASTCondExpr)ASTCondExpr.jjtCreate(this, JJTCONDEXPR);
00667   boolean jjtc000 = true;
00668   jjtree.openNodeScope(jjtn000);SimpleNode ts = null, th = null, e = null;
00669     try {
00670       ts = OrExpr();
00671       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00672       case 82:
00673         jj_consume_token(82);
00674         th = CondExpr();
00675         jj_consume_token(83);
00676         e = CondExpr();
00677         break;
00678       default:
00679         jj_la1[6] = jj_gen;
00680         ;
00681       }
00682     jjtree.closeNodeScope(jjtn000, true);
00683     jjtc000 = false;
00684     if (th != null && e != null)
00685     {
00686        jjtn000.setTestExpr(ts);
00687        jjtn000.setThenExpr(th);
00688        jjtn000.setElseExpr(e);
00689        {if (true) return jjtn000;}
00690     } else {if (true) return ts;}  // Skip pass-thru
00691 
00692     } catch (Throwable jjte000) {
00693     if (jjtc000) {
00694       jjtree.clearNodeScope(jjtn000);
00695       jjtc000 = false;
00696     } else {
00697       jjtree.popNode();
00698     }
00699     if (jjte000 instanceof RuntimeException) {
00700       {if (true) throw (RuntimeException)jjte000;}
00701     }
00702     if (jjte000 instanceof ParseException) {
00703       {if (true) throw (ParseException)jjte000;}
00704     }
00705     {if (true) throw (Error)jjte000;}
00706     } finally {
00707     if (jjtc000) {
00708       jjtree.closeNodeScope(jjtn000, true);
00709     }
00710     }
00711     throw new Error("Missing return statement in function");
00712   }  
00713   final public void disable_tracing() {
00714   }  
00715   final public ASTDotClassExpr DotClassExpr() throws ParseException {
00716  /*@bgen(jjtree) DotClassExpr */
00717   ASTDotClassExpr jjtn000 = (ASTDotClassExpr)ASTDotClassExpr.jjtCreate(this, JJTDOTCLASSEXPR);
00718   boolean jjtc000 = true;
00719   jjtree.openNodeScope(jjtn000);SimpleNode n;
00720     try {
00721       n = Type();
00722       jj_consume_token(DOT);
00723       jj_consume_token(CLASS);
00724      jjtree.closeNodeScope(jjtn000, true);
00725      jjtc000 = false;
00726      jjtn000.setExpr(n);
00727      {if (true) return jjtn000;}
00728     } catch (Throwable jjte000) {
00729      if (jjtc000) {
00730        jjtree.clearNodeScope(jjtn000);
00731        jjtc000 = false;
00732      } else {
00733        jjtree.popNode();
00734      }
00735      if (jjte000 instanceof RuntimeException) {
00736        {if (true) throw (RuntimeException)jjte000;}
00737      }
00738      if (jjte000 instanceof ParseException) {
00739        {if (true) throw (ParseException)jjte000;}
00740      }
00741      {if (true) throw (Error)jjte000;}
00742     } finally {
00743      if (jjtc000) {
00744        jjtree.closeNodeScope(jjtn000, true);
00745      }
00746     }
00747     throw new Error("Missing return statement in function");
00748   }  
00749   final public ASTDottedExpr DottedExpr() throws ParseException {
00750  /*@bgen(jjtree) DottedExpr */
00751   ASTDottedExpr jjtn000 = (ASTDottedExpr)ASTDottedExpr.jjtCreate(this, JJTDOTTEDEXPR);
00752   boolean jjtc000 = true;
00753   jjtree.openNodeScope(jjtn000);Token t;
00754     try {
00755       if (jj_2_6(2)) {
00756         jj_consume_token(DOT);
00757         t = jj_consume_token(THIS);
00758       } else {
00759         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00760         case DOT:
00761           jj_consume_token(DOT);
00762           t = jj_consume_token(IDENTIFIER);
00763       jjtree.closeNodeScope(jjtn000, true);
00764       jjtc000 = false;
00765        jjtn000.setTag(t.image);
00766        {if (true) return jjtn000;}
00767           break;
00768         default:
00769           jj_la1[32] = jj_gen;
00770           jj_consume_token(-1);
00771           throw new ParseException();
00772         }
00773       }
00774     } finally {
00775       if (jjtc000) {
00776         jjtree.closeNodeScope(jjtn000, true);
00777       }
00778     }
00779     throw new Error("Missing return statement in function");
00780   }  
00781   final public void enable_tracing() {
00782   }  
00783   final public SimpleNode EqExpr() throws ParseException {
00784  /*@bgen(jjtree) EqExpr */
00785   ASTEqExpr jjtn000 = (ASTEqExpr)ASTEqExpr.jjtCreate(this, JJTEQEXPR);
00786   boolean jjtc000 = true;
00787   jjtree.openNodeScope(jjtn000);LinkedList tl = new LinkedList();
00788   LinkedList el = new LinkedList();
00789   Token t;
00790   SimpleNode n;
00791     try {
00792       n = InstanceOfExpr();
00793                          el.addLast(n);
00794       label_9:
00795       while (true) {
00796         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00797         case EQ:
00798         case NE:
00799           ;
00800           break;
00801         default:
00802           jj_la1[12] = jj_gen;
00803           break label_9;
00804         }
00805         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00806         case EQ:
00807           t = jj_consume_token(EQ);
00808           break;
00809         case NE:
00810           t = jj_consume_token(NE);
00811           break;
00812         default:
00813           jj_la1[13] = jj_gen;
00814           jj_consume_token(-1);
00815           throw new ParseException();
00816         }
00817                               tl.addLast(t.image);
00818         n = InstanceOfExpr();
00819                                                                       el.addLast(n);
00820       }
00821     jjtree.closeNodeScope(jjtn000, true);
00822     jjtc000 = false;
00823     if (!tl.isEmpty())
00824     {
00825       jjtn000.setExprList(el);
00826       jjtn000.setTokenList(tl);
00827       {if (true) return jjtn000;}
00828     } else {if (true) return n;}  // Skip pass-thru
00829 
00830     } catch (Throwable jjte000) {
00831     if (jjtc000) {
00832       jjtree.clearNodeScope(jjtn000);
00833       jjtc000 = false;
00834     } else {
00835       jjtree.popNode();
00836     }
00837     if (jjte000 instanceof RuntimeException) {
00838       {if (true) throw (RuntimeException)jjte000;}
00839     }
00840     if (jjte000 instanceof ParseException) {
00841       {if (true) throw (ParseException)jjte000;}
00842     }
00843     {if (true) throw (Error)jjte000;}
00844     } finally {
00845     if (jjtc000) {
00846       jjtree.closeNodeScope(jjtn000, true);
00847     }
00848     }
00849     throw new Error("Missing return statement in function");
00850   }  
00851   final public ParseException generateParseException() {
00852     jj_expentries.removeAllElements();
00853     boolean[] la1tokens = new boolean[84];
00854     for (int i = 0; i < 84; i++) {
00855       la1tokens[i] = false;
00856     }
00857     if (jj_kind >= 0) {
00858       la1tokens[jj_kind] = true;
00859       jj_kind = -1;
00860     }
00861     for (int i = 0; i < 36; i++) {
00862       if (jj_la1[i] == jj_gen) {
00863         for (int j = 0; j < 32; j++) {
00864           if ((jj_la1_0[i] & (1<<j)) != 0) {
00865             la1tokens[j] = true;
00866           }
00867           if ((jj_la1_1[i] & (1<<j)) != 0) {
00868             la1tokens[32+j] = true;
00869           }
00870           if ((jj_la1_2[i] & (1<<j)) != 0) {
00871             la1tokens[64+j] = true;
00872           }
00873         }
00874       }
00875     }
00876     for (int i = 0; i < 84; i++) {
00877       if (la1tokens[i]) {
00878         jj_expentry = new int[1];
00879         jj_expentry[0] = i;
00880         jj_expentries.addElement(jj_expentry);
00881       }
00882     }
00883     jj_endpos = 0;
00884     jj_rescan_token();
00885     jj_add_error_token(0, 0);
00886     int[][] exptokseq = new int[jj_expentries.size()][];
00887     for (int i = 0; i < jj_expentries.size(); i++) {
00888       exptokseq[i] = (int[])jj_expentries.elementAt(i);
00889     }
00890     return new ParseException(token, exptokseq, tokenImage);
00891   }  
00892   final public Token getNextToken() {
00893     if (token.next != null) token = token.next;
00894     else token = token.next = token_source.getNextToken();
00895     jj_ntk = -1;
00896     jj_gen++;
00897     return token;
00898   }  
00899   final public Token getToken(int index) {
00900     Token t = lookingAhead ? jj_scanpos : token;
00901     for (int i = 0; i < index; i++) {
00902       if (t.next != null) t = t.next;
00903       else t = t.next = token_source.getNextToken();
00904     }
00905     return t;
00906   }  
00907     public static void help()
00908     {
00909         System.out.println("Predicate Parser:  Usage is one of:");
00910         System.out.println("         java PredicateParser < inputfile");
00911         System.out.println("OR");
00912         System.out.println("         java PredicateParser inputfile");
00913     }
00914   final public SimpleNode InstanceOfExpr() throws ParseException {
00915  /*@bgen(jjtree) InstanceOfExpr */
00916   ASTInstanceOfExpr jjtn000 = (ASTInstanceOfExpr)ASTInstanceOfExpr.jjtCreate(this, JJTINSTANCEOFEXPR);
00917   boolean jjtc000 = true;
00918   jjtree.openNodeScope(jjtn000);SimpleNode n = null, t = null;
00919     try {
00920       n = RelationalExpr();
00921       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
00922       case INSTANCEOF:
00923         jj_consume_token(INSTANCEOF);
00924         t = Type();
00925         break;
00926       default:
00927         jj_la1[14] = jj_gen;
00928         ;
00929       }
00930     jjtree.closeNodeScope(jjtn000, true);
00931     jjtc000 = false;
00932      if (t != null)
00933      {
00934         jjtn000.setType(t);
00935         jjtn000.setExpr(n);
00936         {if (true) return jjtn000;}
00937      } else {if (true) return n;}  // Skip pass-thru
00938 
00939     } catch (Throwable jjte000) {
00940     if (jjtc000) {
00941       jjtree.clearNodeScope(jjtn000);
00942       jjtc000 = false;
00943     } else {
00944       jjtree.popNode();
00945     }
00946     if (jjte000 instanceof RuntimeException) {
00947       {if (true) throw (RuntimeException)jjte000;}
00948     }
00949     if (jjte000 instanceof ParseException) {
00950       {if (true) throw (ParseException)jjte000;}
00951     }
00952     {if (true) throw (Error)jjte000;}
00953     } finally {
00954     if (jjtc000) {
00955       jjtree.closeNodeScope(jjtn000, true);
00956     }
00957     }
00958     throw new Error("Missing return statement in function");
00959   }  
00960   final private boolean jj_2_1(int xla) {
00961     jj_la = xla; jj_lastpos = jj_scanpos = token;
00962     boolean retval = !jj_3_1();
00963     jj_save(0, xla);
00964     return retval;
00965   }  
00966   final private boolean jj_2_2(int xla) {
00967     jj_la = xla; jj_lastpos = jj_scanpos = token;
00968     boolean retval = !jj_3_2();
00969     jj_save(1, xla);
00970     return retval;
00971   }  
00972   final private boolean jj_2_3(int xla) {
00973     jj_la = xla; jj_lastpos = jj_scanpos = token;
00974     boolean retval = !jj_3_3();
00975     jj_save(2, xla);
00976     return retval;
00977   }  
00978   final private boolean jj_2_4(int xla) {
00979     jj_la = xla; jj_lastpos = jj_scanpos = token;
00980     boolean retval = !jj_3_4();
00981     jj_save(3, xla);
00982     return retval;
00983   }  
00984   final private boolean jj_2_5(int xla) {
00985     jj_la = xla; jj_lastpos = jj_scanpos = token;
00986     boolean retval = !jj_3_5();
00987     jj_save(4, xla);
00988     return retval;
00989   }  
00990   final private boolean jj_2_6(int xla) {
00991     jj_la = xla; jj_lastpos = jj_scanpos = token;
00992     boolean retval = !jj_3_6();
00993     jj_save(5, xla);
00994     return retval;
00995   }  
00996   final private boolean jj_3_1() {
00997     if (jj_scan_token(DOT)) return true;
00998     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
00999     if (jj_scan_token(IDENTIFIER)) return true;
01000     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01001     return false;
01002   }  
01003   final private boolean jj_3_2() {
01004     if (jj_3R_15()) return true;
01005     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01006     return false;
01007   }  
01008   final private boolean jj_3_3() {
01009     if (jj_scan_token(LPAREN)) return true;
01010     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01011     if (jj_3R_16()) return true;
01012     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01013     return false;
01014   }  
01015   final private boolean jj_3_4() {
01016     if (jj_scan_token(LPAREN)) return true;
01017     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01018     if (jj_3R_17()) return true;
01019     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01020     if (jj_scan_token(LBRACKET)) return true;
01021     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01022     return false;
01023   }  
01024   final private boolean jj_3_5() {
01025     if (jj_3R_18()) return true;
01026     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01027     if (jj_scan_token(DOT)) return true;
01028     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01029     if (jj_scan_token(CLASS)) return true;
01030     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01031     return false;
01032   }  
01033   final private boolean jj_3_6() {
01034     if (jj_scan_token(DOT)) return true;
01035     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01036     if (jj_scan_token(THIS)) return true;
01037     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01038     return false;
01039   }  
01040   final private boolean jj_3R_15() {
01041     Token xsp;
01042     xsp = jj_scanpos;
01043     if (jj_3_3()) {
01044     jj_scanpos = xsp;
01045     if (jj_3R_19()) {
01046     jj_scanpos = xsp;
01047     if (jj_3R_20()) return true;
01048     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01049     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01050     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01051     return false;
01052   }  
01053   final private boolean jj_3R_16() {
01054     Token xsp;
01055     xsp = jj_scanpos;
01056     if (jj_3R_21()) {
01057     jj_scanpos = xsp;
01058     if (jj_3R_22()) {
01059     jj_scanpos = xsp;
01060     if (jj_3R_23()) {
01061     jj_scanpos = xsp;
01062     if (jj_3R_24()) {
01063     jj_scanpos = xsp;
01064     if (jj_3R_25()) {
01065     jj_scanpos = xsp;
01066     if (jj_3R_26()) {
01067     jj_scanpos = xsp;
01068     if (jj_3R_27()) {
01069     jj_scanpos = xsp;
01070     if (jj_3R_28()) return true;
01071     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01072     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01073     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01074     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01075     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01076     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01077     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01078     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01079     return false;
01080   }  
01081   final private boolean jj_3R_17() {
01082     if (jj_scan_token(IDENTIFIER)) return true;
01083     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01084     Token xsp;
01085     while (true) {
01086       xsp = jj_scanpos;
01087       if (jj_3_1()) { jj_scanpos = xsp; break; }
01088       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01089     }
01090     return false;
01091   }  
01092   final private boolean jj_3R_18() {
01093     Token xsp;
01094     xsp = jj_scanpos;
01095     if (jj_3R_29()) {
01096     jj_scanpos = xsp;
01097     if (jj_3R_30()) return true;
01098     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01099     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01100     while (true) {
01101       xsp = jj_scanpos;
01102       if (jj_3R_31()) { jj_scanpos = xsp; break; }
01103       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01104     }
01105     return false;
01106   }  
01107   final private boolean jj_3R_19() {
01108     if (jj_scan_token(LPAREN)) return true;
01109     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01110     if (jj_3R_17()) return true;
01111     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01112     if (jj_scan_token(LBRACKET)) return true;
01113     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01114     if (jj_scan_token(RBRACKET)) return true;
01115     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01116     return false;
01117   }  
01118   final private boolean jj_3R_20() {
01119     if (jj_scan_token(LPAREN)) return true;
01120     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01121     if (jj_3R_17()) return true;
01122     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01123     if (jj_scan_token(RPAREN)) return true;
01124     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01125     Token xsp;
01126     xsp = jj_scanpos;
01127     if (jj_3R_32()) {
01128     jj_scanpos = xsp;
01129     if (jj_3R_33()) {
01130     jj_scanpos = xsp;
01131     if (jj_3R_34()) {
01132     jj_scanpos = xsp;
01133     if (jj_3R_35()) {
01134     jj_scanpos = xsp;
01135     if (jj_3R_36()) {
01136     jj_scanpos = xsp;
01137     if (jj_3R_37()) {
01138     jj_scanpos = xsp;
01139     if (jj_3R_38()) return true;
01140     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01141     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01142     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01143     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01144     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01145     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01146     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01147     return false;
01148   }  
01149   final private boolean jj_3R_21() {
01150     if (jj_scan_token(BOOLEAN)) return true;
01151     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01152     return false;
01153   }  
01154   final private boolean jj_3R_22() {
01155     if (jj_scan_token(CHAR)) return true;
01156     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01157     return false;
01158   }  
01159   final private boolean jj_3R_23() {
01160     if (jj_scan_token(BYTE)) return true;
01161     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01162     return false;
01163   }  
01164   final private boolean jj_3R_24() {
01165     if (jj_scan_token(SHORT)) return true;
01166     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01167     return false;
01168   }  
01169   final private boolean jj_3R_25() {
01170     if (jj_scan_token(INT)) return true;
01171     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01172     return false;
01173   }  
01174   final private boolean jj_3R_26() {
01175     if (jj_scan_token(LONG)) return true;
01176     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01177     return false;
01178   }  
01179   final private boolean jj_3R_27() {
01180     if (jj_scan_token(FLOAT)) return true;
01181     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01182     return false;
01183   }  
01184   final private boolean jj_3R_28() {
01185     if (jj_scan_token(DOUBLE)) return true;
01186     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01187     return false;
01188   }  
01189   final private boolean jj_3R_29() {
01190     if (jj_3R_16()) return true;
01191     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01192     return false;
01193   }  
01194   final private boolean jj_3R_30() {
01195     if (jj_3R_17()) return true;
01196     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01197     return false;
01198   }  
01199   final private boolean jj_3R_31() {
01200     if (jj_scan_token(LBRACKET)) return true;
01201     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01202     if (jj_scan_token(RBRACKET)) return true;
01203     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01204     return false;
01205   }  
01206   final private boolean jj_3R_32() {
01207     if (jj_scan_token(TILDE)) return true;
01208     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01209     return false;
01210   }  
01211   final private boolean jj_3R_33() {
01212     if (jj_scan_token(BANG)) return true;
01213     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01214     return false;
01215   }  
01216   final private boolean jj_3R_34() {
01217     if (jj_scan_token(LPAREN)) return true;
01218     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01219     return false;
01220   }  
01221   final private boolean jj_3R_35() {
01222     if (jj_scan_token(IDENTIFIER)) return true;
01223     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01224     return false;
01225   }  
01226   final private boolean jj_3R_36() {
01227     if (jj_3R_39()) return true;
01228     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01229     return false;
01230   }  
01231   final private boolean jj_3R_37() {
01232     if (jj_scan_token(THIS)) return true;
01233     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01234     return false;
01235   }  
01236   final private boolean jj_3R_38() {
01237     if (jj_scan_token(SUPER)) return true;
01238     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01239     return false;
01240   }  
01241   final private boolean jj_3R_39() {
01242     Token xsp;
01243     xsp = jj_scanpos;
01244     if (jj_3R_40()) {
01245     jj_scanpos = xsp;
01246     if (jj_3R_41()) {
01247     jj_scanpos = xsp;
01248     if (jj_3R_42()) {
01249     jj_scanpos = xsp;
01250     if (jj_3R_43()) {
01251     jj_scanpos = xsp;
01252     if (jj_3R_44()) {
01253     jj_scanpos = xsp;
01254     if (jj_3R_45()) {
01255     jj_scanpos = xsp;
01256     if (jj_3R_46()) return true;
01257     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01258     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01259     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01260     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01261     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01262     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01263     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01264     return false;
01265   }  
01266   final private boolean jj_3R_40() {
01267     if (jj_scan_token(INTEGER_LITERAL)) return true;
01268     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01269     return false;
01270   }  
01271   final private boolean jj_3R_41() {
01272     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
01273     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01274     return false;
01275   }  
01276   final private boolean jj_3R_42() {
01277     if (jj_scan_token(CHARACTER_LITERAL)) return true;
01278     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01279     return false;
01280   }  
01281   final private boolean jj_3R_43() {
01282     if (jj_scan_token(STRING_LITERAL)) return true;
01283     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01284     return false;
01285   }  
01286   final private boolean jj_3R_44() {
01287     if (jj_scan_token(TRUE)) return true;
01288     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01289     return false;
01290   }  
01291   final private boolean jj_3R_45() {
01292     if (jj_scan_token(FALSE)) return true;
01293     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01294     return false;
01295   }  
01296   final private boolean jj_3R_46() {
01297     if (jj_scan_token(NULL)) return true;
01298     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
01299     return false;
01300   }  
01301   private void jj_add_error_token(int kind, int pos) {
01302     if (pos >= 100) return;
01303     if (pos == jj_endpos + 1) {
01304       jj_lasttokens[jj_endpos++] = kind;
01305     } else if (jj_endpos != 0) {
01306       jj_expentry = new int[jj_endpos];
01307       for (int i = 0; i < jj_endpos; i++) {
01308         jj_expentry[i] = jj_lasttokens[i];
01309       }
01310       boolean exists = false;
01311       for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
01312         int[] oldentry = (int[])(enum.nextElement());
01313         if (oldentry.length == jj_expentry.length) {
01314           exists = true;
01315           for (int i = 0; i < jj_expentry.length; i++) {
01316             if (oldentry[i] != jj_expentry[i]) {
01317               exists = false;
01318               break;
01319             }
01320           }
01321           if (exists) break;
01322         }
01323       }
01324       if (!exists) jj_expentries.addElement(jj_expentry);
01325       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
01326     }
01327   }  
01328   final private Token jj_consume_token(int kind) throws ParseException {
01329     Token oldToken;
01330     if ((oldToken = token).next != null) token = token.next;
01331     else token = token.next = token_source.getNextToken();
01332     jj_ntk = -1;
01333     if (token.kind == kind) {
01334       jj_gen++;
01335       if (++jj_gc > 100) {
01336         jj_gc = 0;
01337         for (int i = 0; i < jj_2_rtns.length; i++) {
01338           JJCalls c = jj_2_rtns[i];
01339           while (c != null) {
01340             if (c.gen < jj_gen) c.first = null;
01341             c = c.next;
01342           }
01343         }
01344       }
01345       return token;
01346     }
01347     token = oldToken;
01348     jj_kind = kind;
01349     throw generateParseException();
01350   }  
01351   final private int jj_ntk() {
01352     if ((jj_nt=token.next) == null)
01353       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
01354     else
01355       return (jj_ntk = jj_nt.kind);
01356   }  
01357   final private void jj_rescan_token() {
01358     jj_rescan = true;
01359     for (int i = 0; i < 6; i++) {
01360       JJCalls p = jj_2_rtns[i];
01361       do {
01362         if (p.gen > jj_gen) {
01363           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
01364           switch (i) {
01365             case 0: jj_3_1(); break;
01366             case 1: jj_3_2(); break;
01367             case 2: jj_3_3(); break;
01368             case 3: jj_3_4(); break;
01369             case 4: jj_3_5(); break;
01370             case 5: jj_3_6(); break;
01371           }
01372         }
01373         p = p.next;
01374       } while (p != null);
01375     }
01376     jj_rescan = false;
01377   }  
01378   final private void jj_save(int index, int xla) {
01379     JJCalls p = jj_2_rtns[index];
01380     while (p.gen > jj_gen) {
01381       if (p.next == null) { p = p.next = new JJCalls(); break; }
01382       p = p.next;
01383     }
01384     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
01385   }  
01386   final private boolean jj_scan_token(int kind) {
01387     if (jj_scanpos == jj_lastpos) {
01388       jj_la--;
01389       if (jj_scanpos.next == null) {
01390         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
01391       } else {
01392         jj_lastpos = jj_scanpos = jj_scanpos.next;
01393       }
01394     } else {
01395       jj_scanpos = jj_scanpos.next;
01396     }
01397     if (jj_rescan) {
01398       int i = 0; Token tok = token;
01399       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
01400       if (tok != null) jj_add_error_token(kind, i);
01401     }
01402     return (jj_scanpos.kind != kind);
01403   }  
01404   final public ASTLiteral Literal() throws ParseException {
01405  /*@bgen(jjtree) Literal */
01406   ASTLiteral jjtn000 = (ASTLiteral)ASTLiteral.jjtCreate(this, JJTLITERAL);
01407   boolean jjtc000 = true;
01408   jjtree.openNodeScope(jjtn000);Token t;
01409   Object l = null;
01410     try {
01411       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01412       case INTEGER_LITERAL:
01413         t = jj_consume_token(INTEGER_LITERAL);
01414          try {
01415             l = new Integer(t.image);
01416          } catch (NumberFormatException e)
01417          {
01418             try {
01419                l = new Long(t.image);
01420             } catch (Exception ex)
01421             {
01422                {if (true) throw new RuntimeException(ex.getMessage());}
01423             }
01424          }
01425         break;
01426       case FLOATING_POINT_LITERAL:
01427         t = jj_consume_token(FLOATING_POINT_LITERAL);
01428          try {
01429             l = new Float(t.image);
01430          } catch (NumberFormatException e)
01431          {
01432             try {
01433                l = new Double(t.image);
01434             } catch (Exception ex)
01435             {
01436                {if (true) throw new RuntimeException(ex.getMessage());}
01437             }
01438          }
01439         break;
01440       case CHARACTER_LITERAL:
01441         t = jj_consume_token(CHARACTER_LITERAL);
01442                               l = new Character(t.image.charAt(0));
01443         break;
01444       case STRING_LITERAL:
01445         t = jj_consume_token(STRING_LITERAL);
01446                             l = t.image;
01447         break;
01448       case TRUE:
01449         t = jj_consume_token(TRUE);
01450                   l = Boolean.TRUE;
01451         break;
01452       case FALSE:
01453         t = jj_consume_token(FALSE);
01454                   l = Boolean.FALSE;
01455         break;
01456       case NULL:
01457         t = jj_consume_token(NULL);
01458                   l = null;
01459         break;
01460       default:
01461         jj_la1[33] = jj_gen;
01462         jj_consume_token(-1);
01463         throw new ParseException();
01464       }
01465     jjtree.closeNodeScope(jjtn000, true);
01466     jjtc000 = false;
01467     jjtn000.setTag(t.image);
01468     jjtn000.setLiteral(l);
01469     {if (true) return jjtn000;}
01470     } finally {
01471     if (jjtc000) {
01472       jjtree.closeNodeScope(jjtn000, true);
01473     }
01474     }
01475     throw new Error("Missing return statement in function");
01476   }  
01477     public static void main (String [] args) {
01478         if (args.length > 1) { help(); return; }
01479         try {
01480             if (args.length == 0)
01481             {
01482                 System.out.println("Predicate Parser:  Reading from standard input...");
01483                 parse(System.in);
01484             } else if (args.length == 1)
01485             {
01486                 System.out.println("Predicate Parser:  Reading from file " + args[0] + "...");
01487                 parse(new FileInputStream(args[0]));
01488             }
01489         } catch (Exception e)
01490         {
01491             System.out.println(e.getMessage());
01492             System.out.println("Error!");
01493         }
01494     }
01495   final public SimpleNode MulDivExpr() throws ParseException {
01496  /*@bgen(jjtree) MulDivExpr */
01497   ASTMulDivExpr jjtn000 = (ASTMulDivExpr)ASTMulDivExpr.jjtCreate(this, JJTMULDIVEXPR);
01498   boolean jjtc000 = true;
01499   jjtree.openNodeScope(jjtn000);LinkedList tl = new LinkedList();
01500   LinkedList el = new LinkedList();
01501   Token t;
01502   SimpleNode n;
01503     try {
01504       n = UnaryExpr();
01505                     el.addLast(n);
01506       label_12:
01507       while (true) {
01508         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01509         case STAR:
01510         case SLASH:
01511         case REM:
01512           ;
01513           break;
01514         default:
01515           jj_la1[21] = jj_gen;
01516           break label_12;
01517         }
01518         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01519         case STAR:
01520           t = jj_consume_token(STAR);
01521           break;
01522         case SLASH:
01523           t = jj_consume_token(SLASH);
01524           break;
01525         case REM:
01526           t = jj_consume_token(REM);
01527           break;
01528         default:
01529           jj_la1[22] = jj_gen;
01530           jj_consume_token(-1);
01531           throw new ParseException();
01532         }
01533                                       tl.addLast(t.image);
01534         n = UnaryExpr();
01535                                                                                el.addLast(n);
01536       }
01537     jjtree.closeNodeScope(jjtn000, true);
01538     jjtc000 = false;
01539     if (!tl.isEmpty())
01540     {
01541       jjtn000.setExprList(el);
01542       jjtn000.setTokenList(tl);
01543       {if (true) return jjtn000;}
01544     } else {if (true) return n;}  // Skip pass-thru
01545 
01546     } catch (Throwable jjte000) {
01547     if (jjtc000) {
01548       jjtree.clearNodeScope(jjtn000);
01549       jjtc000 = false;
01550     } else {
01551       jjtree.popNode();
01552     }
01553     if (jjte000 instanceof RuntimeException) {
01554       {if (true) throw (RuntimeException)jjte000;}
01555     }
01556     if (jjte000 instanceof ParseException) {
01557       {if (true) throw (ParseException)jjte000;}
01558     }
01559     {if (true) throw (Error)jjte000;}
01560     } finally {
01561     if (jjtc000) {
01562       jjtree.closeNodeScope(jjtn000, true);
01563     }
01564     }
01565     throw new Error("Missing return statement in function");
01566   }  
01567   final public ASTName Name() throws ParseException {
01568  /*@bgen(jjtree) Name */
01569   ASTName jjtn000 = (ASTName)ASTName.jjtCreate(this, JJTNAME);
01570   boolean jjtc000 = true;
01571   jjtree.openNodeScope(jjtn000);Token t;
01572   String s;
01573     try {
01574       t = jj_consume_token(IDENTIFIER);
01575                      s = t.image;
01576       label_3:
01577       while (true) {
01578         if (jj_2_1(2)) {
01579           ;
01580         } else {
01581           break label_3;
01582         }
01583         jj_consume_token(DOT);
01584         t = jj_consume_token(IDENTIFIER);
01585                                         s += "." + t.image;
01586       }
01587     jjtree.closeNodeScope(jjtn000, true);
01588     jjtc000 = false;
01589      jjtn000.setTag(s);
01590      {if (true) return jjtn000;}
01591     } finally {
01592     if (jjtc000) {
01593       jjtree.closeNodeScope(jjtn000, true);
01594     }
01595     }
01596     throw new Error("Missing return statement in function");
01597   }  
01598   final public SimpleNode OrExpr() throws ParseException {
01599  /*@bgen(jjtree) OrExpr */
01600   ASTOrExpr jjtn000 = (ASTOrExpr)ASTOrExpr.jjtCreate(this, JJTOREXPR);
01601   boolean jjtc000 = true;
01602   jjtree.openNodeScope(jjtn000);LinkedList el = new LinkedList();
01603   SimpleNode n;
01604     try {
01605       n = AndExpr();
01606                   el.addLast(n);
01607       label_4:
01608       while (true) {
01609         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01610         case SC_OR:
01611           ;
01612           break;
01613         default:
01614           jj_la1[7] = jj_gen;
01615           break label_4;
01616         }
01617         jj_consume_token(SC_OR);
01618         n = AndExpr();
01619                                                           el.addLast(n);
01620       }
01621     jjtree.closeNodeScope(jjtn000, true);
01622     jjtc000 = false;
01623      if (el.size() > 1)
01624      {
01625         jjtn000.setExprList(el);
01626         jjtn000.setToken("||");
01627         {if (true) return jjtn000;}
01628      } else {if (true) return n;}  // Skip pass-thru
01629 
01630     } catch (Throwable jjte000) {
01631     if (jjtc000) {
01632       jjtree.clearNodeScope(jjtn000);
01633       jjtc000 = false;
01634     } else {
01635       jjtree.popNode();
01636     }
01637     if (jjte000 instanceof RuntimeException) {
01638       {if (true) throw (RuntimeException)jjte000;}
01639     }
01640     if (jjte000 instanceof ParseException) {
01641       {if (true) throw (ParseException)jjte000;}
01642     }
01643     {if (true) throw (Error)jjte000;}
01644     } finally {
01645     if (jjtc000) {
01646       jjtree.closeNodeScope(jjtn000, true);
01647     }
01648     }
01649     throw new Error("Missing return statement in function");
01650   }  
01651     public static ASTCompilationUnit parse(InputStream i) throws ParseException
01652     {
01653         PredicateParser parser = new PredicateParser(i);
01654         return parser.CompilationUnit();
01655     }
01656   final public ASTPrimaryExpr PrimaryExpr() throws ParseException {
01657  /*@bgen(jjtree) PrimaryExpr */
01658   ASTPrimaryExpr jjtn000 = (ASTPrimaryExpr)ASTPrimaryExpr.jjtCreate(this, JJTPRIMARYEXPR);
01659   boolean jjtc000 = true;
01660   jjtree.openNodeScope(jjtn000);SimpleNode n = null, p = null;
01661   LinkedList l = new LinkedList();
01662   int pref = -1;
01663     try {
01664       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01665       case FALSE:
01666       case NULL:
01667       case TRUE:
01668       case INTEGER_LITERAL:
01669       case FLOATING_POINT_LITERAL:
01670       case CHARACTER_LITERAL:
01671       case STRING_LITERAL:
01672         p = Literal();
01673                            pref = 1;
01674         break;
01675       case LPAREN:
01676         jj_consume_token(LPAREN);
01677         p = CondExpr();
01678         jj_consume_token(RPAREN);
01679                                pref = 2;
01680         break;
01681       case THIS:
01682         p = ThisExpr();
01683                            pref = 3;
01684         break;
01685       case SUPER:
01686         p = SuperExpr();
01687                            pref = 4;
01688         break;
01689       default:
01690         jj_la1[28] = jj_gen;
01691         if (jj_2_5(2147483647)) {
01692           p = DotClassExpr();
01693                                                            pref = 5;
01694         } else {
01695           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01696           case IDENTIFIER:
01697             p = Name();
01698                            pref = 6;
01699             break;
01700           default:
01701             jj_la1[29] = jj_gen;
01702             jj_consume_token(-1);
01703             throw new ParseException();
01704           }
01705         }
01706       }
01707       label_13:
01708       while (true) {
01709         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01710         case LBRACKET:
01711         case DOT:
01712           ;
01713           break;
01714         default:
01715           jj_la1[30] = jj_gen;
01716           break label_13;
01717         }
01718         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01719         case LBRACKET:
01720           n = ArrayExpr();
01721         if (pref != 6) {if (true) throw new RuntimeException("Invalid combination");}
01722         if (p != null)
01723         {
01724             n.setTag(p.getTag());
01725             p = null;
01726         }
01727         l.addLast(n);
01728           break;
01729         case DOT:
01730           n = DottedExpr();
01731         if (pref == 1 || pref == 3 || pref == 4 || pref == 5 || pref == 7) {if (true) throw new RuntimeException("Invalid combination");}
01732         if (p != null)
01733         {
01734             ((ASTDottedExpr) n).setContext(p.getTag());
01735             p = null;
01736         } else {if (true) throw new RuntimeException("Not handled yet!");}
01737 
01738         if (!n.getTag().equals("this"))
01739         {
01740             pref = 6;
01741             {if (true) throw new RuntimeException("Not supported yet!");}
01742         } else
01743         {
01744             pref = 7;
01745         }
01746         l.addLast(n);
01747           break;
01748         default:
01749           jj_la1[31] = jj_gen;
01750           jj_consume_token(-1);
01751           throw new ParseException();
01752         }
01753       }
01754     jjtree.closeNodeScope(jjtn000, true);
01755     jjtc000 = false;
01756     if (p != null) l.addLast(p);
01757     jjtn000.setNodes(l);
01758     {if (true) return jjtn000;}
01759     } catch (Throwable jjte000) {
01760     if (jjtc000) {
01761       jjtree.clearNodeScope(jjtn000);
01762       jjtc000 = false;
01763     } else {
01764       jjtree.popNode();
01765     }
01766     if (jjte000 instanceof RuntimeException) {
01767       {if (true) throw (RuntimeException)jjte000;}
01768     }
01769     if (jjte000 instanceof ParseException) {
01770       {if (true) throw (ParseException)jjte000;}
01771     }
01772     {if (true) throw (Error)jjte000;}
01773     } finally {
01774     if (jjtc000) {
01775       jjtree.closeNodeScope(jjtn000, true);
01776     }
01777     }
01778     throw new Error("Missing return statement in function");
01779   }  
01780   final public ASTPrimitiveType PrimitiveType() throws ParseException {
01781  /*@bgen(jjtree) PrimitiveType */
01782   ASTPrimitiveType jjtn000 = (ASTPrimitiveType)ASTPrimitiveType.jjtCreate(this, JJTPRIMITIVETYPE);
01783   boolean jjtc000 = true;
01784   jjtree.openNodeScope(jjtn000);Token t;
01785     try {
01786       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01787       case BOOLEAN:
01788         t = jj_consume_token(BOOLEAN);
01789         break;
01790       case CHAR:
01791         t = jj_consume_token(CHAR);
01792         break;
01793       case BYTE:
01794         t = jj_consume_token(BYTE);
01795         break;
01796       case SHORT:
01797         t = jj_consume_token(SHORT);
01798         break;
01799       case INT:
01800         t = jj_consume_token(INT);
01801         break;
01802       case LONG:
01803         t = jj_consume_token(LONG);
01804         break;
01805       case FLOAT:
01806         t = jj_consume_token(FLOAT);
01807         break;
01808       case DOUBLE:
01809         t = jj_consume_token(DOUBLE);
01810         break;
01811       default:
01812         jj_la1[5] = jj_gen;
01813         jj_consume_token(-1);
01814         throw new ParseException();
01815       }
01816     jjtree.closeNodeScope(jjtn000, true);
01817     jjtc000 = false;
01818     jjtn000.setTag(t.image);
01819     {if (true) return jjtn000;}
01820     } finally {
01821     if (jjtc000) {
01822       jjtree.closeNodeScope(jjtn000, true);
01823     }
01824     }
01825     throw new Error("Missing return statement in function");
01826   }  
01827   public void ReInit(PredicateParserTokenManager tm) {
01828     token_source = tm;
01829     token = new Token();
01830     jj_ntk = -1;
01831     jjtree.reset();
01832     jj_gen = 0;
01833     for (int i = 0; i < 36; i++) jj_la1[i] = -1;
01834     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
01835   }  
01836   public void ReInit(java.io.InputStream stream) {
01837     jj_input_stream.ReInit(stream, 1, 1);
01838     token_source.ReInit(jj_input_stream);
01839     token = new Token();
01840     jj_ntk = -1;
01841     jjtree.reset();
01842     jj_gen = 0;
01843     for (int i = 0; i < 36; i++) jj_la1[i] = -1;
01844     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
01845   }  
01846   public void ReInit(java.io.Reader stream) {
01847     jj_input_stream.ReInit(stream, 1, 1);
01848     token_source.ReInit(jj_input_stream);
01849     token = new Token();
01850     jj_ntk = -1;
01851     jjtree.reset();
01852     jj_gen = 0;
01853     for (int i = 0; i < 36; i++) jj_la1[i] = -1;
01854     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
01855   }  
01856   final public SimpleNode RelationalExpr() throws ParseException {
01857  /*@bgen(jjtree) RelationalExpr */
01858   ASTRelationalExpr jjtn000 = (ASTRelationalExpr)ASTRelationalExpr.jjtCreate(this, JJTRELATIONALEXPR);
01859   boolean jjtc000 = true;
01860   jjtree.openNodeScope(jjtn000);Token t;
01861   SimpleNode n;
01862     try {
01863       n = ShiftExpr();
01864       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01865       case GT:
01866       case LT:
01867       case LE:
01868       case GE:
01869         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01870         case LT:
01871           t = jj_consume_token(LT);
01872           break;
01873         case GT:
01874           t = jj_consume_token(GT);
01875           break;
01876         case LE:
01877           t = jj_consume_token(LE);
01878           break;
01879         case GE:
01880           t = jj_consume_token(GE);
01881           break;
01882         default:
01883           jj_la1[15] = jj_gen;
01884           jj_consume_token(-1);
01885           throw new ParseException();
01886         }
01887        jjtn000.setTag(t.image);
01888        jjtn000.setOp1(n);
01889         n = ShiftExpr();
01890                         jjtn000.setOp2(n); {if (true) return jjtn000;}
01891         break;
01892       default:
01893         jj_la1[16] = jj_gen;
01894         ;
01895       }
01896     jjtree.closeNodeScope(jjtn000, true);
01897     jjtc000 = false;
01898     {if (true) return n;}  // Skip pass-thru
01899 
01900     } catch (Throwable jjte000) {
01901     if (jjtc000) {
01902       jjtree.clearNodeScope(jjtn000);
01903       jjtc000 = false;
01904     } else {
01905       jjtree.popNode();
01906     }
01907     if (jjte000 instanceof RuntimeException) {
01908       {if (true) throw (RuntimeException)jjte000;}
01909     }
01910     if (jjte000 instanceof ParseException) {
01911       {if (true) throw (ParseException)jjte000;}
01912     }
01913     {if (true) throw (Error)jjte000;}
01914     } finally {
01915     if (jjtc000) {
01916       jjtree.closeNodeScope(jjtn000, true);
01917     }
01918     }
01919     throw new Error("Missing return statement in function");
01920   }  
01921   final public SimpleNode ShiftExpr() throws ParseException {
01922  /*@bgen(jjtree) ShiftExpr */
01923   ASTShiftExpr jjtn000 = (ASTShiftExpr)ASTShiftExpr.jjtCreate(this, JJTSHIFTEXPR);
01924   boolean jjtc000 = true;
01925   jjtree.openNodeScope(jjtn000);LinkedList tl = new LinkedList();
01926   LinkedList el = new LinkedList();
01927   Token t;
01928   SimpleNode n;
01929     try {
01930       n = AddSubExpr();
01931                      el.addLast(n);
01932       label_10:
01933       while (true) {
01934         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01935         case LSHIFT:
01936         case RSIGNEDSHIFT:
01937         case RUNSIGNEDSHIFT:
01938           ;
01939           break;
01940         default:
01941           jj_la1[17] = jj_gen;
01942           break label_10;
01943         }
01944         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
01945         case LSHIFT:
01946           t = jj_consume_token(LSHIFT);
01947           break;
01948         case RSIGNEDSHIFT:
01949           t = jj_consume_token(RSIGNEDSHIFT);
01950           break;
01951         case RUNSIGNEDSHIFT:
01952           t = jj_consume_token(RUNSIGNEDSHIFT);
01953           break;
01954         default:
01955           jj_la1[18] = jj_gen;
01956           jj_consume_token(-1);
01957           throw new ParseException();
01958         }
01959                                           tl.addLast(t.image);
01960         n = AddSubExpr();
01961                                                                               el.addLast(n);
01962       }
01963     jjtree.closeNodeScope(jjtn000, true);
01964     jjtc000 = false;
01965     if (!tl.isEmpty())
01966     {
01967       jjtn000.setExprList(el);
01968       jjtn000.setTokenList(tl);
01969       {if (true) return jjtn000;}
01970     } else {if (true) return n;}  // Skip pass-thru
01971 
01972     } catch (Throwable jjte000) {
01973     if (jjtc000) {
01974       jjtree.clearNodeScope(jjtn000);
01975       jjtc000 = false;
01976     } else {
01977       jjtree.popNode();
01978     }
01979     if (jjte000 instanceof RuntimeException) {
01980       {if (true) throw (RuntimeException)jjte000;}
01981     }
01982     if (jjte000 instanceof ParseException) {
01983       {if (true) throw (ParseException)jjte000;}
01984     }
01985     {if (true) throw (Error)jjte000;}
01986     } finally {
01987     if (jjtc000) {
01988       jjtree.closeNodeScope(jjtn000, true);
01989     }
01990     }
01991     throw new Error("Missing return statement in function");
01992   }  
01993   final public ASTSuperExpr SuperExpr() throws ParseException {
01994  /*@bgen(jjtree) SuperExpr */
01995   ASTSuperExpr jjtn000 = (ASTSuperExpr)ASTSuperExpr.jjtCreate(this, JJTSUPEREXPR);
01996   boolean jjtc000 = true;
01997   jjtree.openNodeScope(jjtn000);Token t;
01998     try {
01999       jj_consume_token(SUPER);
02000       jj_consume_token(DOT);
02001       t = jj_consume_token(IDENTIFIER);
02002      jjtree.closeNodeScope(jjtn000, true);
02003      jjtc000 = false;
02004       jjtn000.setTag(t.image);
02005       {if (true) return jjtn000;}
02006     } finally {
02007      if (jjtc000) {
02008        jjtree.closeNodeScope(jjtn000, true);
02009      }
02010     }
02011     throw new Error("Missing return statement in function");
02012   }  
02013   final public ASTThisExpr ThisExpr() throws ParseException {
02014  /*@bgen(jjtree) ThisExpr */
02015   ASTThisExpr jjtn000 = (ASTThisExpr)ASTThisExpr.jjtCreate(this, JJTTHISEXPR);
02016   boolean jjtc000 = true;
02017   jjtree.openNodeScope(jjtn000);
02018     try {
02019       jj_consume_token(THIS);
02020             jjtree.closeNodeScope(jjtn000, true);
02021             jjtc000 = false;
02022             {if (true) return jjtn000;}
02023     } finally {
02024      if (jjtc000) {
02025        jjtree.closeNodeScope(jjtn000, true);
02026      }
02027     }
02028     throw new Error("Missing return statement in function");
02029   }  
02030 /*
02031  * Type, name and Expr syntax follows.
02032  */
02033   final public ASTType Type() throws ParseException {
02034  /*@bgen(jjtree) Type */
02035   ASTType jjtn000 = (ASTType)ASTType.jjtCreate(this, JJTTYPE);
02036   boolean jjtc000 = true;
02037   jjtree.openNodeScope(jjtn000);SimpleNode n;
02038   int dim = 0;
02039     try {
02040       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
02041       case BOOLEAN:
02042       case BYTE:
02043       case CHAR:
02044       case DOUBLE:
02045       case FLOAT:
02046       case INT:
02047       case LONG:
02048       case SHORT:
02049         n = PrimitiveType();
02050         break;
02051       case IDENTIFIER:
02052         n = Name();
02053         break;
02054       default:
02055         jj_la1[3] = jj_gen;
02056         jj_consume_token(-1);
02057         throw new ParseException();
02058       }
02059       label_2:
02060       while (true) {
02061         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
02062         case LBRACKET:
02063           ;
02064           break;
02065         default:
02066           jj_la1[4] = jj_gen;
02067           break label_2;
02068         }
02069         jj_consume_token(LBRACKET);
02070         jj_consume_token(RBRACKET);
02071                                                    dim++;
02072       }
02073     jjtree.closeNodeScope(jjtn000, true);
02074     jjtc000 = false;
02075      String s = n.getTag();
02076      jjtn000.setBaseType(s);
02077      if (dim > 0)
02078      {
02079         for (int i = 0; i < dim; i++) s += "[]";
02080         jjtn000.setDimension(dim);
02081      }
02082      jjtn000.setTag(s);
02083      {if (true) return jjtn000;}
02084     } catch (Throwable jjte000) {
02085     if (jjtc000) {
02086       jjtree.clearNodeScope(jjtn000);
02087       jjtc000 = false;
02088     } else {
02089       jjtree.popNode();
02090     }
02091     if (jjte000 instanceof RuntimeException) {
02092       {if (true) throw (RuntimeException)jjte000;}
02093     }
02094     if (jjte000 instanceof ParseException) {
02095       {if (true) throw (ParseException)jjte000;}
02096     }
02097     {if (true) throw (Error)jjte000;}
02098     } finally {
02099     if (jjtc000) {
02100       jjtree.closeNodeScope(jjtn000, true);
02101     }
02102     }
02103     throw new Error("Missing return statement in function");
02104   }  
02105   final public ASTUnaryExpr UnaryExpr() throws ParseException {
02106  /*@bgen(jjtree) UnaryExpr */
02107   ASTUnaryExpr jjtn000 = (ASTUnaryExpr)ASTUnaryExpr.jjtCreate(this, JJTUNARYEXPR);
02108   boolean jjtc000 = true;
02109   jjtree.openNodeScope(jjtn000);SimpleNode n;
02110     try {
02111       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
02112       case BANG:
02113       case TILDE:
02114       case PLUS:
02115       case MINUS:
02116         n = UnaryMathExpr();
02117         break;
02118       default:
02119         jj_la1[23] = jj_gen;
02120         if (jj_2_2(2147483647)) {
02121           n = CastExpr();
02122         } else {
02123           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
02124           case BOOLEAN:
02125           case BYTE:
02126           case CHAR:
02127           case DOUBLE:
02128           case FALSE:
02129           case FLOAT:
02130           case INT:
02131           case LONG:
02132           case NULL:
02133           case SUPER:
02134           case SHORT:
02135           case THIS:
02136           case TRUE:
02137           case INTEGER_LITERAL:
02138           case FLOATING_POINT_LITERAL:
02139           case CHARACTER_LITERAL:
02140           case STRING_LITERAL:
02141           case IDENTIFIER:
02142           case LPAREN:
02143             n = PrimaryExpr();
02144             break;
02145           default:
02146             jj_la1[24] = jj_gen;
02147             jj_consume_token(-1);
02148             throw new ParseException();
02149           }
02150         }
02151       }
02152      jjtree.closeNodeScope(jjtn000, true);
02153      jjtc000 = false;
02154      jjtn000.setExpr(n);
02155      {if (true) return jjtn000;}
02156     } catch (Throwable jjte000) {
02157      if (jjtc000) {
02158        jjtree.clearNodeScope(jjtn000);
02159        jjtc000 = false;
02160      } else {
02161        jjtree.popNode();
02162      }
02163      if (jjte000 instanceof RuntimeException) {
02164        {if (true) throw (RuntimeException)jjte000;}
02165      }
02166      if (jjte000 instanceof ParseException) {
02167        {if (true) throw (ParseException)jjte000;}
02168      }
02169      {if (true) throw (Error)jjte000;}
02170     } finally {
02171      if (jjtc000) {
02172        jjtree.closeNodeScope(jjtn000, true);
02173      }
02174     }
02175     throw new Error("Missing return statement in function");
02176   }  
02177   final public ASTUnaryMathExpr UnaryMathExpr() throws ParseException {
02178  /*@bgen(jjtree) UnaryMathExpr */
02179   ASTUnaryMathExpr jjtn000 = (ASTUnaryMathExpr)ASTUnaryMathExpr.jjtCreate(this, JJTUNARYMATHEXPR);
02180   boolean jjtc000 = true;
02181   jjtree.openNodeScope(jjtn000);SimpleNode n;
02182   Token t;
02183     try {
02184       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
02185       case PLUS:
02186         t = jj_consume_token(PLUS);
02187         break;
02188       case MINUS:
02189         t = jj_consume_token(MINUS);
02190         break;
02191       case TILDE:
02192         t = jj_consume_token(TILDE);
02193         break;
02194       case BANG:
02195         t = jj_consume_token(BANG);
02196         break;
02197       default:
02198         jj_la1[25] = jj_gen;
02199         jj_consume_token(-1);
02200         throw new ParseException();
02201       }
02202       n = UnaryExpr();
02203      jjtree.closeNodeScope(jjtn000, true);
02204      jjtc000 = false;
02205      jjtn000.setTag(t.image);
02206      jjtn000.setExpr(n);
02207      {if (true) return jjtn000;}
02208     } catch (Throwable jjte000) {
02209     if (jjtc000) {
02210       jjtree.clearNodeScope(jjtn000);
02211       jjtc000 = false;
02212     } else {
02213       jjtree.popNode();
02214     }
02215     if (jjte000 instanceof RuntimeException) {
02216       {if (true) throw (RuntimeException)jjte000;}
02217     }
02218     if (jjte000 instanceof ParseException) {
02219       {if (true) throw (ParseException)jjte000;}
02220     }
02221     {if (true) throw (Error)jjte000;}
02222     } finally {
02223     if (jjtc000) {
02224       jjtree.closeNodeScope(jjtn000, true);
02225     }
02226     }
02227     throw new Error("Missing return statement in function");
02228   }  
02229 }