Clover coverage report - XJavaDoc - 1.1 Coverage timestamp: Sun Oct 3 2004 19:56:54 BST FRAMES NO FRAMES |
file stats: | LOC: | 10,139 |  | Methods: | 570
| NCLOC: | 9,343 |  | Classes: | 3
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
Source file | Conditionals | Statements | Methods | TOTAL
NodeParser.java | 15.9% | 26.5% | 45.1% | 23.7% |

1 |  |
     /* Generated By:JJTree&JavaCC: Do not edit this line. NodeParser.java */
2 |  |
     package xjavadoc;
3 |  |
4 |  |
     import java.lang.reflect.Modifier;
5 |  |
     import java.util.*;
6 |  |
     import java.io.InputStream;
7 |  |
     import java.io.ByteArrayInputStream;
8 |  |
9 |  |
     public class NodeParser implements/*@bgen(jjtree)*/ NodeParserTreeConstants,JavaParser, NodeParserConstants {/*@bgen(jjtree)*/
10 |  |
       protected JJTNodeParserState jjtree = new JJTNodeParserState();private XJavaDoc _xJavaDoc;
11 |  |
        private XTagFactory _tagFactory;
12 |  |
13 |  |
        private String _packageName = "";
14 |  |
        // The class we're currently parsing
15 |  |
        private SourceClass _sourceClass;
16 |  |
        private Stack _sourceClassStack = new Stack();
17 |  |
18 |  |
        // Flag that tells us if the main class/interface has been parsed.
19 |  |
        // Needed to support more than one "outer" class in one source.
20 |  |
        private boolean _hasParsedMain = false;
21 |  |
22 |  |
23 | 328 |
        private static final void setToken(AbstractProgramElement element, Token token) {
24 | 328 |
            element.setToken( token );
25 |  |
            //element.setDoc(getJavaDocSpecialToken( token ));
26 |  |
        }
27 |  |
28 | 304 |
        private final void clearNameBuffer() {
29 | 304 |
           if( _nameBuffer.length() > 0 ) {
30 | 280 |
              _nameBuffer.delete(0, _nameBuffer.length());
31 |  |
           }
32 |  |
        }
33 |  |
34 |  |
        private final StringBuffer _nameBuffer = new StringBuffer();
35 |  |
36 |  |
        private static class Parameter {
37 |  |
           public String type;
38 |  |
           public String name;
39 |  |
           public int dimension;
40 |  |
        }
41 |  |
        private Parameter _parameter;
42 |  |
43 |  |
        // Reference to the first token in a Name() production.
44 |  |
        private Token _nameToken;
45 |  |
46 |  |
        /**
47 |  |
         * Should be called before UnmodifiedClassDeclaration or UnmodifiedInterfaceDeclaration
48 |  |
         */
49 | 44 |
        private SourceClass pushAndGet() {
50 |  |
            // Push a source class onto the stack. If the stack is empty,
51 |  |
            // push the outer class. Otherwise, instantiate a new (inner) class
52 |  |
            // and push that instead.
53 | 44 |
            SourceClass clazz = null;
54 | 44 |
            if( _sourceClassStack.isEmpty() ) {
55 |  |
               // It's an outer class. In rare cases there is more than one outer classes
56 |  |
               // in one source. handle that here.
57 | 20 |
               if( !_hasParsedMain ) {
58 |  |
                  // the usual case
59 | 12 |
                  clazz = _sourceClass;
60 |  |
               } else {
61 |  |
                  // the source contains more than one classes
62 | 8 |
                  clazz = new SourceClass(_sourceClass, 0, _tagFactory);
63 |  |
               }
64 |  |
            } else {
65 | 24 |
               clazz = new SourceClass(currentClass(), _tagFactory);
66 |  |
            }
67 | 44 |
            _sourceClassStack.push(clazz);
68 | 44 |
            return clazz;
69 |  |
        }
70 |  |
71 |  |
        /**
72 |  |
         * Should be called after UnmodifiedClassDeclaration or UnmodifiedInterfaceDeclaration
73 |  |
         */
74 | 44 |
        private void popAndAddInner() {
75 | 44 |
         SourceClass clazz = (SourceClass) _sourceClassStack.pop();
76 | 44 |
         if( clazz.getContainingClass() != null ) {
77 |  |
             // Add the class as an inner class
78 | 24 |
             currentClass().addInnerClass(clazz);
79 | 24 |
             _xJavaDoc.addSourceClass(clazz);
80 |  |
         }
81 |  |
        }
82 |  |
83 | 436 |
        private SourceClass currentClass() {
84 | 436 |
            return (SourceClass)_sourceClassStack.peek();
85 |  |
        }
86 |  |
87 |  |
         /**
88 |  |
          * This constructor was added to allow the re-use of parsers.
89 |  |
          * The normal constructor takes a single argument which
90 |  |
          * an InputStream. This simply creates a re-usable parser
91 |  |
          * object, we satisfy the requirement of an InputStream
92 |  |
          * by using a newline character as an input stream.
93 |  |
          */
94 | 12 |
         public NodeParser( XJavaDoc xJavaDoc, XTagFactory tagFactory )
95 |  |
         {
96 | 12 |
             this(new ByteArrayInputStream("\n".getBytes()));
97 | 12 |
             _xJavaDoc = xJavaDoc;
98 | 12 |
             _tagFactory = tagFactory;
99 |  |
         }
100 |  |
101 |  |
         /**
102 |  |
          * This was also added to allow parsers to be
103 |  |
          * re-usable. Normal JavaCC use entails passing an
104 |  |
          * input stream to the constructor and the parsing
105 |  |
          * process is carried out once. We want to be able
106 |  |
          * to re-use parsers: we do this by adding this
107 |  |
          * method and re-initializing the lexer with
108 |  |
          * the new stream that we want parsed.
109 |  |
          */
110 | 12 |
         public void populate(SourceClass sourceClass)
111 |  |
             throws ParseException
112 |  |
         {
113 | 12 |
             _sourceClass = sourceClass;
114 |  |
115 |  |
             // Reset state
116 | 12 |
             _sourceClassStack.clear();
117 | 12 |
             _packageName = "";
118 | 12 |
             _parameter = new Parameter();
119 | 12 |
             _nameToken = null;
120 | 12 |
             clearNameBuffer();
121 |  |
122 | 12 |
             try
123 |  |
             {
124 |  |
125 |  |
                 // now reinit the Parser with this CharStream
126 |  |
                 //
127 | 12 |
                 ReInit(sourceClass.getReader());
128 |  |
129 |  |
                 // Start the parsing.
130 | 12 |
                 CompilationUnit( sourceClass );
131 |  |
             }
132 |  |
             catch (ParseException pe)
133 |  |
             {
134 | 0 |
                 throw new ParseException (pe.currentToken,
135 |  |
                     pe.expectedTokenSequences, pe.tokenImage);
136 |  |
             }
137 |  |
             catch (TokenMgrError tme)
138 |  |
             {
139 | 0 |
                 throw new ParseException("Lexical error: " + tme.toString());
140 |  |
             }
141 |  |
         }
142 |  |
143 |  |
     /*****************************************
144 |  |
      * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
145 |  |
      *****************************************/
146 |  |
147 |  |
     /*
148 |  |
      * Program structuring syntax follows.
149 |  |
      */
150 | 12 |
       final public void CompilationUnit(SourceClass sourceClass) throws ParseException {
151 |  |
      /*@bgen(jjtree) CompilationUnit */
152 | 12 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTCOMPILATIONUNIT);
153 | 12 |
       boolean jjtc000 = true;
154 | 12 |
       jjtree.openNodeScope(jjtn000);
155 | 12 |
         try {
156 | 12 |
           switch (jj_nt.kind) {
157 |  |
           case PACKAGE:
158 | 4 |
             PackageDeclaration();
159 | 4 |
             break;
160 |  |
           default:
161 | 8 |
             jj_la1[0] = jj_gen;
162 |  |
             ;
163 |  |
           }
164 | 12 |
           label_1:
165 |  |
           while (true) {
166 | 40 |
             switch (jj_nt.kind) {
167 |  |
             case IMPORT:
168 |  |
               ;
169 | 28 |
               break;
170 |  |
             default:
171 | 12 |
               jj_la1[1] = jj_gen;
172 | 12 |
               break label_1;
173 |  |
             }
174 | 28 |
             ImportDeclaration();
175 |  |
           }
176 | 12 |
           label_2:
177 |  |
           while (true) {
178 | 32 |
             switch (jj_nt.kind) {
179 |  |
             case ABSTRACT:
180 |  |
             case CLASS:
181 |  |
             case FINAL:
182 |  |
             case INTERFACE:
183 |  |
             case PUBLIC:
184 |  |
             case STRICTFP:
185 |  |
             case SEMICOLON:
186 |  |
               ;
187 | 20 |
               break;
188 |  |
             default:
189 | 12 |
               jj_la1[2] = jj_gen;
190 | 12 |
               break label_2;
191 |  |
             }
192 | 20 |
             TypeDeclaration();
193 |  |
           }
194 | 12 |
           jj_consume_token(0);
195 | 12 |
         jjtree.closeNodeScope(jjtn000, true);
196 | 12 |
         jjtc000 = false;
197 |  |
           // sourceClass must know about the CompilationUnit node
198 |  |
           // if it wants to mutate or print the code
199 | 12 |
           sourceClass.setCompilationUnit( jjtn000 );
200 |  |
201 | 12 |
         if( _sourceClassStack.size() != 0 ) {
202 | 0 |
            {if (true) throw new IllegalStateException("There should be no more classes on the stack:" + _sourceClassStack.size());}
203 |  |
         }
204 |  |
         } catch (Throwable jjte000) {
205 | 0 |
         if (jjtc000) {
206 | 0 |
           jjtree.clearNodeScope(jjtn000);
207 | 0 |
           jjtc000 = false;
208 |  |
         } else {
209 | 0 |
           jjtree.popNode();
210 |  |
         }
211 | 0 |
         if (jjte000 instanceof RuntimeException) {
212 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
213 |  |
         }
214 | 0 |
         if (jjte000 instanceof ParseException) {
215 | 0 |
           {if (true) throw (ParseException)jjte000;}
216 |  |
         }
217 | 0 |
         {if (true) throw (Error)jjte000;}
218 |  |
         } finally {
219 | 12 |
         if (jjtc000) {
220 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
221 |  |
         }
222 |  |
         }
223 |  |
       }
224 |  |
225 | 4 |
       final public void PackageDeclaration() throws ParseException {
226 |  |
      /*@bgen(jjtree) PackageDeclaration */
227 | 4 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTPACKAGEDECLARATION);
228 | 4 |
       boolean jjtc000 = true;
229 | 4 |
       jjtree.openNodeScope(jjtn000);
230 | 4 |
         try {
231 | 4 |
           jj_consume_token(PACKAGE);
232 | 4 |
           _packageName = Name();
233 | 4 |
           jj_consume_token(SEMICOLON);
234 | 4 |
         jjtree.closeNodeScope(jjtn000, true);
235 | 4 |
         jjtc000 = false;
236 | 4 |
          _sourceClass.setContainingPackage( _packageName );
237 |  |
         } catch (Throwable jjte000) {
238 | 0 |
         if (jjtc000) {
239 | 0 |
           jjtree.clearNodeScope(jjtn000);
240 | 0 |
           jjtc000 = false;
241 |  |
         } else {
242 | 0 |
           jjtree.popNode();
243 |  |
         }
244 | 0 |
         if (jjte000 instanceof RuntimeException) {
245 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
246 |  |
         }
247 | 0 |
         if (jjte000 instanceof ParseException) {
248 | 0 |
           {if (true) throw (ParseException)jjte000;}
249 |  |
         }
250 | 0 |
         {if (true) throw (Error)jjte000;}
251 |  |
         } finally {
252 | 4 |
         if (jjtc000) {
253 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
254 |  |
         }
255 |  |
         }
256 |  |
       }
257 |  |
258 | 28 |
       final public void ImportDeclaration() throws ParseException {
259 |  |
      /*@bgen(jjtree) ImportDeclaration */
260 | 28 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTIMPORTDECLARATION);
261 | 28 |
        boolean jjtc000 = true;
262 | 28 |
        jjtree.openNodeScope(jjtn000);String importedElement;
263 | 28 |
        boolean isPackage = false;
264 | 28 |
         try {
265 | 28 |
           jj_consume_token(IMPORT);
266 | 28 |
           importedElement = Name();
267 | 28 |
           switch (jj_nt.kind) {
268 |  |
           case DOT:
269 | 16 |
             jj_consume_token(DOT);
270 | 16 |
             jj_consume_token(STAR);
271 | 16 |
          isPackage = true;
272 | 16 |
             break;
273 |  |
           default:
274 | 12 |
             jj_la1[3] = jj_gen;
275 |  |
             ;
276 |  |
           }
277 | 28 |
           jj_consume_token(SEMICOLON);
278 | 28 |
         jjtree.closeNodeScope(jjtn000, true);
279 | 28 |
         jjtc000 = false;
280 | 28 |
          if( isPackage ) {
281 | 16 |
             _sourceClass.addImportedPackage(importedElement);
282 |  |
          } else {
283 | 12 |
             _sourceClass.addImportedClass(importedElement);
284 |  |
          }
285 |  |
         } catch (Throwable jjte000) {
286 | 0 |
         if (jjtc000) {
287 | 0 |
           jjtree.clearNodeScope(jjtn000);
288 | 0 |
           jjtc000 = false;
289 |  |
         } else {
290 | 0 |
           jjtree.popNode();
291 |  |
         }
292 | 0 |
         if (jjte000 instanceof RuntimeException) {
293 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
294 |  |
         }
295 | 0 |
         if (jjte000 instanceof ParseException) {
296 | 0 |
           {if (true) throw (ParseException)jjte000;}
297 |  |
         }
298 | 0 |
         {if (true) throw (Error)jjte000;}
299 |  |
         } finally {
300 | 28 |
         if (jjtc000) {
301 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
302 |  |
         }
303 |  |
         }
304 |  |
       }
305 |  |
306 | 20 |
       final public void TypeDeclaration() throws ParseException {
307 |  |
      /*@bgen(jjtree) TypeDeclaration */
308 | 20 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTTYPEDECLARATION);
309 | 20 |
       boolean jjtc000 = true;
310 | 20 |
       jjtree.openNodeScope(jjtn000);
311 | 20 |
         try {
312 | 20 |
           if (jj_2_1(2147483647)) {
313 | 20 |
             ClassDeclaration();
314 | 20 |
                            jjtree.closeNodeScope(jjtn000, true);
315 | 20 |
                            jjtc000 = false;
316 | 20 |
         _hasParsedMain = true;
317 |  |
           } else {
318 | 0 |
             switch (jj_nt.kind) {
319 |  |
             case ABSTRACT:
320 |  |
             case INTERFACE:
321 |  |
             case PUBLIC:
322 |  |
             case STRICTFP:
323 | 0 |
               InterfaceDeclaration();
324 | 0 |
                                jjtree.closeNodeScope(jjtn000, true);
325 | 0 |
                                jjtc000 = false;
326 | 0 |
         _hasParsedMain = true;
327 | 0 |
               break;
328 |  |
             case SEMICOLON:
329 | 0 |
               jj_consume_token(SEMICOLON);
330 | 0 |
               break;
331 |  |
             default:
332 | 0 |
               jj_la1[4] = jj_gen;
333 | 0 |
               jj_consume_token(-1);
334 | 0 |
               throw new ParseException();
335 |  |
             }
336 |  |
           }
337 |  |
         } catch (Throwable jjte000) {
338 | 0 |
         if (jjtc000) {
339 | 0 |
           jjtree.clearNodeScope(jjtn000);
340 | 0 |
           jjtc000 = false;
341 |  |
         } else {
342 | 0 |
           jjtree.popNode();
343 |  |
         }
344 | 0 |
         if (jjte000 instanceof RuntimeException) {
345 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
346 |  |
         }
347 | 0 |
         if (jjte000 instanceof ParseException) {
348 | 0 |
           {if (true) throw (ParseException)jjte000;}
349 |  |
         }
350 | 0 |
         {if (true) throw (Error)jjte000;}
351 |  |
         } finally {
352 | 20 |
         if (jjtc000) {
353 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
354 |  |
         }
355 |  |
         }
356 |  |
       }
357 |  |
358 |  |
     /*
359 |  |
      * Declaration syntax follows.
360 |  |
      */
361 |  |
362 |  |
     /*
363 |  |
     Javadoc is stored in special tokens, and will either be
364 |  |
     attached to the first modifier token (if there are any modifiers)
365 |  |
     or to the first token in UnmodifiedClassDeclaration
366 |  |
     */
367 | 20 |
       final public void ClassDeclaration() throws ParseException {
368 |  |
      /*@bgen(jjtree) ClassDeclaration */
369 | 20 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTCLASSDECLARATION);
370 | 20 |
        boolean jjtc000 = true;
371 | 20 |
        jjtree.openNodeScope(jjtn000);SourceClass sourceClass = pushAndGet();
372 | 20 |
        Token t = null;
373 | 20 |
         try {
374 | 20 |
           label_3:
375 |  |
           while (true) {
376 | 20 |
             switch (jj_nt.kind) {
377 |  |
             case ABSTRACT:
378 |  |
             case FINAL:
379 |  |
             case PUBLIC:
380 |  |
             case STRICTFP:
381 |  |
               ;
382 | 0 |
               break;
383 |  |
             default:
384 | 20 |
               jj_la1[5] = jj_gen;
385 | 20 |
               break label_3;
386 |  |
             }
387 | 0 |
             switch (jj_nt.kind) {
388 |  |
             case ABSTRACT:
389 | 0 |
               t = jj_consume_token(ABSTRACT);
390 | 0 |
            setToken(sourceClass, t);
391 | 0 |
            sourceClass.addModifier( Modifier.ABSTRACT );
392 | 0 |
               break;
393 |  |
             case FINAL:
394 | 0 |
               t = jj_consume_token(FINAL);
395 | 0 |
            setToken(sourceClass, t);
396 | 0 |
            sourceClass.addModifier( Modifier.FINAL );
397 | 0 |
               break;
398 |  |
             case PUBLIC:
399 | 0 |
               t = jj_consume_token(PUBLIC);
400 | 0 |
            setToken(sourceClass, t);
401 | 0 |
            sourceClass.addModifier( Modifier.PUBLIC );
402 | 0 |
               break;
403 |  |
             case STRICTFP:
404 | 0 |
               t = jj_consume_token(STRICTFP);
405 | 0 |
            setToken(sourceClass, t);
406 | 0 |
            sourceClass.addModifier( Modifier.STRICT );
407 | 0 |
               break;
408 |  |
             default:
409 | 0 |
               jj_la1[6] = jj_gen;
410 | 0 |
               jj_consume_token(-1);
411 | 0 |
               throw new ParseException();
412 |  |
             }
413 |  |
           }
414 | 20 |
           UnmodifiedClassDeclaration();
415 | 20 |
         jjtree.closeNodeScope(jjtn000, true);
416 | 20 |
         jjtc000 = false;
417 | 20 |
          popAndAddInner();
418 |  |
         } catch (Throwable jjte000) {
419 | 0 |
         if (jjtc000) {
420 | 0 |
           jjtree.clearNodeScope(jjtn000);
421 | 0 |
           jjtc000 = false;
422 |  |
         } else {
423 | 0 |
           jjtree.popNode();
424 |  |
         }
425 | 0 |
         if (jjte000 instanceof RuntimeException) {
426 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
427 |  |
         }
428 | 0 |
         if (jjte000 instanceof ParseException) {
429 | 0 |
           {if (true) throw (ParseException)jjte000;}
430 |  |
         }
431 | 0 |
         {if (true) throw (Error)jjte000;}
432 |  |
         } finally {
433 | 20 |
         if (jjtc000) {
434 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
435 |  |
         }
436 |  |
         }
437 |  |
       }
438 |  |
439 | 44 |
       final public void UnmodifiedClassDeclaration() throws ParseException {
440 |  |
      /*@bgen(jjtree) UnmodifiedClassDeclaration */
441 | 44 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTUNMODIFIEDCLASSDECLARATION);
442 | 44 |
        boolean jjtc000 = true;
443 | 44 |
        jjtree.openNodeScope(jjtn000);// Get a ref to the containing class
444 | 44 |
        SourceClass sourceClass = currentClass();
445 |  |
446 | 44 |
        Token ct;
447 | 44 |
        Token name = null;
448 | 44 |
        String superclass = null;
449 | 44 |
         try {
450 | 44 |
           ct = jj_consume_token(CLASS);
451 | 44 |
             if(sourceClass!=null) {
452 | 44 |
                 setToken( sourceClass, ct );
453 | 44 |
                 sourceClass.setInterface( false );
454 |  |
             }
455 | 44 |
           name = jj_consume_token(IDENTIFIER);
456 | 44 |
         if(sourceClass.isInner()) {
457 | 24 |
             sourceClass.setName(name.image);
458 | 24 |
             _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
459 | 24 |
             _xJavaDoc.addSourceClass( sourceClass );
460 |  |
         } else {
461 | 20 |
             sourceClass.setQualifiedName(Util.getQualifiedNameFor(_packageName,name.image));
462 | 20 |
             _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
463 | 20 |
             _xJavaDoc.addSourceClass( sourceClass );
464 | 20 |
             sourceClass.resolveImportedClasses();
465 |  |
466 |  |
             // we're adding to xjavadoc in case we're an "extra" class (XJD-8).
467 | 20 |
             _xJavaDoc.addSourceClass(sourceClass);
468 |  |
         }
469 | 44 |
           switch (jj_nt.kind) {
470 |  |
           case EXTENDS:
471 | 28 |
             jj_consume_token(EXTENDS);
472 | 28 |
             superclass = Name();
473 | 28 |
             break;
474 |  |
           default:
475 | 16 |
             jj_la1[7] = jj_gen;
476 |  |
             ;
477 |  |
           }
478 | 44 |
           switch (jj_nt.kind) {
479 |  |
           case IMPLEMENTS:
480 | 12 |
             jj_consume_token(IMPLEMENTS);
481 | 12 |
             Interfaces_NameList();
482 | 12 |
             break;
483 |  |
           default:
484 | 32 |
             jj_la1[8] = jj_gen;
485 |  |
             ;
486 |  |
           }
487 | 44 |
           ClassBody();
488 | 44 |
          jjtree.closeNodeScope(jjtn000, true);
489 | 44 |
          jjtc000 = false;
490 | 44 |
         if( superclass != null ) {
491 | 28 |
             sourceClass.setSuperclass(superclass);
492 |  |
         } else {
493 | 16 |
             sourceClass.setSuperclass("java.lang.Object");
494 |  |
         }
495 |  |
         } catch (Throwable jjte000) {
496 | 0 |
          if (jjtc000) {
497 | 0 |
            jjtree.clearNodeScope(jjtn000);
498 | 0 |
            jjtc000 = false;
499 |  |
          } else {
500 | 0 |
            jjtree.popNode();
501 |  |
          }
502 | 0 |
          if (jjte000 instanceof RuntimeException) {
503 | 0 |
            {if (true) throw (RuntimeException)jjte000;}
504 |  |
          }
505 | 0 |
          if (jjte000 instanceof ParseException) {
506 | 0 |
            {if (true) throw (ParseException)jjte000;}
507 |  |
          }
508 | 0 |
          {if (true) throw (Error)jjte000;}
509 |  |
         } finally {
510 | 44 |
          if (jjtc000) {
511 | 0 |
            jjtree.closeNodeScope(jjtn000, true);
512 |  |
          }
513 |  |
         }
514 |  |
       }
515 |  |
516 | 44 |
       final public void ClassBody() throws ParseException {
517 |  |
      /*@bgen(jjtree) ClassBody */
518 | 44 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTCLASSBODY);
519 | 44 |
       boolean jjtc000 = true;
520 | 44 |
       jjtree.openNodeScope(jjtn000);
521 | 44 |
         try {
522 | 44 |
           jj_consume_token(LBRACE);
523 | 44 |
           label_4:
524 |  |
           while (true) {
525 | 212 |
             switch (jj_nt.kind) {
526 |  |
             case ABSTRACT:
527 |  |
             case BOOLEAN:
528 |  |
             case BYTE:
529 |  |
             case CHAR:
530 |  |
             case CLASS:
531 |  |
             case DOUBLE:
532 |  |
             case FINAL:
533 |  |
             case FLOAT:
534 |  |
             case INT:
535 |  |
             case INTERFACE:
536 |  |
             case LONG:
537 |  |
             case NATIVE:
538 |  |
             case PRIVATE:
539 |  |
             case PROTECTED:
540 |  |
             case PUBLIC:
541 |  |
             case SHORT:
542 |  |
             case STATIC:
543 |  |
             case SYNCHRONIZED:
544 |  |
             case TRANSIENT:
545 |  |
             case VOID:
546 |  |
             case VOLATILE:
547 |  |
             case STRICTFP:
548 |  |
             case IDENTIFIER:
549 |  |
             case LBRACE:
550 |  |
               ;
551 | 168 |
               break;
552 |  |
             default:
553 | 44 |
               jj_la1[9] = jj_gen;
554 | 44 |
               break label_4;
555 |  |
             }
556 | 168 |
             ClassBodyDeclaration();
557 |  |
           }
558 | 44 |
           jj_consume_token(RBRACE);
559 |  |
         } catch (Throwable jjte000) {
560 | 0 |
         if (jjtc000) {
561 | 0 |
           jjtree.clearNodeScope(jjtn000);
562 | 0 |
           jjtc000 = false;
563 |  |
         } else {
564 | 0 |
           jjtree.popNode();
565 |  |
         }
566 | 0 |
         if (jjte000 instanceof RuntimeException) {
567 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
568 |  |
         }
569 | 0 |
         if (jjte000 instanceof ParseException) {
570 | 0 |
           {if (true) throw (ParseException)jjte000;}
571 |  |
         }
572 | 0 |
         {if (true) throw (Error)jjte000;}
573 |  |
         } finally {
574 | 44 |
         if (jjtc000) {
575 | 44 |
           jjtree.closeNodeScope(jjtn000, true);
576 |  |
         }
577 |  |
         }
578 |  |
       }
579 |  |
580 | 16 |
       final public void NestedClassDeclaration() throws ParseException {
581 |  |
      /*@bgen(jjtree) NestedClassDeclaration */
582 | 16 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTNESTEDCLASSDECLARATION);
583 | 16 |
        boolean jjtc000 = true;
584 | 16 |
        jjtree.openNodeScope(jjtn000);SourceClass sourceClass = pushAndGet();
585 | 16 |
        Token t;
586 | 16 |
         try {
587 | 16 |
           label_5:
588 |  |
           while (true) {
589 | 32 |
             switch (jj_nt.kind) {
590 |  |
             case ABSTRACT:
591 |  |
             case FINAL:
592 |  |
             case PRIVATE:
593 |  |
             case PROTECTED:
594 |  |
             case PUBLIC:
595 |  |
             case STATIC:
596 |  |
             case STRICTFP:
597 |  |
               ;
598 | 16 |
               break;
599 |  |
             default:
600 | 16 |
               jj_la1[10] = jj_gen;
601 | 16 |
               break label_5;
602 |  |
             }
603 | 16 |
             switch (jj_nt.kind) {
604 |  |
             case STATIC:
605 | 0 |
               t = jj_consume_token(STATIC);
606 | 0 |
            sourceClass.addModifier( Modifier.STATIC );
607 | 0 |
            sourceClass.setToken( t );
608 | 0 |
               break;
609 |  |
             case ABSTRACT:
610 | 0 |
               t = jj_consume_token(ABSTRACT);
611 | 0 |
            sourceClass.addModifier( Modifier.ABSTRACT );
612 | 0 |
            sourceClass.setToken( t );
613 | 0 |
               break;
614 |  |
             case FINAL:
615 | 0 |
               t = jj_consume_token(FINAL);
616 | 0 |
            sourceClass.addModifier( Modifier.FINAL );
617 | 0 |
            sourceClass.setToken( t );
618 | 0 |
               break;
619 |  |
             case PUBLIC:
620 | 16 |
               t = jj_consume_token(PUBLIC);
621 | 16 |
            sourceClass.addModifier( Modifier.PUBLIC );
622 | 16 |
            sourceClass.setToken( t );
623 | 16 |
               break;
624 |  |
             case PROTECTED:
625 | 0 |
               t = jj_consume_token(PROTECTED);
626 | 0 |
            sourceClass.addModifier( Modifier.PROTECTED );
627 | 0 |
            sourceClass.setToken( t );
628 | 0 |
               break;
629 |  |
             case PRIVATE:
630 | 0 |
               t = jj_consume_token(PRIVATE);
631 | 0 |
            sourceClass.addModifier( Modifier.PRIVATE );
632 | 0 |
            sourceClass.setToken( t );
633 | 0 |
               break;
634 |  |
             case STRICTFP:
635 | 0 |
               t = jj_consume_token(STRICTFP);
636 | 0 |
            sourceClass.addModifier( Modifier.STRICT );
637 | 0 |
            sourceClass.setToken( t );
638 | 0 |
               break;
639 |  |
             default:
640 | 0 |
               jj_la1[11] = jj_gen;
641 | 0 |
               jj_consume_token(-1);
642 | 0 |
               throw new ParseException();
643 |  |
             }
644 |  |
           }
645 | 16 |
           UnmodifiedClassDeclaration();
646 | 16 |
         jjtree.closeNodeScope(jjtn000, true);
647 | 16 |
         jjtc000 = false;
648 | 16 |
         popAndAddInner();
649 |  |
         } catch (Throwable jjte000) {
650 | 0 |
         if (jjtc000) {
651 | 0 |
           jjtree.clearNodeScope(jjtn000);
652 | 0 |
           jjtc000 = false;
653 |  |
         } else {
654 | 0 |
           jjtree.popNode();
655 |  |
         }
656 | 0 |
         if (jjte000 instanceof RuntimeException) {
657 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
658 |  |
         }
659 | 0 |
         if (jjte000 instanceof ParseException) {
660 | 0 |
           {if (true) throw (ParseException)jjte000;}
661 |  |
         }
662 | 0 |
         {if (true) throw (Error)jjte000;}
663 |  |
         } finally {
664 | 16 |
         if (jjtc000) {
665 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
666 |  |
         }
667 |  |
         }
668 |  |
       }
669 |  |
670 | 168 |
       final public void ClassBodyDeclaration() throws ParseException {
671 |  |
      /*@bgen(jjtree) ClassBodyDeclaration */
672 | 168 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTCLASSBODYDECLARATION);
673 | 168 |
        boolean jjtc000 = true;
674 | 168 |
        jjtree.openNodeScope(jjtn000);SourceClass sourceClass = currentClass();
675 | 168 |
         try {
676 | 168 |
           if (jj_2_2(2)) {
677 | 4 |
             Initializer();
678 | 164 |
           } else if (jj_2_3(2147483647)) {
679 | 16 |
             NestedClassDeclaration();
680 | 148 |
           } else if (jj_2_4(2147483647)) {
681 | 0 |
             NestedInterfaceDeclaration();
682 | 148 |
           } else if (jj_2_5(2147483647)) {
683 | 24 |
             ConstructorDeclaration();
684 | 124 |
           } else if (jj_2_6(2147483647)) {
685 | 76 |
             MethodDeclaration();
686 |  |
           } else {
687 | 48 |
             switch (jj_nt.kind) {
688 |  |
             case BOOLEAN:
689 |  |
             case BYTE:
690 |  |
             case CHAR:
691 |  |
             case DOUBLE:
692 |  |
             case FINAL:
693 |  |
             case FLOAT:
694 |  |
             case INT:
695 |  |
             case LONG:
696 |  |
             case PRIVATE:
697 |  |
             case PROTECTED:
698 |  |
             case PUBLIC:
699 |  |
             case SHORT:
700 |  |
             case STATIC:
701 |  |
             case TRANSIENT:
702 |  |
             case VOLATILE:
703 |  |
             case IDENTIFIER:
704 | 48 |
               FieldDeclaration();
705 | 48 |
               break;
706 |  |
             default:
707 | 0 |
               jj_la1[12] = jj_gen;
708 | 0 |
               jj_consume_token(-1);
709 | 0 |
               throw new ParseException();
710 |  |
             }
711 |  |
           }
712 |  |
         } catch (Throwable jjte000) {
713 | 0 |
         if (jjtc000) {
714 | 0 |
           jjtree.clearNodeScope(jjtn000);
715 | 0 |
           jjtc000 = false;
716 |  |
         } else {
717 | 0 |
           jjtree.popNode();
718 |  |
         }
719 | 0 |
         if (jjte000 instanceof RuntimeException) {
720 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
721 |  |
         }
722 | 0 |
         if (jjte000 instanceof ParseException) {
723 | 0 |
           {if (true) throw (ParseException)jjte000;}
724 |  |
         }
725 | 0 |
         {if (true) throw (Error)jjte000;}
726 |  |
         } finally {
727 | 168 |
         if (jjtc000) {
728 | 168 |
           jjtree.closeNodeScope(jjtn000, true);
729 |  |
         }
730 |  |
         }
731 |  |
       }
732 |  |
733 |  |
     // This production is to determine lookahead only.
734 | 0 |
       final public void MethodDeclarationLookahead() throws ParseException {
735 |  |
      /*@bgen(jjtree) MethodDeclarationLookahead */
736 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTMETHODDECLARATIONLOOKAHEAD);
737 | 0 |
       boolean jjtc000 = true;
738 | 0 |
       jjtree.openNodeScope(jjtn000);
739 | 0 |
         try {
740 | 0 |
           label_6:
741 |  |
           while (true) {
742 | 0 |
             switch (jj_nt.kind) {
743 |  |
             case ABSTRACT:
744 |  |
             case FINAL:
745 |  |
             case NATIVE:
746 |  |
             case PRIVATE:
747 |  |
             case PROTECTED:
748 |  |
             case PUBLIC:
749 |  |
             case STATIC:
750 |  |
             case SYNCHRONIZED:
751 |  |
             case STRICTFP:
752 |  |
               ;
753 | 0 |
               break;
754 |  |
             default:
755 | 0 |
               jj_la1[13] = jj_gen;
756 | 0 |
               break label_6;
757 |  |
             }
758 | 0 |
             switch (jj_nt.kind) {
759 |  |
             case PUBLIC:
760 | 0 |
               jj_consume_token(PUBLIC);
761 | 0 |
               break;
762 |  |
             case PROTECTED:
763 | 0 |
               jj_consume_token(PROTECTED);
764 | 0 |
               break;
765 |  |
             case PRIVATE:
766 | 0 |
               jj_consume_token(PRIVATE);
767 | 0 |
               break;
768 |  |
             case STATIC:
769 | 0 |
               jj_consume_token(STATIC);
770 | 0 |
               break;
771 |  |
             case ABSTRACT:
772 | 0 |
               jj_consume_token(ABSTRACT);
773 | 0 |
               break;
774 |  |
             case FINAL:
775 | 0 |
               jj_consume_token(FINAL);
776 | 0 |
               break;
777 |  |
             case NATIVE:
778 | 0 |
               jj_consume_token(NATIVE);
779 | 0 |
               break;
780 |  |
             case SYNCHRONIZED:
781 | 0 |
               jj_consume_token(SYNCHRONIZED);
782 | 0 |
               break;
783 |  |
             case STRICTFP:
784 | 0 |
               jj_consume_token(STRICTFP);
785 | 0 |
               break;
786 |  |
             default:
787 | 0 |
               jj_la1[14] = jj_gen;
788 | 0 |
               jj_consume_token(-1);
789 | 0 |
               throw new ParseException();
790 |  |
             }
791 |  |
           }
792 | 0 |
           ResultType(null);
793 | 0 |
           jj_consume_token(IDENTIFIER);
794 | 0 |
           jj_consume_token(LPAREN);
795 |  |
         } catch (Throwable jjte000) {
796 | 0 |
         if (jjtc000) {
797 | 0 |
           jjtree.clearNodeScope(jjtn000);
798 | 0 |
           jjtc000 = false;
799 |  |
         } else {
800 | 0 |
           jjtree.popNode();
801 |  |
         }
802 | 0 |
         if (jjte000 instanceof RuntimeException) {
803 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
804 |  |
         }
805 | 0 |
         if (jjte000 instanceof ParseException) {
806 | 0 |
           {if (true) throw (ParseException)jjte000;}
807 |  |
         }
808 | 0 |
         {if (true) throw (Error)jjte000;}
809 |  |
         } finally {
810 | 0 |
         if (jjtc000) {
811 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
812 |  |
         }
813 |  |
         }
814 |  |
       }
815 |  |
816 | 0 |
       final public void InterfaceDeclaration() throws ParseException {
817 |  |
      /*@bgen(jjtree) InterfaceDeclaration */
818 | 0 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTINTERFACEDECLARATION);
819 | 0 |
        boolean jjtc000 = true;
820 | 0 |
        jjtree.openNodeScope(jjtn000);SourceClass sourceClass = pushAndGet();
821 | 0 |
        Token t = null;
822 | 0 |
         try {
823 | 0 |
           label_7:
824 |  |
           while (true) {
825 | 0 |
             switch (jj_nt.kind) {
826 |  |
             case ABSTRACT:
827 |  |
             case PUBLIC:
828 |  |
             case STRICTFP:
829 |  |
               ;
830 | 0 |
               break;
831 |  |
             default:
832 | 0 |
               jj_la1[15] = jj_gen;
833 | 0 |
               break label_7;
834 |  |
             }
835 | 0 |
             switch (jj_nt.kind) {
836 |  |
             case ABSTRACT:
837 | 0 |
               t = jj_consume_token(ABSTRACT);
838 | 0 |
            sourceClass.addModifier( Modifier.ABSTRACT );
839 | 0 |
            sourceClass.setToken( t );
840 | 0 |
               break;
841 |  |
             case PUBLIC:
842 | 0 |
               t = jj_consume_token(PUBLIC);
843 | 0 |
            sourceClass.addModifier( Modifier.PUBLIC );
844 | 0 |
            sourceClass.setToken( t );
845 | 0 |
               break;
846 |  |
             case STRICTFP:
847 | 0 |
               t = jj_consume_token(STRICTFP);
848 | 0 |
            sourceClass.addModifier( Modifier.STRICT );
849 | 0 |
            sourceClass.setToken( t );
850 | 0 |
               break;
851 |  |
             default:
852 | 0 |
               jj_la1[16] = jj_gen;
853 | 0 |
               jj_consume_token(-1);
854 | 0 |
               throw new ParseException();
855 |  |
             }
856 |  |
           }
857 | 0 |
           UnmodifiedInterfaceDeclaration();
858 | 0 |
         jjtree.closeNodeScope(jjtn000, true);
859 | 0 |
         jjtc000 = false;
860 | 0 |
          popAndAddInner();
861 |  |
         } catch (Throwable jjte000) {
862 | 0 |
         if (jjtc000) {
863 | 0 |
           jjtree.clearNodeScope(jjtn000);
864 | 0 |
           jjtc000 = false;
865 |  |
         } else {
866 | 0 |
           jjtree.popNode();
867 |  |
         }
868 | 0 |
         if (jjte000 instanceof RuntimeException) {
869 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
870 |  |
         }
871 | 0 |
         if (jjte000 instanceof ParseException) {
872 | 0 |
           {if (true) throw (ParseException)jjte000;}
873 |  |
         }
874 | 0 |
         {if (true) throw (Error)jjte000;}
875 |  |
         } finally {
876 | 0 |
         if (jjtc000) {
877 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
878 |  |
         }
879 |  |
         }
880 |  |
       }
881 |  |
882 | 0 |
       final public void NestedInterfaceDeclaration() throws ParseException {
883 |  |
      /*@bgen(jjtree) NestedInterfaceDeclaration */
884 | 0 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTNESTEDINTERFACEDECLARATION);
885 | 0 |
        boolean jjtc000 = true;
886 | 0 |
        jjtree.openNodeScope(jjtn000);SourceClass sourceClass = pushAndGet();
887 | 0 |
        Token t;
888 | 0 |
         try {
889 | 0 |
           label_8:
890 |  |
           while (true) {
891 | 0 |
             switch (jj_nt.kind) {
892 |  |
             case ABSTRACT:
893 |  |
             case FINAL:
894 |  |
             case PRIVATE:
895 |  |
             case PROTECTED:
896 |  |
             case PUBLIC:
897 |  |
             case STATIC:
898 |  |
             case STRICTFP:
899 |  |
               ;
900 | 0 |
               break;
901 |  |
             default:
902 | 0 |
               jj_la1[17] = jj_gen;
903 | 0 |
               break label_8;
904 |  |
             }
905 | 0 |
             switch (jj_nt.kind) {
906 |  |
             case STATIC:
907 | 0 |
               t = jj_consume_token(STATIC);
908 | 0 |
            sourceClass.addModifier( Modifier.STATIC );
909 | 0 |
            sourceClass.setToken( t );
910 | 0 |
               break;
911 |  |
             case ABSTRACT:
912 | 0 |
               t = jj_consume_token(ABSTRACT);
913 | 0 |
            sourceClass.addModifier( Modifier.ABSTRACT );
914 | 0 |
            sourceClass.setToken( t );
915 | 0 |
               break;
916 |  |
             case FINAL:
917 | 0 |
               t = jj_consume_token(FINAL);
918 | 0 |
            sourceClass.addModifier( Modifier.FINAL );
919 | 0 |
            sourceClass.setToken( t );
920 | 0 |
               break;
921 |  |
             case PUBLIC:
922 | 0 |
               t = jj_consume_token(PUBLIC);
923 | 0 |
            sourceClass.addModifier( Modifier.PUBLIC );
924 | 0 |
            sourceClass.setToken( t );
925 | 0 |
               break;
926 |  |
             case PROTECTED:
927 | 0 |
               t = jj_consume_token(PROTECTED);
928 | 0 |
            sourceClass.addModifier( Modifier.PROTECTED );
929 | 0 |
            sourceClass.setToken( t );
930 | 0 |
               break;
931 |  |
             case PRIVATE:
932 | 0 |
               t = jj_consume_token(PRIVATE);
933 | 0 |
            sourceClass.addModifier( Modifier.PRIVATE );
934 | 0 |
            sourceClass.setToken( t );
935 | 0 |
               break;
936 |  |
             case STRICTFP:
937 | 0 |
               t = jj_consume_token(STRICTFP);
938 | 0 |
            sourceClass.addModifier( Modifier.STRICT );
939 | 0 |
            sourceClass.setToken( t );
940 | 0 |
               break;
941 |  |
             default:
942 | 0 |
               jj_la1[18] = jj_gen;
943 | 0 |
               jj_consume_token(-1);
944 | 0 |
               throw new ParseException();
945 |  |
             }
946 |  |
           }
947 | 0 |
           UnmodifiedInterfaceDeclaration();
948 | 0 |
         jjtree.closeNodeScope(jjtn000, true);
949 | 0 |
         jjtc000 = false;
950 | 0 |
         popAndAddInner();
951 |  |
         } catch (Throwable jjte000) {
952 | 0 |
         if (jjtc000) {
953 | 0 |
           jjtree.clearNodeScope(jjtn000);
954 | 0 |
           jjtc000 = false;
955 |  |
         } else {
956 | 0 |
           jjtree.popNode();
957 |  |
         }
958 | 0 |
         if (jjte000 instanceof RuntimeException) {
959 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
960 |  |
         }
961 | 0 |
         if (jjte000 instanceof ParseException) {
962 | 0 |
           {if (true) throw (ParseException)jjte000;}
963 |  |
         }
964 | 0 |
         {if (true) throw (Error)jjte000;}
965 |  |
         } finally {
966 | 0 |
         if (jjtc000) {
967 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
968 |  |
         }
969 |  |
         }
970 |  |
       }
971 |  |
972 | 0 |
       final public void UnmodifiedInterfaceDeclaration() throws ParseException {
973 |  |
      /*@bgen(jjtree) UnmodifiedInterfaceDeclaration */
974 | 0 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTUNMODIFIEDINTERFACEDECLARATION);
975 | 0 |
        boolean jjtc000 = true;
976 | 0 |
        jjtree.openNodeScope(jjtn000);SourceClass sourceClass = currentClass();
977 | 0 |
        Token it;
978 | 0 |
        Token name = null;
979 | 0 |
         try {
980 | 0 |
           it = jj_consume_token(INTERFACE);
981 | 0 |
           name = jj_consume_token(IDENTIFIER);
982 |  |
           // interfaces are always abstract
983 | 0 |
           sourceClass.addModifier( Modifier.ABSTRACT );
984 |  |
985 | 0 |
           if(sourceClass.isInner()) {
986 | 0 |
             sourceClass.setName(name.image);
987 | 0 |
             _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
988 | 0 |
             _xJavaDoc.addSourceClass( sourceClass );
989 |  |
           } else {
990 | 0 |
             sourceClass.setQualifiedName(Util.getQualifiedNameFor(_packageName,name.image));
991 | 0 |
             _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
992 | 0 |
             _xJavaDoc.addSourceClass( sourceClass );
993 | 0 |
             sourceClass.resolveImportedClasses();
994 |  |
           }
995 |  |
996 | 0 |
           sourceClass.setInterface( true );
997 | 0 |
           setToken(sourceClass,it);
998 | 0 |
           switch (jj_nt.kind) {
999 |  |
           case EXTENDS:
1000 | 0 |
             jj_consume_token(EXTENDS);
1001 | 0 |
             Interfaces_NameList();
1002 | 0 |
             break;
1003 |  |
           default:
1004 | 0 |
             jj_la1[19] = jj_gen;
1005 |  |
             ;
1006 |  |
           }
1007 | 0 |
           jj_consume_token(LBRACE);
1008 | 0 |
           label_9:
1009 |  |
           while (true) {
1010 | 0 |
             switch (jj_nt.kind) {
1011 |  |
             case ABSTRACT:
1012 |  |
             case BOOLEAN:
1013 |  |
             case BYTE:
1014 |  |
             case CHAR:
1015 |  |
             case CLASS:
1016 |  |
             case DOUBLE:
1017 |  |
             case FINAL:
1018 |  |
             case FLOAT:
1019 |  |
             case INT:
1020 |  |
             case INTERFACE:
1021 |  |
             case LONG:
1022 |  |
             case NATIVE:
1023 |  |
             case PRIVATE:
1024 |  |
             case PROTECTED:
1025 |  |
             case PUBLIC:
1026 |  |
             case SHORT:
1027 |  |
             case STATIC:
1028 |  |
             case SYNCHRONIZED:
1029 |  |
             case TRANSIENT:
1030 |  |
             case VOID:
1031 |  |
             case VOLATILE:
1032 |  |
             case STRICTFP:
1033 |  |
             case IDENTIFIER:
1034 |  |
               ;
1035 | 0 |
               break;
1036 |  |
             default:
1037 | 0 |
               jj_la1[20] = jj_gen;
1038 | 0 |
               break label_9;
1039 |  |
             }
1040 | 0 |
             InterfaceMemberDeclaration();
1041 |  |
           }
1042 | 0 |
           jj_consume_token(RBRACE);
1043 | 0 |
         jjtree.closeNodeScope(jjtn000, true);
1044 | 0 |
         jjtc000 = false;
1045 | 0 |
         if(sourceClass.isInner()) {
1046 | 0 |
             sourceClass.setName(name.image);
1047 |  |
         }
1048 |  |
         } catch (Throwable jjte000) {
1049 | 0 |
         if (jjtc000) {
1050 | 0 |
           jjtree.clearNodeScope(jjtn000);
1051 | 0 |
           jjtc000 = false;
1052 |  |
         } else {
1053 | 0 |
           jjtree.popNode();
1054 |  |
         }
1055 | 0 |
         if (jjte000 instanceof RuntimeException) {
1056 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
1057 |  |
         }
1058 | 0 |
         if (jjte000 instanceof ParseException) {
1059 | 0 |
           {if (true) throw (ParseException)jjte000;}
1060 |  |
         }
1061 | 0 |
         {if (true) throw (Error)jjte000;}
1062 |  |
         } finally {
1063 | 0 |
         if (jjtc000) {
1064 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
1065 |  |
         }
1066 |  |
         }
1067 |  |
       }
1068 |  |
1069 | 0 |
       final public void InterfaceMemberDeclaration() throws ParseException {
1070 |  |
      /*@bgen(jjtree) InterfaceMemberDeclaration */
1071 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTINTERFACEMEMBERDECLARATION);
1072 | 0 |
       boolean jjtc000 = true;
1073 | 0 |
       jjtree.openNodeScope(jjtn000);
1074 | 0 |
         try {
1075 | 0 |
           if (jj_2_7(2147483647)) {
1076 | 0 |
             NestedClassDeclaration();
1077 | 0 |
           } else if (jj_2_8(2147483647)) {
1078 | 0 |
             NestedInterfaceDeclaration();
1079 | 0 |
           } else if (jj_2_9(2147483647)) {
1080 | 0 |
             MethodDeclaration();
1081 |  |
           } else {
1082 | 0 |
             switch (jj_nt.kind) {
1083 |  |
             case BOOLEAN:
1084 |  |
             case BYTE:
1085 |  |
             case CHAR:
1086 |  |
             case DOUBLE:
1087 |  |
             case FINAL:
1088 |  |
             case FLOAT:
1089 |  |
             case INT:
1090 |  |
             case LONG:
1091 |  |
             case PRIVATE:
1092 |  |
             case PROTECTED:
1093 |  |
             case PUBLIC:
1094 |  |
             case SHORT:
1095 |  |
             case STATIC:
1096 |  |
             case TRANSIENT:
1097 |  |
             case VOLATILE:
1098 |  |
             case IDENTIFIER:
1099 | 0 |
               FieldDeclaration();
1100 | 0 |
               break;
1101 |  |
             default:
1102 | 0 |
               jj_la1[21] = jj_gen;
1103 | 0 |
               jj_consume_token(-1);
1104 | 0 |
               throw new ParseException();
1105 |  |
             }
1106 |  |
           }
1107 |  |
         } catch (Throwable jjte000) {
1108 | 0 |
         if (jjtc000) {
1109 | 0 |
           jjtree.clearNodeScope(jjtn000);
1110 | 0 |
           jjtc000 = false;
1111 |  |
         } else {
1112 | 0 |
           jjtree.popNode();
1113 |  |
         }
1114 | 0 |
         if (jjte000 instanceof RuntimeException) {
1115 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
1116 |  |
         }
1117 | 0 |
         if (jjte000 instanceof ParseException) {
1118 | 0 |
           {if (true) throw (ParseException)jjte000;}
1119 |  |
         }
1120 | 0 |
         {if (true) throw (Error)jjte000;}
1121 |  |
         } finally {
1122 | 0 |
         if (jjtc000) {
1123 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
1124 |  |
         }
1125 |  |
         }
1126 |  |
       }
1127 |  |
1128 | 48 |
       final public void FieldDeclaration() throws ParseException {
1129 |  |
      /*@bgen(jjtree) FieldDeclaration */
1130 | 48 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTFIELDDECLARATION);
1131 | 48 |
        boolean jjtc000 = true;
1132 | 48 |
        jjtree.openNodeScope(jjtn000);SourceClass sourceClass = currentClass();
1133 |  |
1134 |  |
        /* NOTE: We also support lame style like
1135 |  |
1136 |  |
        private static int a,b,c,d;
1137 |  |
1138 |  |
        They should share the same javadoc, type and modifiers
1139 |  |
        */
1140 |  |
1141 | 48 |
        Token t = null;
1142 | 48 |
        FieldImpl fieldImpl = null;
1143 | 48 |
        fieldImpl = new FieldImpl(sourceClass, _tagFactory);
1144 | 48 |
         try {
1145 | 48 |
           label_10:
1146 |  |
           while (true) {
1147 | 128 |
             switch (jj_nt.kind) {
1148 |  |
             case FINAL:
1149 |  |
             case PRIVATE:
1150 |  |
             case PROTECTED:
1151 |  |
             case PUBLIC:
1152 |  |
             case STATIC:
1153 |  |
             case TRANSIENT:
1154 |  |
             case VOLATILE:
1155 |  |
               ;
1156 | 80 |
               break;
1157 |  |
             default:
1158 | 48 |
               jj_la1[22] = jj_gen;
1159 | 48 |
               break label_10;
1160 |  |
             }
1161 | 80 |
             switch (jj_nt.kind) {
1162 |  |
             case PUBLIC:
1163 | 8 |
               t = jj_consume_token(PUBLIC);
1164 | 8 |
            fieldImpl.addModifier( Modifier.PUBLIC );
1165 | 8 |
            setToken(fieldImpl,t);
1166 | 8 |
               break;
1167 |  |
             case PROTECTED:
1168 | 8 |
               t = jj_consume_token(PROTECTED);
1169 | 8 |
            fieldImpl.addModifier( Modifier.PROTECTED );
1170 | 8 |
            setToken(fieldImpl,t);
1171 | 8 |
               break;
1172 |  |
             case PRIVATE:
1173 | 32 |
               t = jj_consume_token(PRIVATE);
1174 | 32 |
            fieldImpl.addModifier( Modifier.PRIVATE );
1175 | 32 |
            setToken(fieldImpl,t);
1176 | 32 |
               break;
1177 |  |
             case STATIC:
1178 | 0 |
               t = jj_consume_token(STATIC);
1179 | 0 |
            fieldImpl.addModifier( Modifier.STATIC );
1180 | 0 |
            setToken(fieldImpl,t);
1181 | 0 |
               break;
1182 |  |
             case FINAL:
1183 | 32 |
               t = jj_consume_token(FINAL);
1184 | 32 |
            fieldImpl.addModifier( Modifier.FINAL );
1185 | 32 |
            setToken(fieldImpl,t);
1186 | 32 |
               break;
1187 |  |
             case TRANSIENT:
1188 | 0 |
               t = jj_consume_token(TRANSIENT);
1189 | 0 |
            fieldImpl.addModifier( Modifier.TRANSIENT );
1190 | 0 |
            setToken(fieldImpl,t);
1191 | 0 |
               break;
1192 |  |
             case VOLATILE:
1193 | 0 |
               t = jj_consume_token(VOLATILE);
1194 | 0 |
            fieldImpl.addModifier( Modifier.VOLATILE );
1195 | 0 |
            setToken(fieldImpl,t);
1196 | 0 |
               break;
1197 |  |
             default:
1198 | 0 |
               jj_la1[23] = jj_gen;
1199 | 0 |
               jj_consume_token(-1);
1200 | 0 |
               throw new ParseException();
1201 |  |
             }
1202 |  |
           }
1203 | 48 |
           Field_Type(fieldImpl);
1204 | 48 |
           FieldDeclarator(fieldImpl);
1205 | 48 |
           label_11:
1206 |  |
           while (true) {
1207 | 48 |
             switch (jj_nt.kind) {
1208 |  |
             case COMMA:
1209 |  |
               ;
1210 | 0 |
               break;
1211 |  |
             default:
1212 | 48 |
               jj_la1[24] = jj_gen;
1213 | 48 |
               break label_11;
1214 |  |
             }
1215 | 0 |
             jj_consume_token(COMMA);
1216 | 0 |
             FieldImpl badProgrammingStyleFieldImpl = new FieldImpl(sourceClass, _tagFactory);
1217 | 0 |
             badProgrammingStyleFieldImpl.setType(fieldImpl.getTypeAsString());
1218 | 0 |
             FieldDeclarator(badProgrammingStyleFieldImpl);
1219 | 0 |
             sourceClass.addField(badProgrammingStyleFieldImpl);
1220 |  |
           }
1221 | 48 |
           jj_consume_token(SEMICOLON);
1222 | 48 |
         jjtree.closeNodeScope(jjtn000, true);
1223 | 48 |
         jjtc000 = false;
1224 |  |
         // we must add the field after parsing the field because the name must be set
1225 | 48 |
         sourceClass.addField(fieldImpl);
1226 |  |
         } catch (Throwable jjte000) {
1227 | 0 |
         if (jjtc000) {
1228 | 0 |
           jjtree.clearNodeScope(jjtn000);
1229 | 0 |
           jjtc000 = false;
1230 |  |
         } else {
1231 | 0 |
           jjtree.popNode();
1232 |  |
         }
1233 | 0 |
         if (jjte000 instanceof RuntimeException) {
1234 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
1235 |  |
         }
1236 | 0 |
         if (jjte000 instanceof ParseException) {
1237 | 0 |
           {if (true) throw (ParseException)jjte000;}
1238 |  |
         }
1239 | 0 |
         {if (true) throw (Error)jjte000;}
1240 |  |
         } finally {
1241 | 48 |
         if (jjtc000) {
1242 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
1243 |  |
         }
1244 |  |
         }
1245 |  |
       }
1246 |  |
1247 | 48 |
       final public void FieldDeclarator(FieldImpl fieldImpl) throws ParseException {
1248 |  |
      /*@bgen(jjtree) FieldDeclarator */
1249 | 48 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTFIELDDECLARATOR);
1250 | 48 |
       boolean jjtc000 = true;
1251 | 48 |
       jjtree.openNodeScope(jjtn000);
1252 | 48 |
         try {
1253 | 48 |
           Field_VariableDeclaratorId(fieldImpl);
1254 | 48 |
           switch (jj_nt.kind) {
1255 |  |
           case ASSIGN:
1256 | 16 |
             jj_consume_token(ASSIGN);
1257 | 16 |
             VariableInitializer();
1258 | 16 |
             break;
1259 |  |
           default:
1260 | 32 |
             jj_la1[25] = jj_gen;
1261 |  |
             ;
1262 |  |
           }
1263 |  |
         } catch (Throwable jjte000) {
1264 | 0 |
         if (jjtc000) {
1265 | 0 |
           jjtree.clearNodeScope(jjtn000);
1266 | 0 |
           jjtc000 = false;
1267 |  |
         } else {
1268 | 0 |
           jjtree.popNode();
1269 |  |
         }
1270 | 0 |
         if (jjte000 instanceof RuntimeException) {
1271 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
1272 |  |
         }
1273 | 0 |
         if (jjte000 instanceof ParseException) {
1274 | 0 |
           {if (true) throw (ParseException)jjte000;}
1275 |  |
         }
1276 | 0 |
         {if (true) throw (Error)jjte000;}
1277 |  |
         } finally {
1278 | 48 |
         if (jjtc000) {
1279 | 48 |
           jjtree.closeNodeScope(jjtn000, true);
1280 |  |
         }
1281 |  |
         }
1282 |  |
       }
1283 |  |
1284 | 42 |
       final public void VariableDeclarator() throws ParseException {
1285 |  |
      /*@bgen(jjtree) VariableDeclarator */
1286 | 42 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTVARIABLEDECLARATOR);
1287 | 42 |
       boolean jjtc000 = true;
1288 | 42 |
       jjtree.openNodeScope(jjtn000);
1289 | 42 |
         try {
1290 | 42 |
           VariableDeclaratorId();
1291 | 42 |
           switch (jj_nt.kind) {
1292 |  |
           case ASSIGN:
1293 | 38 |
             jj_consume_token(ASSIGN);
1294 | 38 |
             VariableInitializer();
1295 | 38 |
             break;
1296 |  |
           default:
1297 | 4 |
             jj_la1[26] = jj_gen;
1298 |  |
             ;
1299 |  |
           }
1300 |  |
         } catch (Throwable jjte000) {
1301 | 0 |
         if (jjtc000) {
1302 | 0 |
           jjtree.clearNodeScope(jjtn000);
1303 | 0 |
           jjtc000 = false;
1304 |  |
         } else {
1305 | 0 |
           jjtree.popNode();
1306 |  |
         }
1307 | 0 |
         if (jjte000 instanceof RuntimeException) {
1308 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
1309 |  |
         }
1310 | 0 |
         if (jjte000 instanceof ParseException) {
1311 | 0 |
           {if (true) throw (ParseException)jjte000;}
1312 |  |
         }
1313 | 0 |
         {if (true) throw (Error)jjte000;}
1314 |  |
         } finally {
1315 | 42 |
         if (jjtc000) {
1316 | 42 |
           jjtree.closeNodeScope(jjtn000, true);
1317 |  |
         }
1318 |  |
         }
1319 |  |
       }
1320 |  |
1321 | 48 |
       final public void Field_VariableDeclaratorId(FieldImpl fieldImpl) throws ParseException {
1322 |  |
      /*@bgen(jjtree) Field_VariableDeclaratorId */
1323 | 48 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTFIELD_VARIABLEDECLARATORID);
1324 | 48 |
        boolean jjtc000 = true;
1325 | 48 |
        jjtree.openNodeScope(jjtn000);Token t = null;
1326 | 48 |
         try {
1327 | 48 |
           t = jj_consume_token(IDENTIFIER);
1328 | 48 |
           label_12:
1329 |  |
           while (true) {
1330 | 48 |
             switch (jj_nt.kind) {
1331 |  |
             case LBRACKET:
1332 |  |
               ;
1333 | 0 |
               break;
1334 |  |
             default:
1335 | 48 |
               jj_la1[27] = jj_gen;
1336 | 48 |
               break label_12;
1337 |  |
             }
1338 | 0 |
             jj_consume_token(LBRACKET);
1339 | 0 |
             jj_consume_token(RBRACKET);
1340 | 0 |
                                  fieldImpl.setDimension(fieldImpl.getDimension() + 1);
1341 |  |
           }
1342 | 48 |
         jjtree.closeNodeScope(jjtn000, true);
1343 | 48 |
         jjtc000 = false;
1344 | 48 |
          fieldImpl.setName( t.image );
1345 |  |
         } finally {
1346 | 48 |
         if (jjtc000) {
1347 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
1348 |  |
         }
1349 |  |
         }
1350 |  |
       }
1351 |  |
1352 | 56 |
       final public void Parameter_VariableDeclaratorId() throws ParseException {
1353 |  |
      /*@bgen(jjtree) Parameter_VariableDeclaratorId */
1354 | 56 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTPARAMETER_VARIABLEDECLARATORID);
1355 | 56 |
        boolean jjtc000 = true;
1356 | 56 |
        jjtree.openNodeScope(jjtn000);Token t = null;
1357 | 56 |
         try {
1358 | 56 |
           t = jj_consume_token(IDENTIFIER);
1359 | 56 |
           label_13:
1360 |  |
           while (true) {
1361 | 64 |
             switch (jj_nt.kind) {
1362 |  |
             case LBRACKET:
1363 |  |
               ;
1364 | 8 |
               break;
1365 |  |
             default:
1366 | 56 |
               jj_la1[28] = jj_gen;
1367 | 56 |
               break label_13;
1368 |  |
             }
1369 | 8 |
             jj_consume_token(LBRACKET);
1370 | 8 |
             jj_consume_token(RBRACKET);
1371 | 8 |
                                  _parameter.dimension++;
1372 |  |
           }
1373 | 56 |
         jjtree.closeNodeScope(jjtn000, true);
1374 | 56 |
         jjtc000 = false;
1375 | 56 |
          _parameter.name = t.image;
1376 |  |
         } finally {
1377 | 56 |
         if (jjtc000) {
1378 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
1379 |  |
         }
1380 |  |
         }
1381 |  |
       }
1382 |  |
1383 | 42 |
       final public void VariableDeclaratorId() throws ParseException {
1384 |  |
      /*@bgen(jjtree) VariableDeclaratorId */
1385 | 42 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTVARIABLEDECLARATORID);
1386 | 42 |
       boolean jjtc000 = true;
1387 | 42 |
       jjtree.openNodeScope(jjtn000);
1388 | 42 |
         try {
1389 | 42 |
           jj_consume_token(IDENTIFIER);
1390 | 42 |
           label_14:
1391 |  |
           while (true) {
1392 | 42 |
             switch (jj_nt.kind) {
1393 |  |
             case LBRACKET:
1394 |  |
               ;
1395 | 0 |
               break;
1396 |  |
             default:
1397 | 42 |
               jj_la1[29] = jj_gen;
1398 | 42 |
               break label_14;
1399 |  |
             }
1400 | 0 |
             jj_consume_token(LBRACKET);
1401 | 0 |
             jj_consume_token(RBRACKET);
1402 |  |
           }
1403 |  |
         } finally {
1404 | 42 |
         if (jjtc000) {
1405 | 42 |
           jjtree.closeNodeScope(jjtn000, true);
1406 |  |
         }
1407 |  |
         }
1408 |  |
       }
1409 |  |
1410 | 54 |
       final public void VariableInitializer() throws ParseException {
1411 |  |
      /*@bgen(jjtree) VariableInitializer */
1412 | 54 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTVARIABLEINITIALIZER);
1413 | 54 |
       boolean jjtc000 = true;
1414 | 54 |
       jjtree.openNodeScope(jjtn000);
1415 | 54 |
         try {
1416 | 54 |
           switch (jj_nt.kind) {
1417 |  |
           case LBRACE:
1418 | 0 |
             ArrayInitializer();
1419 | 0 |
             break;
1420 |  |
           case BOOLEAN:
1421 |  |
           case BYTE:
1422 |  |
           case CHAR:
1423 |  |
           case DOUBLE:
1424 |  |
           case FALSE:
1425 |  |
           case FLOAT:
1426 |  |
           case INT:
1427 |  |
           case LONG:
1428 |  |
           case NEW:
1429 |  |
           case NULL:
1430 |  |
           case SHORT:
1431 |  |
           case SUPER:
1432 |  |
           case THIS:
1433 |  |
           case TRUE:
1434 |  |
           case VOID:
1435 |  |
           case INTEGER_LITERAL:
1436 |  |
           case FLOATING_POINT_LITERAL:
1437 |  |
           case CHARACTER_LITERAL:
1438 |  |
           case STRING_LITERAL:
1439 |  |
           case IDENTIFIER:
1440 |  |
           case LPAREN:
1441 |  |
           case BANG:
1442 |  |
           case TILDE:
1443 |  |
           case INCR:
1444 |  |
           case DECR:
1445 |  |
           case PLUS:
1446 |  |
           case MINUS:
1447 | 54 |
             Expression();
1448 | 54 |
             break;
1449 |  |
           default:
1450 | 0 |
             jj_la1[30] = jj_gen;
1451 | 0 |
             jj_consume_token(-1);
1452 | 0 |
             throw new ParseException();
1453 |  |
           }
1454 |  |
         } catch (Throwable jjte000) {
1455 | 0 |
         if (jjtc000) {
1456 | 0 |
           jjtree.clearNodeScope(jjtn000);
1457 | 0 |
           jjtc000 = false;
1458 |  |
         } else {
1459 | 0 |
           jjtree.popNode();
1460 |  |
         }
1461 | 0 |
         if (jjte000 instanceof RuntimeException) {
1462 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
1463 |  |
         }
1464 | 0 |
         if (jjte000 instanceof ParseException) {
1465 | 0 |
           {if (true) throw (ParseException)jjte000;}
1466 |  |
         }
1467 | 0 |
         {if (true) throw (Error)jjte000;}
1468 |  |
         } finally {
1469 | 54 |
         if (jjtc000) {
1470 | 54 |
           jjtree.closeNodeScope(jjtn000, true);
1471 |  |
         }
1472 |  |
         }
1473 |  |
       }
1474 |  |
1475 | 0 |
       final public void ArrayInitializer() throws ParseException {
1476 |  |
      /*@bgen(jjtree) ArrayInitializer */
1477 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTARRAYINITIALIZER);
1478 | 0 |
       boolean jjtc000 = true;
1479 | 0 |
       jjtree.openNodeScope(jjtn000);
1480 | 0 |
         try {
1481 | 0 |
           jj_consume_token(LBRACE);
1482 | 0 |
           switch (jj_nt.kind) {
1483 |  |
           case BOOLEAN:
1484 |  |
           case BYTE:
1485 |  |
           case CHAR:
1486 |  |
           case DOUBLE:
1487 |  |
           case FALSE:
1488 |  |
           case FLOAT:
1489 |  |
           case INT:
1490 |  |
           case LONG:
1491 |  |
           case NEW:
1492 |  |
           case NULL:
1493 |  |
           case SHORT:
1494 |  |
           case SUPER:
1495 |  |
           case THIS:
1496 |  |
           case TRUE:
1497 |  |
           case VOID:
1498 |  |
           case INTEGER_LITERAL:
1499 |  |
           case FLOATING_POINT_LITERAL:
1500 |  |
           case CHARACTER_LITERAL:
1501 |  |
           case STRING_LITERAL:
1502 |  |
           case IDENTIFIER:
1503 |  |
           case LPAREN:
1504 |  |
           case LBRACE:
1505 |  |
           case BANG:
1506 |  |
           case TILDE:
1507 |  |
           case INCR:
1508 |  |
           case DECR:
1509 |  |
           case PLUS:
1510 |  |
           case MINUS:
1511 | 0 |
             VariableInitializer();
1512 | 0 |
             label_15:
1513 |  |
             while (true) {
1514 | 0 |
               if (jj_2_10(2)) {
1515 |  |
                 ;
1516 |  |
               } else {
1517 | 0 |
                 break label_15;
1518 |  |
               }
1519 | 0 |
               jj_consume_token(COMMA);
1520 | 0 |
               VariableInitializer();
1521 |  |
             }
1522 | 0 |
             break;
1523 |  |
           default:
1524 | 0 |
             jj_la1[31] = jj_gen;
1525 |  |
             ;
1526 |  |
           }
1527 | 0 |
           switch (jj_nt.kind) {
1528 |  |
           case COMMA:
1529 | 0 |
             jj_consume_token(COMMA);
1530 | 0 |
             break;
1531 |  |
           default:
1532 | 0 |
             jj_la1[32] = jj_gen;
1533 |  |
             ;
1534 |  |
           }
1535 | 0 |
           jj_consume_token(RBRACE);
1536 |  |
         } catch (Throwable jjte000) {
1537 | 0 |
         if (jjtc000) {
1538 | 0 |
           jjtree.clearNodeScope(jjtn000);
1539 | 0 |
           jjtc000 = false;
1540 |  |
         } else {
1541 | 0 |
           jjtree.popNode();
1542 |  |
         }
1543 | 0 |
         if (jjte000 instanceof RuntimeException) {
1544 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
1545 |  |
         }
1546 | 0 |
         if (jjte000 instanceof ParseException) {
1547 | 0 |
           {if (true) throw (ParseException)jjte000;}
1548 |  |
         }
1549 | 0 |
         {if (true) throw (Error)jjte000;}
1550 |  |
         } finally {
1551 | 0 |
         if (jjtc000) {
1552 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
1553 |  |
         }
1554 |  |
         }
1555 |  |
       }
1556 |  |
1557 | 76 |
       final public void MethodDeclaration() throws ParseException {
1558 |  |
      /*@bgen(jjtree) MethodDeclaration */
1559 | 76 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTMETHODDECLARATION);
1560 | 76 |
        boolean jjtc000 = true;
1561 | 76 |
        jjtree.openNodeScope(jjtn000);SourceClass sourceClass = currentClass();
1562 |  |
1563 | 76 |
        Token t = null;
1564 | 76 |
        String exceptions = null;
1565 |  |
1566 |  |
        //this may remain null for anonymous inner classes (sourceClass==null), not a problem because we're not going to access class structure of an anonymous inner class
1567 | 76 |
        MethodImpl methodImpl = null;
1568 |  |
1569 | 76 |
         if(sourceClass!=null) {
1570 | 76 |
            methodImpl = new MethodImpl(sourceClass, _tagFactory);
1571 |  |
         }
1572 | 76 |
         try {
1573 | 76 |
           label_16:
1574 |  |
           while (true) {
1575 | 140 |
             switch (jj_nt.kind) {
1576 |  |
             case ABSTRACT:
1577 |  |
             case FINAL:
1578 |  |
             case NATIVE:
1579 |  |
             case PRIVATE:
1580 |  |
             case PROTECTED:
1581 |  |
             case PUBLIC:
1582 |  |
             case STATIC:
1583 |  |
             case SYNCHRONIZED:
1584 |  |
             case STRICTFP:
1585 |  |
               ;
1586 | 64 |
               break;
1587 |  |
             default:
1588 | 76 |
               jj_la1[33] = jj_gen;
1589 | 76 |
               break label_16;
1590 |  |
             }
1591 | 64 |
             switch (jj_nt.kind) {
1592 |  |
             case PUBLIC:
1593 | 40 |
               t = jj_consume_token(PUBLIC);
1594 | 40 |
             if(methodImpl!=null) {
1595 | 40 |
                 methodImpl.addModifier( Modifier.PUBLIC );
1596 | 40 |
                 setToken( methodImpl, t );
1597 |  |
             }
1598 | 40 |
               break;
1599 |  |
             case PROTECTED:
1600 | 8 |
               t = jj_consume_token(PROTECTED);
1601 | 8 |
             if(methodImpl!=null) {
1602 | 8 |
                 methodImpl.addModifier( Modifier.PROTECTED );
1603 | 8 |
                 setToken( methodImpl, t );
1604 |  |
             }
1605 | 8 |
               break;
1606 |  |
             case PRIVATE:
1607 | 16 |
               t = jj_consume_token(PRIVATE);
1608 | 16 |
             if(methodImpl!=null) {
1609 | 16 |
                 methodImpl.addModifier( Modifier.PRIVATE );
1610 | 16 |
                 setToken( methodImpl, t );
1611 |  |
             }
1612 | 16 |
               break;
1613 |  |
             case STATIC:
1614 | 0 |
               t = jj_consume_token(STATIC);
1615 | 0 |
             if(methodImpl!=null) {
1616 | 0 |
                 methodImpl.addModifier( Modifier.STATIC );
1617 | 0 |
                 setToken( methodImpl, t );
1618 |  |
             }
1619 | 0 |
               break;
1620 |  |
             case ABSTRACT:
1621 | 0 |
               t = jj_consume_token(ABSTRACT);
1622 | 0 |
             if(methodImpl!=null) {
1623 | 0 |
                 methodImpl.addModifier( Modifier.ABSTRACT );
1624 | 0 |
                 setToken( methodImpl, t );
1625 |  |
             }
1626 | 0 |
               break;
1627 |  |
             case FINAL:
1628 | 0 |
               t = jj_consume_token(FINAL);
1629 | 0 |
             if(methodImpl!=null) {
1630 | 0 |
                 methodImpl.addModifier( Modifier.FINAL );
1631 | 0 |
                 setToken( methodImpl, t );
1632 |  |
             }
1633 | 0 |
               break;
1634 |  |
             case NATIVE:
1635 | 0 |
               t = jj_consume_token(NATIVE);
1636 | 0 |
             if(methodImpl!=null) {
1637 | 0 |
                 methodImpl.addModifier( Modifier.NATIVE );
1638 | 0 |
                 setToken( methodImpl, t );
1639 |  |
             }
1640 | 0 |
               break;
1641 |  |
             case SYNCHRONIZED:
1642 | 0 |
               t = jj_consume_token(SYNCHRONIZED);
1643 | 0 |
             if(methodImpl!=null) {
1644 | 0 |
                 methodImpl.addModifier( Modifier.SYNCHRONIZED );
1645 | 0 |
                 setToken( methodImpl, t );
1646 |  |
             }
1647 | 0 |
               break;
1648 |  |
             case STRICTFP:
1649 | 0 |
               t = jj_consume_token(STRICTFP);
1650 | 0 |
             if(methodImpl!=null) {
1651 | 0 |
                 methodImpl.addModifier( Modifier.STRICT );
1652 | 0 |
                 setToken( methodImpl, t );
1653 |  |
             }
1654 | 0 |
               break;
1655 |  |
             default:
1656 | 0 |
               jj_la1[34] = jj_gen;
1657 | 0 |
               jj_consume_token(-1);
1658 | 0 |
               throw new ParseException();
1659 |  |
             }
1660 |  |
           }
1661 | 76 |
           ResultType(methodImpl);
1662 | 76 |
           MethodDeclarator(methodImpl);
1663 | 76 |
           switch (jj_nt.kind) {
1664 |  |
           case THROWS:
1665 | 0 |
             jj_consume_token(THROWS);
1666 | 0 |
             ExecutableMemberThrows_NameList(methodImpl);
1667 | 0 |
             break;
1668 |  |
           default:
1669 | 76 |
             jj_la1[35] = jj_gen;
1670 |  |
             ;
1671 |  |
           }
1672 | 76 |
           switch (jj_nt.kind) {
1673 |  |
           case LBRACE:
1674 | 76 |
             Method_Block();
1675 | 76 |
             break;
1676 |  |
           case SEMICOLON:
1677 | 0 |
             jj_consume_token(SEMICOLON);
1678 | 0 |
             break;
1679 |  |
           default:
1680 | 0 |
             jj_la1[36] = jj_gen;
1681 | 0 |
             jj_consume_token(-1);
1682 | 0 |
             throw new ParseException();
1683 |  |
           }
1684 | 76 |
         jjtree.closeNodeScope(jjtn000, true);
1685 | 76 |
         jjtc000 = false;
1686 |  |
         // we must add the method after the fields are in, because the
1687 |  |
         // signature must be complete when adding
1688 | 76 |
         sourceClass.addMethod(methodImpl);
1689 |  |
         } catch (Throwable jjte000) {
1690 | 0 |
         if (jjtc000) {
1691 | 0 |
           jjtree.clearNodeScope(jjtn000);
1692 | 0 |
           jjtc000 = false;
1693 |  |
         } else {
1694 | 0 |
           jjtree.popNode();
1695 |  |
         }
1696 | 0 |
         if (jjte000 instanceof RuntimeException) {
1697 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
1698 |  |
         }
1699 | 0 |
         if (jjte000 instanceof ParseException) {
1700 | 0 |
           {if (true) throw (ParseException)jjte000;}
1701 |  |
         }
1702 | 0 |
         {if (true) throw (Error)jjte000;}
1703 |  |
         } finally {
1704 | 76 |
         if (jjtc000) {
1705 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
1706 |  |
         }
1707 |  |
         }
1708 |  |
       }
1709 |  |
1710 | 76 |
       final public void MethodDeclarator(MethodImpl methodImpl) throws ParseException {
1711 |  |
      /*@bgen(jjtree) MethodDeclarator */
1712 | 76 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTMETHODDECLARATOR);
1713 | 76 |
        boolean jjtc000 = true;
1714 | 76 |
        jjtree.openNodeScope(jjtn000);Token t = null;
1715 | 76 |
         try {
1716 | 76 |
           t = jj_consume_token(IDENTIFIER);
1717 | 76 |
          if( methodImpl != null ) {
1718 | 76 |
             methodImpl.setName( t.image );
1719 |  |
          }
1720 | 76 |
           FormalParameters(methodImpl);
1721 | 76 |
           label_17:
1722 |  |
           while (true) {
1723 | 76 |
             switch (jj_nt.kind) {
1724 |  |
             case LBRACKET:
1725 |  |
               ;
1726 | 0 |
               break;
1727 |  |
             default:
1728 | 76 |
               jj_la1[37] = jj_gen;
1729 | 76 |
               break label_17;
1730 |  |
             }
1731 | 0 |
             jj_consume_token(LBRACKET);
1732 | 0 |
             jj_consume_token(RBRACKET);
1733 | 0 |
          methodImpl.setReturnDimension( methodImpl.getReturnType().getDimension() + 1 );
1734 |  |
           }
1735 |  |
         } catch (Throwable jjte000) {
1736 | 0 |
         if (jjtc000) {
1737 | 0 |
           jjtree.clearNodeScope(jjtn000);
1738 | 0 |
           jjtc000 = false;
1739 |  |
         } else {
1740 | 0 |
           jjtree.popNode();
1741 |  |
         }
1742 | 0 |
         if (jjte000 instanceof RuntimeException) {
1743 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
1744 |  |
         }
1745 | 0 |
         if (jjte000 instanceof ParseException) {
1746 | 0 |
           {if (true) throw (ParseException)jjte000;}
1747 |  |
         }
1748 | 0 |
         {if (true) throw (Error)jjte000;}
1749 |  |
         } finally {
1750 | 76 |
         if (jjtc000) {
1751 | 76 |
           jjtree.closeNodeScope(jjtn000, true);
1752 |  |
         }
1753 |  |
         }
1754 |  |
       }
1755 |  |
1756 | 100 |
       final public void FormalParameters(AbstractExecutableMember member) throws ParseException {
1757 |  |
      /*@bgen(jjtree) FormalParameters */
1758 | 100 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTFORMALPARAMETERS);
1759 | 100 |
       boolean jjtc000 = true;
1760 | 100 |
       jjtree.openNodeScope(jjtn000);
1761 | 100 |
         try {
1762 | 100 |
           jj_consume_token(LPAREN);
1763 | 100 |
           switch (jj_nt.kind) {
1764 |  |
           case BOOLEAN:
1765 |  |
           case BYTE:
1766 |  |
           case CHAR:
1767 |  |
           case DOUBLE:
1768 |  |
           case FINAL:
1769 |  |
           case FLOAT:
1770 |  |
           case INT:
1771 |  |
           case LONG:
1772 |  |
           case SHORT:
1773 |  |
           case IDENTIFIER:
1774 | 40 |
             FormalParameter(member);
1775 | 40 |
             label_18:
1776 |  |
             while (true) {
1777 | 56 |
               switch (jj_nt.kind) {
1778 |  |
               case COMMA:
1779 |  |
                 ;
1780 | 16 |
                 break;
1781 |  |
               default:
1782 | 40 |
                 jj_la1[38] = jj_gen;
1783 | 40 |
                 break label_18;
1784 |  |
               }
1785 | 16 |
               jj_consume_token(COMMA);
1786 | 16 |
               FormalParameter(member);
1787 |  |
             }
1788 | 40 |
             break;
1789 |  |
           default:
1790 | 60 |
             jj_la1[39] = jj_gen;
1791 |  |
             ;
1792 |  |
           }
1793 | 100 |
           jj_consume_token(RPAREN);
1794 |  |
         } catch (Throwable jjte000) {
1795 | 0 |
         if (jjtc000) {
1796 | 0 |
           jjtree.clearNodeScope(jjtn000);
1797 | 0 |
           jjtc000 = false;
1798 |  |
         } else {
1799 | 0 |
           jjtree.popNode();
1800 |  |
         }
1801 | 0 |
         if (jjte000 instanceof RuntimeException) {
1802 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
1803 |  |
         }
1804 | 0 |
         if (jjte000 instanceof ParseException) {
1805 | 0 |
           {if (true) throw (ParseException)jjte000;}
1806 |  |
         }
1807 | 0 |
         {if (true) throw (Error)jjte000;}
1808 |  |
         } finally {
1809 | 100 |
         if (jjtc000) {
1810 | 100 |
           jjtree.closeNodeScope(jjtn000, true);
1811 |  |
         }
1812 |  |
         }
1813 |  |
       }
1814 |  |
1815 | 56 |
       final public void FormalParameter(AbstractExecutableMember member) throws ParseException {
1816 |  |
      /*@bgen(jjtree) FormalParameter */
1817 | 56 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTFORMALPARAMETER);
1818 | 56 |
        boolean jjtc000 = true;
1819 | 56 |
        jjtree.openNodeScope(jjtn000);if(member != null) {
1820 |  |
           // reset the _parameter helper's dimension
1821 | 56 |
           _parameter.dimension = 0;
1822 |  |
        }
1823 | 56 |
         try {
1824 | 56 |
           switch (jj_nt.kind) {
1825 |  |
           case FINAL:
1826 | 0 |
             jj_consume_token(FINAL);
1827 | 0 |
             break;
1828 |  |
           default:
1829 | 56 |
             jj_la1[40] = jj_gen;
1830 |  |
             ;
1831 |  |
           }
1832 | 56 |
           Parameter_Type();
1833 | 56 |
           Parameter_VariableDeclaratorId();
1834 | 56 |
         jjtree.closeNodeScope(jjtn000, true);
1835 | 56 |
         jjtc000 = false;
1836 | 56 |
          if( member != null ) {
1837 | 56 |
             member.addParameterData(_parameter.type, _parameter.name, _parameter.dimension);
1838 |  |
          }
1839 |  |
         } catch (Throwable jjte000) {
1840 | 0 |
         if (jjtc000) {
1841 | 0 |
           jjtree.clearNodeScope(jjtn000);
1842 | 0 |
           jjtc000 = false;
1843 |  |
         } else {
1844 | 0 |
           jjtree.popNode();
1845 |  |
         }
1846 | 0 |
         if (jjte000 instanceof RuntimeException) {
1847 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
1848 |  |
         }
1849 | 0 |
         if (jjte000 instanceof ParseException) {
1850 | 0 |
           {if (true) throw (ParseException)jjte000;}
1851 |  |
         }
1852 | 0 |
         {if (true) throw (Error)jjte000;}
1853 |  |
         } finally {
1854 | 56 |
         if (jjtc000) {
1855 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
1856 |  |
         }
1857 |  |
         }
1858 |  |
       }
1859 |  |
1860 | 24 |
       final public void ConstructorDeclaration() throws ParseException {
1861 |  |
      /*@bgen(jjtree) ConstructorDeclaration */
1862 | 24 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTCONSTRUCTORDECLARATION);
1863 | 24 |
        boolean jjtc000 = true;
1864 | 24 |
        jjtree.openNodeScope(jjtn000);SourceClass sourceClass = currentClass();
1865 | 24 |
        Token t = null;
1866 | 24 |
        ConstructorImpl constructor = constructor = new ConstructorImpl(sourceClass, _tagFactory);
1867 | 24 |
         try {
1868 | 24 |
           switch (jj_nt.kind) {
1869 |  |
           case PRIVATE:
1870 |  |
           case PROTECTED:
1871 |  |
           case PUBLIC:
1872 | 16 |
             switch (jj_nt.kind) {
1873 |  |
             case PUBLIC:
1874 | 8 |
               t = jj_consume_token(PUBLIC);
1875 | 8 |
            constructor.addModifier( Modifier.PUBLIC );
1876 | 8 |
            setToken( constructor, t );
1877 | 8 |
               break;
1878 |  |
             case PROTECTED:
1879 | 8 |
               t = jj_consume_token(PROTECTED);
1880 | 8 |
            constructor.addModifier( Modifier.PROTECTED );
1881 | 8 |
            setToken( constructor, t );
1882 | 8 |
               break;
1883 |  |
             case PRIVATE:
1884 | 0 |
               t = jj_consume_token(PRIVATE);
1885 | 0 |
            constructor.addModifier( Modifier.PRIVATE );
1886 | 0 |
            setToken( constructor, t );
1887 | 0 |
               break;
1888 |  |
             default:
1889 | 0 |
               jj_la1[41] = jj_gen;
1890 | 0 |
               jj_consume_token(-1);
1891 | 0 |
               throw new ParseException();
1892 |  |
             }
1893 | 16 |
             break;
1894 |  |
           default:
1895 | 8 |
             jj_la1[42] = jj_gen;
1896 |  |
             ;
1897 |  |
           }
1898 | 24 |
           jj_consume_token(IDENTIFIER);
1899 | 24 |
           FormalParameters(constructor);
1900 | 24 |
           switch (jj_nt.kind) {
1901 |  |
           case THROWS:
1902 | 0 |
             jj_consume_token(THROWS);
1903 | 0 |
             ExecutableMemberThrows_NameList(constructor);
1904 | 0 |
             break;
1905 |  |
           default:
1906 | 24 |
             jj_la1[43] = jj_gen;
1907 |  |
             ;
1908 |  |
           }
1909 | 24 |
           jj_consume_token(LBRACE);
1910 | 24 |
           if (jj_2_11(2147483647)) {
1911 | 0 |
             ExplicitConstructorInvocation();
1912 |  |
           } else {
1913 |  |
             ;
1914 |  |
           }
1915 | 24 |
           label_19:
1916 |  |
           while (true) {
1917 | 24 |
             switch (jj_nt.kind) {
1918 |  |
             case BOOLEAN:
1919 |  |
             case BREAK:
1920 |  |
             case BYTE:
1921 |  |
             case CHAR:
1922 |  |
             case CLASS:
1923 |  |
             case CONTINUE:
1924 |  |
             case DO:
1925 |  |
             case DOUBLE:
1926 |  |
             case FALSE:
1927 |  |
             case FINAL:
1928 |  |
             case FLOAT:
1929 |  |
             case FOR:
1930 |  |
             case IF:
1931 |  |
             case INT:
1932 |  |
             case INTERFACE:
1933 |  |
             case LONG:
1934 |  |
             case NEW:
1935 |  |
             case NULL:
1936 |  |
             case RETURN:
1937 |  |
             case SHORT:
1938 |  |
             case SUPER:
1939 |  |
             case SWITCH:
1940 |  |
             case SYNCHRONIZED:
1941 |  |
             case THIS:
1942 |  |
             case THROW:
1943 |  |
             case TRUE:
1944 |  |
             case TRY:
1945 |  |
             case VOID:
1946 |  |
             case WHILE:
1947 |  |
             case ASSERT:
1948 |  |
             case INTEGER_LITERAL:
1949 |  |
             case FLOATING_POINT_LITERAL:
1950 |  |
             case CHARACTER_LITERAL:
1951 |  |
             case STRING_LITERAL:
1952 |  |
             case IDENTIFIER:
1953 |  |
             case LPAREN:
1954 |  |
             case LBRACE:
1955 |  |
             case SEMICOLON:
1956 |  |
             case INCR:
1957 |  |
             case DECR:
1958 |  |
               ;
1959 | 0 |
               break;
1960 |  |
             default:
1961 | 24 |
               jj_la1[44] = jj_gen;
1962 | 24 |
               break label_19;
1963 |  |
             }
1964 | 0 |
             BlockStatement();
1965 |  |
           }
1966 | 24 |
           jj_consume_token(RBRACE);
1967 | 24 |
         jjtree.closeNodeScope(jjtn000, true);
1968 | 24 |
         jjtc000 = false;
1969 |  |
         // we must add the method after the fields are in, because the
1970 |  |
         // signature must be complete when adding
1971 | 24 |
         sourceClass.addConstructor(constructor);
1972 |  |
         } catch (Throwable jjte000) {
1973 | 0 |
         if (jjtc000) {
1974 | 0 |
           jjtree.clearNodeScope(jjtn000);
1975 | 0 |
           jjtc000 = false;
1976 |  |
         } else {
1977 | 0 |
           jjtree.popNode();
1978 |  |
         }
1979 | 0 |
         if (jjte000 instanceof RuntimeException) {
1980 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
1981 |  |
         }
1982 | 0 |
         if (jjte000 instanceof ParseException) {
1983 | 0 |
           {if (true) throw (ParseException)jjte000;}
1984 |  |
         }
1985 | 0 |
         {if (true) throw (Error)jjte000;}
1986 |  |
         } finally {
1987 | 24 |
         if (jjtc000) {
1988 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
1989 |  |
         }
1990 |  |
         }
1991 |  |
       }
1992 |  |
1993 | 0 |
       final public void ExplicitConstructorInvocation() throws ParseException {
1994 |  |
      /*@bgen(jjtree) ExplicitConstructorInvocation */
1995 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTEXPLICITCONSTRUCTORINVOCATION);
1996 | 0 |
       boolean jjtc000 = true;
1997 | 0 |
       jjtree.openNodeScope(jjtn000);
1998 | 0 |
         try {
1999 | 0 |
           if (jj_2_13(2147483647)) {
2000 | 0 |
             jj_consume_token(THIS);
2001 | 0 |
             Arguments();
2002 | 0 |
             jj_consume_token(SEMICOLON);
2003 |  |
           } else {
2004 | 0 |
             switch (jj_nt.kind) {
2005 |  |
             case BOOLEAN:
2006 |  |
             case BYTE:
2007 |  |
             case CHAR:
2008 |  |
             case DOUBLE:
2009 |  |
             case FALSE:
2010 |  |
             case FLOAT:
2011 |  |
             case INT:
2012 |  |
             case LONG:
2013 |  |
             case NEW:
2014 |  |
             case NULL:
2015 |  |
             case SHORT:
2016 |  |
             case SUPER:
2017 |  |
             case THIS:
2018 |  |
             case TRUE:
2019 |  |
             case VOID:
2020 |  |
             case INTEGER_LITERAL:
2021 |  |
             case FLOATING_POINT_LITERAL:
2022 |  |
             case CHARACTER_LITERAL:
2023 |  |
             case STRING_LITERAL:
2024 |  |
             case IDENTIFIER:
2025 |  |
             case LPAREN:
2026 | 0 |
               if (jj_2_12(2)) {
2027 | 0 |
                 PrimaryExpression();
2028 | 0 |
                 jj_consume_token(DOT);
2029 |  |
               } else {
2030 |  |
                 ;
2031 |  |
               }
2032 | 0 |
               jj_consume_token(SUPER);
2033 | 0 |
               Arguments();
2034 | 0 |
               jj_consume_token(SEMICOLON);
2035 | 0 |
               break;
2036 |  |
             default:
2037 | 0 |
               jj_la1[45] = jj_gen;
2038 | 0 |
               jj_consume_token(-1);
2039 | 0 |
               throw new ParseException();
2040 |  |
             }
2041 |  |
           }
2042 |  |
         } catch (Throwable jjte000) {
2043 | 0 |
         if (jjtc000) {
2044 | 0 |
           jjtree.clearNodeScope(jjtn000);
2045 | 0 |
           jjtc000 = false;
2046 |  |
         } else {
2047 | 0 |
           jjtree.popNode();
2048 |  |
         }
2049 | 0 |
         if (jjte000 instanceof RuntimeException) {
2050 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2051 |  |
         }
2052 | 0 |
         if (jjte000 instanceof ParseException) {
2053 | 0 |
           {if (true) throw (ParseException)jjte000;}
2054 |  |
         }
2055 | 0 |
         {if (true) throw (Error)jjte000;}
2056 |  |
         } finally {
2057 | 0 |
         if (jjtc000) {
2058 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
2059 |  |
         }
2060 |  |
         }
2061 |  |
       }
2062 |  |
2063 | 4 |
       final public void Initializer() throws ParseException {
2064 |  |
      /*@bgen(jjtree) Initializer */
2065 | 4 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTINITIALIZER);
2066 | 4 |
       boolean jjtc000 = true;
2067 | 4 |
       jjtree.openNodeScope(jjtn000);
2068 | 4 |
         try {
2069 | 4 |
           switch (jj_nt.kind) {
2070 |  |
           case STATIC:
2071 | 4 |
             jj_consume_token(STATIC);
2072 | 4 |
             break;
2073 |  |
           default:
2074 | 0 |
             jj_la1[46] = jj_gen;
2075 |  |
             ;
2076 |  |
           }
2077 | 4 |
           Block();
2078 |  |
         } catch (Throwable jjte000) {
2079 | 0 |
         if (jjtc000) {
2080 | 0 |
           jjtree.clearNodeScope(jjtn000);
2081 | 0 |
           jjtc000 = false;
2082 |  |
         } else {
2083 | 0 |
           jjtree.popNode();
2084 |  |
         }
2085 | 0 |
         if (jjte000 instanceof RuntimeException) {
2086 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2087 |  |
         }
2088 | 0 |
         if (jjte000 instanceof ParseException) {
2089 | 0 |
           {if (true) throw (ParseException)jjte000;}
2090 |  |
         }
2091 | 0 |
         {if (true) throw (Error)jjte000;}
2092 |  |
         } finally {
2093 | 4 |
         if (jjtc000) {
2094 | 4 |
           jjtree.closeNodeScope(jjtn000, true);
2095 |  |
         }
2096 |  |
         }
2097 |  |
       }
2098 |  |
2099 |  |
     /*
2100 |  |
      * Type, name and expression syntax follows.
2101 |  |
      */
2102 | 48 |
       final public void Field_Type(FieldImpl fieldImpl) throws ParseException {
2103 |  |
      /*@bgen(jjtree) Field_Type */
2104 | 48 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTFIELD_TYPE);
2105 | 48 |
        boolean jjtc000 = true;
2106 | 48 |
        jjtree.openNodeScope(jjtn000);Token typeToken;
2107 | 48 |
        String type;
2108 | 48 |
         try {
2109 | 48 |
           switch (jj_nt.kind) {
2110 |  |
           case BOOLEAN:
2111 |  |
           case BYTE:
2112 |  |
           case CHAR:
2113 |  |
           case DOUBLE:
2114 |  |
           case FLOAT:
2115 |  |
           case INT:
2116 |  |
           case LONG:
2117 |  |
           case SHORT:
2118 | 0 |
             typeToken = PrimitiveType();
2119 | 0 |
           if( fieldImpl != null ) {
2120 | 0 |
             fieldImpl.setType(typeToken.image);
2121 | 0 |
             setToken( fieldImpl, typeToken );
2122 |  |
           }
2123 | 0 |
             break;
2124 |  |
           case IDENTIFIER:
2125 | 48 |
             type = Name();
2126 | 48 |
           if( fieldImpl != null ) {
2127 | 48 |
             fieldImpl.setType(type);
2128 | 48 |
             setToken( fieldImpl, _nameToken );
2129 |  |
           }
2130 | 48 |
             break;
2131 |  |
           default:
2132 | 0 |
             jj_la1[47] = jj_gen;
2133 | 0 |
             jj_consume_token(-1);
2134 | 0 |
             throw new ParseException();
2135 |  |
           }
2136 | 48 |
           label_20:
2137 |  |
           while (true) {
2138 | 48 |
             switch (jj_nt.kind) {
2139 |  |
             case LBRACKET:
2140 |  |
               ;
2141 | 0 |
               break;
2142 |  |
             default:
2143 | 48 |
               jj_la1[48] = jj_gen;
2144 | 48 |
               break label_20;
2145 |  |
             }
2146 | 0 |
             jj_consume_token(LBRACKET);
2147 | 0 |
             jj_consume_token(RBRACKET);
2148 | 0 |
          if( fieldImpl != null ) {
2149 | 0 |
             fieldImpl.setDimension(fieldImpl.getDimension() + 1);
2150 |  |
          }
2151 |  |
           }
2152 |  |
         } catch (Throwable jjte000) {
2153 | 0 |
         if (jjtc000) {
2154 | 0 |
           jjtree.clearNodeScope(jjtn000);
2155 | 0 |
           jjtc000 = false;
2156 |  |
         } else {
2157 | 0 |
           jjtree.popNode();
2158 |  |
         }
2159 | 0 |
         if (jjte000 instanceof RuntimeException) {
2160 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2161 |  |
         }
2162 | 0 |
         if (jjte000 instanceof ParseException) {
2163 | 0 |
           {if (true) throw (ParseException)jjte000;}
2164 |  |
         }
2165 | 0 |
         {if (true) throw (Error)jjte000;}
2166 |  |
         } finally {
2167 | 48 |
         if (jjtc000) {
2168 | 48 |
           jjtree.closeNodeScope(jjtn000, true);
2169 |  |
         }
2170 |  |
         }
2171 |  |
       }
2172 |  |
2173 | 32 |
       final public void MethodResult_Type(MethodImpl methodImpl) throws ParseException {
2174 |  |
      /*@bgen(jjtree) MethodResult_Type */
2175 | 32 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTMETHODRESULT_TYPE);
2176 | 32 |
        boolean jjtc000 = true;
2177 | 32 |
        jjtree.openNodeScope(jjtn000);Token typeToken;
2178 | 32 |
        String type;
2179 | 32 |
         try {
2180 | 32 |
           switch (jj_nt.kind) {
2181 |  |
           case BOOLEAN:
2182 |  |
           case BYTE:
2183 |  |
           case CHAR:
2184 |  |
           case DOUBLE:
2185 |  |
           case FLOAT:
2186 |  |
           case INT:
2187 |  |
           case LONG:
2188 |  |
           case SHORT:
2189 | 4 |
             typeToken = PrimitiveType();
2190 | 4 |
           if( methodImpl != null ) {
2191 | 0 |
             methodImpl.setReturnType(typeToken.image);
2192 | 0 |
             setToken( methodImpl, typeToken );
2193 |  |
           }
2194 | 4 |
             break;
2195 |  |
           case IDENTIFIER:
2196 | 28 |
             type = Name();
2197 | 28 |
           if( methodImpl != null ) {
2198 | 24 |
             methodImpl.setReturnType(type);
2199 | 24 |
             setToken( methodImpl, _nameToken );
2200 |  |
           }
2201 | 28 |
             break;
2202 |  |
           default:
2203 | 0 |
             jj_la1[49] = jj_gen;
2204 | 0 |
             jj_consume_token(-1);
2205 | 0 |
             throw new ParseException();
2206 |  |
           }
2207 | 32 |
           label_21:
2208 |  |
           while (true) {
2209 | 40 |
             switch (jj_nt.kind) {
2210 |  |
             case LBRACKET:
2211 |  |
               ;
2212 | 8 |
               break;
2213 |  |
             default:
2214 | 32 |
               jj_la1[50] = jj_gen;
2215 | 32 |
               break label_21;
2216 |  |
             }
2217 | 8 |
             jj_consume_token(LBRACKET);
2218 | 8 |
             jj_consume_token(RBRACKET);
2219 | 8 |
          if( methodImpl != null ) {
2220 | 0 |
             methodImpl.setReturnDimension(methodImpl.getReturnType().getDimension() + 1);
2221 |  |
          }
2222 |  |
           }
2223 |  |
         } catch (Throwable jjte000) {
2224 | 0 |
         if (jjtc000) {
2225 | 0 |
           jjtree.clearNodeScope(jjtn000);
2226 | 0 |
           jjtc000 = false;
2227 |  |
         } else {
2228 | 0 |
           jjtree.popNode();
2229 |  |
         }
2230 | 0 |
         if (jjte000 instanceof RuntimeException) {
2231 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2232 |  |
         }
2233 | 0 |
         if (jjte000 instanceof ParseException) {
2234 | 0 |
           {if (true) throw (ParseException)jjte000;}
2235 |  |
         }
2236 | 0 |
         {if (true) throw (Error)jjte000;}
2237 |  |
         } finally {
2238 | 32 |
         if (jjtc000) {
2239 | 32 |
           jjtree.closeNodeScope(jjtn000, true);
2240 |  |
         }
2241 |  |
         }
2242 |  |
       }
2243 |  |
2244 | 56 |
       final public void Parameter_Type() throws ParseException {
2245 |  |
      /*@bgen(jjtree) Parameter_Type */
2246 | 56 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTPARAMETER_TYPE);
2247 | 56 |
        boolean jjtc000 = true;
2248 | 56 |
        jjtree.openNodeScope(jjtn000);Token primitive;
2249 | 56 |
        String name;
2250 | 56 |
         try {
2251 | 56 |
           switch (jj_nt.kind) {
2252 |  |
           case BOOLEAN:
2253 |  |
           case BYTE:
2254 |  |
           case CHAR:
2255 |  |
           case DOUBLE:
2256 |  |
           case FLOAT:
2257 |  |
           case INT:
2258 |  |
           case LONG:
2259 |  |
           case SHORT:
2260 | 16 |
             primitive = PrimitiveType();
2261 | 16 |
            _parameter.type = primitive.image;
2262 | 16 |
             break;
2263 |  |
           case IDENTIFIER:
2264 | 40 |
             name = Name();
2265 | 40 |
            _parameter.type = name;
2266 | 40 |
             break;
2267 |  |
           default:
2268 | 0 |
             jj_la1[51] = jj_gen;
2269 | 0 |
             jj_consume_token(-1);
2270 | 0 |
             throw new ParseException();
2271 |  |
           }
2272 | 56 |
           label_22:
2273 |  |
           while (true) {
2274 | 72 |
             switch (jj_nt.kind) {
2275 |  |
             case LBRACKET:
2276 |  |
               ;
2277 | 16 |
               break;
2278 |  |
             default:
2279 | 56 |
               jj_la1[52] = jj_gen;
2280 | 56 |
               break label_22;
2281 |  |
             }
2282 | 16 |
             jj_consume_token(LBRACKET);
2283 | 16 |
             jj_consume_token(RBRACKET);
2284 | 16 |
                   _parameter.dimension++;
2285 |  |
           }
2286 |  |
         } catch (Throwable jjte000) {
2287 | 0 |
         if (jjtc000) {
2288 | 0 |
           jjtree.clearNodeScope(jjtn000);
2289 | 0 |
           jjtc000 = false;
2290 |  |
         } else {
2291 | 0 |
           jjtree.popNode();
2292 |  |
         }
2293 | 0 |
         if (jjte000 instanceof RuntimeException) {
2294 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2295 |  |
         }
2296 | 0 |
         if (jjte000 instanceof ParseException) {
2297 | 0 |
           {if (true) throw (ParseException)jjte000;}
2298 |  |
         }
2299 | 0 |
         {if (true) throw (Error)jjte000;}
2300 |  |
         } finally {
2301 | 56 |
         if (jjtc000) {
2302 | 56 |
           jjtree.closeNodeScope(jjtn000, true);
2303 |  |
         }
2304 |  |
         }
2305 |  |
       }
2306 |  |
2307 | 66 |
       final public void Type() throws ParseException {
2308 |  |
      /*@bgen(jjtree) Type */
2309 | 66 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTTYPE);
2310 | 66 |
       boolean jjtc000 = true;
2311 | 66 |
       jjtree.openNodeScope(jjtn000);
2312 | 66 |
         try {
2313 | 66 |
           switch (jj_nt.kind) {
2314 |  |
           case BOOLEAN:
2315 |  |
           case BYTE:
2316 |  |
           case CHAR:
2317 |  |
           case DOUBLE:
2318 |  |
           case FLOAT:
2319 |  |
           case INT:
2320 |  |
           case LONG:
2321 |  |
           case SHORT:
2322 | 34 |
             PrimitiveType();
2323 | 34 |
             break;
2324 |  |
           case IDENTIFIER:
2325 | 32 |
             Name();
2326 | 32 |
             break;
2327 |  |
           default:
2328 | 0 |
             jj_la1[53] = jj_gen;
2329 | 0 |
             jj_consume_token(-1);
2330 | 0 |
             throw new ParseException();
2331 |  |
           }
2332 | 66 |
           label_23:
2333 |  |
           while (true) {
2334 | 66 |
             switch (jj_nt.kind) {
2335 |  |
             case LBRACKET:
2336 |  |
               ;
2337 | 0 |
               break;
2338 |  |
             default:
2339 | 66 |
               jj_la1[54] = jj_gen;
2340 | 66 |
               break label_23;
2341 |  |
             }
2342 | 0 |
             jj_consume_token(LBRACKET);
2343 | 0 |
             jj_consume_token(RBRACKET);
2344 |  |
           }
2345 |  |
         } catch (Throwable jjte000) {
2346 | 0 |
         if (jjtc000) {
2347 | 0 |
           jjtree.clearNodeScope(jjtn000);
2348 | 0 |
           jjtc000 = false;
2349 |  |
         } else {
2350 | 0 |
           jjtree.popNode();
2351 |  |
         }
2352 | 0 |
         if (jjte000 instanceof RuntimeException) {
2353 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2354 |  |
         }
2355 | 0 |
         if (jjte000 instanceof ParseException) {
2356 | 0 |
           {if (true) throw (ParseException)jjte000;}
2357 |  |
         }
2358 | 0 |
         {if (true) throw (Error)jjte000;}
2359 |  |
         } finally {
2360 | 66 |
         if (jjtc000) {
2361 | 66 |
           jjtree.closeNodeScope(jjtn000, true);
2362 |  |
         }
2363 |  |
         }
2364 |  |
       }
2365 |  |
2366 | 54 |
       final public Token PrimitiveType() throws ParseException {
2367 |  |
      /*@bgen(jjtree) PrimitiveType */
2368 | 54 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTPRIMITIVETYPE);
2369 | 54 |
        boolean jjtc000 = true;
2370 | 54 |
        jjtree.openNodeScope(jjtn000);Token t = null;
2371 | 54 |
         try {
2372 | 54 |
           switch (jj_nt.kind) {
2373 |  |
           case BOOLEAN:
2374 | 0 |
             t = jj_consume_token(BOOLEAN);
2375 | 0 |
                     jjtree.closeNodeScope(jjtn000, true);
2376 | 0 |
                     jjtc000 = false;
2377 | 0 |
                     {if (true) return t;}
2378 | 0 |
             break;
2379 |  |
           case CHAR:
2380 | 0 |
             t = jj_consume_token(CHAR);
2381 | 0 |
                  jjtree.closeNodeScope(jjtn000, true);
2382 | 0 |
                  jjtc000 = false;
2383 | 0 |
                  {if (true) return t;}
2384 | 0 |
             break;
2385 |  |
           case BYTE:
2386 | 0 |
             t = jj_consume_token(BYTE);
2387 | 0 |
                  jjtree.closeNodeScope(jjtn000, true);
2388 | 0 |
                  jjtc000 = false;
2389 | 0 |
                  {if (true) return t;}
2390 | 0 |
             break;
2391 |  |
           case SHORT:
2392 | 0 |
             t = jj_consume_token(SHORT);
2393 | 0 |
                   jjtree.closeNodeScope(jjtn000, true);
2394 | 0 |
                   jjtc000 = false;
2395 | 0 |
                   {if (true) return t;}
2396 | 0 |
             break;
2397 |  |
           case INT:
2398 | 54 |
             t = jj_consume_token(INT);
2399 | 54 |
                 jjtree.closeNodeScope(jjtn000, true);
2400 | 54 |
                 jjtc000 = false;
2401 | 54 |
                 {if (true) return t;}
2402 | 0 |
             break;
2403 |  |
           case LONG:
2404 | 0 |
             t = jj_consume_token(LONG);
2405 | 0 |
                  jjtree.closeNodeScope(jjtn000, true);
2406 | 0 |
                  jjtc000 = false;
2407 | 0 |
                  {if (true) return t;}
2408 | 0 |
             break;
2409 |  |
           case FLOAT:
2410 | 0 |
             t = jj_consume_token(FLOAT);
2411 | 0 |
                   jjtree.closeNodeScope(jjtn000, true);
2412 | 0 |
                   jjtc000 = false;
2413 | 0 |
                   {if (true) return t;}
2414 | 0 |
             break;
2415 |  |
           case DOUBLE:
2416 | 0 |
             t = jj_consume_token(DOUBLE);
2417 | 0 |
                    jjtree.closeNodeScope(jjtn000, true);
2418 | 0 |
                    jjtc000 = false;
2419 | 0 |
                    {if (true) return t;}
2420 | 0 |
             break;
2421 |  |
           default:
2422 | 0 |
             jj_la1[55] = jj_gen;
2423 | 0 |
             jj_consume_token(-1);
2424 | 0 |
             throw new ParseException();
2425 |  |
           }
2426 |  |
         } finally {
2427 | 54 |
         if (jjtc000) {
2428 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
2429 |  |
         }
2430 |  |
         }
2431 | 0 |
         throw new Error("Missing return statement in function");
2432 |  |
       }
2433 |  |
2434 | 84 |
       final public void ResultType(MethodImpl methodImpl) throws ParseException {
2435 |  |
      /*@bgen(jjtree) ResultType */
2436 | 84 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTRESULTTYPE);
2437 | 84 |
        boolean jjtc000 = true;
2438 | 84 |
        jjtree.openNodeScope(jjtn000);Token t = null;
2439 | 84 |
         try {
2440 | 84 |
           switch (jj_nt.kind) {
2441 |  |
           case VOID:
2442 | 52 |
             t = jj_consume_token(VOID);
2443 | 52 |
                  jjtree.closeNodeScope(jjtn000, true);
2444 | 52 |
                  jjtc000 = false;
2445 | 52 |
          if( methodImpl != null ) {
2446 | 52 |
             methodImpl.setReturnType( "void" );
2447 | 52 |
             methodImpl.setReturnDimension( 0 );
2448 | 52 |
             setToken( methodImpl, t );
2449 |  |
          }
2450 | 52 |
             break;
2451 |  |
           case BOOLEAN:
2452 |  |
           case BYTE:
2453 |  |
           case CHAR:
2454 |  |
           case DOUBLE:
2455 |  |
           case FLOAT:
2456 |  |
           case INT:
2457 |  |
           case LONG:
2458 |  |
           case SHORT:
2459 |  |
           case IDENTIFIER:
2460 | 32 |
             MethodResult_Type(methodImpl);
2461 | 32 |
             break;
2462 |  |
           default:
2463 | 0 |
             jj_la1[56] = jj_gen;
2464 | 0 |
             jj_consume_token(-1);
2465 | 0 |
             throw new ParseException();
2466 |  |
           }
2467 |  |
         } catch (Throwable jjte000) {
2468 | 0 |
         if (jjtc000) {
2469 | 0 |
           jjtree.clearNodeScope(jjtn000);
2470 | 0 |
           jjtc000 = false;
2471 |  |
         } else {
2472 | 0 |
           jjtree.popNode();
2473 |  |
         }
2474 | 0 |
         if (jjte000 instanceof RuntimeException) {
2475 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2476 |  |
         }
2477 | 0 |
         if (jjte000 instanceof ParseException) {
2478 | 0 |
           {if (true) throw (ParseException)jjte000;}
2479 |  |
         }
2480 | 0 |
         {if (true) throw (Error)jjte000;}
2481 |  |
         } finally {
2482 | 84 |
         if (jjtc000) {
2483 | 32 |
           jjtree.closeNodeScope(jjtn000, true);
2484 |  |
         }
2485 |  |
         }
2486 |  |
       }
2487 |  |
2488 | 264 |
       final public String Name() throws ParseException {
2489 |  |
      /*@bgen(jjtree) Name */
2490 | 264 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTNAME);
2491 | 264 |
        boolean jjtc000 = true;
2492 | 264 |
        jjtree.openNodeScope(jjtn000);// reset the buffer
2493 | 264 |
        clearNameBuffer();
2494 | 264 |
        Token t = null;
2495 | 264 |
         try {
2496 | 264 |
           _nameToken = jj_consume_token(IDENTIFIER);
2497 | 264 |
          _nameBuffer.append(_nameToken.image);
2498 | 264 |
           label_24:
2499 |  |
           while (true) {
2500 | 372 |
             if (jj_2_14(2)) {
2501 |  |
               ;
2502 |  |
             } else {
2503 | 264 |
               break label_24;
2504 |  |
             }
2505 | 108 |
             jj_consume_token(DOT);
2506 | 108 |
             t = jj_consume_token(IDENTIFIER);
2507 | 108 |
          _nameBuffer.append(".").append(t.image);
2508 |  |
           }
2509 | 264 |
         jjtree.closeNodeScope(jjtn000, true);
2510 | 264 |
         jjtc000 = false;
2511 | 264 |
          {if (true) return _nameBuffer.toString();}
2512 |  |
         } finally {
2513 | 264 |
         if (jjtc000) {
2514 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
2515 |  |
         }
2516 |  |
         }
2517 | 0 |
         throw new Error("Missing return statement in function");
2518 |  |
       }
2519 |  |
2520 | 0 |
       final public void ExecutableMemberThrows_Name(AbstractExecutableMember member) throws ParseException {
2521 |  |
      /*@bgen(jjtree) ExecutableMemberThrows_Name */
2522 | 0 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTEXECUTABLEMEMBERTHROWS_NAME);
2523 | 0 |
        boolean jjtc000 = true;
2524 | 0 |
        jjtree.openNodeScope(jjtn000);// reset the buffer
2525 | 0 |
        clearNameBuffer();
2526 | 0 |
        Token t = null;
2527 | 0 |
         try {
2528 | 0 |
           t = jj_consume_token(IDENTIFIER);
2529 | 0 |
          _nameBuffer.append(t.image);
2530 | 0 |
           label_25:
2531 |  |
           while (true) {
2532 | 0 |
             switch (jj_nt.kind) {
2533 |  |
             case DOT:
2534 |  |
               ;
2535 | 0 |
               break;
2536 |  |
             default:
2537 | 0 |
               jj_la1[57] = jj_gen;
2538 | 0 |
               break label_25;
2539 |  |
             }
2540 | 0 |
             jj_consume_token(DOT);
2541 | 0 |
             t = jj_consume_token(IDENTIFIER);
2542 | 0 |
          _nameBuffer.append(".").append(t.image);
2543 |  |
           }
2544 | 0 |
         jjtree.closeNodeScope(jjtn000, true);
2545 | 0 |
         jjtc000 = false;
2546 | 0 |
          if( member != null ) {
2547 | 0 |
             member.addThrownException( _nameBuffer.toString() );
2548 |  |
          }
2549 |  |
         } finally {
2550 | 0 |
         if (jjtc000) {
2551 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
2552 |  |
         }
2553 |  |
         }
2554 |  |
       }
2555 |  |
2556 | 28 |
       final public void Interfaces_Name() throws ParseException {
2557 |  |
      /*@bgen(jjtree) Interfaces_Name */
2558 | 28 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTINTERFACES_NAME);
2559 | 28 |
        boolean jjtc000 = true;
2560 | 28 |
        jjtree.openNodeScope(jjtn000);SourceClass sourceClass = currentClass();
2561 |  |
2562 |  |
        // reset the buffer
2563 | 28 |
        clearNameBuffer();
2564 | 28 |
        Token t = null;
2565 | 28 |
         try {
2566 | 28 |
           t = jj_consume_token(IDENTIFIER);
2567 | 28 |
          _nameBuffer.append(t.image);
2568 | 28 |
           label_26:
2569 |  |
           while (true) {
2570 | 56 |
             switch (jj_nt.kind) {
2571 |  |
             case DOT:
2572 |  |
               ;
2573 | 28 |
               break;
2574 |  |
             default:
2575 | 28 |
               jj_la1[58] = jj_gen;
2576 | 28 |
               break label_26;
2577 |  |
             }
2578 | 28 |
             jj_consume_token(DOT);
2579 | 28 |
             t = jj_consume_token(IDENTIFIER);
2580 | 28 |
          _nameBuffer.append(".").append(t.image);
2581 |  |
           }
2582 | 28 |
         jjtree.closeNodeScope(jjtn000, true);
2583 | 28 |
         jjtc000 = false;
2584 | 28 |
          sourceClass.addInterface( _nameBuffer.toString() );
2585 |  |
         } finally {
2586 | 28 |
         if (jjtc000) {
2587 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
2588 |  |
         }
2589 |  |
         }
2590 |  |
       }
2591 |  |
2592 | 0 |
       final public void NameList() throws ParseException {
2593 |  |
      /*@bgen(jjtree) NameList */
2594 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTNAMELIST);
2595 | 0 |
       boolean jjtc000 = true;
2596 | 0 |
       jjtree.openNodeScope(jjtn000);
2597 | 0 |
         try {
2598 | 0 |
           Name();
2599 | 0 |
           label_27:
2600 |  |
           while (true) {
2601 | 0 |
             switch (jj_nt.kind) {
2602 |  |
             case COMMA:
2603 |  |
               ;
2604 | 0 |
               break;
2605 |  |
             default:
2606 | 0 |
               jj_la1[59] = jj_gen;
2607 | 0 |
               break label_27;
2608 |  |
             }
2609 | 0 |
             jj_consume_token(COMMA);
2610 | 0 |
             Name();
2611 |  |
           }
2612 |  |
         } catch (Throwable jjte000) {
2613 | 0 |
         if (jjtc000) {
2614 | 0 |
           jjtree.clearNodeScope(jjtn000);
2615 | 0 |
           jjtc000 = false;
2616 |  |
         } else {
2617 | 0 |
           jjtree.popNode();
2618 |  |
         }
2619 | 0 |
         if (jjte000 instanceof RuntimeException) {
2620 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2621 |  |
         }
2622 | 0 |
         if (jjte000 instanceof ParseException) {
2623 | 0 |
           {if (true) throw (ParseException)jjte000;}
2624 |  |
         }
2625 | 0 |
         {if (true) throw (Error)jjte000;}
2626 |  |
         } finally {
2627 | 0 |
         if (jjtc000) {
2628 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
2629 |  |
         }
2630 |  |
         }
2631 |  |
       }
2632 |  |
2633 | 0 |
       final public void ExecutableMemberThrows_NameList(AbstractExecutableMember member) throws ParseException {
2634 |  |
      /*@bgen(jjtree) ExecutableMemberThrows_NameList */
2635 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTEXECUTABLEMEMBERTHROWS_NAMELIST);
2636 | 0 |
       boolean jjtc000 = true;
2637 | 0 |
       jjtree.openNodeScope(jjtn000);
2638 | 0 |
         try {
2639 | 0 |
           ExecutableMemberThrows_Name(member);
2640 | 0 |
           label_28:
2641 |  |
           while (true) {
2642 | 0 |
             switch (jj_nt.kind) {
2643 |  |
             case COMMA:
2644 |  |
               ;
2645 | 0 |
               break;
2646 |  |
             default:
2647 | 0 |
               jj_la1[60] = jj_gen;
2648 | 0 |
               break label_28;
2649 |  |
             }
2650 | 0 |
             jj_consume_token(COMMA);
2651 | 0 |
             ExecutableMemberThrows_Name(member);
2652 |  |
           }
2653 |  |
         } catch (Throwable jjte000) {
2654 | 0 |
         if (jjtc000) {
2655 | 0 |
           jjtree.clearNodeScope(jjtn000);
2656 | 0 |
           jjtc000 = false;
2657 |  |
         } else {
2658 | 0 |
           jjtree.popNode();
2659 |  |
         }
2660 | 0 |
         if (jjte000 instanceof RuntimeException) {
2661 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2662 |  |
         }
2663 | 0 |
         if (jjte000 instanceof ParseException) {
2664 | 0 |
           {if (true) throw (ParseException)jjte000;}
2665 |  |
         }
2666 | 0 |
         {if (true) throw (Error)jjte000;}
2667 |  |
         } finally {
2668 | 0 |
         if (jjtc000) {
2669 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
2670 |  |
         }
2671 |  |
         }
2672 |  |
       }
2673 |  |
2674 | 12 |
       final public void Interfaces_NameList() throws ParseException {
2675 |  |
      /*@bgen(jjtree) Interfaces_NameList */
2676 | 12 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTINTERFACES_NAMELIST);
2677 | 12 |
       boolean jjtc000 = true;
2678 | 12 |
       jjtree.openNodeScope(jjtn000);
2679 | 12 |
         try {
2680 | 12 |
           Interfaces_Name();
2681 | 12 |
           label_29:
2682 |  |
           while (true) {
2683 | 28 |
             switch (jj_nt.kind) {
2684 |  |
             case COMMA:
2685 |  |
               ;
2686 | 16 |
               break;
2687 |  |
             default:
2688 | 12 |
               jj_la1[61] = jj_gen;
2689 | 12 |
               break label_29;
2690 |  |
             }
2691 | 16 |
             jj_consume_token(COMMA);
2692 | 16 |
             Interfaces_Name();
2693 |  |
           }
2694 |  |
         } catch (Throwable jjte000) {
2695 | 0 |
         if (jjtc000) {
2696 | 0 |
           jjtree.clearNodeScope(jjtn000);
2697 | 0 |
           jjtc000 = false;
2698 |  |
         } else {
2699 | 0 |
           jjtree.popNode();
2700 |  |
         }
2701 | 0 |
         if (jjte000 instanceof RuntimeException) {
2702 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2703 |  |
         }
2704 | 0 |
         if (jjte000 instanceof ParseException) {
2705 | 0 |
           {if (true) throw (ParseException)jjte000;}
2706 |  |
         }
2707 | 0 |
         {if (true) throw (Error)jjte000;}
2708 |  |
         } finally {
2709 | 12 |
         if (jjtc000) {
2710 | 12 |
           jjtree.closeNodeScope(jjtn000, true);
2711 |  |
         }
2712 |  |
         }
2713 |  |
       }
2714 |  |
2715 |  |
     /*
2716 |  |
      * Expression syntax follows.
2717 |  |
      */
2718 | 138 |
       final public void Expression() throws ParseException {
2719 |  |
      /*@bgen(jjtree) Expression */
2720 | 138 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTEXPRESSION);
2721 | 138 |
       boolean jjtc000 = true;
2722 | 138 |
       jjtree.openNodeScope(jjtn000);
2723 | 138 |
         try {
2724 | 138 |
           ConditionalExpression();
2725 | 138 |
           switch (jj_nt.kind) {
2726 |  |
           case ASSIGN:
2727 |  |
           case PLUSASSIGN:
2728 |  |
           case MINUSASSIGN:
2729 |  |
           case STARASSIGN:
2730 |  |
           case SLASHASSIGN:
2731 |  |
           case ANDASSIGN:
2732 |  |
           case ORASSIGN:
2733 |  |
           case XORASSIGN:
2734 |  |
           case REMASSIGN:
2735 |  |
           case LSHIFTASSIGN:
2736 |  |
           case RSIGNEDSHIFTASSIGN:
2737 |  |
           case RUNSIGNEDSHIFTASSIGN:
2738 | 0 |
             AssignmentOperator();
2739 | 0 |
             Expression();
2740 | 0 |
             break;
2741 |  |
           default:
2742 | 138 |
             jj_la1[62] = jj_gen;
2743 |  |
             ;
2744 |  |
           }
2745 |  |
         } catch (Throwable jjte000) {
2746 | 0 |
         if (jjtc000) {
2747 | 0 |
           jjtree.clearNodeScope(jjtn000);
2748 | 0 |
           jjtc000 = false;
2749 |  |
         } else {
2750 | 0 |
           jjtree.popNode();
2751 |  |
         }
2752 | 0 |
         if (jjte000 instanceof RuntimeException) {
2753 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2754 |  |
         }
2755 | 0 |
         if (jjte000 instanceof ParseException) {
2756 | 0 |
           {if (true) throw (ParseException)jjte000;}
2757 |  |
         }
2758 | 0 |
         {if (true) throw (Error)jjte000;}
2759 |  |
         } finally {
2760 | 138 |
         if (jjtc000) {
2761 | 138 |
           jjtree.closeNodeScope(jjtn000, true);
2762 |  |
         }
2763 |  |
         }
2764 |  |
       }
2765 |  |
2766 | 0 |
       final public void AssignmentOperator() throws ParseException {
2767 |  |
      /*@bgen(jjtree) AssignmentOperator */
2768 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTASSIGNMENTOPERATOR);
2769 | 0 |
       boolean jjtc000 = true;
2770 | 0 |
       jjtree.openNodeScope(jjtn000);
2771 | 0 |
         try {
2772 | 0 |
           switch (jj_nt.kind) {
2773 |  |
           case ASSIGN:
2774 | 0 |
             jj_consume_token(ASSIGN);
2775 | 0 |
             break;
2776 |  |
           case STARASSIGN:
2777 | 0 |
             jj_consume_token(STARASSIGN);
2778 | 0 |
             break;
2779 |  |
           case SLASHASSIGN:
2780 | 0 |
             jj_consume_token(SLASHASSIGN);
2781 | 0 |
             break;
2782 |  |
           case REMASSIGN:
2783 | 0 |
             jj_consume_token(REMASSIGN);
2784 | 0 |
             break;
2785 |  |
           case PLUSASSIGN:
2786 | 0 |
             jj_consume_token(PLUSASSIGN);
2787 | 0 |
             break;
2788 |  |
           case MINUSASSIGN:
2789 | 0 |
             jj_consume_token(MINUSASSIGN);
2790 | 0 |
             break;
2791 |  |
           case LSHIFTASSIGN:
2792 | 0 |
             jj_consume_token(LSHIFTASSIGN);
2793 | 0 |
             break;
2794 |  |
           case RSIGNEDSHIFTASSIGN:
2795 | 0 |
             jj_consume_token(RSIGNEDSHIFTASSIGN);
2796 | 0 |
             break;
2797 |  |
           case RUNSIGNEDSHIFTASSIGN:
2798 | 0 |
             jj_consume_token(RUNSIGNEDSHIFTASSIGN);
2799 | 0 |
             break;
2800 |  |
           case ANDASSIGN:
2801 | 0 |
             jj_consume_token(ANDASSIGN);
2802 | 0 |
             break;
2803 |  |
           case XORASSIGN:
2804 | 0 |
             jj_consume_token(XORASSIGN);
2805 | 0 |
             break;
2806 |  |
           case ORASSIGN:
2807 | 0 |
             jj_consume_token(ORASSIGN);
2808 | 0 |
             break;
2809 |  |
           default:
2810 | 0 |
             jj_la1[63] = jj_gen;
2811 | 0 |
             jj_consume_token(-1);
2812 | 0 |
             throw new ParseException();
2813 |  |
           }
2814 |  |
         } finally {
2815 | 0 |
         if (jjtc000) {
2816 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
2817 |  |
         }
2818 |  |
         }
2819 |  |
       }
2820 |  |
2821 | 138 |
       final public void ConditionalExpression() throws ParseException {
2822 |  |
      /*@bgen(jjtree) ConditionalExpression */
2823 | 138 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTCONDITIONALEXPRESSION);
2824 | 138 |
       boolean jjtc000 = true;
2825 | 138 |
       jjtree.openNodeScope(jjtn000);
2826 | 138 |
         try {
2827 | 138 |
           ConditionalOrExpression();
2828 | 138 |
           switch (jj_nt.kind) {
2829 |  |
           case HOOK:
2830 | 0 |
             jj_consume_token(HOOK);
2831 | 0 |
             Expression();
2832 | 0 |
             jj_consume_token(COLON);
2833 | 0 |
             ConditionalExpression();
2834 | 0 |
             break;
2835 |  |
           default:
2836 | 138 |
             jj_la1[64] = jj_gen;
2837 |  |
             ;
2838 |  |
           }
2839 |  |
         } catch (Throwable jjte000) {
2840 | 0 |
         if (jjtc000) {
2841 | 0 |
           jjtree.clearNodeScope(jjtn000);
2842 | 0 |
           jjtc000 = false;
2843 |  |
         } else {
2844 | 0 |
           jjtree.popNode();
2845 |  |
         }
2846 | 0 |
         if (jjte000 instanceof RuntimeException) {
2847 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2848 |  |
         }
2849 | 0 |
         if (jjte000 instanceof ParseException) {
2850 | 0 |
           {if (true) throw (ParseException)jjte000;}
2851 |  |
         }
2852 | 0 |
         {if (true) throw (Error)jjte000;}
2853 |  |
         } finally {
2854 | 138 |
         if (jjtc000) {
2855 | 138 |
           jjtree.closeNodeScope(jjtn000, true);
2856 |  |
         }
2857 |  |
         }
2858 |  |
       }
2859 |  |
2860 | 138 |
       final public void ConditionalOrExpression() throws ParseException {
2861 |  |
      /*@bgen(jjtree) ConditionalOrExpression */
2862 | 138 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTCONDITIONALOREXPRESSION);
2863 | 138 |
       boolean jjtc000 = true;
2864 | 138 |
       jjtree.openNodeScope(jjtn000);
2865 | 138 |
         try {
2866 | 138 |
           ConditionalAndExpression();
2867 | 138 |
           label_30:
2868 |  |
           while (true) {
2869 | 138 |
             switch (jj_nt.kind) {
2870 |  |
             case SC_OR:
2871 |  |
               ;
2872 | 0 |
               break;
2873 |  |
             default:
2874 | 138 |
               jj_la1[65] = jj_gen;
2875 | 138 |
               break label_30;
2876 |  |
             }
2877 | 0 |
             jj_consume_token(SC_OR);
2878 | 0 |
             ConditionalAndExpression();
2879 |  |
           }
2880 |  |
         } catch (Throwable jjte000) {
2881 | 0 |
         if (jjtc000) {
2882 | 0 |
           jjtree.clearNodeScope(jjtn000);
2883 | 0 |
           jjtc000 = false;
2884 |  |
         } else {
2885 | 0 |
           jjtree.popNode();
2886 |  |
         }
2887 | 0 |
         if (jjte000 instanceof RuntimeException) {
2888 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2889 |  |
         }
2890 | 0 |
         if (jjte000 instanceof ParseException) {
2891 | 0 |
           {if (true) throw (ParseException)jjte000;}
2892 |  |
         }
2893 | 0 |
         {if (true) throw (Error)jjte000;}
2894 |  |
         } finally {
2895 | 138 |
         if (jjtc000) {
2896 | 138 |
           jjtree.closeNodeScope(jjtn000, true);
2897 |  |
         }
2898 |  |
         }
2899 |  |
       }
2900 |  |
2901 | 138 |
       final public void ConditionalAndExpression() throws ParseException {
2902 |  |
      /*@bgen(jjtree) ConditionalAndExpression */
2903 | 138 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTCONDITIONALANDEXPRESSION);
2904 | 138 |
       boolean jjtc000 = true;
2905 | 138 |
       jjtree.openNodeScope(jjtn000);
2906 | 138 |
         try {
2907 | 138 |
           InclusiveOrExpression();
2908 | 138 |
           label_31:
2909 |  |
           while (true) {
2910 | 138 |
             switch (jj_nt.kind) {
2911 |  |
             case SC_AND:
2912 |  |
               ;
2913 | 0 |
               break;
2914 |  |
             default:
2915 | 138 |
               jj_la1[66] = jj_gen;
2916 | 138 |
               break label_31;
2917 |  |
             }
2918 | 0 |
             jj_consume_token(SC_AND);
2919 | 0 |
             InclusiveOrExpression();
2920 |  |
           }
2921 |  |
         } catch (Throwable jjte000) {
2922 | 0 |
         if (jjtc000) {
2923 | 0 |
           jjtree.clearNodeScope(jjtn000);
2924 | 0 |
           jjtc000 = false;
2925 |  |
         } else {
2926 | 0 |
           jjtree.popNode();
2927 |  |
         }
2928 | 0 |
         if (jjte000 instanceof RuntimeException) {
2929 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2930 |  |
         }
2931 | 0 |
         if (jjte000 instanceof ParseException) {
2932 | 0 |
           {if (true) throw (ParseException)jjte000;}
2933 |  |
         }
2934 | 0 |
         {if (true) throw (Error)jjte000;}
2935 |  |
         } finally {
2936 | 138 |
         if (jjtc000) {
2937 | 138 |
           jjtree.closeNodeScope(jjtn000, true);
2938 |  |
         }
2939 |  |
         }
2940 |  |
       }
2941 |  |
2942 | 138 |
       final public void InclusiveOrExpression() throws ParseException {
2943 |  |
      /*@bgen(jjtree) InclusiveOrExpression */
2944 | 138 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTINCLUSIVEOREXPRESSION);
2945 | 138 |
       boolean jjtc000 = true;
2946 | 138 |
       jjtree.openNodeScope(jjtn000);
2947 | 138 |
         try {
2948 | 138 |
           ExclusiveOrExpression();
2949 | 138 |
           label_32:
2950 |  |
           while (true) {
2951 | 138 |
             switch (jj_nt.kind) {
2952 |  |
             case BIT_OR:
2953 |  |
               ;
2954 | 0 |
               break;
2955 |  |
             default:
2956 | 138 |
               jj_la1[67] = jj_gen;
2957 | 138 |
               break label_32;
2958 |  |
             }
2959 | 0 |
             jj_consume_token(BIT_OR);
2960 | 0 |
             ExclusiveOrExpression();
2961 |  |
           }
2962 |  |
         } catch (Throwable jjte000) {
2963 | 0 |
         if (jjtc000) {
2964 | 0 |
           jjtree.clearNodeScope(jjtn000);
2965 | 0 |
           jjtc000 = false;
2966 |  |
         } else {
2967 | 0 |
           jjtree.popNode();
2968 |  |
         }
2969 | 0 |
         if (jjte000 instanceof RuntimeException) {
2970 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
2971 |  |
         }
2972 | 0 |
         if (jjte000 instanceof ParseException) {
2973 | 0 |
           {if (true) throw (ParseException)jjte000;}
2974 |  |
         }
2975 | 0 |
         {if (true) throw (Error)jjte000;}
2976 |  |
         } finally {
2977 | 138 |
         if (jjtc000) {
2978 | 138 |
           jjtree.closeNodeScope(jjtn000, true);
2979 |  |
         }
2980 |  |
         }
2981 |  |
       }
2982 |  |
2983 | 138 |
       final public void ExclusiveOrExpression() throws ParseException {
2984 |  |
      /*@bgen(jjtree) ExclusiveOrExpression */
2985 | 138 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTEXCLUSIVEOREXPRESSION);
2986 | 138 |
       boolean jjtc000 = true;
2987 | 138 |
       jjtree.openNodeScope(jjtn000);
2988 | 138 |
         try {
2989 | 138 |
           AndExpression();
2990 | 138 |
           label_33:
2991 |  |
           while (true) {
2992 | 138 |
             switch (jj_nt.kind) {
2993 |  |
             case XOR:
2994 |  |
               ;
2995 | 0 |
               break;
2996 |  |
             default:
2997 | 138 |
               jj_la1[68] = jj_gen;
2998 | 138 |
               break label_33;
2999 |  |
             }
3000 | 0 |
             jj_consume_token(XOR);
3001 | 0 |
             AndExpression();
3002 |  |
           }
3003 |  |
         } catch (Throwable jjte000) {
3004 | 0 |
         if (jjtc000) {
3005 | 0 |
           jjtree.clearNodeScope(jjtn000);
3006 | 0 |
           jjtc000 = false;
3007 |  |
         } else {
3008 | 0 |
           jjtree.popNode();
3009 |  |
         }
3010 | 0 |
         if (jjte000 instanceof RuntimeException) {
3011 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3012 |  |
         }
3013 | 0 |
         if (jjte000 instanceof ParseException) {
3014 | 0 |
           {if (true) throw (ParseException)jjte000;}
3015 |  |
         }
3016 | 0 |
         {if (true) throw (Error)jjte000;}
3017 |  |
         } finally {
3018 | 138 |
         if (jjtc000) {
3019 | 138 |
           jjtree.closeNodeScope(jjtn000, true);
3020 |  |
         }
3021 |  |
         }
3022 |  |
       }
3023 |  |
3024 | 138 |
       final public void AndExpression() throws ParseException {
3025 |  |
      /*@bgen(jjtree) AndExpression */
3026 | 138 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTANDEXPRESSION);
3027 | 138 |
       boolean jjtc000 = true;
3028 | 138 |
       jjtree.openNodeScope(jjtn000);
3029 | 138 |
         try {
3030 | 138 |
           EqualityExpression();
3031 | 138 |
           label_34:
3032 |  |
           while (true) {
3033 | 138 |
             switch (jj_nt.kind) {
3034 |  |
             case BIT_AND:
3035 |  |
               ;
3036 | 0 |
               break;
3037 |  |
             default:
3038 | 138 |
               jj_la1[69] = jj_gen;
3039 | 138 |
               break label_34;
3040 |  |
             }
3041 | 0 |
             jj_consume_token(BIT_AND);
3042 | 0 |
             EqualityExpression();
3043 |  |
           }
3044 |  |
         } catch (Throwable jjte000) {
3045 | 0 |
         if (jjtc000) {
3046 | 0 |
           jjtree.clearNodeScope(jjtn000);
3047 | 0 |
           jjtc000 = false;
3048 |  |
         } else {
3049 | 0 |
           jjtree.popNode();
3050 |  |
         }
3051 | 0 |
         if (jjte000 instanceof RuntimeException) {
3052 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3053 |  |
         }
3054 | 0 |
         if (jjte000 instanceof ParseException) {
3055 | 0 |
           {if (true) throw (ParseException)jjte000;}
3056 |  |
         }
3057 | 0 |
         {if (true) throw (Error)jjte000;}
3058 |  |
         } finally {
3059 | 138 |
         if (jjtc000) {
3060 | 138 |
           jjtree.closeNodeScope(jjtn000, true);
3061 |  |
         }
3062 |  |
         }
3063 |  |
       }
3064 |  |
3065 | 138 |
       final public void EqualityExpression() throws ParseException {
3066 |  |
      /*@bgen(jjtree) EqualityExpression */
3067 | 138 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTEQUALITYEXPRESSION);
3068 | 138 |
       boolean jjtc000 = true;
3069 | 138 |
       jjtree.openNodeScope(jjtn000);
3070 | 138 |
         try {
3071 | 138 |
           InstanceOfExpression();
3072 | 138 |
           label_35:
3073 |  |
           while (true) {
3074 | 138 |
             switch (jj_nt.kind) {
3075 |  |
             case EQ:
3076 |  |
             case NE:
3077 |  |
               ;
3078 | 0 |
               break;
3079 |  |
             default:
3080 | 138 |
               jj_la1[70] = jj_gen;
3081 | 138 |
               break label_35;
3082 |  |
             }
3083 | 0 |
             switch (jj_nt.kind) {
3084 |  |
             case EQ:
3085 | 0 |
               jj_consume_token(EQ);
3086 | 0 |
               break;
3087 |  |
             case NE:
3088 | 0 |
               jj_consume_token(NE);
3089 | 0 |
               break;
3090 |  |
             default:
3091 | 0 |
               jj_la1[71] = jj_gen;
3092 | 0 |
               jj_consume_token(-1);
3093 | 0 |
               throw new ParseException();
3094 |  |
             }
3095 | 0 |
             InstanceOfExpression();
3096 |  |
           }
3097 |  |
         } catch (Throwable jjte000) {
3098 | 0 |
         if (jjtc000) {
3099 | 0 |
           jjtree.clearNodeScope(jjtn000);
3100 | 0 |
           jjtc000 = false;
3101 |  |
         } else {
3102 | 0 |
           jjtree.popNode();
3103 |  |
         }
3104 | 0 |
         if (jjte000 instanceof RuntimeException) {
3105 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3106 |  |
         }
3107 | 0 |
         if (jjte000 instanceof ParseException) {
3108 | 0 |
           {if (true) throw (ParseException)jjte000;}
3109 |  |
         }
3110 | 0 |
         {if (true) throw (Error)jjte000;}
3111 |  |
         } finally {
3112 | 138 |
         if (jjtc000) {
3113 | 138 |
           jjtree.closeNodeScope(jjtn000, true);
3114 |  |
         }
3115 |  |
         }
3116 |  |
       }
3117 |  |
3118 | 138 |
       final public void InstanceOfExpression() throws ParseException {
3119 |  |
      /*@bgen(jjtree) InstanceOfExpression */
3120 | 138 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTINSTANCEOFEXPRESSION);
3121 | 138 |
       boolean jjtc000 = true;
3122 | 138 |
       jjtree.openNodeScope(jjtn000);
3123 | 138 |
         try {
3124 | 138 |
           RelationalExpression();
3125 | 138 |
           switch (jj_nt.kind) {
3126 |  |
           case INSTANCEOF:
3127 | 0 |
             jj_consume_token(INSTANCEOF);
3128 | 0 |
             Type();
3129 | 0 |
             break;
3130 |  |
           default:
3131 | 138 |
             jj_la1[72] = jj_gen;
3132 |  |
             ;
3133 |  |
           }
3134 |  |
         } catch (Throwable jjte000) {
3135 | 0 |
         if (jjtc000) {
3136 | 0 |
           jjtree.clearNodeScope(jjtn000);
3137 | 0 |
           jjtc000 = false;
3138 |  |
         } else {
3139 | 0 |
           jjtree.popNode();
3140 |  |
         }
3141 | 0 |
         if (jjte000 instanceof RuntimeException) {
3142 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3143 |  |
         }
3144 | 0 |
         if (jjte000 instanceof ParseException) {
3145 | 0 |
           {if (true) throw (ParseException)jjte000;}
3146 |  |
         }
3147 | 0 |
         {if (true) throw (Error)jjte000;}
3148 |  |
         } finally {
3149 | 138 |
         if (jjtc000) {
3150 | 138 |
           jjtree.closeNodeScope(jjtn000, true);
3151 |  |
         }
3152 |  |
         }
3153 |  |
       }
3154 |  |
3155 | 138 |
       final public void RelationalExpression() throws ParseException {
3156 |  |
      /*@bgen(jjtree) RelationalExpression */
3157 | 138 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTRELATIONALEXPRESSION);
3158 | 138 |
       boolean jjtc000 = true;
3159 | 138 |
       jjtree.openNodeScope(jjtn000);
3160 | 138 |
         try {
3161 | 138 |
           ShiftExpression();
3162 | 138 |
           label_36:
3163 |  |
           while (true) {
3164 | 138 |
             switch (jj_nt.kind) {
3165 |  |
             case GT:
3166 |  |
             case LT:
3167 |  |
             case LE:
3168 |  |
             case GE:
3169 |  |
               ;
3170 | 0 |
               break;
3171 |  |
             default:
3172 | 138 |
               jj_la1[73] = jj_gen;
3173 | 138 |
               break label_36;
3174 |  |
             }
3175 | 0 |
             switch (jj_nt.kind) {
3176 |  |
             case LT:
3177 | 0 |
               jj_consume_token(LT);
3178 | 0 |
               break;
3179 |  |
             case GT:
3180 | 0 |
               jj_consume_token(GT);
3181 | 0 |
               break;
3182 |  |
             case LE:
3183 | 0 |
               jj_consume_token(LE);
3184 | 0 |
               break;
3185 |  |
             case GE:
3186 | 0 |
               jj_consume_token(GE);
3187 | 0 |
               break;
3188 |  |
             default:
3189 | 0 |
               jj_la1[74] = jj_gen;
3190 | 0 |
               jj_consume_token(-1);
3191 | 0 |
               throw new ParseException();
3192 |  |
             }
3193 | 0 |
             ShiftExpression();
3194 |  |
           }
3195 |  |
         } catch (Throwable jjte000) {
3196 | 0 |
         if (jjtc000) {
3197 | 0 |
           jjtree.clearNodeScope(jjtn000);
3198 | 0 |
           jjtc000 = false;
3199 |  |
         } else {
3200 | 0 |
           jjtree.popNode();
3201 |  |
         }
3202 | 0 |
         if (jjte000 instanceof RuntimeException) {
3203 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3204 |  |
         }
3205 | 0 |
         if (jjte000 instanceof ParseException) {
3206 | 0 |
           {if (true) throw (ParseException)jjte000;}
3207 |  |
         }
3208 | 0 |
         {if (true) throw (Error)jjte000;}
3209 |  |
         } finally {
3210 | 138 |
         if (jjtc000) {
3211 | 138 |
           jjtree.closeNodeScope(jjtn000, true);
3212 |  |
         }
3213 |  |
         }
3214 |  |
       }
3215 |  |
3216 | 138 |
       final public void ShiftExpression() throws ParseException {
3217 |  |
      /*@bgen(jjtree) ShiftExpression */
3218 | 138 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTSHIFTEXPRESSION);
3219 | 138 |
       boolean jjtc000 = true;
3220 | 138 |
       jjtree.openNodeScope(jjtn000);
3221 | 138 |
         try {
3222 | 138 |
           AdditiveExpression();
3223 | 138 |
           label_37:
3224 |  |
           while (true) {
3225 | 138 |
             switch (jj_nt.kind) {
3226 |  |
             case LSHIFT:
3227 |  |
             case RSIGNEDSHIFT:
3228 |  |
             case RUNSIGNEDSHIFT:
3229 |  |
               ;
3230 | 0 |
               break;
3231 |  |
             default:
3232 | 138 |
               jj_la1[75] = jj_gen;
3233 | 138 |
               break label_37;
3234 |  |
             }
3235 | 0 |
             switch (jj_nt.kind) {
3236 |  |
             case LSHIFT:
3237 | 0 |
               jj_consume_token(LSHIFT);
3238 | 0 |
               break;
3239 |  |
             case RSIGNEDSHIFT:
3240 | 0 |
               jj_consume_token(RSIGNEDSHIFT);
3241 | 0 |
               break;
3242 |  |
             case RUNSIGNEDSHIFT:
3243 | 0 |
               jj_consume_token(RUNSIGNEDSHIFT);
3244 | 0 |
               break;
3245 |  |
             default:
3246 | 0 |
               jj_la1[76] = jj_gen;
3247 | 0 |
               jj_consume_token(-1);
3248 | 0 |
               throw new ParseException();
3249 |  |
             }
3250 | 0 |
             AdditiveExpression();
3251 |  |
           }
3252 |  |
         } catch (Throwable jjte000) {
3253 | 0 |
         if (jjtc000) {
3254 | 0 |
           jjtree.clearNodeScope(jjtn000);
3255 | 0 |
           jjtc000 = false;
3256 |  |
         } else {
3257 | 0 |
           jjtree.popNode();
3258 |  |
         }
3259 | 0 |
         if (jjte000 instanceof RuntimeException) {
3260 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3261 |  |
         }
3262 | 0 |
         if (jjte000 instanceof ParseException) {
3263 | 0 |
           {if (true) throw (ParseException)jjte000;}
3264 |  |
         }
3265 | 0 |
         {if (true) throw (Error)jjte000;}
3266 |  |
         } finally {
3267 | 138 |
         if (jjtc000) {
3268 | 138 |
           jjtree.closeNodeScope(jjtn000, true);
3269 |  |
         }
3270 |  |
         }
3271 |  |
       }
3272 |  |
3273 | 138 |
       final public void AdditiveExpression() throws ParseException {
3274 |  |
      /*@bgen(jjtree) AdditiveExpression */
3275 | 138 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTADDITIVEEXPRESSION);
3276 | 138 |
       boolean jjtc000 = true;
3277 | 138 |
       jjtree.openNodeScope(jjtn000);
3278 | 138 |
         try {
3279 | 138 |
           MultiplicativeExpression();
3280 | 138 |
           label_38:
3281 |  |
           while (true) {
3282 | 154 |
             switch (jj_nt.kind) {
3283 |  |
             case PLUS:
3284 |  |
             case MINUS:
3285 |  |
               ;
3286 | 16 |
               break;
3287 |  |
             default:
3288 | 138 |
               jj_la1[77] = jj_gen;
3289 | 138 |
               break label_38;
3290 |  |
             }
3291 | 16 |
             switch (jj_nt.kind) {
3292 |  |
             case PLUS:
3293 | 16 |
               jj_consume_token(PLUS);
3294 | 16 |
               break;
3295 |  |
             case MINUS:
3296 | 0 |
               jj_consume_token(MINUS);
3297 | 0 |
               break;
3298 |  |
             default:
3299 | 0 |
               jj_la1[78] = jj_gen;
3300 | 0 |
               jj_consume_token(-1);
3301 | 0 |
               throw new ParseException();
3302 |  |
             }
3303 | 16 |
             MultiplicativeExpression();
3304 |  |
           }
3305 |  |
         } catch (Throwable jjte000) {
3306 | 0 |
         if (jjtc000) {
3307 | 0 |
           jjtree.clearNodeScope(jjtn000);
3308 | 0 |
           jjtc000 = false;
3309 |  |
         } else {
3310 | 0 |
           jjtree.popNode();
3311 |  |
         }
3312 | 0 |
         if (jjte000 instanceof RuntimeException) {
3313 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3314 |  |
         }
3315 | 0 |
         if (jjte000 instanceof ParseException) {
3316 | 0 |
           {if (true) throw (ParseException)jjte000;}
3317 |  |
         }
3318 | 0 |
         {if (true) throw (Error)jjte000;}
3319 |  |
         } finally {
3320 | 138 |
         if (jjtc000) {
3321 | 138 |
           jjtree.closeNodeScope(jjtn000, true);
3322 |  |
         }
3323 |  |
         }
3324 |  |
       }
3325 |  |
3326 | 154 |
       final public void MultiplicativeExpression() throws ParseException {
3327 |  |
      /*@bgen(jjtree) MultiplicativeExpression */
3328 | 154 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTMULTIPLICATIVEEXPRESSION);
3329 | 154 |
       boolean jjtc000 = true;
3330 | 154 |
       jjtree.openNodeScope(jjtn000);
3331 | 154 |
         try {
3332 | 154 |
           UnaryExpression();
3333 | 154 |
           label_39:
3334 |  |
           while (true) {
3335 | 162 |
             switch (jj_nt.kind) {
3336 |  |
             case STAR:
3337 |  |
             case SLASH:
3338 |  |
             case REM:
3339 |  |
               ;
3340 | 8 |
               break;
3341 |  |
             default:
3342 | 154 |
               jj_la1[79] = jj_gen;
3343 | 154 |
               break label_39;
3344 |  |
             }
3345 | 8 |
             switch (jj_nt.kind) {
3346 |  |
             case STAR:
3347 | 8 |
               jj_consume_token(STAR);
3348 | 8 |
               break;
3349 |  |
             case SLASH:
3350 | 0 |
               jj_consume_token(SLASH);
3351 | 0 |
               break;
3352 |  |
             case REM:
3353 | 0 |
               jj_consume_token(REM);
3354 | 0 |
               break;
3355 |  |
             default:
3356 | 0 |
               jj_la1[80] = jj_gen;
3357 | 0 |
               jj_consume_token(-1);
3358 | 0 |
               throw new ParseException();
3359 |  |
             }
3360 | 8 |
             UnaryExpression();
3361 |  |
           }
3362 |  |
         } catch (Throwable jjte000) {
3363 | 0 |
         if (jjtc000) {
3364 | 0 |
           jjtree.clearNodeScope(jjtn000);
3365 | 0 |
           jjtc000 = false;
3366 |  |
         } else {
3367 | 0 |
           jjtree.popNode();
3368 |  |
         }
3369 | 0 |
         if (jjte000 instanceof RuntimeException) {
3370 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3371 |  |
         }
3372 | 0 |
         if (jjte000 instanceof ParseException) {
3373 | 0 |
           {if (true) throw (ParseException)jjte000;}
3374 |  |
         }
3375 | 0 |
         {if (true) throw (Error)jjte000;}
3376 |  |
         } finally {
3377 | 154 |
         if (jjtc000) {
3378 | 154 |
           jjtree.closeNodeScope(jjtn000, true);
3379 |  |
         }
3380 |  |
         }
3381 |  |
       }
3382 |  |
3383 | 182 |
       final public void UnaryExpression() throws ParseException {
3384 |  |
      /*@bgen(jjtree) UnaryExpression */
3385 | 182 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTUNARYEXPRESSION);
3386 | 182 |
       boolean jjtc000 = true;
3387 | 182 |
       jjtree.openNodeScope(jjtn000);
3388 | 182 |
         try {
3389 | 182 |
           switch (jj_nt.kind) {
3390 |  |
           case PLUS:
3391 |  |
           case MINUS:
3392 | 4 |
             switch (jj_nt.kind) {
3393 |  |
             case PLUS:
3394 | 4 |
               jj_consume_token(PLUS);
3395 | 4 |
               break;
3396 |  |
             case MINUS:
3397 | 0 |
               jj_consume_token(MINUS);
3398 | 0 |
               break;
3399 |  |
             default:
3400 | 0 |
               jj_la1[81] = jj_gen;
3401 | 0 |
               jj_consume_token(-1);
3402 | 0 |
               throw new ParseException();
3403 |  |
             }
3404 | 4 |
             UnaryExpression();
3405 | 4 |
             break;
3406 |  |
           case INCR:
3407 | 0 |
             PreIncrementExpression();
3408 | 0 |
             break;
3409 |  |
           case DECR:
3410 | 0 |
             PreDecrementExpression();
3411 | 0 |
             break;
3412 |  |
           case BOOLEAN:
3413 |  |
           case BYTE:
3414 |  |
           case CHAR:
3415 |  |
           case DOUBLE:
3416 |  |
           case FALSE:
3417 |  |
           case FLOAT:
3418 |  |
           case INT:
3419 |  |
           case LONG:
3420 |  |
           case NEW:
3421 |  |
           case NULL:
3422 |  |
           case SHORT:
3423 |  |
           case SUPER:
3424 |  |
           case THIS:
3425 |  |
           case TRUE:
3426 |  |
           case VOID:
3427 |  |
           case INTEGER_LITERAL:
3428 |  |
           case FLOATING_POINT_LITERAL:
3429 |  |
           case CHARACTER_LITERAL:
3430 |  |
           case STRING_LITERAL:
3431 |  |
           case IDENTIFIER:
3432 |  |
           case LPAREN:
3433 |  |
           case BANG:
3434 |  |
           case TILDE:
3435 | 178 |
             UnaryExpressionNotPlusMinus();
3436 | 178 |
             break;
3437 |  |
           default:
3438 | 0 |
             jj_la1[82] = jj_gen;
3439 | 0 |
             jj_consume_token(-1);
3440 | 0 |
             throw new ParseException();
3441 |  |
           }
3442 |  |
         } catch (Throwable jjte000) {
3443 | 0 |
         if (jjtc000) {
3444 | 0 |
           jjtree.clearNodeScope(jjtn000);
3445 | 0 |
           jjtc000 = false;
3446 |  |
         } else {
3447 | 0 |
           jjtree.popNode();
3448 |  |
         }
3449 | 0 |
         if (jjte000 instanceof RuntimeException) {
3450 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3451 |  |
         }
3452 | 0 |
         if (jjte000 instanceof ParseException) {
3453 | 0 |
           {if (true) throw (ParseException)jjte000;}
3454 |  |
         }
3455 | 0 |
         {if (true) throw (Error)jjte000;}
3456 |  |
         } finally {
3457 | 182 |
         if (jjtc000) {
3458 | 182 |
           jjtree.closeNodeScope(jjtn000, true);
3459 |  |
         }
3460 |  |
         }
3461 |  |
       }
3462 |  |
3463 | 0 |
       final public void PreIncrementExpression() throws ParseException {
3464 |  |
      /*@bgen(jjtree) PreIncrementExpression */
3465 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTPREINCREMENTEXPRESSION);
3466 | 0 |
       boolean jjtc000 = true;
3467 | 0 |
       jjtree.openNodeScope(jjtn000);
3468 | 0 |
         try {
3469 | 0 |
           jj_consume_token(INCR);
3470 | 0 |
           PrimaryExpression();
3471 |  |
         } catch (Throwable jjte000) {
3472 | 0 |
         if (jjtc000) {
3473 | 0 |
           jjtree.clearNodeScope(jjtn000);
3474 | 0 |
           jjtc000 = false;
3475 |  |
         } else {
3476 | 0 |
           jjtree.popNode();
3477 |  |
         }
3478 | 0 |
         if (jjte000 instanceof RuntimeException) {
3479 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3480 |  |
         }
3481 | 0 |
         if (jjte000 instanceof ParseException) {
3482 | 0 |
           {if (true) throw (ParseException)jjte000;}
3483 |  |
         }
3484 | 0 |
         {if (true) throw (Error)jjte000;}
3485 |  |
         } finally {
3486 | 0 |
         if (jjtc000) {
3487 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
3488 |  |
         }
3489 |  |
         }
3490 |  |
       }
3491 |  |
3492 | 0 |
       final public void PreDecrementExpression() throws ParseException {
3493 |  |
      /*@bgen(jjtree) PreDecrementExpression */
3494 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTPREDECREMENTEXPRESSION);
3495 | 0 |
       boolean jjtc000 = true;
3496 | 0 |
       jjtree.openNodeScope(jjtn000);
3497 | 0 |
         try {
3498 | 0 |
           jj_consume_token(DECR);
3499 | 0 |
           PrimaryExpression();
3500 |  |
         } catch (Throwable jjte000) {
3501 | 0 |
         if (jjtc000) {
3502 | 0 |
           jjtree.clearNodeScope(jjtn000);
3503 | 0 |
           jjtc000 = false;
3504 |  |
         } else {
3505 | 0 |
           jjtree.popNode();
3506 |  |
         }
3507 | 0 |
         if (jjte000 instanceof RuntimeException) {
3508 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3509 |  |
         }
3510 | 0 |
         if (jjte000 instanceof ParseException) {
3511 | 0 |
           {if (true) throw (ParseException)jjte000;}
3512 |  |
         }
3513 | 0 |
         {if (true) throw (Error)jjte000;}
3514 |  |
         } finally {
3515 | 0 |
         if (jjtc000) {
3516 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
3517 |  |
         }
3518 |  |
         }
3519 |  |
       }
3520 |  |
3521 | 186 |
       final public void UnaryExpressionNotPlusMinus() throws ParseException {
3522 |  |
      /*@bgen(jjtree) UnaryExpressionNotPlusMinus */
3523 | 186 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
3524 | 186 |
       boolean jjtc000 = true;
3525 | 186 |
       jjtree.openNodeScope(jjtn000);
3526 | 186 |
         try {
3527 | 186 |
           switch (jj_nt.kind) {
3528 |  |
           case BANG:
3529 |  |
           case TILDE:
3530 | 0 |
             switch (jj_nt.kind) {
3531 |  |
             case TILDE:
3532 | 0 |
               jj_consume_token(TILDE);
3533 | 0 |
               break;
3534 |  |
             case BANG:
3535 | 0 |
               jj_consume_token(BANG);
3536 | 0 |
               break;
3537 |  |
             default:
3538 | 0 |
               jj_la1[83] = jj_gen;
3539 | 0 |
               jj_consume_token(-1);
3540 | 0 |
               throw new ParseException();
3541 |  |
             }
3542 | 0 |
             UnaryExpression();
3543 | 0 |
             break;
3544 |  |
           default:
3545 | 186 |
             jj_la1[84] = jj_gen;
3546 | 186 |
             if (jj_2_15(2147483647)) {
3547 | 24 |
               CastExpression();
3548 |  |
             } else {
3549 | 162 |
               switch (jj_nt.kind) {
3550 |  |
               case BOOLEAN:
3551 |  |
               case BYTE:
3552 |  |
               case CHAR:
3553 |  |
               case DOUBLE:
3554 |  |
               case FALSE:
3555 |  |
               case FLOAT:
3556 |  |
               case INT:
3557 |  |
               case LONG:
3558 |  |
               case NEW:
3559 |  |
               case NULL:
3560 |  |
               case SHORT:
3561 |  |
               case SUPER:
3562 |  |
               case THIS:
3563 |  |
               case TRUE:
3564 |  |
               case VOID:
3565 |  |
               case INTEGER_LITERAL:
3566 |  |
               case FLOATING_POINT_LITERAL:
3567 |  |
               case CHARACTER_LITERAL:
3568 |  |
               case STRING_LITERAL:
3569 |  |
               case IDENTIFIER:
3570 |  |
               case LPAREN:
3571 | 162 |
                 PostfixExpression();
3572 | 162 |
                 break;
3573 |  |
               default:
3574 | 0 |
                 jj_la1[85] = jj_gen;
3575 | 0 |
                 jj_consume_token(-1);
3576 | 0 |
                 throw new ParseException();
3577 |  |
               }
3578 |  |
             }
3579 |  |
           }
3580 |  |
         } catch (Throwable jjte000) {
3581 | 0 |
         if (jjtc000) {
3582 | 0 |
           jjtree.clearNodeScope(jjtn000);
3583 | 0 |
           jjtc000 = false;
3584 |  |
         } else {
3585 | 0 |
           jjtree.popNode();
3586 |  |
         }
3587 | 0 |
         if (jjte000 instanceof RuntimeException) {
3588 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3589 |  |
         }
3590 | 0 |
         if (jjte000 instanceof ParseException) {
3591 | 0 |
           {if (true) throw (ParseException)jjte000;}
3592 |  |
         }
3593 | 0 |
         {if (true) throw (Error)jjte000;}
3594 |  |
         } finally {
3595 | 186 |
         if (jjtc000) {
3596 | 186 |
           jjtree.closeNodeScope(jjtn000, true);
3597 |  |
         }
3598 |  |
         }
3599 |  |
       }
3600 |  |
3601 |  |
     // This production is to determine lookahead only.  The LOOKAHEAD specifications
3602 |  |
     // below are not used, but they are there just to indicate that we know about
3603 |  |
     // this.
3604 | 0 |
       final public void CastLookahead() throws ParseException {
3605 |  |
      /*@bgen(jjtree) CastLookahead */
3606 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTCASTLOOKAHEAD);
3607 | 0 |
       boolean jjtc000 = true;
3608 | 0 |
       jjtree.openNodeScope(jjtn000);
3609 | 0 |
         try {
3610 | 0 |
           if (jj_2_16(2)) {
3611 | 0 |
             jj_consume_token(LPAREN);
3612 | 0 |
             PrimitiveType();
3613 | 0 |
           } else if (jj_2_17(2147483647)) {
3614 | 0 |
             jj_consume_token(LPAREN);
3615 | 0 |
             Name();
3616 | 0 |
             jj_consume_token(LBRACKET);
3617 | 0 |
             jj_consume_token(RBRACKET);
3618 |  |
           } else {
3619 | 0 |
             switch (jj_nt.kind) {
3620 |  |
             case LPAREN:
3621 | 0 |
               jj_consume_token(LPAREN);
3622 | 0 |
               Name();
3623 | 0 |
               jj_consume_token(RPAREN);
3624 | 0 |
               switch (jj_nt.kind) {
3625 |  |
               case TILDE:
3626 | 0 |
                 jj_consume_token(TILDE);
3627 | 0 |
                 break;
3628 |  |
               case BANG:
3629 | 0 |
                 jj_consume_token(BANG);
3630 | 0 |
                 break;
3631 |  |
               case LPAREN:
3632 | 0 |
                 jj_consume_token(LPAREN);
3633 | 0 |
                 break;
3634 |  |
               case IDENTIFIER:
3635 | 0 |
                 jj_consume_token(IDENTIFIER);
3636 | 0 |
                 break;
3637 |  |
               case THIS:
3638 | 0 |
                 jj_consume_token(THIS);
3639 | 0 |
                 break;
3640 |  |
               case SUPER:
3641 | 0 |
                 jj_consume_token(SUPER);
3642 | 0 |
                 break;
3643 |  |
               case NEW:
3644 | 0 |
                 jj_consume_token(NEW);
3645 | 0 |
                 break;
3646 |  |
               case FALSE:
3647 |  |
               case NULL:
3648 |  |
               case TRUE:
3649 |  |
               case INTEGER_LITERAL:
3650 |  |
               case FLOATING_POINT_LITERAL:
3651 |  |
               case CHARACTER_LITERAL:
3652 |  |
               case STRING_LITERAL:
3653 | 0 |
                 Literal();
3654 | 0 |
                 break;
3655 |  |
               default:
3656 | 0 |
                 jj_la1[86] = jj_gen;
3657 | 0 |
                 jj_consume_token(-1);
3658 | 0 |
                 throw new ParseException();
3659 |  |
               }
3660 | 0 |
               break;
3661 |  |
             default:
3662 | 0 |
               jj_la1[87] = jj_gen;
3663 | 0 |
               jj_consume_token(-1);
3664 | 0 |
               throw new ParseException();
3665 |  |
             }
3666 |  |
           }
3667 |  |
         } catch (Throwable jjte000) {
3668 | 0 |
         if (jjtc000) {
3669 | 0 |
           jjtree.clearNodeScope(jjtn000);
3670 | 0 |
           jjtc000 = false;
3671 |  |
         } else {
3672 | 0 |
           jjtree.popNode();
3673 |  |
         }
3674 | 0 |
         if (jjte000 instanceof RuntimeException) {
3675 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3676 |  |
         }
3677 | 0 |
         if (jjte000 instanceof ParseException) {
3678 | 0 |
           {if (true) throw (ParseException)jjte000;}
3679 |  |
         }
3680 | 0 |
         {if (true) throw (Error)jjte000;}
3681 |  |
         } finally {
3682 | 0 |
         if (jjtc000) {
3683 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
3684 |  |
         }
3685 |  |
         }
3686 |  |
       }
3687 |  |
3688 | 162 |
       final public void PostfixExpression() throws ParseException {
3689 |  |
      /*@bgen(jjtree) PostfixExpression */
3690 | 162 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTPOSTFIXEXPRESSION);
3691 | 162 |
       boolean jjtc000 = true;
3692 | 162 |
       jjtree.openNodeScope(jjtn000);
3693 | 162 |
         try {
3694 | 162 |
           PrimaryExpression();
3695 | 162 |
           switch (jj_nt.kind) {
3696 |  |
           case INCR:
3697 |  |
           case DECR:
3698 | 0 |
             switch (jj_nt.kind) {
3699 |  |
             case INCR:
3700 | 0 |
               jj_consume_token(INCR);
3701 | 0 |
               break;
3702 |  |
             case DECR:
3703 | 0 |
               jj_consume_token(DECR);
3704 | 0 |
               break;
3705 |  |
             default:
3706 | 0 |
               jj_la1[88] = jj_gen;
3707 | 0 |
               jj_consume_token(-1);
3708 | 0 |
               throw new ParseException();
3709 |  |
             }
3710 | 0 |
             break;
3711 |  |
           default:
3712 | 162 |
             jj_la1[89] = jj_gen;
3713 |  |
             ;
3714 |  |
           }
3715 |  |
         } catch (Throwable jjte000) {
3716 | 0 |
         if (jjtc000) {
3717 | 0 |
           jjtree.clearNodeScope(jjtn000);
3718 | 0 |
           jjtc000 = false;
3719 |  |
         } else {
3720 | 0 |
           jjtree.popNode();
3721 |  |
         }
3722 | 0 |
         if (jjte000 instanceof RuntimeException) {
3723 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3724 |  |
         }
3725 | 0 |
         if (jjte000 instanceof ParseException) {
3726 | 0 |
           {if (true) throw (ParseException)jjte000;}
3727 |  |
         }
3728 | 0 |
         {if (true) throw (Error)jjte000;}
3729 |  |
         } finally {
3730 | 162 |
         if (jjtc000) {
3731 | 162 |
           jjtree.closeNodeScope(jjtn000, true);
3732 |  |
         }
3733 |  |
         }
3734 |  |
       }
3735 |  |
3736 | 24 |
       final public void CastExpression() throws ParseException {
3737 |  |
      /*@bgen(jjtree) CastExpression */
3738 | 24 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTCASTEXPRESSION);
3739 | 24 |
       boolean jjtc000 = true;
3740 | 24 |
       jjtree.openNodeScope(jjtn000);
3741 | 24 |
         try {
3742 | 24 |
           if (jj_2_18(2147483647)) {
3743 | 16 |
             jj_consume_token(LPAREN);
3744 | 16 |
             Type();
3745 | 16 |
             jj_consume_token(RPAREN);
3746 | 16 |
             UnaryExpression();
3747 |  |
           } else {
3748 | 8 |
             switch (jj_nt.kind) {
3749 |  |
             case LPAREN:
3750 | 8 |
               jj_consume_token(LPAREN);
3751 | 8 |
               Type();
3752 | 8 |
               jj_consume_token(RPAREN);
3753 | 8 |
               UnaryExpressionNotPlusMinus();
3754 | 8 |
               break;
3755 |  |
             default:
3756 | 0 |
               jj_la1[90] = jj_gen;
3757 | 0 |
               jj_consume_token(-1);
3758 | 0 |
               throw new ParseException();
3759 |  |
             }
3760 |  |
           }
3761 |  |
         } catch (Throwable jjte000) {
3762 | 0 |
         if (jjtc000) {
3763 | 0 |
           jjtree.clearNodeScope(jjtn000);
3764 | 0 |
           jjtc000 = false;
3765 |  |
         } else {
3766 | 0 |
           jjtree.popNode();
3767 |  |
         }
3768 | 0 |
         if (jjte000 instanceof RuntimeException) {
3769 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3770 |  |
         }
3771 | 0 |
         if (jjte000 instanceof ParseException) {
3772 | 0 |
           {if (true) throw (ParseException)jjte000;}
3773 |  |
         }
3774 | 0 |
         {if (true) throw (Error)jjte000;}
3775 |  |
         } finally {
3776 | 24 |
         if (jjtc000) {
3777 | 24 |
           jjtree.closeNodeScope(jjtn000, true);
3778 |  |
         }
3779 |  |
         }
3780 |  |
       }
3781 |  |
3782 | 190 |
       final public void PrimaryExpression() throws ParseException {
3783 |  |
      /*@bgen(jjtree) PrimaryExpression */
3784 | 190 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTPRIMARYEXPRESSION);
3785 | 190 |
       boolean jjtc000 = true;
3786 | 190 |
       jjtree.openNodeScope(jjtn000);
3787 | 190 |
         try {
3788 | 190 |
           PrimaryPrefix();
3789 | 190 |
           label_40:
3790 |  |
           while (true) {
3791 | 222 |
             if (jj_2_19(2)) {
3792 |  |
               ;
3793 |  |
             } else {
3794 | 190 |
               break label_40;
3795 |  |
             }
3796 | 32 |
             PrimarySuffix();
3797 |  |
           }
3798 |  |
         } catch (Throwable jjte000) {
3799 | 0 |
         if (jjtc000) {
3800 | 0 |
           jjtree.clearNodeScope(jjtn000);
3801 | 0 |
           jjtc000 = false;
3802 |  |
         } else {
3803 | 0 |
           jjtree.popNode();
3804 |  |
         }
3805 | 0 |
         if (jjte000 instanceof RuntimeException) {
3806 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3807 |  |
         }
3808 | 0 |
         if (jjte000 instanceof ParseException) {
3809 | 0 |
           {if (true) throw (ParseException)jjte000;}
3810 |  |
         }
3811 | 0 |
         {if (true) throw (Error)jjte000;}
3812 |  |
         } finally {
3813 | 190 |
         if (jjtc000) {
3814 | 190 |
           jjtree.closeNodeScope(jjtn000, true);
3815 |  |
         }
3816 |  |
         }
3817 |  |
       }
3818 |  |
3819 | 190 |
       final public void PrimaryPrefix() throws ParseException {
3820 |  |
      /*@bgen(jjtree) PrimaryPrefix */
3821 | 190 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTPRIMARYPREFIX);
3822 | 190 |
       boolean jjtc000 = true;
3823 | 190 |
       jjtree.openNodeScope(jjtn000);
3824 | 190 |
         try {
3825 | 190 |
           switch (jj_nt.kind) {
3826 |  |
           case FALSE:
3827 |  |
           case NULL:
3828 |  |
           case TRUE:
3829 |  |
           case INTEGER_LITERAL:
3830 |  |
           case FLOATING_POINT_LITERAL:
3831 |  |
           case CHARACTER_LITERAL:
3832 |  |
           case STRING_LITERAL:
3833 | 102 |
             Literal();
3834 | 102 |
             break;
3835 |  |
           case THIS:
3836 | 4 |
             jj_consume_token(THIS);
3837 | 4 |
             break;
3838 |  |
           case SUPER:
3839 | 0 |
             jj_consume_token(SUPER);
3840 | 0 |
             jj_consume_token(DOT);
3841 | 0 |
             jj_consume_token(IDENTIFIER);
3842 | 0 |
             break;
3843 |  |
           case LPAREN:
3844 | 24 |
             jj_consume_token(LPAREN);
3845 | 24 |
             Expression();
3846 | 24 |
             jj_consume_token(RPAREN);
3847 | 24 |
             break;
3848 |  |
           case NEW:
3849 | 8 |
             AllocationExpression();
3850 | 8 |
             break;
3851 |  |
           default:
3852 | 52 |
             jj_la1[91] = jj_gen;
3853 | 52 |
             if (jj_2_20(2147483647)) {
3854 | 8 |
               ResultType(null);
3855 | 8 |
               jj_consume_token(DOT);
3856 | 8 |
               jj_consume_token(CLASS);
3857 |  |
             } else {
3858 | 44 |
               switch (jj_nt.kind) {
3859 |  |
               case IDENTIFIER:
3860 | 44 |
                 Name();
3861 | 44 |
                 break;
3862 |  |
               default:
3863 | 0 |
                 jj_la1[92] = jj_gen;
3864 | 0 |
                 jj_consume_token(-1);
3865 | 0 |
                 throw new ParseException();
3866 |  |
               }
3867 |  |
             }
3868 |  |
           }
3869 |  |
         } catch (Throwable jjte000) {
3870 | 0 |
         if (jjtc000) {
3871 | 0 |
           jjtree.clearNodeScope(jjtn000);
3872 | 0 |
           jjtc000 = false;
3873 |  |
         } else {
3874 | 0 |
           jjtree.popNode();
3875 |  |
         }
3876 | 0 |
         if (jjte000 instanceof RuntimeException) {
3877 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3878 |  |
         }
3879 | 0 |
         if (jjte000 instanceof ParseException) {
3880 | 0 |
           {if (true) throw (ParseException)jjte000;}
3881 |  |
         }
3882 | 0 |
         {if (true) throw (Error)jjte000;}
3883 |  |
         } finally {
3884 | 190 |
         if (jjtc000) {
3885 | 190 |
           jjtree.closeNodeScope(jjtn000, true);
3886 |  |
         }
3887 |  |
         }
3888 |  |
       }
3889 |  |
3890 | 32 |
       final public void PrimarySuffix() throws ParseException {
3891 |  |
      /*@bgen(jjtree) PrimarySuffix */
3892 | 32 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTPRIMARYSUFFIX);
3893 | 32 |
       boolean jjtc000 = true;
3894 | 32 |
       jjtree.openNodeScope(jjtn000);
3895 | 32 |
         try {
3896 | 32 |
           if (jj_2_21(2)) {
3897 | 0 |
             jj_consume_token(DOT);
3898 | 0 |
             jj_consume_token(THIS);
3899 | 32 |
           } else if (jj_2_22(2)) {
3900 | 0 |
             jj_consume_token(DOT);
3901 | 0 |
             jj_consume_token(SUPER);
3902 | 32 |
           } else if (jj_2_23(2)) {
3903 | 4 |
             jj_consume_token(DOT);
3904 | 4 |
             AllocationExpression();
3905 |  |
           } else {
3906 | 28 |
             switch (jj_nt.kind) {
3907 |  |
             case LBRACKET:
3908 | 0 |
               jj_consume_token(LBRACKET);
3909 | 0 |
               Expression();
3910 | 0 |
               jj_consume_token(RBRACKET);
3911 | 0 |
               break;
3912 |  |
             case DOT:
3913 | 4 |
               jj_consume_token(DOT);
3914 | 4 |
               jj_consume_token(IDENTIFIER);
3915 | 4 |
               break;
3916 |  |
             case LPAREN:
3917 | 24 |
               Arguments();
3918 | 24 |
               break;
3919 |  |
             default:
3920 | 0 |
               jj_la1[93] = jj_gen;
3921 | 0 |
               jj_consume_token(-1);
3922 | 0 |
               throw new ParseException();
3923 |  |
             }
3924 |  |
           }
3925 |  |
         } catch (Throwable jjte000) {
3926 | 0 |
         if (jjtc000) {
3927 | 0 |
           jjtree.clearNodeScope(jjtn000);
3928 | 0 |
           jjtc000 = false;
3929 |  |
         } else {
3930 | 0 |
           jjtree.popNode();
3931 |  |
         }
3932 | 0 |
         if (jjte000 instanceof RuntimeException) {
3933 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3934 |  |
         }
3935 | 0 |
         if (jjte000 instanceof ParseException) {
3936 | 0 |
           {if (true) throw (ParseException)jjte000;}
3937 |  |
         }
3938 | 0 |
         {if (true) throw (Error)jjte000;}
3939 |  |
         } finally {
3940 | 32 |
         if (jjtc000) {
3941 | 32 |
           jjtree.closeNodeScope(jjtn000, true);
3942 |  |
         }
3943 |  |
         }
3944 |  |
       }
3945 |  |
3946 | 102 |
       final public void Literal() throws ParseException {
3947 |  |
      /*@bgen(jjtree) Literal */
3948 | 102 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTLITERAL);
3949 | 102 |
       boolean jjtc000 = true;
3950 | 102 |
       jjtree.openNodeScope(jjtn000);
3951 | 102 |
         try {
3952 | 102 |
           switch (jj_nt.kind) {
3953 |  |
           case INTEGER_LITERAL:
3954 | 22 |
             jj_consume_token(INTEGER_LITERAL);
3955 | 22 |
             break;
3956 |  |
           case FLOATING_POINT_LITERAL:
3957 | 0 |
             jj_consume_token(FLOATING_POINT_LITERAL);
3958 | 0 |
             break;
3959 |  |
           case CHARACTER_LITERAL:
3960 | 0 |
             jj_consume_token(CHARACTER_LITERAL);
3961 | 0 |
             break;
3962 |  |
           case STRING_LITERAL:
3963 | 56 |
             jj_consume_token(STRING_LITERAL);
3964 | 56 |
             break;
3965 |  |
           case FALSE:
3966 |  |
           case TRUE:
3967 | 16 |
             BooleanLiteral();
3968 | 16 |
             break;
3969 |  |
           case NULL:
3970 | 8 |
             NullLiteral();
3971 | 8 |
             break;
3972 |  |
           default:
3973 | 0 |
             jj_la1[94] = jj_gen;
3974 | 0 |
             jj_consume_token(-1);
3975 | 0 |
             throw new ParseException();
3976 |  |
           }
3977 |  |
         } catch (Throwable jjte000) {
3978 | 0 |
         if (jjtc000) {
3979 | 0 |
           jjtree.clearNodeScope(jjtn000);
3980 | 0 |
           jjtc000 = false;
3981 |  |
         } else {
3982 | 0 |
           jjtree.popNode();
3983 |  |
         }
3984 | 0 |
         if (jjte000 instanceof RuntimeException) {
3985 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
3986 |  |
         }
3987 | 0 |
         if (jjte000 instanceof ParseException) {
3988 | 0 |
           {if (true) throw (ParseException)jjte000;}
3989 |  |
         }
3990 | 0 |
         {if (true) throw (Error)jjte000;}
3991 |  |
         } finally {
3992 | 102 |
         if (jjtc000) {
3993 | 102 |
           jjtree.closeNodeScope(jjtn000, true);
3994 |  |
         }
3995 |  |
         }
3996 |  |
       }
3997 |  |
3998 | 16 |
       final public void BooleanLiteral() throws ParseException {
3999 |  |
      /*@bgen(jjtree) BooleanLiteral */
4000 | 16 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTBOOLEANLITERAL);
4001 | 16 |
       boolean jjtc000 = true;
4002 | 16 |
       jjtree.openNodeScope(jjtn000);
4003 | 16 |
         try {
4004 | 16 |
           switch (jj_nt.kind) {
4005 |  |
           case TRUE:
4006 | 16 |
             jj_consume_token(TRUE);
4007 | 16 |
             break;
4008 |  |
           case FALSE:
4009 | 0 |
             jj_consume_token(FALSE);
4010 | 0 |
             break;
4011 |  |
           default:
4012 | 0 |
             jj_la1[95] = jj_gen;
4013 | 0 |
             jj_consume_token(-1);
4014 | 0 |
             throw new ParseException();
4015 |  |
           }
4016 |  |
         } finally {
4017 | 16 |
         if (jjtc000) {
4018 | 16 |
           jjtree.closeNodeScope(jjtn000, true);
4019 |  |
         }
4020 |  |
         }
4021 |  |
       }
4022 |  |
4023 | 8 |
       final public void NullLiteral() throws ParseException {
4024 |  |
      /*@bgen(jjtree) NullLiteral */
4025 | 8 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTNULLLITERAL);
4026 | 8 |
       boolean jjtc000 = true;
4027 | 8 |
       jjtree.openNodeScope(jjtn000);
4028 | 8 |
         try {
4029 | 8 |
           jj_consume_token(NULL);
4030 |  |
         } finally {
4031 | 8 |
         if (jjtc000) {
4032 | 8 |
           jjtree.closeNodeScope(jjtn000, true);
4033 |  |
         }
4034 |  |
         }
4035 |  |
       }
4036 |  |
4037 | 36 |
       final public void Arguments() throws ParseException {
4038 |  |
      /*@bgen(jjtree) Arguments */
4039 | 36 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTARGUMENTS);
4040 | 36 |
       boolean jjtc000 = true;
4041 | 36 |
       jjtree.openNodeScope(jjtn000);
4042 | 36 |
         try {
4043 | 36 |
           jj_consume_token(LPAREN);
4044 | 36 |
           switch (jj_nt.kind) {
4045 |  |
           case BOOLEAN:
4046 |  |
           case BYTE:
4047 |  |
           case CHAR:
4048 |  |
           case DOUBLE:
4049 |  |
           case FALSE:
4050 |  |
           case FLOAT:
4051 |  |
           case INT:
4052 |  |
           case LONG:
4053 |  |
           case NEW:
4054 |  |
           case NULL:
4055 |  |
           case SHORT:
4056 |  |
           case SUPER:
4057 |  |
           case THIS:
4058 |  |
           case TRUE:
4059 |  |
           case VOID:
4060 |  |
           case INTEGER_LITERAL:
4061 |  |
           case FLOATING_POINT_LITERAL:
4062 |  |
           case CHARACTER_LITERAL:
4063 |  |
           case STRING_LITERAL:
4064 |  |
           case IDENTIFIER:
4065 |  |
           case LPAREN:
4066 |  |
           case BANG:
4067 |  |
           case TILDE:
4068 |  |
           case INCR:
4069 |  |
           case DECR:
4070 |  |
           case PLUS:
4071 |  |
           case MINUS:
4072 | 12 |
             ArgumentList();
4073 | 12 |
             break;
4074 |  |
           default:
4075 | 24 |
             jj_la1[96] = jj_gen;
4076 |  |
             ;
4077 |  |
           }
4078 | 36 |
           jj_consume_token(RPAREN);
4079 |  |
         } catch (Throwable jjte000) {
4080 | 0 |
         if (jjtc000) {
4081 | 0 |
           jjtree.clearNodeScope(jjtn000);
4082 | 0 |
           jjtc000 = false;
4083 |  |
         } else {
4084 | 0 |
           jjtree.popNode();
4085 |  |
         }
4086 | 0 |
         if (jjte000 instanceof RuntimeException) {
4087 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
4088 |  |
         }
4089 | 0 |
         if (jjte000 instanceof ParseException) {
4090 | 0 |
           {if (true) throw (ParseException)jjte000;}
4091 |  |
         }
4092 | 0 |
         {if (true) throw (Error)jjte000;}
4093 |  |
         } finally {
4094 | 36 |
         if (jjtc000) {
4095 | 36 |
           jjtree.closeNodeScope(jjtn000, true);
4096 |  |
         }
4097 |  |
         }
4098 |  |
       }
4099 |  |
4100 | 12 |
       final public void ArgumentList() throws ParseException {
4101 |  |
      /*@bgen(jjtree) ArgumentList */
4102 | 12 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTARGUMENTLIST);
4103 | 12 |
       boolean jjtc000 = true;
4104 | 12 |
       jjtree.openNodeScope(jjtn000);
4105 | 12 |
         try {
4106 | 12 |
           Expression();
4107 | 12 |
           label_41:
4108 |  |
           while (true) {
4109 | 16 |
             switch (jj_nt.kind) {
4110 |  |
             case COMMA:
4111 |  |
               ;
4112 | 4 |
               break;
4113 |  |
             default:
4114 | 12 |
               jj_la1[97] = jj_gen;
4115 | 12 |
               break label_41;
4116 |  |
             }
4117 | 4 |
             jj_consume_token(COMMA);
4118 | 4 |
             Expression();
4119 |  |
           }
4120 |  |
         } catch (Throwable jjte000) {
4121 | 0 |
         if (jjtc000) {
4122 | 0 |
           jjtree.clearNodeScope(jjtn000);
4123 | 0 |
           jjtc000 = false;
4124 |  |
         } else {
4125 | 0 |
           jjtree.popNode();
4126 |  |
         }
4127 | 0 |
         if (jjte000 instanceof RuntimeException) {
4128 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
4129 |  |
         }
4130 | 0 |
         if (jjte000 instanceof ParseException) {
4131 | 0 |
           {if (true) throw (ParseException)jjte000;}
4132 |  |
         }
4133 | 0 |
         {if (true) throw (Error)jjte000;}
4134 |  |
         } finally {
4135 | 12 |
         if (jjtc000) {
4136 | 12 |
           jjtree.closeNodeScope(jjtn000, true);
4137 |  |
         }
4138 |  |
         }
4139 |  |
       }
4140 |  |
4141 |  |
     /**
4142 |  |
      * @todo Anonymous classes will cause NPE. Need to check for nullity in a lot of places
4143 |  |
      */
4144 | 12 |
       final public void AllocationExpression() throws ParseException {
4145 |  |
      /*@bgen(jjtree) AllocationExpression */
4146 | 12 |
        SimpleNode jjtn000 = new SimpleNode(this, JJTALLOCATIONEXPRESSION);
4147 | 12 |
        boolean jjtc000 = true;
4148 | 12 |
        jjtree.openNodeScope(jjtn000);String realisedClass;
4149 | 12 |
         try {
4150 | 12 |
           if (jj_2_24(2)) {
4151 | 0 |
             jj_consume_token(NEW);
4152 | 0 |
             PrimitiveType();
4153 | 0 |
             ArrayDimsAndInits();
4154 |  |
           } else {
4155 | 12 |
             switch (jj_nt.kind) {
4156 |  |
             case NEW:
4157 | 12 |
               jj_consume_token(NEW);
4158 | 12 |
               realisedClass = Name();
4159 | 12 |
               switch (jj_nt.kind) {
4160 |  |
               case LBRACKET:
4161 | 0 |
                 ArrayDimsAndInits();
4162 | 0 |
                 break;
4163 |  |
               case LPAREN:
4164 | 12 |
                 Arguments();
4165 | 12 |
                 switch (jj_nt.kind) {
4166 |  |
                 case LBRACE:
4167 |  |
                 // ANONYMOUS CLASS
4168 | 0 |
                 SourceClass containingClass = currentClass();
4169 | 0 |
             pushAndGet();
4170 | 0 |
                   ClassBody();
4171 |  |
             // Don't care about anonymous classes. They don't have javadocs
4172 |  |
             // _xJavaDoc.addSourceClass(anonymousClass);
4173 | 0 |
             currentClass().setName(containingClass.getNextAnonymousClassName());
4174 | 0 |
             currentClass().setRealised(realisedClass);
4175 | 0 |
             popAndAddInner();
4176 | 0 |
                   break;
4177 |  |
                 default:
4178 | 12 |
                   jj_la1[98] = jj_gen;
4179 |  |
                   ;
4180 |  |
                 }
4181 | 12 |
                 break;
4182 |  |
               default:
4183 | 0 |
                 jj_la1[99] = jj_gen;
4184 | 0 |
                 jj_consume_token(-1);
4185 | 0 |
                 throw new ParseException();
4186 |  |
               }
4187 | 12 |
               break;
4188 |  |
             default:
4189 | 0 |
               jj_la1[100] = jj_gen;
4190 | 0 |
               jj_consume_token(-1);
4191 | 0 |
               throw new ParseException();
4192 |  |
             }
4193 |  |
           }
4194 |  |
         } catch (Throwable jjte000) {
4195 | 0 |
         if (jjtc000) {
4196 | 0 |
           jjtree.clearNodeScope(jjtn000);
4197 | 0 |
           jjtc000 = false;
4198 |  |
         } else {
4199 | 0 |
           jjtree.popNode();
4200 |  |
         }
4201 | 0 |
         if (jjte000 instanceof RuntimeException) {
4202 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
4203 |  |
         }
4204 | 0 |
         if (jjte000 instanceof ParseException) {
4205 | 0 |
           {if (true) throw (ParseException)jjte000;}
4206 |  |
         }
4207 | 0 |
         {if (true) throw (Error)jjte000;}
4208 |  |
         } finally {
4209 | 12 |
         if (jjtc000) {
4210 | 12 |
           jjtree.closeNodeScope(jjtn000, true);
4211 |  |
         }
4212 |  |
         }
4213 |  |
       }
4214 |  |
4215 |  |
     /*
4216 |  |
      * The second LOOKAHEAD specification below is to parse to PrimarySuffix
4217 |  |
      * if there is an expression between the "[...]".
4218 |  |
      */
4219 | 0 |
       final public void ArrayDimsAndInits() throws ParseException {
4220 |  |
      /*@bgen(jjtree) ArrayDimsAndInits */
4221 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTARRAYDIMSANDINITS);
4222 | 0 |
       boolean jjtc000 = true;
4223 | 0 |
       jjtree.openNodeScope(jjtn000);
4224 | 0 |
         try {
4225 | 0 |
           if (jj_2_27(2)) {
4226 | 0 |
             label_42:
4227 |  |
             while (true) {
4228 | 0 |
               jj_consume_token(LBRACKET);
4229 | 0 |
               Expression();
4230 | 0 |
               jj_consume_token(RBRACKET);
4231 | 0 |
               if (jj_2_25(2)) {
4232 |  |
                 ;
4233 |  |
               } else {
4234 | 0 |
                 break label_42;
4235 |  |
               }
4236 |  |
             }
4237 | 0 |
             label_43:
4238 |  |
             while (true) {
4239 | 0 |
               if (jj_2_26(2)) {
4240 |  |
                 ;
4241 |  |
               } else {
4242 | 0 |
                 break label_43;
4243 |  |
               }
4244 | 0 |
               jj_consume_token(LBRACKET);
4245 | 0 |
               jj_consume_token(RBRACKET);
4246 |  |
             }
4247 |  |
           } else {
4248 | 0 |
             switch (jj_nt.kind) {
4249 |  |
             case LBRACKET:
4250 | 0 |
               label_44:
4251 |  |
               while (true) {
4252 | 0 |
                 jj_consume_token(LBRACKET);
4253 | 0 |
                 jj_consume_token(RBRACKET);
4254 | 0 |
                 switch (jj_nt.kind) {
4255 |  |
                 case LBRACKET:
4256 |  |
                   ;
4257 | 0 |
                   break;
4258 |  |
                 default:
4259 | 0 |
                   jj_la1[101] = jj_gen;
4260 | 0 |
                   break label_44;
4261 |  |
                 }
4262 |  |
               }
4263 | 0 |
               ArrayInitializer();
4264 | 0 |
               break;
4265 |  |
             default:
4266 | 0 |
               jj_la1[102] = jj_gen;
4267 | 0 |
               jj_consume_token(-1);
4268 | 0 |
               throw new ParseException();
4269 |  |
             }
4270 |  |
           }
4271 |  |
         } catch (Throwable jjte000) {
4272 | 0 |
         if (jjtc000) {
4273 | 0 |
           jjtree.clearNodeScope(jjtn000);
4274 | 0 |
           jjtc000 = false;
4275 |  |
         } else {
4276 | 0 |
           jjtree.popNode();
4277 |  |
         }
4278 | 0 |
         if (jjte000 instanceof RuntimeException) {
4279 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
4280 |  |
         }
4281 | 0 |
         if (jjte000 instanceof ParseException) {
4282 | 0 |
           {if (true) throw (ParseException)jjte000;}
4283 |  |
         }
4284 | 0 |
         {if (true) throw (Error)jjte000;}
4285 |  |
         } finally {
4286 | 0 |
         if (jjtc000) {
4287 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
4288 |  |
         }
4289 |  |
         }
4290 |  |
       }
4291 |  |
4292 |  |
     /*
4293 |  |
      * Statement syntax follows.
4294 |  |
      */
4295 | 64 |
       final public void Statement() throws ParseException {
4296 |  |
      /*@bgen(jjtree) Statement */
4297 | 64 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTSTATEMENT);
4298 | 64 |
       boolean jjtc000 = true;
4299 | 64 |
       jjtree.openNodeScope(jjtn000);
4300 | 64 |
         try {
4301 | 64 |
           if (jj_2_28(2)) {
4302 | 0 |
             LabeledStatement();
4303 |  |
           } else {
4304 | 64 |
             switch (jj_nt.kind) {
4305 |  |
             case LBRACE:
4306 | 0 |
               Block();
4307 | 0 |
               break;
4308 |  |
             case SEMICOLON:
4309 | 0 |
               EmptyStatement();
4310 | 0 |
               break;
4311 |  |
             case BOOLEAN:
4312 |  |
             case BYTE:
4313 |  |
             case CHAR:
4314 |  |
             case DOUBLE:
4315 |  |
             case FALSE:
4316 |  |
             case FLOAT:
4317 |  |
             case INT:
4318 |  |
             case LONG:
4319 |  |
             case NEW:
4320 |  |
             case NULL:
4321 |  |
             case SHORT:
4322 |  |
             case SUPER:
4323 |  |
             case THIS:
4324 |  |
             case TRUE:
4325 |  |
             case VOID:
4326 |  |
             case INTEGER_LITERAL:
4327 |  |
             case FLOATING_POINT_LITERAL:
4328 |  |
             case CHARACTER_LITERAL:
4329 |  |
             case STRING_LITERAL:
4330 |  |
             case IDENTIFIER:
4331 |  |
             case LPAREN:
4332 |  |
             case INCR:
4333 |  |
             case DECR:
4334 | 28 |
               StatementExpression();
4335 | 28 |
               jj_consume_token(SEMICOLON);
4336 | 28 |
               break;
4337 |  |
             case SWITCH:
4338 | 0 |
               SwitchStatement();
4339 | 0 |
               break;
4340 |  |
             case IF:
4341 | 0 |
               IfStatement();
4342 | 0 |
               break;
4343 |  |
             case WHILE:
4344 | 0 |
               WhileStatement();
4345 | 0 |
               break;
4346 |  |
             case DO:
4347 | 0 |
               DoStatement();
4348 | 0 |
               break;
4349 |  |
             case FOR:
4350 | 0 |
               ForStatement();
4351 | 0 |
               break;
4352 |  |
             case BREAK:
4353 | 0 |
               BreakStatement();
4354 | 0 |
               break;
4355 |  |
             case CONTINUE:
4356 | 0 |
               ContinueStatement();
4357 | 0 |
               break;
4358 |  |
             case RETURN:
4359 | 20 |
               ReturnStatement();
4360 | 20 |
               break;
4361 |  |
             case THROW:
4362 | 0 |
               ThrowStatement();
4363 | 0 |
               break;
4364 |  |
             case SYNCHRONIZED:
4365 | 0 |
               SynchronizedStatement();
4366 | 0 |
               break;
4367 |  |
             case TRY:
4368 | 0 |
               TryStatement();
4369 | 0 |
               break;
4370 |  |
             case ASSERT:
4371 | 16 |
               AssertStatement();
4372 | 16 |
               break;
4373 |  |
             default:
4374 | 0 |
               jj_la1[103] = jj_gen;
4375 | 0 |
               jj_consume_token(-1);
4376 | 0 |
               throw new ParseException();
4377 |  |
             }
4378 |  |
           }
4379 |  |
         } catch (Throwable jjte000) {
4380 | 0 |
         if (jjtc000) {
4381 | 0 |
           jjtree.clearNodeScope(jjtn000);
4382 | 0 |
           jjtc000 = false;
4383 |  |
         } else {
4384 | 0 |
           jjtree.popNode();
4385 |  |
         }
4386 | 0 |
         if (jjte000 instanceof RuntimeException) {
4387 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
4388 |  |
         }
4389 | 0 |
         if (jjte000 instanceof ParseException) {
4390 | 0 |
           {if (true) throw (ParseException)jjte000;}
4391 |  |
         }
4392 | 0 |
         {if (true) throw (Error)jjte000;}
4393 |  |
         } finally {
4394 | 64 |
         if (jjtc000) {
4395 | 64 |
           jjtree.closeNodeScope(jjtn000, true);
4396 |  |
         }
4397 |  |
         }
4398 |  |
       }
4399 |  |
4400 | 0 |
       final public void LabeledStatement() throws ParseException {
4401 |  |
      /*@bgen(jjtree) LabeledStatement */
4402 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTLABELEDSTATEMENT);
4403 | 0 |
       boolean jjtc000 = true;
4404 | 0 |
       jjtree.openNodeScope(jjtn000);
4405 | 0 |
         try {
4406 | 0 |
           jj_consume_token(IDENTIFIER);
4407 | 0 |
           jj_consume_token(COLON);
4408 | 0 |
           Statement();
4409 |  |
         } catch (Throwable jjte000) {
4410 | 0 |
         if (jjtc000) {
4411 | 0 |
           jjtree.clearNodeScope(jjtn000);
4412 | 0 |
           jjtc000 = false;
4413 |  |
         } else {
4414 | 0 |
           jjtree.popNode();
4415 |  |
         }
4416 | 0 |
         if (jjte000 instanceof RuntimeException) {
4417 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
4418 |  |
         }
4419 | 0 |
         if (jjte000 instanceof ParseException) {
4420 | 0 |
           {if (true) throw (ParseException)jjte000;}
4421 |  |
         }
4422 | 0 |
         {if (true) throw (Error)jjte000;}
4423 |  |
         } finally {
4424 | 0 |
         if (jjtc000) {
4425 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
4426 |  |
         }
4427 |  |
         }
4428 |  |
       }
4429 |  |
4430 | 4 |
       final public void Block() throws ParseException {
4431 |  |
      /*@bgen(jjtree) Block */
4432 | 4 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTBLOCK);
4433 | 4 |
       boolean jjtc000 = true;
4434 | 4 |
       jjtree.openNodeScope(jjtn000);
4435 | 4 |
         try {
4436 | 4 |
           jj_consume_token(LBRACE);
4437 | 4 |
           label_45:
4438 |  |
           while (true) {
4439 | 8 |
             switch (jj_nt.kind) {
4440 |  |
             case BOOLEAN:
4441 |  |
             case BREAK:
4442 |  |
             case BYTE:
4443 |  |
             case CHAR:
4444 |  |
             case CLASS:
4445 |  |
             case CONTINUE:
4446 |  |
             case DO:
4447 |  |
             case DOUBLE:
4448 |  |
             case FALSE:
4449 |  |
             case FINAL:
4450 |  |
             case FLOAT:
4451 |  |
             case FOR:
4452 |  |
             case IF:
4453 |  |
             case INT:
4454 |  |
             case INTERFACE:
4455 |  |
             case LONG:
4456 |  |
             case NEW:
4457 |  |
             case NULL:
4458 |  |
             case RETURN:
4459 |  |
             case SHORT:
4460 |  |
             case SUPER:
4461 |  |
             case SWITCH:
4462 |  |
             case SYNCHRONIZED:
4463 |  |
             case THIS:
4464 |  |
             case THROW:
4465 |  |
             case TRUE:
4466 |  |
             case TRY:
4467 |  |
             case VOID:
4468 |  |
             case WHILE:
4469 |  |
             case ASSERT:
4470 |  |
             case INTEGER_LITERAL:
4471 |  |
             case FLOATING_POINT_LITERAL:
4472 |  |
             case CHARACTER_LITERAL:
4473 |  |
             case STRING_LITERAL:
4474 |  |
             case IDENTIFIER:
4475 |  |
             case LPAREN:
4476 |  |
             case LBRACE:
4477 |  |
             case SEMICOLON:
4478 |  |
             case INCR:
4479 |  |
             case DECR:
4480 |  |
               ;
4481 | 4 |
               break;
4482 |  |
             default:
4483 | 4 |
               jj_la1[104] = jj_gen;
4484 | 4 |
               break label_45;
4485 |  |
             }
4486 | 4 |
             BlockStatement();
4487 |  |
           }
4488 | 4 |
           jj_consume_token(RBRACE);
4489 |  |
         } catch (Throwable jjte000) {
4490 | 0 |
         if (jjtc000) {
4491 | 0 |
           jjtree.clearNodeScope(jjtn000);
4492 | 0 |
           jjtc000 = false;
4493 |  |
         } else {
4494 | 0 |
           jjtree.popNode();
4495 |  |
         }
4496 | 0 |
         if (jjte000 instanceof RuntimeException) {
4497 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
4498 |  |
         }
4499 | 0 |
         if (jjte000 instanceof ParseException) {
4500 | 0 |
           {if (true) throw (ParseException)jjte000;}
4501 |  |
         }
4502 | 0 |
         {if (true) throw (Error)jjte000;}
4503 |  |
         } finally {
4504 | 4 |
         if (jjtc000) {
4505 | 4 |
           jjtree.closeNodeScope(jjtn000, true);
4506 |  |
         }
4507 |  |
         }
4508 |  |
       }
4509 |  |
4510 | 76 |
       final public void Method_Block() throws ParseException {
4511 |  |
      /*@bgen(jjtree) Method_Block */
4512 | 76 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTMETHOD_BLOCK);
4513 | 76 |
       boolean jjtc000 = true;
4514 | 76 |
       jjtree.openNodeScope(jjtn000);
4515 | 76 |
         try {
4516 | 76 |
           jj_consume_token(LBRACE);
4517 | 76 |
           label_46:
4518 |  |
           while (true) {
4519 | 186 |
             switch (jj_nt.kind) {
4520 |  |
             case BOOLEAN:
4521 |  |
             case BREAK:
4522 |  |
             case BYTE:
4523 |  |
             case CHAR:
4524 |  |
             case CLASS:
4525 |  |
             case CONTINUE:
4526 |  |
             case DO:
4527 |  |
             case DOUBLE:
4528 |  |
             case FALSE:
4529 |  |
             case FINAL:
4530 |  |
             case FLOAT:
4531 |  |
             case FOR:
4532 |  |
             case IF:
4533 |  |
             case INT:
4534 |  |
             case INTERFACE:
4535 |  |
             case LONG:
4536 |  |
             case NEW:
4537 |  |
             case NULL:
4538 |  |
             case RETURN:
4539 |  |
             case SHORT:
4540 |  |
             case SUPER:
4541 |  |
             case SWITCH:
4542 |  |
             case SYNCHRONIZED:
4543 |  |
             case THIS:
4544 |  |
             case THROW:
4545 |  |
             case TRUE:
4546 |  |
             case TRY:
4547 |  |
             case VOID:
4548 |  |
             case WHILE:
4549 |  |
             case ASSERT:
4550 |  |
             case INTEGER_LITERAL:
4551 |  |
             case FLOATING_POINT_LITERAL:
4552 |  |
             case CHARACTER_LITERAL:
4553 |  |
             case STRING_LITERAL:
4554 |  |
             case IDENTIFIER:
4555 |  |
             case LPAREN:
4556 |  |
             case LBRACE:
4557 |  |
             case SEMICOLON:
4558 |  |
             case INCR:
4559 |  |
             case DECR:
4560 |  |
               ;
4561 | 110 |
               break;
4562 |  |
             default:
4563 | 76 |
               jj_la1[105] = jj_gen;
4564 | 76 |
               break label_46;
4565 |  |
             }
4566 | 110 |
             Method_BlockStatement();
4567 |  |
           }
4568 | 76 |
           jj_consume_token(RBRACE);
4569 | 76 |
           switch (jj_nt.kind) {
4570 |  |
           case SEMICOLON:
4571 | 8 |
             jj_consume_token(SEMICOLON);
4572 | 8 |
             break;
4573 |  |
           default:
4574 | 68 |
             jj_la1[106] = jj_gen;
4575 |  |
             ;
4576 |  |
           }
4577 |  |
         } catch (Throwable jjte000) {
4578 | 0 |
         if (jjtc000) {
4579 | 0 |
           jjtree.clearNodeScope(jjtn000);
4580 | 0 |
           jjtc000 = false;
4581 |  |
         } else {
4582 | 0 |
           jjtree.popNode();
4583 |  |
         }
4584 | 0 |
         if (jjte000 instanceof RuntimeException) {
4585 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
4586 |  |
         }
4587 | 0 |
         if (jjte000 instanceof ParseException) {
4588 | 0 |
           {if (true) throw (ParseException)jjte000;}
4589 |  |
         }
4590 | 0 |
         {if (true) throw (Error)jjte000;}
4591 |  |
         } finally {
4592 | 76 |
         if (jjtc000) {
4593 | 76 |
           jjtree.closeNodeScope(jjtn000, true);
4594 |  |
         }
4595 |  |
         }
4596 |  |
       }
4597 |  |
4598 |  |
     /**
4599 |  |
      * @todo not sure if the UnmodifiedClassDeclaration/UnmodifiedInterfaceDeclaration
4600 |  |
      * ever get called, now that we have two different blocks. It would be nice to remove them
4601 |  |
      */
4602 | 4 |
       final public void BlockStatement() throws ParseException {
4603 |  |
      /*@bgen(jjtree) BlockStatement */
4604 | 4 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTBLOCKSTATEMENT);
4605 | 4 |
       boolean jjtc000 = true;
4606 | 4 |
       jjtree.openNodeScope(jjtn000);
4607 | 4 |
         try {
4608 | 4 |
           if (jj_2_29(2147483647)) {
4609 | 4 |
             LocalVariableDeclaration();
4610 | 4 |
             jj_consume_token(SEMICOLON);
4611 |  |
           } else {
4612 | 0 |
             switch (jj_nt.kind) {
4613 |  |
             case BOOLEAN:
4614 |  |
             case BREAK:
4615 |  |
             case BYTE:
4616 |  |
             case CHAR:
4617 |  |
             case CONTINUE:
4618 |  |
             case DO:
4619 |  |
             case DOUBLE:
4620 |  |
             case FALSE:
4621 |  |
             case FLOAT:
4622 |  |
             case FOR:
4623 |  |
             case IF:
4624 |  |
             case INT:
4625 |  |
             case LONG:
4626 |  |
             case NEW:
4627 |  |
             case NULL:
4628 |  |
             case RETURN:
4629 |  |
             case SHORT:
4630 |  |
             case SUPER:
4631 |  |
             case SWITCH:
4632 |  |
             case SYNCHRONIZED:
4633 |  |
             case THIS:
4634 |  |
             case THROW:
4635 |  |
             case TRUE:
4636 |  |
             case TRY:
4637 |  |
             case VOID:
4638 |  |
             case WHILE:
4639 |  |
             case ASSERT:
4640 |  |
             case INTEGER_LITERAL:
4641 |  |
             case FLOATING_POINT_LITERAL:
4642 |  |
             case CHARACTER_LITERAL:
4643 |  |
             case STRING_LITERAL:
4644 |  |
             case IDENTIFIER:
4645 |  |
             case LPAREN:
4646 |  |
             case LBRACE:
4647 |  |
             case SEMICOLON:
4648 |  |
             case INCR:
4649 |  |
             case DECR:
4650 | 0 |
               Statement();
4651 | 0 |
               break;
4652 |  |
             case CLASS:
4653 | 0 |
          pushAndGet();
4654 | 0 |
               UnmodifiedClassDeclaration();
4655 | 0 |
         jjtree.closeNodeScope(jjtn000, true);
4656 | 0 |
         jjtc000 = false;
4657 | 0 |
          popAndAddInner();
4658 | 0 |
               break;
4659 |  |
             case INTERFACE:
4660 | 0 |
          pushAndGet();
4661 | 0 |
               UnmodifiedInterfaceDeclaration();
4662 | 0 |
         jjtree.closeNodeScope(jjtn000, true);
4663 | 0 |
         jjtc000 = false;
4664 | 0 |
          popAndAddInner();
4665 | 0 |
               break;
4666 |  |
             default:
4667 | 0 |
               jj_la1[107] = jj_gen;
4668 | 0 |
               jj_consume_token(-1);
4669 | 0 |
               throw new ParseException();
4670 |  |
             }
4671 |  |
           }
4672 |  |
         } catch (Throwable jjte000) {
4673 | 0 |
         if (jjtc000) {
4674 | 0 |
           jjtree.clearNodeScope(jjtn000);
4675 | 0 |
           jjtc000 = false;
4676 |  |
         } else {
4677 | 0 |
           jjtree.popNode();
4678 |  |
         }
4679 | 0 |
         if (jjte000 instanceof RuntimeException) {
4680 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
4681 |  |
         }
4682 | 0 |
         if (jjte000 instanceof ParseException) {
4683 | 0 |
           {if (true) throw (ParseException)jjte000;}
4684 |  |
         }
4685 | 0 |
         {if (true) throw (Error)jjte000;}
4686 |  |
         } finally {
4687 | 4 |
         if (jjtc000) {
4688 | 4 |
           jjtree.closeNodeScope(jjtn000, true);
4689 |  |
         }
4690 |  |
         }
4691 |  |
       }
4692 |  |
4693 | 110 |
       final public void Method_BlockStatement() throws ParseException {
4694 |  |
      /*@bgen(jjtree) Method_BlockStatement */
4695 | 110 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTMETHOD_BLOCKSTATEMENT);
4696 | 110 |
       boolean jjtc000 = true;
4697 | 110 |
       jjtree.openNodeScope(jjtn000);
4698 | 110 |
         try {
4699 | 110 |
           if (jj_2_30(2147483647)) {
4700 | 38 |
             LocalVariableDeclaration();
4701 | 38 |
             jj_consume_token(SEMICOLON);
4702 |  |
           } else {
4703 | 72 |
             switch (jj_nt.kind) {
4704 |  |
             case BOOLEAN:
4705 |  |
             case BREAK:
4706 |  |
             case BYTE:
4707 |  |
             case CHAR:
4708 |  |
             case CONTINUE:
4709 |  |
             case DO:
4710 |  |
             case DOUBLE:
4711 |  |
             case FALSE:
4712 |  |
             case FLOAT:
4713 |  |
             case FOR:
4714 |  |
             case IF:
4715 |  |
             case INT:
4716 |  |
             case LONG:
4717 |  |
             case NEW:
4718 |  |
             case NULL:
4719 |  |
             case RETURN:
4720 |  |
             case SHORT:
4721 |  |
             case SUPER:
4722 |  |
             case SWITCH:
4723 |  |
             case SYNCHRONIZED:
4724 |  |
             case THIS:
4725 |  |
             case THROW:
4726 |  |
             case TRUE:
4727 |  |
             case TRY:
4728 |  |
             case VOID:
4729 |  |
             case WHILE:
4730 |  |
             case ASSERT:
4731 |  |
             case INTEGER_LITERAL:
4732 |  |
             case FLOATING_POINT_LITERAL:
4733 |  |
             case CHARACTER_LITERAL:
4734 |  |
             case STRING_LITERAL:
4735 |  |
             case IDENTIFIER:
4736 |  |
             case LPAREN:
4737 |  |
             case LBRACE:
4738 |  |
             case SEMICOLON:
4739 |  |
             case INCR:
4740 |  |
             case DECR:
4741 | 64 |
               Statement();
4742 | 64 |
               break;
4743 |  |
             case CLASS:
4744 | 8 |
          pushAndGet();
4745 | 8 |
               UnmodifiedClassDeclaration();
4746 | 8 |
         jjtree.closeNodeScope(jjtn000, true);
4747 | 8 |
         jjtc000 = false;
4748 | 8 |
          popAndAddInner();
4749 | 8 |
               break;
4750 |  |
             case INTERFACE:
4751 | 0 |
          pushAndGet();
4752 | 0 |
               UnmodifiedInterfaceDeclaration();
4753 | 0 |
         jjtree.closeNodeScope(jjtn000, true);
4754 | 0 |
         jjtc000 = false;
4755 | 0 |
          popAndAddInner();
4756 | 0 |
               break;
4757 |  |
             default:
4758 | 0 |
               jj_la1[108] = jj_gen;
4759 | 0 |
               jj_consume_token(-1);
4760 | 0 |
               throw new ParseException();
4761 |  |
             }
4762 |  |
           }
4763 |  |
         } catch (Throwable jjte000) {
4764 | 0 |
         if (jjtc000) {
4765 | 0 |
           jjtree.clearNodeScope(jjtn000);
4766 | 0 |
           jjtc000 = false;
4767 |  |
         } else {
4768 | 0 |
           jjtree.popNode();
4769 |  |
         }
4770 | 0 |
         if (jjte000 instanceof RuntimeException) {
4771 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
4772 |  |
         }
4773 | 0 |
         if (jjte000 instanceof ParseException) {
4774 | 0 |
           {if (true) throw (ParseException)jjte000;}
4775 |  |
         }
4776 | 0 |
         {if (true) throw (Error)jjte000;}
4777 |  |
         } finally {
4778 | 110 |
         if (jjtc000) {
4779 | 102 |
           jjtree.closeNodeScope(jjtn000, true);
4780 |  |
         }
4781 |  |
         }
4782 |  |
       }
4783 |  |
4784 | 42 |
       final public void LocalVariableDeclaration() throws ParseException {
4785 |  |
      /*@bgen(jjtree) LocalVariableDeclaration */
4786 | 42 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTLOCALVARIABLEDECLARATION);
4787 | 42 |
       boolean jjtc000 = true;
4788 | 42 |
       jjtree.openNodeScope(jjtn000);
4789 | 42 |
         try {
4790 | 42 |
           switch (jj_nt.kind) {
4791 |  |
           case FINAL:
4792 | 0 |
             jj_consume_token(FINAL);
4793 | 0 |
             break;
4794 |  |
           default:
4795 | 42 |
             jj_la1[109] = jj_gen;
4796 |  |
             ;
4797 |  |
           }
4798 | 42 |
           Type();
4799 | 42 |
           VariableDeclarator();
4800 | 42 |
           label_47:
4801 |  |
           while (true) {
4802 | 42 |
             switch (jj_nt.kind) {
4803 |  |
             case COMMA:
4804 |  |
               ;
4805 | 0 |
               break;
4806 |  |
             default:
4807 | 42 |
               jj_la1[110] = jj_gen;
4808 | 42 |
               break label_47;
4809 |  |
             }
4810 | 0 |
             jj_consume_token(COMMA);
4811 | 0 |
             VariableDeclarator();
4812 |  |
           }
4813 |  |
         } catch (Throwable jjte000) {
4814 | 0 |
         if (jjtc000) {
4815 | 0 |
           jjtree.clearNodeScope(jjtn000);
4816 | 0 |
           jjtc000 = false;
4817 |  |
         } else {
4818 | 0 |
           jjtree.popNode();
4819 |  |
         }
4820 | 0 |
         if (jjte000 instanceof RuntimeException) {
4821 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
4822 |  |
         }
4823 | 0 |
         if (jjte000 instanceof ParseException) {
4824 | 0 |
           {if (true) throw (ParseException)jjte000;}
4825 |  |
         }
4826 | 0 |
         {if (true) throw (Error)jjte000;}
4827 |  |
         } finally {
4828 | 42 |
         if (jjtc000) {
4829 | 42 |
           jjtree.closeNodeScope(jjtn000, true);
4830 |  |
         }
4831 |  |
         }
4832 |  |
       }
4833 |  |
4834 | 0 |
       final public void EmptyStatement() throws ParseException {
4835 |  |
      /*@bgen(jjtree) EmptyStatement */
4836 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTEMPTYSTATEMENT);
4837 | 0 |
       boolean jjtc000 = true;
4838 | 0 |
       jjtree.openNodeScope(jjtn000);
4839 | 0 |
         try {
4840 | 0 |
           jj_consume_token(SEMICOLON);
4841 |  |
         } finally {
4842 | 0 |
         if (jjtc000) {
4843 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
4844 |  |
         }
4845 |  |
         }
4846 |  |
       }
4847 |  |
4848 | 28 |
       final public void StatementExpression() throws ParseException {
4849 |  |
      /*@bgen(jjtree) StatementExpression */
4850 | 28 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTSTATEMENTEXPRESSION);
4851 | 28 |
       boolean jjtc000 = true;
4852 | 28 |
       jjtree.openNodeScope(jjtn000);
4853 | 28 |
         try {
4854 | 28 |
           switch (jj_nt.kind) {
4855 |  |
           case INCR:
4856 | 0 |
             PreIncrementExpression();
4857 | 0 |
             break;
4858 |  |
           case DECR:
4859 | 0 |
             PreDecrementExpression();
4860 | 0 |
             break;
4861 |  |
           case BOOLEAN:
4862 |  |
           case BYTE:
4863 |  |
           case CHAR:
4864 |  |
           case DOUBLE:
4865 |  |
           case FALSE:
4866 |  |
           case FLOAT:
4867 |  |
           case INT:
4868 |  |
           case LONG:
4869 |  |
           case NEW:
4870 |  |
           case NULL:
4871 |  |
           case SHORT:
4872 |  |
           case SUPER:
4873 |  |
           case THIS:
4874 |  |
           case TRUE:
4875 |  |
           case VOID:
4876 |  |
           case INTEGER_LITERAL:
4877 |  |
           case FLOATING_POINT_LITERAL:
4878 |  |
           case CHARACTER_LITERAL:
4879 |  |
           case STRING_LITERAL:
4880 |  |
           case IDENTIFIER:
4881 |  |
           case LPAREN:
4882 | 28 |
             PrimaryExpression();
4883 | 28 |
             switch (jj_nt.kind) {
4884 |  |
             case ASSIGN:
4885 |  |
             case INCR:
4886 |  |
             case DECR:
4887 |  |
             case PLUSASSIGN:
4888 |  |
             case MINUSASSIGN:
4889 |  |
             case STARASSIGN:
4890 |  |
             case SLASHASSIGN:
4891 |  |
             case ANDASSIGN:
4892 |  |
             case ORASSIGN:
4893 |  |
             case XORASSIGN:
4894 |  |
             case REMASSIGN:
4895 |  |
             case LSHIFTASSIGN:
4896 |  |
             case RSIGNEDSHIFTASSIGN:
4897 |  |
             case RUNSIGNEDSHIFTASSIGN:
4898 | 0 |
               switch (jj_nt.kind) {
4899 |  |
               case INCR:
4900 | 0 |
                 jj_consume_token(INCR);
4901 | 0 |
                 break;
4902 |  |
               case DECR:
4903 | 0 |
                 jj_consume_token(DECR);
4904 | 0 |
                 break;
4905 |  |
               case ASSIGN:
4906 |  |
               case PLUSASSIGN:
4907 |  |
               case MINUSASSIGN:
4908 |  |
               case STARASSIGN:
4909 |  |
               case SLASHASSIGN:
4910 |  |
               case ANDASSIGN:
4911 |  |
               case ORASSIGN:
4912 |  |
               case XORASSIGN:
4913 |  |
               case REMASSIGN:
4914 |  |
               case LSHIFTASSIGN:
4915 |  |
               case RSIGNEDSHIFTASSIGN:
4916 |  |
               case RUNSIGNEDSHIFTASSIGN:
4917 | 0 |
                 AssignmentOperator();
4918 | 0 |
                 Expression();
4919 | 0 |
                 break;
4920 |  |
               default:
4921 | 0 |
                 jj_la1[111] = jj_gen;
4922 | 0 |
                 jj_consume_token(-1);
4923 | 0 |
                 throw new ParseException();
4924 |  |
               }
4925 | 0 |
               break;
4926 |  |
             default:
4927 | 28 |
               jj_la1[112] = jj_gen;
4928 |  |
               ;
4929 |  |
             }
4930 | 28 |
             break;
4931 |  |
           default:
4932 | 0 |
             jj_la1[113] = jj_gen;
4933 | 0 |
             jj_consume_token(-1);
4934 | 0 |
             throw new ParseException();
4935 |  |
           }
4936 |  |
         } catch (Throwable jjte000) {
4937 | 0 |
         if (jjtc000) {
4938 | 0 |
           jjtree.clearNodeScope(jjtn000);
4939 | 0 |
           jjtc000 = false;
4940 |  |
         } else {
4941 | 0 |
           jjtree.popNode();
4942 |  |
         }
4943 | 0 |
         if (jjte000 instanceof RuntimeException) {
4944 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
4945 |  |
         }
4946 | 0 |
         if (jjte000 instanceof ParseException) {
4947 | 0 |
           {if (true) throw (ParseException)jjte000;}
4948 |  |
         }
4949 | 0 |
         {if (true) throw (Error)jjte000;}
4950 |  |
         } finally {
4951 | 28 |
         if (jjtc000) {
4952 | 28 |
           jjtree.closeNodeScope(jjtn000, true);
4953 |  |
         }
4954 |  |
         }
4955 |  |
       }
4956 |  |
4957 | 0 |
       final public void SwitchStatement() throws ParseException {
4958 |  |
      /*@bgen(jjtree) SwitchStatement */
4959 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTSWITCHSTATEMENT);
4960 | 0 |
       boolean jjtc000 = true;
4961 | 0 |
       jjtree.openNodeScope(jjtn000);
4962 | 0 |
         try {
4963 | 0 |
           jj_consume_token(SWITCH);
4964 | 0 |
           jj_consume_token(LPAREN);
4965 | 0 |
           Expression();
4966 | 0 |
           jj_consume_token(RPAREN);
4967 | 0 |
           jj_consume_token(LBRACE);
4968 | 0 |
           label_48:
4969 |  |
           while (true) {
4970 | 0 |
             switch (jj_nt.kind) {
4971 |  |
             case CASE:
4972 |  |
             case _DEFAULT:
4973 |  |
               ;
4974 | 0 |
               break;
4975 |  |
             default:
4976 | 0 |
               jj_la1[114] = jj_gen;
4977 | 0 |
               break label_48;
4978 |  |
             }
4979 | 0 |
             SwitchLabel();
4980 | 0 |
             label_49:
4981 |  |
             while (true) {
4982 | 0 |
               switch (jj_nt.kind) {
4983 |  |
               case BOOLEAN:
4984 |  |
               case BREAK:
4985 |  |
               case BYTE:
4986 |  |
               case CHAR:
4987 |  |
               case CLASS:
4988 |  |
               case CONTINUE:
4989 |  |
               case DO:
4990 |  |
               case DOUBLE:
4991 |  |
               case FALSE:
4992 |  |
               case FINAL:
4993 |  |
               case FLOAT:
4994 |  |
               case FOR:
4995 |  |
               case IF:
4996 |  |
               case INT:
4997 |  |
               case INTERFACE:
4998 |  |
               case LONG:
4999 |  |
               case NEW:
5000 |  |
               case NULL:
5001 |  |
               case RETURN:
5002 |  |
               case SHORT:
5003 |  |
               case SUPER:
5004 |  |
               case SWITCH:
5005 |  |
               case SYNCHRONIZED:
5006 |  |
               case THIS:
5007 |  |
               case THROW:
5008 |  |
               case TRUE:
5009 |  |
               case TRY:
5010 |  |
               case VOID:
5011 |  |
               case WHILE:
5012 |  |
               case ASSERT:
5013 |  |
               case INTEGER_LITERAL:
5014 |  |
               case FLOATING_POINT_LITERAL:
5015 |  |
               case CHARACTER_LITERAL:
5016 |  |
               case STRING_LITERAL:
5017 |  |
               case IDENTIFIER:
5018 |  |
               case LPAREN:
5019 |  |
               case LBRACE:
5020 |  |
               case SEMICOLON:
5021 |  |
               case INCR:
5022 |  |
               case DECR:
5023 |  |
                 ;
5024 | 0 |
                 break;
5025 |  |
               default:
5026 | 0 |
                 jj_la1[115] = jj_gen;
5027 | 0 |
                 break label_49;
5028 |  |
               }
5029 | 0 |
               BlockStatement();
5030 |  |
             }
5031 |  |
           }
5032 | 0 |
           jj_consume_token(RBRACE);
5033 |  |
         } catch (Throwable jjte000) {
5034 | 0 |
         if (jjtc000) {
5035 | 0 |
           jjtree.clearNodeScope(jjtn000);
5036 | 0 |
           jjtc000 = false;
5037 |  |
         } else {
5038 | 0 |
           jjtree.popNode();
5039 |  |
         }
5040 | 0 |
         if (jjte000 instanceof RuntimeException) {
5041 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5042 |  |
         }
5043 | 0 |
         if (jjte000 instanceof ParseException) {
5044 | 0 |
           {if (true) throw (ParseException)jjte000;}
5045 |  |
         }
5046 | 0 |
         {if (true) throw (Error)jjte000;}
5047 |  |
         } finally {
5048 | 0 |
         if (jjtc000) {
5049 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5050 |  |
         }
5051 |  |
         }
5052 |  |
       }
5053 |  |
5054 | 0 |
       final public void SwitchLabel() throws ParseException {
5055 |  |
      /*@bgen(jjtree) SwitchLabel */
5056 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTSWITCHLABEL);
5057 | 0 |
       boolean jjtc000 = true;
5058 | 0 |
       jjtree.openNodeScope(jjtn000);
5059 | 0 |
         try {
5060 | 0 |
           switch (jj_nt.kind) {
5061 |  |
           case CASE:
5062 | 0 |
             jj_consume_token(CASE);
5063 | 0 |
             Expression();
5064 | 0 |
             jj_consume_token(COLON);
5065 | 0 |
             break;
5066 |  |
           case _DEFAULT:
5067 | 0 |
             jj_consume_token(_DEFAULT);
5068 | 0 |
             jj_consume_token(COLON);
5069 | 0 |
             break;
5070 |  |
           default:
5071 | 0 |
             jj_la1[116] = jj_gen;
5072 | 0 |
             jj_consume_token(-1);
5073 | 0 |
             throw new ParseException();
5074 |  |
           }
5075 |  |
         } catch (Throwable jjte000) {
5076 | 0 |
         if (jjtc000) {
5077 | 0 |
           jjtree.clearNodeScope(jjtn000);
5078 | 0 |
           jjtc000 = false;
5079 |  |
         } else {
5080 | 0 |
           jjtree.popNode();
5081 |  |
         }
5082 | 0 |
         if (jjte000 instanceof RuntimeException) {
5083 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5084 |  |
         }
5085 | 0 |
         if (jjte000 instanceof ParseException) {
5086 | 0 |
           {if (true) throw (ParseException)jjte000;}
5087 |  |
         }
5088 | 0 |
         {if (true) throw (Error)jjte000;}
5089 |  |
         } finally {
5090 | 0 |
         if (jjtc000) {
5091 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5092 |  |
         }
5093 |  |
         }
5094 |  |
       }
5095 |  |
5096 | 0 |
       final public void IfStatement() throws ParseException {
5097 |  |
      /*@bgen(jjtree) IfStatement */
5098 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTIFSTATEMENT);
5099 | 0 |
       boolean jjtc000 = true;
5100 | 0 |
       jjtree.openNodeScope(jjtn000);
5101 | 0 |
         try {
5102 | 0 |
           jj_consume_token(IF);
5103 | 0 |
           jj_consume_token(LPAREN);
5104 | 0 |
           Expression();
5105 | 0 |
           jj_consume_token(RPAREN);
5106 | 0 |
           Statement();
5107 | 0 |
           switch (jj_nt.kind) {
5108 |  |
           case ELSE:
5109 | 0 |
             jj_consume_token(ELSE);
5110 | 0 |
             Statement();
5111 | 0 |
             break;
5112 |  |
           default:
5113 | 0 |
             jj_la1[117] = jj_gen;
5114 |  |
             ;
5115 |  |
           }
5116 |  |
         } catch (Throwable jjte000) {
5117 | 0 |
         if (jjtc000) {
5118 | 0 |
           jjtree.clearNodeScope(jjtn000);
5119 | 0 |
           jjtc000 = false;
5120 |  |
         } else {
5121 | 0 |
           jjtree.popNode();
5122 |  |
         }
5123 | 0 |
         if (jjte000 instanceof RuntimeException) {
5124 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5125 |  |
         }
5126 | 0 |
         if (jjte000 instanceof ParseException) {
5127 | 0 |
           {if (true) throw (ParseException)jjte000;}
5128 |  |
         }
5129 | 0 |
         {if (true) throw (Error)jjte000;}
5130 |  |
         } finally {
5131 | 0 |
         if (jjtc000) {
5132 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5133 |  |
         }
5134 |  |
         }
5135 |  |
       }
5136 |  |
5137 | 0 |
       final public void WhileStatement() throws ParseException {
5138 |  |
      /*@bgen(jjtree) WhileStatement */
5139 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTWHILESTATEMENT);
5140 | 0 |
       boolean jjtc000 = true;
5141 | 0 |
       jjtree.openNodeScope(jjtn000);
5142 | 0 |
         try {
5143 | 0 |
           jj_consume_token(WHILE);
5144 | 0 |
           jj_consume_token(LPAREN);
5145 | 0 |
           Expression();
5146 | 0 |
           jj_consume_token(RPAREN);
5147 | 0 |
           Statement();
5148 |  |
         } catch (Throwable jjte000) {
5149 | 0 |
         if (jjtc000) {
5150 | 0 |
           jjtree.clearNodeScope(jjtn000);
5151 | 0 |
           jjtc000 = false;
5152 |  |
         } else {
5153 | 0 |
           jjtree.popNode();
5154 |  |
         }
5155 | 0 |
         if (jjte000 instanceof RuntimeException) {
5156 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5157 |  |
         }
5158 | 0 |
         if (jjte000 instanceof ParseException) {
5159 | 0 |
           {if (true) throw (ParseException)jjte000;}
5160 |  |
         }
5161 | 0 |
         {if (true) throw (Error)jjte000;}
5162 |  |
         } finally {
5163 | 0 |
         if (jjtc000) {
5164 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5165 |  |
         }
5166 |  |
         }
5167 |  |
       }
5168 |  |
5169 | 0 |
       final public void DoStatement() throws ParseException {
5170 |  |
      /*@bgen(jjtree) DoStatement */
5171 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTDOSTATEMENT);
5172 | 0 |
       boolean jjtc000 = true;
5173 | 0 |
       jjtree.openNodeScope(jjtn000);
5174 | 0 |
         try {
5175 | 0 |
           jj_consume_token(DO);
5176 | 0 |
           Statement();
5177 | 0 |
           jj_consume_token(WHILE);
5178 | 0 |
           jj_consume_token(LPAREN);
5179 | 0 |
           Expression();
5180 | 0 |
           jj_consume_token(RPAREN);
5181 | 0 |
           jj_consume_token(SEMICOLON);
5182 |  |
         } catch (Throwable jjte000) {
5183 | 0 |
         if (jjtc000) {
5184 | 0 |
           jjtree.clearNodeScope(jjtn000);
5185 | 0 |
           jjtc000 = false;
5186 |  |
         } else {
5187 | 0 |
           jjtree.popNode();
5188 |  |
         }
5189 | 0 |
         if (jjte000 instanceof RuntimeException) {
5190 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5191 |  |
         }
5192 | 0 |
         if (jjte000 instanceof ParseException) {
5193 | 0 |
           {if (true) throw (ParseException)jjte000;}
5194 |  |
         }
5195 | 0 |
         {if (true) throw (Error)jjte000;}
5196 |  |
         } finally {
5197 | 0 |
         if (jjtc000) {
5198 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5199 |  |
         }
5200 |  |
         }
5201 |  |
       }
5202 |  |
5203 | 0 |
       final public void ForStatement() throws ParseException {
5204 |  |
      /*@bgen(jjtree) ForStatement */
5205 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTFORSTATEMENT);
5206 | 0 |
       boolean jjtc000 = true;
5207 | 0 |
       jjtree.openNodeScope(jjtn000);
5208 | 0 |
         try {
5209 | 0 |
           jj_consume_token(FOR);
5210 | 0 |
           jj_consume_token(LPAREN);
5211 | 0 |
           switch (jj_nt.kind) {
5212 |  |
           case BOOLEAN:
5213 |  |
           case BYTE:
5214 |  |
           case CHAR:
5215 |  |
           case DOUBLE:
5216 |  |
           case FALSE:
5217 |  |
           case FINAL:
5218 |  |
           case FLOAT:
5219 |  |
           case INT:
5220 |  |
           case LONG:
5221 |  |
           case NEW:
5222 |  |
           case NULL:
5223 |  |
           case SHORT:
5224 |  |
           case SUPER:
5225 |  |
           case THIS:
5226 |  |
           case TRUE:
5227 |  |
           case VOID:
5228 |  |
           case INTEGER_LITERAL:
5229 |  |
           case FLOATING_POINT_LITERAL:
5230 |  |
           case CHARACTER_LITERAL:
5231 |  |
           case STRING_LITERAL:
5232 |  |
           case IDENTIFIER:
5233 |  |
           case LPAREN:
5234 |  |
           case INCR:
5235 |  |
           case DECR:
5236 | 0 |
             ForInit();
5237 | 0 |
             break;
5238 |  |
           default:
5239 | 0 |
             jj_la1[118] = jj_gen;
5240 |  |
             ;
5241 |  |
           }
5242 | 0 |
           jj_consume_token(SEMICOLON);
5243 | 0 |
           switch (jj_nt.kind) {
5244 |  |
           case BOOLEAN:
5245 |  |
           case BYTE:
5246 |  |
           case CHAR:
5247 |  |
           case DOUBLE:
5248 |  |
           case FALSE:
5249 |  |
           case FLOAT:
5250 |  |
           case INT:
5251 |  |
           case LONG:
5252 |  |
           case NEW:
5253 |  |
           case NULL:
5254 |  |
           case SHORT:
5255 |  |
           case SUPER:
5256 |  |
           case THIS:
5257 |  |
           case TRUE:
5258 |  |
           case VOID:
5259 |  |
           case INTEGER_LITERAL:
5260 |  |
           case FLOATING_POINT_LITERAL:
5261 |  |
           case CHARACTER_LITERAL:
5262 |  |
           case STRING_LITERAL:
5263 |  |
           case IDENTIFIER:
5264 |  |
           case LPAREN:
5265 |  |
           case BANG:
5266 |  |
           case TILDE:
5267 |  |
           case INCR:
5268 |  |
           case DECR:
5269 |  |
           case PLUS:
5270 |  |
           case MINUS:
5271 | 0 |
             Expression();
5272 | 0 |
             break;
5273 |  |
           default:
5274 | 0 |
             jj_la1[119] = jj_gen;
5275 |  |
             ;
5276 |  |
           }
5277 | 0 |
           jj_consume_token(SEMICOLON);
5278 | 0 |
           switch (jj_nt.kind) {
5279 |  |
           case BOOLEAN:
5280 |  |
           case BYTE:
5281 |  |
           case CHAR:
5282 |  |
           case DOUBLE:
5283 |  |
           case FALSE:
5284 |  |
           case FLOAT:
5285 |  |
           case INT:
5286 |  |
           case LONG:
5287 |  |
           case NEW:
5288 |  |
           case NULL:
5289 |  |
           case SHORT:
5290 |  |
           case SUPER:
5291 |  |
           case THIS:
5292 |  |
           case TRUE:
5293 |  |
           case VOID:
5294 |  |
           case INTEGER_LITERAL:
5295 |  |
           case FLOATING_POINT_LITERAL:
5296 |  |
           case CHARACTER_LITERAL:
5297 |  |
           case STRING_LITERAL:
5298 |  |
           case IDENTIFIER:
5299 |  |
           case LPAREN:
5300 |  |
           case INCR:
5301 |  |
           case DECR:
5302 | 0 |
             ForUpdate();
5303 | 0 |
             break;
5304 |  |
           default:
5305 | 0 |
             jj_la1[120] = jj_gen;
5306 |  |
             ;
5307 |  |
           }
5308 | 0 |
           jj_consume_token(RPAREN);
5309 | 0 |
           Statement();
5310 |  |
         } catch (Throwable jjte000) {
5311 | 0 |
         if (jjtc000) {
5312 | 0 |
           jjtree.clearNodeScope(jjtn000);
5313 | 0 |
           jjtc000 = false;
5314 |  |
         } else {
5315 | 0 |
           jjtree.popNode();
5316 |  |
         }
5317 | 0 |
         if (jjte000 instanceof RuntimeException) {
5318 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5319 |  |
         }
5320 | 0 |
         if (jjte000 instanceof ParseException) {
5321 | 0 |
           {if (true) throw (ParseException)jjte000;}
5322 |  |
         }
5323 | 0 |
         {if (true) throw (Error)jjte000;}
5324 |  |
         } finally {
5325 | 0 |
         if (jjtc000) {
5326 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5327 |  |
         }
5328 |  |
         }
5329 |  |
       }
5330 |  |
5331 | 0 |
       final public void ForInit() throws ParseException {
5332 |  |
      /*@bgen(jjtree) ForInit */
5333 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTFORINIT);
5334 | 0 |
       boolean jjtc000 = true;
5335 | 0 |
       jjtree.openNodeScope(jjtn000);
5336 | 0 |
         try {
5337 | 0 |
           if (jj_2_31(2147483647)) {
5338 | 0 |
             LocalVariableDeclaration();
5339 |  |
           } else {
5340 | 0 |
             switch (jj_nt.kind) {
5341 |  |
             case BOOLEAN:
5342 |  |
             case BYTE:
5343 |  |
             case CHAR:
5344 |  |
             case DOUBLE:
5345 |  |
             case FALSE:
5346 |  |
             case FLOAT:
5347 |  |
             case INT:
5348 |  |
             case LONG:
5349 |  |
             case NEW:
5350 |  |
             case NULL:
5351 |  |
             case SHORT:
5352 |  |
             case SUPER:
5353 |  |
             case THIS:
5354 |  |
             case TRUE:
5355 |  |
             case VOID:
5356 |  |
             case INTEGER_LITERAL:
5357 |  |
             case FLOATING_POINT_LITERAL:
5358 |  |
             case CHARACTER_LITERAL:
5359 |  |
             case STRING_LITERAL:
5360 |  |
             case IDENTIFIER:
5361 |  |
             case LPAREN:
5362 |  |
             case INCR:
5363 |  |
             case DECR:
5364 | 0 |
               StatementExpressionList();
5365 | 0 |
               break;
5366 |  |
             default:
5367 | 0 |
               jj_la1[121] = jj_gen;
5368 | 0 |
               jj_consume_token(-1);
5369 | 0 |
               throw new ParseException();
5370 |  |
             }
5371 |  |
           }
5372 |  |
         } catch (Throwable jjte000) {
5373 | 0 |
         if (jjtc000) {
5374 | 0 |
           jjtree.clearNodeScope(jjtn000);
5375 | 0 |
           jjtc000 = false;
5376 |  |
         } else {
5377 | 0 |
           jjtree.popNode();
5378 |  |
         }
5379 | 0 |
         if (jjte000 instanceof RuntimeException) {
5380 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5381 |  |
         }
5382 | 0 |
         if (jjte000 instanceof ParseException) {
5383 | 0 |
           {if (true) throw (ParseException)jjte000;}
5384 |  |
         }
5385 | 0 |
         {if (true) throw (Error)jjte000;}
5386 |  |
         } finally {
5387 | 0 |
         if (jjtc000) {
5388 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5389 |  |
         }
5390 |  |
         }
5391 |  |
       }
5392 |  |
5393 | 0 |
       final public void StatementExpressionList() throws ParseException {
5394 |  |
      /*@bgen(jjtree) StatementExpressionList */
5395 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTSTATEMENTEXPRESSIONLIST);
5396 | 0 |
       boolean jjtc000 = true;
5397 | 0 |
       jjtree.openNodeScope(jjtn000);
5398 | 0 |
         try {
5399 | 0 |
           StatementExpression();
5400 | 0 |
           label_50:
5401 |  |
           while (true) {
5402 | 0 |
             switch (jj_nt.kind) {
5403 |  |
             case COMMA:
5404 |  |
               ;
5405 | 0 |
               break;
5406 |  |
             default:
5407 | 0 |
               jj_la1[122] = jj_gen;
5408 | 0 |
               break label_50;
5409 |  |
             }
5410 | 0 |
             jj_consume_token(COMMA);
5411 | 0 |
             StatementExpression();
5412 |  |
           }
5413 |  |
         } catch (Throwable jjte000) {
5414 | 0 |
         if (jjtc000) {
5415 | 0 |
           jjtree.clearNodeScope(jjtn000);
5416 | 0 |
           jjtc000 = false;
5417 |  |
         } else {
5418 | 0 |
           jjtree.popNode();
5419 |  |
         }
5420 | 0 |
         if (jjte000 instanceof RuntimeException) {
5421 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5422 |  |
         }
5423 | 0 |
         if (jjte000 instanceof ParseException) {
5424 | 0 |
           {if (true) throw (ParseException)jjte000;}
5425 |  |
         }
5426 | 0 |
         {if (true) throw (Error)jjte000;}
5427 |  |
         } finally {
5428 | 0 |
         if (jjtc000) {
5429 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5430 |  |
         }
5431 |  |
         }
5432 |  |
       }
5433 |  |
5434 | 0 |
       final public void ForUpdate() throws ParseException {
5435 |  |
      /*@bgen(jjtree) ForUpdate */
5436 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTFORUPDATE);
5437 | 0 |
       boolean jjtc000 = true;
5438 | 0 |
       jjtree.openNodeScope(jjtn000);
5439 | 0 |
         try {
5440 | 0 |
           StatementExpressionList();
5441 |  |
         } catch (Throwable jjte000) {
5442 | 0 |
         if (jjtc000) {
5443 | 0 |
           jjtree.clearNodeScope(jjtn000);
5444 | 0 |
           jjtc000 = false;
5445 |  |
         } else {
5446 | 0 |
           jjtree.popNode();
5447 |  |
         }
5448 | 0 |
         if (jjte000 instanceof RuntimeException) {
5449 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5450 |  |
         }
5451 | 0 |
         if (jjte000 instanceof ParseException) {
5452 | 0 |
           {if (true) throw (ParseException)jjte000;}
5453 |  |
         }
5454 | 0 |
         {if (true) throw (Error)jjte000;}
5455 |  |
         } finally {
5456 | 0 |
         if (jjtc000) {
5457 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5458 |  |
         }
5459 |  |
         }
5460 |  |
       }
5461 |  |
5462 | 0 |
       final public void BreakStatement() throws ParseException {
5463 |  |
      /*@bgen(jjtree) BreakStatement */
5464 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTBREAKSTATEMENT);
5465 | 0 |
       boolean jjtc000 = true;
5466 | 0 |
       jjtree.openNodeScope(jjtn000);
5467 | 0 |
         try {
5468 | 0 |
           jj_consume_token(BREAK);
5469 | 0 |
           switch (jj_nt.kind) {
5470 |  |
           case IDENTIFIER:
5471 | 0 |
             jj_consume_token(IDENTIFIER);
5472 | 0 |
             break;
5473 |  |
           default:
5474 | 0 |
             jj_la1[123] = jj_gen;
5475 |  |
             ;
5476 |  |
           }
5477 | 0 |
           jj_consume_token(SEMICOLON);
5478 |  |
         } finally {
5479 | 0 |
         if (jjtc000) {
5480 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5481 |  |
         }
5482 |  |
         }
5483 |  |
       }
5484 |  |
5485 | 0 |
       final public void ContinueStatement() throws ParseException {
5486 |  |
      /*@bgen(jjtree) ContinueStatement */
5487 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTCONTINUESTATEMENT);
5488 | 0 |
       boolean jjtc000 = true;
5489 | 0 |
       jjtree.openNodeScope(jjtn000);
5490 | 0 |
         try {
5491 | 0 |
           jj_consume_token(CONTINUE);
5492 | 0 |
           switch (jj_nt.kind) {
5493 |  |
           case IDENTIFIER:
5494 | 0 |
             jj_consume_token(IDENTIFIER);
5495 | 0 |
             break;
5496 |  |
           default:
5497 | 0 |
             jj_la1[124] = jj_gen;
5498 |  |
             ;
5499 |  |
           }
5500 | 0 |
           jj_consume_token(SEMICOLON);
5501 |  |
         } finally {
5502 | 0 |
         if (jjtc000) {
5503 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5504 |  |
         }
5505 |  |
         }
5506 |  |
       }
5507 |  |
5508 | 20 |
       final public void ReturnStatement() throws ParseException {
5509 |  |
      /*@bgen(jjtree) ReturnStatement */
5510 | 20 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTRETURNSTATEMENT);
5511 | 20 |
       boolean jjtc000 = true;
5512 | 20 |
       jjtree.openNodeScope(jjtn000);
5513 | 20 |
         try {
5514 | 20 |
           jj_consume_token(RETURN);
5515 | 20 |
           switch (jj_nt.kind) {
5516 |  |
           case BOOLEAN:
5517 |  |
           case BYTE:
5518 |  |
           case CHAR:
5519 |  |
           case DOUBLE:
5520 |  |
           case FALSE:
5521 |  |
           case FLOAT:
5522 |  |
           case INT:
5523 |  |
           case LONG:
5524 |  |
           case NEW:
5525 |  |
           case NULL:
5526 |  |
           case SHORT:
5527 |  |
           case SUPER:
5528 |  |
           case THIS:
5529 |  |
           case TRUE:
5530 |  |
           case VOID:
5531 |  |
           case INTEGER_LITERAL:
5532 |  |
           case FLOATING_POINT_LITERAL:
5533 |  |
           case CHARACTER_LITERAL:
5534 |  |
           case STRING_LITERAL:
5535 |  |
           case IDENTIFIER:
5536 |  |
           case LPAREN:
5537 |  |
           case BANG:
5538 |  |
           case TILDE:
5539 |  |
           case INCR:
5540 |  |
           case DECR:
5541 |  |
           case PLUS:
5542 |  |
           case MINUS:
5543 | 20 |
             Expression();
5544 | 20 |
             break;
5545 |  |
           default:
5546 | 0 |
             jj_la1[125] = jj_gen;
5547 |  |
             ;
5548 |  |
           }
5549 | 20 |
           jj_consume_token(SEMICOLON);
5550 |  |
         } catch (Throwable jjte000) {
5551 | 0 |
         if (jjtc000) {
5552 | 0 |
           jjtree.clearNodeScope(jjtn000);
5553 | 0 |
           jjtc000 = false;
5554 |  |
         } else {
5555 | 0 |
           jjtree.popNode();
5556 |  |
         }
5557 | 0 |
         if (jjte000 instanceof RuntimeException) {
5558 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5559 |  |
         }
5560 | 0 |
         if (jjte000 instanceof ParseException) {
5561 | 0 |
           {if (true) throw (ParseException)jjte000;}
5562 |  |
         }
5563 | 0 |
         {if (true) throw (Error)jjte000;}
5564 |  |
         } finally {
5565 | 20 |
         if (jjtc000) {
5566 | 20 |
           jjtree.closeNodeScope(jjtn000, true);
5567 |  |
         }
5568 |  |
         }
5569 |  |
       }
5570 |  |
5571 | 0 |
       final public void ThrowStatement() throws ParseException {
5572 |  |
      /*@bgen(jjtree) ThrowStatement */
5573 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTTHROWSTATEMENT);
5574 | 0 |
       boolean jjtc000 = true;
5575 | 0 |
       jjtree.openNodeScope(jjtn000);
5576 | 0 |
         try {
5577 | 0 |
           jj_consume_token(THROW);
5578 | 0 |
           Expression();
5579 | 0 |
           jj_consume_token(SEMICOLON);
5580 |  |
         } catch (Throwable jjte000) {
5581 | 0 |
         if (jjtc000) {
5582 | 0 |
           jjtree.clearNodeScope(jjtn000);
5583 | 0 |
           jjtc000 = false;
5584 |  |
         } else {
5585 | 0 |
           jjtree.popNode();
5586 |  |
         }
5587 | 0 |
         if (jjte000 instanceof RuntimeException) {
5588 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5589 |  |
         }
5590 | 0 |
         if (jjte000 instanceof ParseException) {
5591 | 0 |
           {if (true) throw (ParseException)jjte000;}
5592 |  |
         }
5593 | 0 |
         {if (true) throw (Error)jjte000;}
5594 |  |
         } finally {
5595 | 0 |
         if (jjtc000) {
5596 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5597 |  |
         }
5598 |  |
         }
5599 |  |
       }
5600 |  |
5601 | 0 |
       final public void SynchronizedStatement() throws ParseException {
5602 |  |
      /*@bgen(jjtree) SynchronizedStatement */
5603 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTSYNCHRONIZEDSTATEMENT);
5604 | 0 |
       boolean jjtc000 = true;
5605 | 0 |
       jjtree.openNodeScope(jjtn000);
5606 | 0 |
         try {
5607 | 0 |
           jj_consume_token(SYNCHRONIZED);
5608 | 0 |
           jj_consume_token(LPAREN);
5609 | 0 |
           Expression();
5610 | 0 |
           jj_consume_token(RPAREN);
5611 | 0 |
           Block();
5612 |  |
         } catch (Throwable jjte000) {
5613 | 0 |
         if (jjtc000) {
5614 | 0 |
           jjtree.clearNodeScope(jjtn000);
5615 | 0 |
           jjtc000 = false;
5616 |  |
         } else {
5617 | 0 |
           jjtree.popNode();
5618 |  |
         }
5619 | 0 |
         if (jjte000 instanceof RuntimeException) {
5620 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5621 |  |
         }
5622 | 0 |
         if (jjte000 instanceof ParseException) {
5623 | 0 |
           {if (true) throw (ParseException)jjte000;}
5624 |  |
         }
5625 | 0 |
         {if (true) throw (Error)jjte000;}
5626 |  |
         } finally {
5627 | 0 |
         if (jjtc000) {
5628 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5629 |  |
         }
5630 |  |
         }
5631 |  |
       }
5632 |  |
5633 | 0 |
       final public void TryStatement() throws ParseException {
5634 |  |
      /*@bgen(jjtree) TryStatement */
5635 | 0 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTTRYSTATEMENT);
5636 | 0 |
       boolean jjtc000 = true;
5637 | 0 |
       jjtree.openNodeScope(jjtn000);
5638 | 0 |
         try {
5639 | 0 |
           jj_consume_token(TRY);
5640 | 0 |
           Block();
5641 | 0 |
           label_51:
5642 |  |
           while (true) {
5643 | 0 |
             switch (jj_nt.kind) {
5644 |  |
             case CATCH:
5645 |  |
               ;
5646 | 0 |
               break;
5647 |  |
             default:
5648 | 0 |
               jj_la1[126] = jj_gen;
5649 | 0 |
               break label_51;
5650 |  |
             }
5651 | 0 |
             jj_consume_token(CATCH);
5652 | 0 |
             jj_consume_token(LPAREN);
5653 | 0 |
             FormalParameter(null);
5654 | 0 |
             jj_consume_token(RPAREN);
5655 | 0 |
             Block();
5656 |  |
           }
5657 | 0 |
           switch (jj_nt.kind) {
5658 |  |
           case FINALLY:
5659 | 0 |
             jj_consume_token(FINALLY);
5660 | 0 |
             Block();
5661 | 0 |
             break;
5662 |  |
           default:
5663 | 0 |
             jj_la1[127] = jj_gen;
5664 |  |
             ;
5665 |  |
           }
5666 |  |
         } catch (Throwable jjte000) {
5667 | 0 |
         if (jjtc000) {
5668 | 0 |
           jjtree.clearNodeScope(jjtn000);
5669 | 0 |
           jjtc000 = false;
5670 |  |
         } else {
5671 | 0 |
           jjtree.popNode();
5672 |  |
         }
5673 | 0 |
         if (jjte000 instanceof RuntimeException) {
5674 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5675 |  |
         }
5676 | 0 |
         if (jjte000 instanceof ParseException) {
5677 | 0 |
           {if (true) throw (ParseException)jjte000;}
5678 |  |
         }
5679 | 0 |
         {if (true) throw (Error)jjte000;}
5680 |  |
         } finally {
5681 | 0 |
         if (jjtc000) {
5682 | 0 |
           jjtree.closeNodeScope(jjtn000, true);
5683 |  |
         }
5684 |  |
         }
5685 |  |
       }
5686 |  |
5687 | 16 |
       final public void AssertStatement() throws ParseException {
5688 |  |
      /*@bgen(jjtree) AssertStatement */
5689 | 16 |
       SimpleNode jjtn000 = new SimpleNode(this, JJTASSERTSTATEMENT);
5690 | 16 |
       boolean jjtc000 = true;
5691 | 16 |
       jjtree.openNodeScope(jjtn000);
5692 | 16 |
         try {
5693 | 16 |
           jj_consume_token(ASSERT);
5694 | 16 |
           Expression();
5695 | 16 |
           switch (jj_nt.kind) {
5696 |  |
           case COLON:
5697 | 8 |
             jj_consume_token(COLON);
5698 | 8 |
             Expression();
5699 | 8 |
             break;
5700 |  |
           default:
5701 | 8 |
             jj_la1[128] = jj_gen;
5702 |  |
             ;
5703 |  |
           }
5704 | 16 |
           jj_consume_token(SEMICOLON);
5705 |  |
         } catch (Throwable jjte000) {
5706 | 0 |
         if (jjtc000) {
5707 | 0 |
           jjtree.clearNodeScope(jjtn000);
5708 | 0 |
           jjtc000 = false;
5709 |  |
         } else {
5710 | 0 |
           jjtree.popNode();
5711 |  |
         }
5712 | 0 |
         if (jjte000 instanceof RuntimeException) {
5713 | 0 |
           {if (true) throw (RuntimeException)jjte000;}
5714 |  |
         }
5715 | 0 |
         if (jjte000 instanceof ParseException) {
5716 | 0 |
           {if (true) throw (ParseException)jjte000;}
5717 |  |
         }
5718 | 0 |
         {if (true) throw (Error)jjte000;}
5719 |  |
         } finally {
5720 | 16 |
         if (jjtc000) {
5721 | 16 |
           jjtree.closeNodeScope(jjtn000, true);
5722 |  |
         }
5723 |  |
         }
5724 |  |
       }
5725 |  |
5726 | 20 |
       final private boolean jj_2_1(int xla) {
5727 | 20 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5728 | 20 |
         boolean retval = !jj_3_1();
5729 | 20 |
         jj_save(0, xla);
5730 | 20 |
         return retval;
5731 |  |
       }
5732 |  |
5733 | 168 |
       final private boolean jj_2_2(int xla) {
5734 | 168 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5735 | 168 |
         boolean retval = !jj_3_2();
5736 | 168 |
         jj_save(1, xla);
5737 | 168 |
         return retval;
5738 |  |
       }
5739 |  |
5740 | 164 |
       final private boolean jj_2_3(int xla) {
5741 | 164 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5742 | 164 |
         boolean retval = !jj_3_3();
5743 | 164 |
         jj_save(2, xla);
5744 | 164 |
         return retval;
5745 |  |
       }
5746 |  |
5747 | 148 |
       final private boolean jj_2_4(int xla) {
5748 | 148 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5749 | 148 |
         boolean retval = !jj_3_4();
5750 | 148 |
         jj_save(3, xla);
5751 | 148 |
         return retval;
5752 |  |
       }
5753 |  |
5754 | 148 |
       final private boolean jj_2_5(int xla) {
5755 | 148 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5756 | 148 |
         boolean retval = !jj_3_5();
5757 | 148 |
         jj_save(4, xla);
5758 | 148 |
         return retval;
5759 |  |
       }
5760 |  |
5761 | 124 |
       final private boolean jj_2_6(int xla) {
5762 | 124 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5763 | 124 |
         boolean retval = !jj_3_6();
5764 | 124 |
         jj_save(5, xla);
5765 | 124 |
         return retval;
5766 |  |
       }
5767 |  |
5768 | 0 |
       final private boolean jj_2_7(int xla) {
5769 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5770 | 0 |
         boolean retval = !jj_3_7();
5771 | 0 |
         jj_save(6, xla);
5772 | 0 |
         return retval;
5773 |  |
       }
5774 |  |
5775 | 0 |
       final private boolean jj_2_8(int xla) {
5776 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5777 | 0 |
         boolean retval = !jj_3_8();
5778 | 0 |
         jj_save(7, xla);
5779 | 0 |
         return retval;
5780 |  |
       }
5781 |  |
5782 | 0 |
       final private boolean jj_2_9(int xla) {
5783 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5784 | 0 |
         boolean retval = !jj_3_9();
5785 | 0 |
         jj_save(8, xla);
5786 | 0 |
         return retval;
5787 |  |
       }
5788 |  |
5789 | 0 |
       final private boolean jj_2_10(int xla) {
5790 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5791 | 0 |
         boolean retval = !jj_3_10();
5792 | 0 |
         jj_save(9, xla);
5793 | 0 |
         return retval;
5794 |  |
       }
5795 |  |
5796 | 24 |
       final private boolean jj_2_11(int xla) {
5797 | 24 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5798 | 24 |
         boolean retval = !jj_3_11();
5799 | 24 |
         jj_save(10, xla);
5800 | 24 |
         return retval;
5801 |  |
       }
5802 |  |
5803 | 0 |
       final private boolean jj_2_12(int xla) {
5804 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5805 | 0 |
         boolean retval = !jj_3_12();
5806 | 0 |
         jj_save(11, xla);
5807 | 0 |
         return retval;
5808 |  |
       }
5809 |  |
5810 | 0 |
       final private boolean jj_2_13(int xla) {
5811 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5812 | 0 |
         boolean retval = !jj_3_13();
5813 | 0 |
         jj_save(12, xla);
5814 | 0 |
         return retval;
5815 |  |
       }
5816 |  |
5817 | 372 |
       final private boolean jj_2_14(int xla) {
5818 | 372 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5819 | 372 |
         boolean retval = !jj_3_14();
5820 | 372 |
         jj_save(13, xla);
5821 | 372 |
         return retval;
5822 |  |
       }
5823 |  |
5824 | 186 |
       final private boolean jj_2_15(int xla) {
5825 | 186 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5826 | 186 |
         boolean retval = !jj_3_15();
5827 | 186 |
         jj_save(14, xla);
5828 | 186 |
         return retval;
5829 |  |
       }
5830 |  |
5831 | 0 |
       final private boolean jj_2_16(int xla) {
5832 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5833 | 0 |
         boolean retval = !jj_3_16();
5834 | 0 |
         jj_save(15, xla);
5835 | 0 |
         return retval;
5836 |  |
       }
5837 |  |
5838 | 0 |
       final private boolean jj_2_17(int xla) {
5839 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5840 | 0 |
         boolean retval = !jj_3_17();
5841 | 0 |
         jj_save(16, xla);
5842 | 0 |
         return retval;
5843 |  |
       }
5844 |  |
5845 | 24 |
       final private boolean jj_2_18(int xla) {
5846 | 24 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5847 | 24 |
         boolean retval = !jj_3_18();
5848 | 24 |
         jj_save(17, xla);
5849 | 24 |
         return retval;
5850 |  |
       }
5851 |  |
5852 | 222 |
       final private boolean jj_2_19(int xla) {
5853 | 222 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5854 | 222 |
         boolean retval = !jj_3_19();
5855 | 222 |
         jj_save(18, xla);
5856 | 222 |
         return retval;
5857 |  |
       }
5858 |  |
5859 | 52 |
       final private boolean jj_2_20(int xla) {
5860 | 52 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5861 | 52 |
         boolean retval = !jj_3_20();
5862 | 52 |
         jj_save(19, xla);
5863 | 52 |
         return retval;
5864 |  |
       }
5865 |  |
5866 | 32 |
       final private boolean jj_2_21(int xla) {
5867 | 32 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5868 | 32 |
         boolean retval = !jj_3_21();
5869 | 32 |
         jj_save(20, xla);
5870 | 32 |
         return retval;
5871 |  |
       }
5872 |  |
5873 | 32 |
       final private boolean jj_2_22(int xla) {
5874 | 32 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5875 | 32 |
         boolean retval = !jj_3_22();
5876 | 32 |
         jj_save(21, xla);
5877 | 32 |
         return retval;
5878 |  |
       }
5879 |  |
5880 | 32 |
       final private boolean jj_2_23(int xla) {
5881 | 32 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5882 | 32 |
         boolean retval = !jj_3_23();
5883 | 32 |
         jj_save(22, xla);
5884 | 32 |
         return retval;
5885 |  |
       }
5886 |  |
5887 | 12 |
       final private boolean jj_2_24(int xla) {
5888 | 12 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5889 | 12 |
         boolean retval = !jj_3_24();
5890 | 12 |
         jj_save(23, xla);
5891 | 12 |
         return retval;
5892 |  |
       }
5893 |  |
5894 | 0 |
       final private boolean jj_2_25(int xla) {
5895 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5896 | 0 |
         boolean retval = !jj_3_25();
5897 | 0 |
         jj_save(24, xla);
5898 | 0 |
         return retval;
5899 |  |
       }
5900 |  |
5901 | 0 |
       final private boolean jj_2_26(int xla) {
5902 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5903 | 0 |
         boolean retval = !jj_3_26();
5904 | 0 |
         jj_save(25, xla);
5905 | 0 |
         return retval;
5906 |  |
       }
5907 |  |
5908 | 0 |
       final private boolean jj_2_27(int xla) {
5909 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5910 | 0 |
         boolean retval = !jj_3_27();
5911 | 0 |
         jj_save(26, xla);
5912 | 0 |
         return retval;
5913 |  |
       }
5914 |  |
5915 | 64 |
       final private boolean jj_2_28(int xla) {
5916 | 64 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5917 | 64 |
         boolean retval = !jj_3_28();
5918 | 64 |
         jj_save(27, xla);
5919 | 64 |
         return retval;
5920 |  |
       }
5921 |  |
5922 | 4 |
       final private boolean jj_2_29(int xla) {
5923 | 4 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5924 | 4 |
         boolean retval = !jj_3_29();
5925 | 4 |
         jj_save(28, xla);
5926 | 4 |
         return retval;
5927 |  |
       }
5928 |  |
5929 | 110 |
       final private boolean jj_2_30(int xla) {
5930 | 110 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5931 | 110 |
         boolean retval = !jj_3_30();
5932 | 110 |
         jj_save(29, xla);
5933 | 110 |
         return retval;
5934 |  |
       }
5935 |  |
5936 | 0 |
       final private boolean jj_2_31(int xla) {
5937 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
5938 | 0 |
         boolean retval = !jj_3_31();
5939 | 0 |
         jj_save(30, xla);
5940 | 0 |
         return retval;
5941 |  |
       }
5942 |  |
5943 | 60 |
       final private boolean jj_3R_170() {
5944 | 60 |
         Token xsp;
5945 | 60 |
         xsp = jj_scanpos;
5946 | 60 |
         if (jj_3R_180()) {
5947 | 60 |
         jj_scanpos = xsp;
5948 | 60 |
         if (jj_3R_181()) {
5949 | 60 |
         jj_scanpos = xsp;
5950 | 60 |
         if (jj_3R_182()) {
5951 | 60 |
         jj_scanpos = xsp;
5952 | 60 |
         if (jj_3R_183()) {
5953 | 48 |
         jj_scanpos = xsp;
5954 | 48 |
         if (jj_3R_184()) {
5955 | 48 |
         jj_scanpos = xsp;
5956 | 48 |
         if (jj_3R_185()) return true;
5957 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5958 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5959 | 8 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5960 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5961 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5962 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5963 | 4 |
         return false;
5964 |  |
       }
5965 |  |
5966 | 60 |
       final private boolean jj_3R_180() {
5967 | 60 |
         if (jj_scan_token(INTEGER_LITERAL)) return true;
5968 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5969 | 0 |
         return false;
5970 |  |
       }
5971 |  |
5972 | 124 |
       final private boolean jj_3R_147() {
5973 | 124 |
         if (jj_scan_token(NATIVE)) return true;
5974 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5975 | 0 |
         return false;
5976 |  |
       }
5977 |  |
5978 | 214 |
       final private boolean jj_3R_132() {
5979 | 190 |
         if (jj_3R_64()) return true;
5980 | 24 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5981 | 0 |
         return false;
5982 |  |
       }
5983 |  |
5984 | 16 |
       final private boolean jj_3R_164() {
5985 | 16 |
         if (jj_scan_token(SUPER)) return true;
5986 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5987 | 0 |
         return false;
5988 |  |
       }
5989 |  |
5990 | 218 |
       final private boolean jj_3R_131() {
5991 | 214 |
         if (jj_scan_token(DOT)) return true;
5992 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5993 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
5994 | 4 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5995 | 0 |
         return false;
5996 |  |
       }
5997 |  |
5998 | 218 |
       final private boolean jj_3R_130() {
5999 | 218 |
         if (jj_scan_token(LBRACKET)) return true;
6000 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6001 | 0 |
         if (jj_3R_70()) return true;
6002 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6003 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
6004 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6005 | 0 |
         return false;
6006 |  |
       }
6007 |  |
6008 | 148 |
       final private boolean jj_3R_95() {
6009 | 148 |
         if (jj_scan_token(STRICTFP)) return true;
6010 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6011 | 0 |
         return false;
6012 |  |
       }
6013 |  |
6014 | 254 |
       final private boolean jj_3_23() {
6015 | 238 |
         if (jj_scan_token(DOT)) return true;
6016 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6017 | 8 |
         if (jj_3R_69()) return true;
6018 | 8 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6019 | 0 |
         return false;
6020 |  |
       }
6021 |  |
6022 | 164 |
       final private boolean jj_3R_88() {
6023 | 164 |
         if (jj_scan_token(STRICTFP)) return true;
6024 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6025 | 0 |
         return false;
6026 |  |
       }
6027 |  |
6028 | 0 |
       final private boolean jj_3R_332() {
6029 | 0 |
         if (jj_scan_token(STRICTFP)) return true;
6030 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6031 | 0 |
         return false;
6032 |  |
       }
6033 |  |
6034 | 156 |
       final private boolean jj_3R_146() {
6035 | 124 |
         if (jj_scan_token(FINAL)) return true;
6036 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6037 | 32 |
         return false;
6038 |  |
       }
6039 |  |
6040 | 16 |
       final private boolean jj_3R_163() {
6041 | 16 |
         if (jj_scan_token(THIS)) return true;
6042 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6043 | 0 |
         return false;
6044 |  |
       }
6045 |  |
6046 | 254 |
       final private boolean jj_3_22() {
6047 | 238 |
         if (jj_scan_token(DOT)) return true;
6048 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6049 | 16 |
         if (jj_scan_token(SUPER)) return true;
6050 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6051 | 0 |
         return false;
6052 |  |
       }
6053 |  |
6054 | 52 |
       final private boolean jj_3_20() {
6055 | 0 |
         if (jj_3R_68()) return true;
6056 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6057 | 40 |
         if (jj_scan_token(DOT)) return true;
6058 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6059 | 4 |
         if (jj_scan_token(CLASS)) return true;
6060 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6061 | 8 |
         return false;
6062 |  |
       }
6063 |  |
6064 | 0 |
       final private boolean jj_3R_331() {
6065 | 0 |
         if (jj_scan_token(PRIVATE)) return true;
6066 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6067 | 0 |
         return false;
6068 |  |
       }
6069 |  |
6070 | 254 |
       final private boolean jj_3_21() {
6071 | 238 |
         if (jj_scan_token(DOT)) return true;
6072 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6073 | 16 |
         if (jj_scan_token(THIS)) return true;
6074 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6075 | 0 |
         return false;
6076 |  |
       }
6077 |  |
6078 | 222 |
       final private boolean jj_3R_67() {
6079 | 222 |
         Token xsp;
6080 | 222 |
         xsp = jj_scanpos;
6081 | 222 |
         if (jj_3_21()) {
6082 | 222 |
         jj_scanpos = xsp;
6083 | 222 |
         if (jj_3_22()) {
6084 | 222 |
         jj_scanpos = xsp;
6085 | 222 |
         if (jj_3_23()) {
6086 | 218 |
         jj_scanpos = xsp;
6087 | 218 |
         if (jj_3R_130()) {
6088 | 218 |
         jj_scanpos = xsp;
6089 | 218 |
         if (jj_3R_131()) {
6090 | 214 |
         jj_scanpos = xsp;
6091 | 190 |
         if (jj_3R_132()) return true;
6092 | 24 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6093 | 4 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6094 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6095 | 4 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6096 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6097 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6098 | 0 |
         return false;
6099 |  |
       }
6100 |  |
6101 | 0 |
       final private boolean jj_3R_330() {
6102 | 0 |
         if (jj_scan_token(PROTECTED)) return true;
6103 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6104 | 0 |
         return false;
6105 |  |
       }
6106 |  |
6107 | 196 |
       final private boolean jj_3R_94() {
6108 | 148 |
         if (jj_scan_token(PRIVATE)) return true;
6109 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6110 | 48 |
         return false;
6111 |  |
       }
6112 |  |
6113 | 36 |
       final private boolean jj_3R_157() {
6114 | 36 |
         if (jj_3R_57()) return true;
6115 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6116 | 0 |
         return false;
6117 |  |
       }
6118 |  |
6119 | 212 |
       final private boolean jj_3R_87() {
6120 | 164 |
         if (jj_scan_token(PRIVATE)) return true;
6121 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6122 | 48 |
         return false;
6123 |  |
       }
6124 |  |
6125 | 222 |
       final private boolean jj_3_19() {
6126 | 190 |
         if (jj_3R_67()) return true;
6127 | 32 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6128 | 0 |
         return false;
6129 |  |
       }
6130 |  |
6131 | 0 |
       final private boolean jj_3R_329() {
6132 | 0 |
         if (jj_scan_token(PUBLIC)) return true;
6133 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6134 | 0 |
         return false;
6135 |  |
       }
6136 |  |
6137 | 36 |
       final private boolean jj_3R_156() {
6138 | 36 |
         if (jj_3R_68()) return true;
6139 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6140 | 0 |
         if (jj_scan_token(DOT)) return true;
6141 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6142 | 0 |
         if (jj_scan_token(CLASS)) return true;
6143 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6144 | 0 |
         return false;
6145 |  |
       }
6146 |  |
6147 | 156 |
       final private boolean jj_3R_145() {
6148 | 156 |
         if (jj_scan_token(ABSTRACT)) return true;
6149 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6150 | 0 |
         return false;
6151 |  |
       }
6152 |  |
6153 | 36 |
       final private boolean jj_3R_155() {
6154 | 36 |
         if (jj_3R_69()) return true;
6155 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6156 | 0 |
         return false;
6157 |  |
       }
6158 |  |
6159 | 0 |
       final private boolean jj_3R_430() {
6160 | 0 |
         if (jj_scan_token(DECR)) return true;
6161 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6162 | 0 |
         return false;
6163 |  |
       }
6164 |  |
6165 | 0 |
       final private boolean jj_3R_328() {
6166 | 0 |
         if (jj_scan_token(FINAL)) return true;
6167 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6168 | 0 |
         return false;
6169 |  |
       }
6170 |  |
6171 | 20 |
       final private boolean jj_3R_162() {
6172 | 16 |
         if (jj_scan_token(IDENTIFIER)) return true;
6173 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6174 | 4 |
         return false;
6175 |  |
       }
6176 |  |
6177 | 36 |
       final private boolean jj_3R_154() {
6178 | 36 |
         if (jj_scan_token(LPAREN)) return true;
6179 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6180 | 0 |
         if (jj_3R_70()) return true;
6181 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6182 | 0 |
         if (jj_scan_token(RPAREN)) return true;
6183 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6184 | 0 |
         return false;
6185 |  |
       }
6186 |  |
6187 | 36 |
       final private boolean jj_3R_153() {
6188 | 36 |
         if (jj_scan_token(SUPER)) return true;
6189 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6190 | 0 |
         if (jj_scan_token(DOT)) return true;
6191 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6192 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
6193 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6194 | 0 |
         return false;
6195 |  |
       }
6196 |  |
6197 | 0 |
       final private boolean jj_3R_327() {
6198 | 0 |
         if (jj_scan_token(ABSTRACT)) return true;
6199 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6200 | 0 |
         return false;
6201 |  |
       }
6202 |  |
6203 | 36 |
       final private boolean jj_3R_152() {
6204 | 36 |
         if (jj_scan_token(THIS)) return true;
6205 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6206 | 0 |
         return false;
6207 |  |
       }
6208 |  |
6209 | 220 |
       final private boolean jj_3R_93() {
6210 | 196 |
         if (jj_scan_token(PROTECTED)) return true;
6211 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6212 | 24 |
         return false;
6213 |  |
       }
6214 |  |
6215 | 20 |
       final private boolean jj_3R_161() {
6216 | 20 |
         if (jj_scan_token(LPAREN)) return true;
6217 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6218 | 0 |
         return false;
6219 |  |
       }
6220 |  |
6221 | 0 |
       final private boolean jj_3R_429() {
6222 | 0 |
         if (jj_scan_token(INCR)) return true;
6223 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6224 | 0 |
         return false;
6225 |  |
       }
6226 |  |
6227 | 0 |
       final private boolean jj_3R_423() {
6228 | 0 |
         Token xsp;
6229 | 0 |
         xsp = jj_scanpos;
6230 | 0 |
         if (jj_3R_429()) {
6231 | 0 |
         jj_scanpos = xsp;
6232 | 0 |
         if (jj_3R_430()) return true;
6233 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6234 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6235 | 0 |
         return false;
6236 |  |
       }
6237 |  |
6238 | 44 |
       final private boolean jj_3R_151() {
6239 | 36 |
         if (jj_3R_170()) return true;
6240 | 8 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6241 | 0 |
         return false;
6242 |  |
       }
6243 |  |
6244 | 44 |
       final private boolean jj_3R_118() {
6245 | 44 |
         Token xsp;
6246 | 44 |
         xsp = jj_scanpos;
6247 | 44 |
         if (jj_3R_151()) {
6248 | 36 |
         jj_scanpos = xsp;
6249 | 36 |
         if (jj_3R_152()) {
6250 | 36 |
         jj_scanpos = xsp;
6251 | 36 |
         if (jj_3R_153()) {
6252 | 36 |
         jj_scanpos = xsp;
6253 | 36 |
         if (jj_3R_154()) {
6254 | 36 |
         jj_scanpos = xsp;
6255 | 36 |
         if (jj_3R_155()) {
6256 | 36 |
         jj_scanpos = xsp;
6257 | 36 |
         if (jj_3R_156()) {
6258 | 36 |
         jj_scanpos = xsp;
6259 | 36 |
         if (jj_3R_157()) return true;
6260 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6261 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6262 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6263 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6264 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6265 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6266 | 8 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6267 | 0 |
         return false;
6268 |  |
       }
6269 |  |
6270 | 0 |
       final private boolean jj_3R_326() {
6271 | 0 |
         if (jj_scan_token(STATIC)) return true;
6272 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6273 | 0 |
         return false;
6274 |  |
       }
6275 |  |
6276 | 0 |
       final private boolean jj_3R_295() {
6277 | 0 |
         Token xsp;
6278 | 0 |
         xsp = jj_scanpos;
6279 | 0 |
         if (jj_3R_326()) {
6280 | 0 |
         jj_scanpos = xsp;
6281 | 0 |
         if (jj_3R_327()) {
6282 | 0 |
         jj_scanpos = xsp;
6283 | 0 |
         if (jj_3R_328()) {
6284 | 0 |
         jj_scanpos = xsp;
6285 | 0 |
         if (jj_3R_329()) {
6286 | 0 |
         jj_scanpos = xsp;
6287 | 0 |
         if (jj_3R_330()) {
6288 | 0 |
         jj_scanpos = xsp;
6289 | 0 |
         if (jj_3R_331()) {
6290 | 0 |
         jj_scanpos = xsp;
6291 | 0 |
         if (jj_3R_332()) return true;
6292 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6293 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6294 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6295 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6296 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6297 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6298 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6299 | 0 |
         return false;
6300 |  |
       }
6301 |  |
6302 | 156 |
       final private boolean jj_3R_144() {
6303 | 156 |
         if (jj_scan_token(STATIC)) return true;
6304 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6305 | 0 |
         return false;
6306 |  |
       }
6307 |  |
6308 | 236 |
       final private boolean jj_3R_86() {
6309 | 212 |
         if (jj_scan_token(PROTECTED)) return true;
6310 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6311 | 24 |
         return false;
6312 |  |
       }
6313 |  |
6314 | 0 |
       final private boolean jj_3R_281() {
6315 | 0 |
         Token xsp;
6316 | 0 |
         while (true) {
6317 | 0 |
           xsp = jj_scanpos;
6318 | 0 |
           if (jj_3R_295()) { jj_scanpos = xsp; break; }
6319 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6320 |  |
         }
6321 | 0 |
         if (jj_3R_191()) return true;
6322 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6323 | 0 |
         return false;
6324 |  |
       }
6325 |  |
6326 | 20 |
       final private boolean jj_3R_160() {
6327 | 20 |
         if (jj_scan_token(BANG)) return true;
6328 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6329 | 0 |
         return false;
6330 |  |
       }
6331 |  |
6332 | 24 |
       final private boolean jj_3_18() {
6333 | 0 |
         if (jj_scan_token(LPAREN)) return true;
6334 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6335 | 8 |
         if (jj_3R_66()) return true;
6336 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6337 | 16 |
         return false;
6338 |  |
       }
6339 |  |
6340 | 44 |
       final private boolean jj_3R_63() {
6341 | 36 |
         if (jj_3R_118()) return true;
6342 | 8 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6343 | 0 |
         Token xsp;
6344 | 0 |
         while (true) {
6345 | 0 |
           xsp = jj_scanpos;
6346 | 0 |
           if (jj_3_19()) { jj_scanpos = xsp; break; }
6347 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6348 |  |
         }
6349 | 0 |
         return false;
6350 |  |
       }
6351 |  |
6352 | 276 |
       final private boolean jj_3R_92() {
6353 | 220 |
         if (jj_scan_token(PUBLIC)) return true;
6354 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6355 | 56 |
         return false;
6356 |  |
       }
6357 |  |
6358 | 20 |
       final private boolean jj_3R_159() {
6359 | 20 |
         if (jj_scan_token(TILDE)) return true;
6360 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6361 | 0 |
         return false;
6362 |  |
       }
6363 |  |
6364 | 20 |
       final private boolean jj_3R_397() {
6365 | 20 |
         if (jj_scan_token(LPAREN)) return true;
6366 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6367 | 0 |
         if (jj_3R_73()) return true;
6368 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6369 | 0 |
         if (jj_scan_token(RPAREN)) return true;
6370 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6371 | 0 |
         if (jj_3R_316()) return true;
6372 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6373 | 0 |
         return false;
6374 |  |
       }
6375 |  |
6376 | 308 |
       final private boolean jj_3R_85() {
6377 | 236 |
         if (jj_scan_token(PUBLIC)) return true;
6378 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6379 | 72 |
         return false;
6380 |  |
       }
6381 |  |
6382 | 204 |
       final private boolean jj_3R_143() {
6383 | 156 |
         if (jj_scan_token(PRIVATE)) return true;
6384 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6385 | 48 |
         return false;
6386 |  |
       }
6387 |  |
6388 | 24 |
       final private boolean jj_3R_396() {
6389 | 20 |
         if (jj_scan_token(LPAREN)) return true;
6390 | 4 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6391 | 0 |
         if (jj_3R_73()) return true;
6392 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6393 | 0 |
         if (jj_scan_token(RPAREN)) return true;
6394 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6395 | 0 |
         if (jj_3R_279()) return true;
6396 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6397 | 0 |
         return false;
6398 |  |
       }
6399 |  |
6400 | 24 |
       final private boolean jj_3R_383() {
6401 | 24 |
         Token xsp;
6402 | 24 |
         xsp = jj_scanpos;
6403 | 24 |
         if (jj_3R_396()) {
6404 | 20 |
         jj_scanpos = xsp;
6405 | 20 |
         if (jj_3R_397()) return true;
6406 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6407 | 4 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6408 | 0 |
         return false;
6409 |  |
       }
6410 |  |
6411 | 68 |
       final private boolean jj_3R_98() {
6412 | 20 |
         if (jj_scan_token(PRIVATE)) return true;
6413 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6414 | 48 |
         return false;
6415 |  |
       }
6416 |  |
6417 | 308 |
       final private boolean jj_3R_91() {
6418 | 276 |
         if (jj_scan_token(FINAL)) return true;
6419 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6420 | 32 |
         return false;
6421 |  |
       }
6422 |  |
6423 | 0 |
       final private boolean jj_3_17() {
6424 | 0 |
         if (jj_scan_token(LPAREN)) return true;
6425 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6426 | 0 |
         if (jj_3R_57()) return true;
6427 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6428 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
6429 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6430 | 0 |
         return false;
6431 |  |
       }
6432 |  |
6433 | 20 |
       final private boolean jj_3R_384() {
6434 | 12 |
         if (jj_3R_63()) return true;
6435 | 8 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6436 | 0 |
         Token xsp;
6437 | 0 |
         xsp = jj_scanpos;
6438 | 0 |
         if (jj_3R_423()) jj_scanpos = xsp;
6439 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6440 | 0 |
         return false;
6441 |  |
       }
6442 |  |
6443 | 340 |
       final private boolean jj_3R_84() {
6444 | 308 |
         if (jj_scan_token(FINAL)) return true;
6445 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6446 | 32 |
         return false;
6447 |  |
       }
6448 |  |
6449 | 220 |
       final private boolean jj_3R_142() {
6450 | 204 |
         if (jj_scan_token(PROTECTED)) return true;
6451 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6452 | 16 |
         return false;
6453 |  |
       }
6454 |  |
6455 | 170 |
       final private boolean jj_3R_121() {
6456 | 142 |
         if (jj_scan_token(LPAREN)) return true;
6457 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6458 | 0 |
         if (jj_3R_57()) return true;
6459 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6460 | 8 |
         if (jj_scan_token(RPAREN)) return true;
6461 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6462 | 20 |
         Token xsp;
6463 | 20 |
         xsp = jj_scanpos;
6464 | 20 |
         if (jj_3R_159()) {
6465 | 20 |
         jj_scanpos = xsp;
6466 | 20 |
         if (jj_3R_160()) {
6467 | 20 |
         jj_scanpos = xsp;
6468 | 20 |
         if (jj_3R_161()) {
6469 | 20 |
         jj_scanpos = xsp;
6470 | 20 |
         if (jj_3R_162()) {
6471 | 16 |
         jj_scanpos = xsp;
6472 | 16 |
         if (jj_3R_163()) {
6473 | 16 |
         jj_scanpos = xsp;
6474 | 16 |
         if (jj_3R_164()) {
6475 | 16 |
         jj_scanpos = xsp;
6476 | 16 |
         if (jj_3R_165()) {
6477 | 16 |
         jj_scanpos = xsp;
6478 | 12 |
         if (jj_3R_166()) return true;
6479 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6480 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6481 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6482 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6483 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6484 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6485 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6486 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6487 | 8 |
         return false;
6488 |  |
       }
6489 |  |
6490 | 92 |
       final private boolean jj_3R_97() {
6491 | 68 |
         if (jj_scan_token(PROTECTED)) return true;
6492 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6493 | 24 |
         return false;
6494 |  |
       }
6495 |  |
6496 | 170 |
       final private boolean jj_3R_120() {
6497 | 142 |
         if (jj_scan_token(LPAREN)) return true;
6498 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6499 | 0 |
         if (jj_3R_57()) return true;
6500 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6501 | 28 |
         if (jj_scan_token(LBRACKET)) return true;
6502 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6503 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
6504 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6505 | 0 |
         return false;
6506 |  |
       }
6507 |  |
6508 | 308 |
       final private boolean jj_3R_90() {
6509 | 308 |
         if (jj_scan_token(ABSTRACT)) return true;
6510 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6511 | 0 |
         return false;
6512 |  |
       }
6513 |  |
6514 | 186 |
       final private boolean jj_3_16() {
6515 | 142 |
         if (jj_scan_token(LPAREN)) return true;
6516 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6517 | 28 |
         if (jj_3R_66()) return true;
6518 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6519 | 16 |
         return false;
6520 |  |
       }
6521 |  |
6522 | 186 |
       final private boolean jj_3R_65() {
6523 | 186 |
         Token xsp;
6524 | 186 |
         xsp = jj_scanpos;
6525 | 186 |
         if (jj_3_16()) {
6526 | 170 |
         jj_scanpos = xsp;
6527 | 170 |
         if (jj_3R_120()) {
6528 | 170 |
         jj_scanpos = xsp;
6529 | 162 |
         if (jj_3R_121()) return true;
6530 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6531 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6532 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6533 | 24 |
         return false;
6534 |  |
       }
6535 |  |
6536 | 186 |
       final private boolean jj_3_15() {
6537 | 162 |
         if (jj_3R_65()) return true;
6538 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6539 | 24 |
         return false;
6540 |  |
       }
6541 |  |
6542 | 340 |
       final private boolean jj_3R_83() {
6543 | 340 |
         if (jj_scan_token(ABSTRACT)) return true;
6544 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6545 | 0 |
         return false;
6546 |  |
       }
6547 |  |
6548 | 268 |
       final private boolean jj_3R_141() {
6549 | 220 |
         if (jj_scan_token(PUBLIC)) return true;
6550 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6551 | 48 |
         return false;
6552 |  |
       }
6553 |  |
6554 | 268 |
       final private boolean jj_3R_99() {
6555 | 268 |
         Token xsp;
6556 | 268 |
         xsp = jj_scanpos;
6557 | 268 |
         if (jj_3R_141()) {
6558 | 220 |
         jj_scanpos = xsp;
6559 | 220 |
         if (jj_3R_142()) {
6560 | 204 |
         jj_scanpos = xsp;
6561 | 204 |
         if (jj_3R_143()) {
6562 | 156 |
         jj_scanpos = xsp;
6563 | 156 |
         if (jj_3R_144()) {
6564 | 156 |
         jj_scanpos = xsp;
6565 | 156 |
         if (jj_3R_145()) {
6566 | 156 |
         jj_scanpos = xsp;
6567 | 156 |
         if (jj_3R_146()) {
6568 | 124 |
         jj_scanpos = xsp;
6569 | 124 |
         if (jj_3R_147()) {
6570 | 124 |
         jj_scanpos = xsp;
6571 | 124 |
         if (jj_3R_148()) {
6572 | 124 |
         jj_scanpos = xsp;
6573 | 124 |
         if (jj_3R_149()) return true;
6574 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6575 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6576 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6577 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6578 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6579 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6580 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6581 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6582 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6583 | 144 |
         return false;
6584 |  |
       }
6585 |  |
6586 | 24 |
       final private boolean jj_3R_382() {
6587 | 24 |
         if (jj_scan_token(BANG)) return true;
6588 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6589 | 0 |
         return false;
6590 |  |
       }
6591 |  |
6592 | 124 |
       final private boolean jj_3_6() {
6593 | 48 |
         if (jj_3R_58()) return true;
6594 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6595 | 76 |
         return false;
6596 |  |
       }
6597 |  |
6598 | 148 |
       final private boolean jj_3R_96() {
6599 | 92 |
         if (jj_scan_token(PUBLIC)) return true;
6600 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6601 | 56 |
         return false;
6602 |  |
       }
6603 |  |
6604 | 148 |
       final private boolean jj_3R_56() {
6605 | 148 |
         Token xsp;
6606 | 148 |
         xsp = jj_scanpos;
6607 | 148 |
         if (jj_3R_96()) {
6608 | 92 |
         jj_scanpos = xsp;
6609 | 92 |
         if (jj_3R_97()) {
6610 | 68 |
         jj_scanpos = xsp;
6611 | 20 |
         if (jj_3R_98()) return true;
6612 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6613 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6614 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6615 | 128 |
         return false;
6616 |  |
       }
6617 |  |
6618 | 124 |
       final private boolean jj_3R_58() {
6619 | 124 |
         Token xsp;
6620 | 124 |
         while (true) {
6621 | 268 |
           xsp = jj_scanpos;
6622 | 124 |
           if (jj_3R_99()) { jj_scanpos = xsp; break; }
6623 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6624 |  |
         }
6625 | 0 |
         if (jj_3R_68()) return true;
6626 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6627 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
6628 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6629 | 48 |
         if (jj_scan_token(LPAREN)) return true;
6630 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6631 | 76 |
         return false;
6632 |  |
       }
6633 |  |
6634 | 20 |
       final private boolean jj_3R_368() {
6635 | 12 |
         if (jj_3R_384()) return true;
6636 | 8 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6637 | 0 |
         return false;
6638 |  |
       }
6639 |  |
6640 | 148 |
       final private boolean jj_3_5() {
6641 | 148 |
         Token xsp;
6642 | 148 |
         xsp = jj_scanpos;
6643 | 20 |
         if (jj_3R_56()) jj_scanpos = xsp;
6644 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6645 | 84 |
         if (jj_3R_57()) return true;
6646 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6647 | 40 |
         if (jj_scan_token(LPAREN)) return true;
6648 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6649 | 24 |
         return false;
6650 |  |
       }
6651 |  |
6652 | 0 |
       final private boolean jj_3R_380() {
6653 | 0 |
         if (jj_scan_token(REM)) return true;
6654 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6655 | 0 |
         return false;
6656 |  |
       }
6657 |  |
6658 | 308 |
       final private boolean jj_3R_55() {
6659 | 308 |
         Token xsp;
6660 | 308 |
         xsp = jj_scanpos;
6661 | 308 |
         if (jj_3R_89()) {
6662 | 308 |
         jj_scanpos = xsp;
6663 | 308 |
         if (jj_3R_90()) {
6664 | 308 |
         jj_scanpos = xsp;
6665 | 308 |
         if (jj_3R_91()) {
6666 | 276 |
         jj_scanpos = xsp;
6667 | 276 |
         if (jj_3R_92()) {
6668 | 220 |
         jj_scanpos = xsp;
6669 | 220 |
         if (jj_3R_93()) {
6670 | 196 |
         jj_scanpos = xsp;
6671 | 196 |
         if (jj_3R_94()) {
6672 | 148 |
         jj_scanpos = xsp;
6673 | 148 |
         if (jj_3R_95()) return true;
6674 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6675 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6676 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6677 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6678 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6679 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6680 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6681 | 160 |
         return false;
6682 |  |
       }
6683 |  |
6684 | 308 |
       final private boolean jj_3R_89() {
6685 | 308 |
         if (jj_scan_token(STATIC)) return true;
6686 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6687 | 0 |
         return false;
6688 |  |
       }
6689 |  |
6690 | 24 |
       final private boolean jj_3R_381() {
6691 | 24 |
         if (jj_scan_token(TILDE)) return true;
6692 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6693 | 0 |
         return false;
6694 |  |
       }
6695 |  |
6696 | 24 |
       final private boolean jj_3R_367() {
6697 | 20 |
         if (jj_3R_383()) return true;
6698 | 4 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6699 | 0 |
         return false;
6700 |  |
       }
6701 |  |
6702 | 148 |
       final private boolean jj_3_4() {
6703 | 148 |
         Token xsp;
6704 | 148 |
         while (true) {
6705 | 308 |
           xsp = jj_scanpos;
6706 | 148 |
           if (jj_3R_55()) { jj_scanpos = xsp; break; }
6707 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6708 |  |
         }
6709 | 148 |
         if (jj_scan_token(INTERFACE)) return true;
6710 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6711 | 0 |
         return false;
6712 |  |
       }
6713 |  |
6714 | 0 |
       final private boolean jj_3R_365() {
6715 | 0 |
         if (jj_scan_token(MINUS)) return true;
6716 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6717 | 0 |
         return false;
6718 |  |
       }
6719 |  |
6720 | 340 |
       final private boolean jj_3R_54() {
6721 | 340 |
         Token xsp;
6722 | 340 |
         xsp = jj_scanpos;
6723 | 340 |
         if (jj_3R_82()) {
6724 | 340 |
         jj_scanpos = xsp;
6725 | 340 |
         if (jj_3R_83()) {
6726 | 340 |
         jj_scanpos = xsp;
6727 | 340 |
         if (jj_3R_84()) {
6728 | 308 |
         jj_scanpos = xsp;
6729 | 308 |
         if (jj_3R_85()) {
6730 | 236 |
         jj_scanpos = xsp;
6731 | 236 |
         if (jj_3R_86()) {
6732 | 212 |
         jj_scanpos = xsp;
6733 | 212 |
         if (jj_3R_87()) {
6734 | 164 |
         jj_scanpos = xsp;
6735 | 164 |
         if (jj_3R_88()) return true;
6736 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6737 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6738 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6739 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6740 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6741 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6742 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6743 | 176 |
         return false;
6744 |  |
       }
6745 |  |
6746 | 340 |
       final private boolean jj_3R_82() {
6747 | 340 |
         if (jj_scan_token(STATIC)) return true;
6748 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6749 | 0 |
         return false;
6750 |  |
       }
6751 |  |
6752 | 24 |
       final private boolean jj_3R_366() {
6753 | 24 |
         Token xsp;
6754 | 24 |
         xsp = jj_scanpos;
6755 | 24 |
         if (jj_3R_381()) {
6756 | 24 |
         jj_scanpos = xsp;
6757 | 24 |
         if (jj_3R_382()) return true;
6758 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6759 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6760 | 0 |
         if (jj_3R_279()) return true;
6761 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6762 | 0 |
         return false;
6763 |  |
       }
6764 |  |
6765 | 24 |
       final private boolean jj_3R_316() {
6766 | 24 |
         Token xsp;
6767 | 24 |
         xsp = jj_scanpos;
6768 | 24 |
         if (jj_3R_366()) {
6769 | 24 |
         jj_scanpos = xsp;
6770 | 24 |
         if (jj_3R_367()) {
6771 | 20 |
         jj_scanpos = xsp;
6772 | 12 |
         if (jj_3R_368()) return true;
6773 | 8 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6774 | 4 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6775 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6776 | 0 |
         return false;
6777 |  |
       }
6778 |  |
6779 | 0 |
       final private boolean jj_3R_277() {
6780 | 0 |
         if (jj_3R_284()) return true;
6781 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6782 | 0 |
         return false;
6783 |  |
       }
6784 |  |
6785 | 164 |
       final private boolean jj_3_3() {
6786 | 164 |
         Token xsp;
6787 | 164 |
         while (true) {
6788 | 340 |
           xsp = jj_scanpos;
6789 | 164 |
           if (jj_3R_54()) { jj_scanpos = xsp; break; }
6790 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6791 |  |
         }
6792 | 148 |
         if (jj_scan_token(CLASS)) return true;
6793 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6794 | 16 |
         return false;
6795 |  |
       }
6796 |  |
6797 | 0 |
       final private boolean jj_3R_379() {
6798 | 0 |
         if (jj_scan_token(SLASH)) return true;
6799 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6800 | 0 |
         return false;
6801 |  |
       }
6802 |  |
6803 | 0 |
       final private boolean jj_3R_313() {
6804 | 0 |
         if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
6805 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6806 | 0 |
         return false;
6807 |  |
       }
6808 |  |
6809 | 0 |
       final private boolean jj_3R_276() {
6810 | 0 |
         if (jj_3R_283()) return true;
6811 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6812 | 0 |
         return false;
6813 |  |
       }
6814 |  |
6815 | 0 |
       final private boolean jj_3R_364() {
6816 | 0 |
         if (jj_scan_token(PLUS)) return true;
6817 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6818 | 0 |
         return false;
6819 |  |
       }
6820 |  |
6821 | 0 |
       final private boolean jj_3R_275() {
6822 | 0 |
         if (jj_3R_282()) return true;
6823 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6824 | 0 |
         return false;
6825 |  |
       }
6826 |  |
6827 | 24 |
       final private boolean jj_3R_254() {
6828 | 24 |
         if (jj_scan_token(DECR)) return true;
6829 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6830 | 0 |
         if (jj_3R_63()) return true;
6831 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6832 | 0 |
         return false;
6833 |  |
       }
6834 |  |
6835 | 0 |
       final private boolean jj_3R_310() {
6836 | 0 |
         Token xsp;
6837 | 0 |
         xsp = jj_scanpos;
6838 | 0 |
         if (jj_3R_364()) {
6839 | 0 |
         jj_scanpos = xsp;
6840 | 0 |
         if (jj_3R_365()) return true;
6841 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6842 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6843 | 0 |
         if (jj_3R_272()) return true;
6844 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6845 | 0 |
         return false;
6846 |  |
       }
6847 |  |
6848 | 0 |
       final private boolean jj_3R_289() {
6849 | 0 |
         if (jj_scan_token(GE)) return true;
6850 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6851 | 0 |
         return false;
6852 |  |
       }
6853 |  |
6854 | 0 |
       final private boolean jj_3R_378() {
6855 | 0 |
         if (jj_scan_token(STAR)) return true;
6856 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6857 | 0 |
         return false;
6858 |  |
       }
6859 |  |
6860 | 0 |
       final private boolean jj_3R_274() {
6861 | 0 |
         if (jj_3R_281()) return true;
6862 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6863 | 0 |
         return false;
6864 |  |
       }
6865 |  |
6866 | 0 |
       final private boolean jj_3R_363() {
6867 | 0 |
         Token xsp;
6868 | 0 |
         xsp = jj_scanpos;
6869 | 0 |
         if (jj_3R_378()) {
6870 | 0 |
         jj_scanpos = xsp;
6871 | 0 |
         if (jj_3R_379()) {
6872 | 0 |
         jj_scanpos = xsp;
6873 | 0 |
         if (jj_3R_380()) return true;
6874 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6875 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6876 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6877 | 0 |
         if (jj_3R_279()) return true;
6878 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6879 | 0 |
         return false;
6880 |  |
       }
6881 |  |
6882 | 0 |
       final private boolean jj_3R_312() {
6883 | 0 |
         if (jj_scan_token(RSIGNEDSHIFT)) return true;
6884 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6885 | 0 |
         return false;
6886 |  |
       }
6887 |  |
6888 | 0 |
       final private boolean jj_3R_273() {
6889 | 0 |
         if (jj_3R_280()) return true;
6890 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6891 | 0 |
         return false;
6892 |  |
       }
6893 |  |
6894 | 24 |
       final private boolean jj_3R_253() {
6895 | 24 |
         if (jj_scan_token(INCR)) return true;
6896 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6897 | 0 |
         if (jj_3R_63()) return true;
6898 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6899 | 0 |
         return false;
6900 |  |
       }
6901 |  |
6902 | 0 |
       final private boolean jj_3R_288() {
6903 | 0 |
         if (jj_scan_token(LE)) return true;
6904 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6905 | 0 |
         return false;
6906 |  |
       }
6907 |  |
6908 | 168 |
       final private boolean jj_3_2() {
6909 | 164 |
         if (jj_3R_53()) return true;
6910 | 4 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6911 | 0 |
         return false;
6912 |  |
       }
6913 |  |
6914 | 0 |
       final private boolean jj_3R_268() {
6915 | 0 |
         Token xsp;
6916 | 0 |
         xsp = jj_scanpos;
6917 | 0 |
         if (jj_3_2()) {
6918 | 0 |
         jj_scanpos = xsp;
6919 | 0 |
         if (jj_3R_273()) {
6920 | 0 |
         jj_scanpos = xsp;
6921 | 0 |
         if (jj_3R_274()) {
6922 | 0 |
         jj_scanpos = xsp;
6923 | 0 |
         if (jj_3R_275()) {
6924 | 0 |
         jj_scanpos = xsp;
6925 | 0 |
         if (jj_3R_276()) {
6926 | 0 |
         jj_scanpos = xsp;
6927 | 0 |
         if (jj_3R_277()) return true;
6928 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6929 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6930 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6931 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6932 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6933 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6934 | 0 |
         return false;
6935 |  |
       }
6936 |  |
6937 | 24 |
       final private boolean jj_3R_315() {
6938 | 24 |
         if (jj_scan_token(MINUS)) return true;
6939 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6940 | 0 |
         return false;
6941 |  |
       }
6942 |  |
6943 | 0 |
       final private boolean jj_3R_311() {
6944 | 0 |
         if (jj_scan_token(LSHIFT)) return true;
6945 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6946 | 0 |
         return false;
6947 |  |
       }
6948 |  |
6949 | 24 |
       final private boolean jj_3R_293() {
6950 | 12 |
         if (jj_3R_316()) return true;
6951 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6952 | 0 |
         return false;
6953 |  |
       }
6954 |  |
6955 | 0 |
       final private boolean jj_3R_285() {
6956 | 0 |
         Token xsp;
6957 | 0 |
         xsp = jj_scanpos;
6958 | 0 |
         if (jj_3R_311()) {
6959 | 0 |
         jj_scanpos = xsp;
6960 | 0 |
         if (jj_3R_312()) {
6961 | 0 |
         jj_scanpos = xsp;
6962 | 0 |
         if (jj_3R_313()) return true;
6963 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6964 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6965 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6966 | 0 |
         if (jj_3R_267()) return true;
6967 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6968 | 0 |
         return false;
6969 |  |
       }
6970 |  |
6971 | 0 |
       final private boolean jj_3R_287() {
6972 | 0 |
         if (jj_scan_token(GT)) return true;
6973 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6974 | 0 |
         return false;
6975 |  |
       }
6976 |  |
6977 | 24 |
       final private boolean jj_3R_292() {
6978 | 24 |
         if (jj_3R_254()) return true;
6979 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6980 | 0 |
         return false;
6981 |  |
       }
6982 |  |
6983 | 24 |
       final private boolean jj_3R_314() {
6984 | 24 |
         if (jj_scan_token(PLUS)) return true;
6985 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6986 | 0 |
         return false;
6987 |  |
       }
6988 |  |
6989 | 0 |
       final private boolean jj_3R_227() {
6990 | 0 |
         if (jj_scan_token(ORASSIGN)) return true;
6991 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6992 | 0 |
         return false;
6993 |  |
       }
6994 |  |
6995 | 24 |
       final private boolean jj_3R_291() {
6996 | 24 |
         if (jj_3R_253()) return true;
6997 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6998 | 0 |
         return false;
6999 |  |
       }
7000 |  |
7001 | 24 |
       final private boolean jj_3R_279() {
7002 | 24 |
         Token xsp;
7003 | 24 |
         xsp = jj_scanpos;
7004 | 24 |
         if (jj_3R_290()) {
7005 | 24 |
         jj_scanpos = xsp;
7006 | 24 |
         if (jj_3R_291()) {
7007 | 24 |
         jj_scanpos = xsp;
7008 | 24 |
         if (jj_3R_292()) {
7009 | 24 |
         jj_scanpos = xsp;
7010 | 12 |
         if (jj_3R_293()) return true;
7011 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7012 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7013 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7014 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7015 | 0 |
         return false;
7016 |  |
       }
7017 |  |
7018 | 24 |
       final private boolean jj_3R_290() {
7019 | 24 |
         Token xsp;
7020 | 24 |
         xsp = jj_scanpos;
7021 | 24 |
         if (jj_3R_314()) {
7022 | 24 |
         jj_scanpos = xsp;
7023 | 24 |
         if (jj_3R_315()) return true;
7024 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7025 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7026 | 0 |
         if (jj_3R_279()) return true;
7027 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7028 | 0 |
         return false;
7029 |  |
       }
7030 |  |
7031 | 0 |
       final private boolean jj_3R_271() {
7032 | 0 |
         if (jj_scan_token(NE)) return true;
7033 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7034 | 0 |
         return false;
7035 |  |
       }
7036 |  |
7037 | 0 |
       final private boolean jj_3R_286() {
7038 | 0 |
         if (jj_scan_token(LT)) return true;
7039 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7040 | 0 |
         return false;
7041 |  |
       }
7042 |  |
7043 | 0 |
       final private boolean jj_3R_278() {
7044 | 0 |
         Token xsp;
7045 | 0 |
         xsp = jj_scanpos;
7046 | 0 |
         if (jj_3R_286()) {
7047 | 0 |
         jj_scanpos = xsp;
7048 | 0 |
         if (jj_3R_287()) {
7049 | 0 |
         jj_scanpos = xsp;
7050 | 0 |
         if (jj_3R_288()) {
7051 | 0 |
         jj_scanpos = xsp;
7052 | 0 |
         if (jj_3R_289()) return true;
7053 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7054 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7055 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7056 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7057 | 0 |
         if (jj_3R_262()) return true;
7058 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7059 | 0 |
         return false;
7060 |  |
       }
7061 |  |
7062 | 0 |
       final private boolean jj_3R_323() {
7063 | 0 |
         if (jj_scan_token(STRICTFP)) return true;
7064 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7065 | 0 |
         return false;
7066 |  |
       }
7067 |  |
7068 | 0 |
       final private boolean jj_3R_226() {
7069 | 0 |
         if (jj_scan_token(XORASSIGN)) return true;
7070 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7071 | 0 |
         return false;
7072 |  |
       }
7073 |  |
7074 | 0 |
       final private boolean jj_3R_269() {
7075 | 0 |
         if (jj_scan_token(INSTANCEOF)) return true;
7076 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7077 | 0 |
         if (jj_3R_73()) return true;
7078 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7079 | 0 |
         return false;
7080 |  |
       }
7081 |  |
7082 | 24 |
       final private boolean jj_3R_272() {
7083 | 12 |
         if (jj_3R_279()) return true;
7084 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7085 | 0 |
         Token xsp;
7086 | 0 |
         while (true) {
7087 | 0 |
           xsp = jj_scanpos;
7088 | 0 |
           if (jj_3R_363()) { jj_scanpos = xsp; break; }
7089 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7090 |  |
         }
7091 | 0 |
         return false;
7092 |  |
       }
7093 |  |
7094 | 0 |
       final private boolean jj_3R_322() {
7095 | 0 |
         if (jj_scan_token(PRIVATE)) return true;
7096 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7097 | 0 |
         return false;
7098 |  |
       }
7099 |  |
7100 | 0 |
       final private boolean jj_3R_270() {
7101 | 0 |
         if (jj_scan_token(EQ)) return true;
7102 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7103 | 0 |
         return false;
7104 |  |
       }
7105 |  |
7106 | 0 |
       final private boolean jj_3R_266() {
7107 | 0 |
         Token xsp;
7108 | 0 |
         xsp = jj_scanpos;
7109 | 0 |
         if (jj_3R_270()) {
7110 | 0 |
         jj_scanpos = xsp;
7111 | 0 |
         if (jj_3R_271()) return true;
7112 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7113 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7114 | 0 |
         if (jj_3R_252()) return true;
7115 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7116 | 0 |
         return false;
7117 |  |
       }
7118 |  |
7119 | 0 |
       final private boolean jj_3R_225() {
7120 | 0 |
         if (jj_scan_token(ANDASSIGN)) return true;
7121 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7122 | 0 |
         return false;
7123 |  |
       }
7124 |  |
7125 | 24 |
       final private boolean jj_3R_267() {
7126 | 12 |
         if (jj_3R_272()) return true;
7127 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7128 | 0 |
         Token xsp;
7129 | 0 |
         while (true) {
7130 | 0 |
           xsp = jj_scanpos;
7131 | 0 |
           if (jj_3R_310()) { jj_scanpos = xsp; break; }
7132 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7133 |  |
         }
7134 | 0 |
         return false;
7135 |  |
       }
7136 |  |
7137 | 0 |
       final private boolean jj_3R_321() {
7138 | 0 |
         if (jj_scan_token(PROTECTED)) return true;
7139 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7140 | 0 |
         return false;
7141 |  |
       }
7142 |  |
7143 | 0 |
       final private boolean jj_3R_320() {
7144 | 0 |
         if (jj_scan_token(PUBLIC)) return true;
7145 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7146 | 0 |
         return false;
7147 |  |
       }
7148 |  |
7149 | 24 |
       final private boolean jj_3R_262() {
7150 | 12 |
         if (jj_3R_267()) return true;
7151 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7152 | 0 |
         Token xsp;
7153 | 0 |
         while (true) {
7154 | 0 |
           xsp = jj_scanpos;
7155 | 0 |
           if (jj_3R_285()) { jj_scanpos = xsp; break; }
7156 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7157 |  |
         }
7158 | 0 |
         return false;
7159 |  |
       }
7160 |  |
7161 | 0 |
       final private boolean jj_3R_261() {
7162 | 0 |
         if (jj_scan_token(BIT_AND)) return true;
7163 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7164 | 0 |
         if (jj_3R_244()) return true;
7165 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7166 | 0 |
         return false;
7167 |  |
       }
7168 |  |
7169 | 0 |
       final private boolean jj_3R_319() {
7170 | 0 |
         if (jj_scan_token(FINAL)) return true;
7171 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7172 | 0 |
         return false;
7173 |  |
       }
7174 |  |
7175 | 0 |
       final private boolean jj_3R_224() {
7176 | 0 |
         if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
7177 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7178 | 0 |
         return false;
7179 |  |
       }
7180 |  |
7181 | 24 |
       final private boolean jj_3R_258() {
7182 | 12 |
         if (jj_3R_262()) return true;
7183 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7184 | 0 |
         Token xsp;
7185 | 0 |
         while (true) {
7186 | 0 |
           xsp = jj_scanpos;
7187 | 0 |
           if (jj_3R_278()) { jj_scanpos = xsp; break; }
7188 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7189 |  |
         }
7190 | 0 |
         return false;
7191 |  |
       }
7192 |  |
7193 | 0 |
       final private boolean jj_3R_318() {
7194 | 0 |
         if (jj_scan_token(ABSTRACT)) return true;
7195 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7196 | 0 |
         return false;
7197 |  |
       }
7198 |  |
7199 | 0 |
       final private boolean jj_3R_251() {
7200 | 0 |
         if (jj_scan_token(BIT_OR)) return true;
7201 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7202 | 0 |
         if (jj_3R_196()) return true;
7203 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7204 | 0 |
         return false;
7205 |  |
       }
7206 |  |
7207 | 0 |
       final private boolean jj_3R_317() {
7208 | 0 |
         if (jj_scan_token(STATIC)) return true;
7209 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7210 | 0 |
         return false;
7211 |  |
       }
7212 |  |
7213 | 0 |
       final private boolean jj_3R_294() {
7214 | 0 |
         Token xsp;
7215 | 0 |
         xsp = jj_scanpos;
7216 | 0 |
         if (jj_3R_317()) {
7217 | 0 |
         jj_scanpos = xsp;
7218 | 0 |
         if (jj_3R_318()) {
7219 | 0 |
         jj_scanpos = xsp;
7220 | 0 |
         if (jj_3R_319()) {
7221 | 0 |
         jj_scanpos = xsp;
7222 | 0 |
         if (jj_3R_320()) {
7223 | 0 |
         jj_scanpos = xsp;
7224 | 0 |
         if (jj_3R_321()) {
7225 | 0 |
         jj_scanpos = xsp;
7226 | 0 |
         if (jj_3R_322()) {
7227 | 0 |
         jj_scanpos = xsp;
7228 | 0 |
         if (jj_3R_323()) return true;
7229 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7230 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7231 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7232 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7233 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7234 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7235 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7236 | 0 |
         return false;
7237 |  |
       }
7238 |  |
7239 | 0 |
       final private boolean jj_3R_223() {
7240 | 0 |
         if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
7241 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7242 | 0 |
         return false;
7243 |  |
       }
7244 |  |
7245 | 24 |
       final private boolean jj_3R_252() {
7246 | 12 |
         if (jj_3R_258()) return true;
7247 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7248 | 0 |
         Token xsp;
7249 | 0 |
         xsp = jj_scanpos;
7250 | 0 |
         if (jj_3R_269()) jj_scanpos = xsp;
7251 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7252 | 0 |
         return false;
7253 |  |
       }
7254 |  |
7255 | 0 |
       final private boolean jj_3R_257() {
7256 | 0 |
         if (jj_scan_token(XOR)) return true;
7257 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7258 | 0 |
         if (jj_3R_228()) return true;
7259 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7260 | 0 |
         return false;
7261 |  |
       }
7262 |  |
7263 | 0 |
       final private boolean jj_3R_280() {
7264 | 0 |
         Token xsp;
7265 | 0 |
         while (true) {
7266 | 0 |
           xsp = jj_scanpos;
7267 | 0 |
           if (jj_3R_294()) { jj_scanpos = xsp; break; }
7268 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7269 |  |
         }
7270 | 0 |
         if (jj_3R_190()) return true;
7271 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7272 | 0 |
         return false;
7273 |  |
       }
7274 |  |
7275 | 0 |
       final private boolean jj_3R_243() {
7276 | 0 |
         if (jj_scan_token(SC_AND)) return true;
7277 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7278 | 0 |
         if (jj_3R_187()) return true;
7279 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7280 | 0 |
         return false;
7281 |  |
       }
7282 |  |
7283 | 0 |
       final private boolean jj_3R_265() {
7284 | 0 |
         if (jj_3R_268()) return true;
7285 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7286 | 0 |
         return false;
7287 |  |
       }
7288 |  |
7289 | 24 |
       final private boolean jj_3R_244() {
7290 | 12 |
         if (jj_3R_252()) return true;
7291 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7292 | 0 |
         Token xsp;
7293 | 0 |
         while (true) {
7294 | 0 |
           xsp = jj_scanpos;
7295 | 0 |
           if (jj_3R_266()) { jj_scanpos = xsp; break; }
7296 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7297 |  |
         }
7298 | 0 |
         return false;
7299 |  |
       }
7300 |  |
7301 | 0 |
       final private boolean jj_3R_215() {
7302 | 0 |
         if (jj_scan_token(SC_OR)) return true;
7303 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7304 | 0 |
         if (jj_3R_175()) return true;
7305 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7306 | 0 |
         return false;
7307 |  |
       }
7308 |  |
7309 | 0 |
       final private boolean jj_3R_222() {
7310 | 0 |
         if (jj_scan_token(LSHIFTASSIGN)) return true;
7311 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7312 | 0 |
         return false;
7313 |  |
       }
7314 |  |
7315 | 0 |
       final private boolean jj_3R_260() {
7316 | 0 |
         if (jj_scan_token(LBRACE)) return true;
7317 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7318 | 0 |
         Token xsp;
7319 | 0 |
         while (true) {
7320 | 0 |
           xsp = jj_scanpos;
7321 | 0 |
           if (jj_3R_265()) { jj_scanpos = xsp; break; }
7322 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7323 |  |
         }
7324 | 0 |
         if (jj_scan_token(RBRACE)) return true;
7325 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7326 | 0 |
         return false;
7327 |  |
       }
7328 |  |
7329 | 24 |
       final private boolean jj_3R_228() {
7330 | 12 |
         if (jj_3R_244()) return true;
7331 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7332 | 0 |
         Token xsp;
7333 | 0 |
         while (true) {
7334 | 0 |
           xsp = jj_scanpos;
7335 | 0 |
           if (jj_3R_261()) { jj_scanpos = xsp; break; }
7336 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7337 |  |
         }
7338 | 0 |
         return false;
7339 |  |
       }
7340 |  |
7341 | 0 |
       final private boolean jj_3R_194() {
7342 | 0 |
         if (jj_scan_token(HOOK)) return true;
7343 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7344 | 0 |
         if (jj_3R_70()) return true;
7345 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7346 | 0 |
         if (jj_scan_token(COLON)) return true;
7347 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7348 | 0 |
         if (jj_3R_136()) return true;
7349 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7350 | 0 |
         return false;
7351 |  |
       }
7352 |  |
7353 | 0 |
       final private boolean jj_3R_221() {
7354 | 0 |
         if (jj_scan_token(MINUSASSIGN)) return true;
7355 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7356 | 0 |
         return false;
7357 |  |
       }
7358 |  |
7359 | 24 |
       final private boolean jj_3R_196() {
7360 | 12 |
         if (jj_3R_228()) return true;
7361 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7362 | 0 |
         Token xsp;
7363 | 0 |
         while (true) {
7364 | 0 |
           xsp = jj_scanpos;
7365 | 0 |
           if (jj_3R_257()) { jj_scanpos = xsp; break; }
7366 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7367 |  |
         }
7368 | 0 |
         return false;
7369 |  |
       }
7370 |  |
7371 | 0 |
       final private boolean jj_3R_220() {
7372 | 0 |
         if (jj_scan_token(PLUSASSIGN)) return true;
7373 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7374 | 0 |
         return false;
7375 |  |
       }
7376 |  |
7377 | 0 |
       final private boolean jj_3R_325() {
7378 | 0 |
         if (jj_scan_token(IMPLEMENTS)) return true;
7379 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7380 | 0 |
         if (jj_3R_369()) return true;
7381 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7382 | 0 |
         return false;
7383 |  |
       }
7384 |  |
7385 | 0 |
       final private boolean jj_3R_324() {
7386 | 0 |
         if (jj_scan_token(EXTENDS)) return true;
7387 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7388 | 0 |
         if (jj_3R_57()) return true;
7389 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7390 | 0 |
         return false;
7391 |  |
       }
7392 |  |
7393 | 24 |
       final private boolean jj_3R_187() {
7394 | 12 |
         if (jj_3R_196()) return true;
7395 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7396 | 0 |
         Token xsp;
7397 | 0 |
         while (true) {
7398 | 0 |
           xsp = jj_scanpos;
7399 | 0 |
           if (jj_3R_251()) { jj_scanpos = xsp; break; }
7400 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7401 |  |
         }
7402 | 0 |
         return false;
7403 |  |
       }
7404 |  |
7405 | 0 |
       final private boolean jj_3R_219() {
7406 | 0 |
         if (jj_scan_token(REMASSIGN)) return true;
7407 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7408 | 0 |
         return false;
7409 |  |
       }
7410 |  |
7411 | 24 |
       final private boolean jj_3R_175() {
7412 | 12 |
         if (jj_3R_187()) return true;
7413 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7414 | 0 |
         Token xsp;
7415 | 0 |
         while (true) {
7416 | 0 |
           xsp = jj_scanpos;
7417 | 0 |
           if (jj_3R_243()) { jj_scanpos = xsp; break; }
7418 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7419 |  |
         }
7420 | 0 |
         return false;
7421 |  |
       }
7422 |  |
7423 | 0 |
       final private boolean jj_3R_218() {
7424 | 0 |
         if (jj_scan_token(SLASHASSIGN)) return true;
7425 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7426 | 0 |
         return false;
7427 |  |
       }
7428 |  |
7429 | 24 |
       final private boolean jj_3R_168() {
7430 | 12 |
         if (jj_3R_175()) return true;
7431 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7432 | 0 |
         Token xsp;
7433 | 0 |
         while (true) {
7434 | 0 |
           xsp = jj_scanpos;
7435 | 0 |
           if (jj_3R_215()) { jj_scanpos = xsp; break; }
7436 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7437 |  |
         }
7438 | 0 |
         return false;
7439 |  |
       }
7440 |  |
7441 | 24 |
       final private boolean jj_3R_136() {
7442 | 12 |
         if (jj_3R_168()) return true;
7443 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7444 | 0 |
         Token xsp;
7445 | 0 |
         xsp = jj_scanpos;
7446 | 0 |
         if (jj_3R_194()) jj_scanpos = xsp;
7447 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7448 | 0 |
         return false;
7449 |  |
       }
7450 |  |
7451 | 0 |
       final private boolean jj_3R_217() {
7452 | 0 |
         if (jj_scan_token(STARASSIGN)) return true;
7453 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7454 | 0 |
         return false;
7455 |  |
       }
7456 |  |
7457 | 0 |
       final private boolean jj_3R_190() {
7458 | 0 |
         if (jj_scan_token(CLASS)) return true;
7459 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7460 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
7461 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7462 | 0 |
         Token xsp;
7463 | 0 |
         xsp = jj_scanpos;
7464 | 0 |
         if (jj_3R_324()) jj_scanpos = xsp;
7465 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7466 | 0 |
         xsp = jj_scanpos;
7467 | 0 |
         if (jj_3R_325()) jj_scanpos = xsp;
7468 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7469 | 0 |
         if (jj_3R_260()) return true;
7470 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7471 | 0 |
         return false;
7472 |  |
       }
7473 |  |
7474 | 0 |
       final private boolean jj_3R_195() {
7475 | 0 |
         Token xsp;
7476 | 0 |
         xsp = jj_scanpos;
7477 | 0 |
         if (jj_3R_216()) {
7478 | 0 |
         jj_scanpos = xsp;
7479 | 0 |
         if (jj_3R_217()) {
7480 | 0 |
         jj_scanpos = xsp;
7481 | 0 |
         if (jj_3R_218()) {
7482 | 0 |
         jj_scanpos = xsp;
7483 | 0 |
         if (jj_3R_219()) {
7484 | 0 |
         jj_scanpos = xsp;
7485 | 0 |
         if (jj_3R_220()) {
7486 | 0 |
         jj_scanpos = xsp;
7487 | 0 |
         if (jj_3R_221()) {
7488 | 0 |
         jj_scanpos = xsp;
7489 | 0 |
         if (jj_3R_222()) {
7490 | 0 |
         jj_scanpos = xsp;
7491 | 0 |
         if (jj_3R_223()) {
7492 | 0 |
         jj_scanpos = xsp;
7493 | 0 |
         if (jj_3R_224()) {
7494 | 0 |
         jj_scanpos = xsp;
7495 | 0 |
         if (jj_3R_225()) {
7496 | 0 |
         jj_scanpos = xsp;
7497 | 0 |
         if (jj_3R_226()) {
7498 | 0 |
         jj_scanpos = xsp;
7499 | 0 |
         if (jj_3R_227()) return true;
7500 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7501 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7502 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7503 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7504 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7505 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7506 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7507 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7508 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7509 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7510 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7511 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7512 | 0 |
         return false;
7513 |  |
       }
7514 |  |
7515 | 0 |
       final private boolean jj_3R_216() {
7516 | 0 |
         if (jj_scan_token(ASSIGN)) return true;
7517 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7518 | 0 |
         return false;
7519 |  |
       }
7520 |  |
7521 | 0 |
       final private boolean jj_3R_186() {
7522 | 0 |
         if (jj_3R_195()) return true;
7523 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7524 | 0 |
         if (jj_3R_70()) return true;
7525 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7526 | 0 |
         return false;
7527 |  |
       }
7528 |  |
7529 | 24 |
       final private boolean jj_3R_70() {
7530 | 12 |
         if (jj_3R_136()) return true;
7531 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7532 | 0 |
         Token xsp;
7533 | 0 |
         xsp = jj_scanpos;
7534 | 0 |
         if (jj_3R_186()) jj_scanpos = xsp;
7535 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7536 | 0 |
         return false;
7537 |  |
       }
7538 |  |
7539 | 20 |
       final private boolean jj_3R_79() {
7540 | 20 |
         if (jj_scan_token(STRICTFP)) return true;
7541 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7542 | 0 |
         return false;
7543 |  |
       }
7544 |  |
7545 | 0 |
       final private boolean jj_3R_386() {
7546 | 0 |
         if (jj_scan_token(COMMA)) return true;
7547 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7548 | 0 |
         if (jj_3R_385()) return true;
7549 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7550 | 0 |
         return false;
7551 |  |
       }
7552 |  |
7553 | 20 |
       final private boolean jj_3R_78() {
7554 | 20 |
         if (jj_scan_token(PUBLIC)) return true;
7555 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7556 | 0 |
         return false;
7557 |  |
       }
7558 |  |
7559 | 0 |
       final private boolean jj_3R_369() {
7560 | 0 |
         if (jj_3R_385()) return true;
7561 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7562 | 0 |
         Token xsp;
7563 | 0 |
         while (true) {
7564 | 0 |
           xsp = jj_scanpos;
7565 | 0 |
           if (jj_3R_386()) { jj_scanpos = xsp; break; }
7566 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7567 |  |
         }
7568 | 0 |
         return false;
7569 |  |
       }
7570 |  |
7571 | 0 |
       final private boolean jj_3R_374() {
7572 | 0 |
         if (jj_scan_token(COMMA)) return true;
7573 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7574 | 0 |
         if (jj_3R_373()) return true;
7575 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7576 | 0 |
         return false;
7577 |  |
       }
7578 |  |
7579 | 0 |
       final private boolean jj_3R_339() {
7580 | 0 |
         if (jj_3R_373()) return true;
7581 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7582 | 0 |
         Token xsp;
7583 | 0 |
         while (true) {
7584 | 0 |
           xsp = jj_scanpos;
7585 | 0 |
           if (jj_3R_374()) { jj_scanpos = xsp; break; }
7586 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7587 |  |
         }
7588 | 0 |
         return false;
7589 |  |
       }
7590 |  |
7591 | 20 |
       final private boolean jj_3R_77() {
7592 | 20 |
         if (jj_scan_token(FINAL)) return true;
7593 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7594 | 0 |
         return false;
7595 |  |
       }
7596 |  |
7597 | 20 |
       final private boolean jj_3R_52() {
7598 | 20 |
         Token xsp;
7599 | 20 |
         xsp = jj_scanpos;
7600 | 20 |
         if (jj_3R_76()) {
7601 | 20 |
         jj_scanpos = xsp;
7602 | 20 |
         if (jj_3R_77()) {
7603 | 20 |
         jj_scanpos = xsp;
7604 | 20 |
         if (jj_3R_78()) {
7605 | 20 |
         jj_scanpos = xsp;
7606 | 20 |
         if (jj_3R_79()) return true;
7607 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7608 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7609 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7610 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7611 | 0 |
         return false;
7612 |  |
       }
7613 |  |
7614 | 20 |
       final private boolean jj_3R_76() {
7615 | 20 |
         if (jj_scan_token(ABSTRACT)) return true;
7616 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7617 | 0 |
         return false;
7618 |  |
       }
7619 |  |
7620 | 20 |
       final private boolean jj_3_1() {
7621 | 20 |
         Token xsp;
7622 | 20 |
         while (true) {
7623 | 20 |
           xsp = jj_scanpos;
7624 | 20 |
           if (jj_3R_52()) { jj_scanpos = xsp; break; }
7625 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7626 |  |
         }
7627 | 0 |
         if (jj_scan_token(CLASS)) return true;
7628 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7629 | 20 |
         return false;
7630 |  |
       }
7631 |  |
7632 | 0 |
       final private boolean jj_3R_398() {
7633 | 0 |
         if (jj_scan_token(DOT)) return true;
7634 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7635 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
7636 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7637 | 0 |
         return false;
7638 |  |
       }
7639 |  |
7640 | 0 |
       final private boolean jj_3R_385() {
7641 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
7642 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7643 | 0 |
         Token xsp;
7644 | 0 |
         while (true) {
7645 | 0 |
           xsp = jj_scanpos;
7646 | 0 |
           if (jj_3R_398()) { jj_scanpos = xsp; break; }
7647 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7648 |  |
         }
7649 | 0 |
         return false;
7650 |  |
       }
7651 |  |
7652 | 0 |
       final private boolean jj_3R_394() {
7653 | 0 |
         if (jj_scan_token(DOT)) return true;
7654 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7655 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
7656 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7657 | 0 |
         return false;
7658 |  |
       }
7659 |  |
7660 | 0 |
       final private boolean jj_3R_373() {
7661 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
7662 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7663 | 0 |
         Token xsp;
7664 | 0 |
         while (true) {
7665 | 0 |
           xsp = jj_scanpos;
7666 | 0 |
           if (jj_3R_394()) { jj_scanpos = xsp; break; }
7667 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7668 |  |
         }
7669 | 0 |
         return false;
7670 |  |
       }
7671 |  |
7672 | 704 |
       final private boolean jj_3_14() {
7673 | 520 |
         if (jj_scan_token(DOT)) return true;
7674 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7675 | 28 |
         if (jj_scan_token(IDENTIFIER)) return true;
7676 | 108 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7677 | 48 |
         return false;
7678 |  |
       }
7679 |  |
7680 | 492 |
       final private boolean jj_3R_57() {
7681 | 208 |
         if (jj_scan_token(IDENTIFIER)) return true;
7682 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7683 | 284 |
         Token xsp;
7684 | 284 |
         while (true) {
7685 | 332 |
           xsp = jj_scanpos;
7686 | 284 |
           if (jj_3_14()) { jj_scanpos = xsp; break; }
7687 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7688 |  |
         }
7689 | 284 |
         return false;
7690 |  |
       }
7691 |  |
7692 | 160 |
       final private boolean jj_3R_134() {
7693 | 36 |
         if (jj_3R_167()) return true;
7694 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7695 | 124 |
         return false;
7696 |  |
       }
7697 |  |
7698 | 212 |
       final private boolean jj_3R_133() {
7699 | 160 |
         if (jj_scan_token(VOID)) return true;
7700 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7701 | 52 |
         return false;
7702 |  |
       }
7703 |  |
7704 | 212 |
       final private boolean jj_3R_68() {
7705 | 212 |
         Token xsp;
7706 | 212 |
         xsp = jj_scanpos;
7707 | 212 |
         if (jj_3R_133()) {
7708 | 160 |
         jj_scanpos = xsp;
7709 | 36 |
         if (jj_3R_134()) return true;
7710 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7711 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7712 | 176 |
         return false;
7713 |  |
       }
7714 |  |
7715 | 300 |
       final private boolean jj_3R_129() {
7716 | 300 |
         if (jj_scan_token(DOUBLE)) return true;
7717 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7718 | 0 |
         return false;
7719 |  |
       }
7720 |  |
7721 | 300 |
       final private boolean jj_3R_128() {
7722 | 300 |
         if (jj_scan_token(FLOAT)) return true;
7723 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7724 | 0 |
         return false;
7725 |  |
       }
7726 |  |
7727 | 96 |
       final private boolean jj_3R_138() {
7728 | 52 |
         if (jj_3R_57()) return true;
7729 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7730 | 44 |
         return false;
7731 |  |
       }
7732 |  |
7733 | 300 |
       final private boolean jj_3R_127() {
7734 | 300 |
         if (jj_scan_token(LONG)) return true;
7735 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7736 | 0 |
         return false;
7737 |  |
       }
7738 |  |
7739 | 354 |
       final private boolean jj_3R_126() {
7740 | 300 |
         if (jj_scan_token(INT)) return true;
7741 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7742 | 54 |
         return false;
7743 |  |
       }
7744 |  |
7745 | 354 |
       final private boolean jj_3R_125() {
7746 | 354 |
         if (jj_scan_token(SHORT)) return true;
7747 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7748 | 0 |
         return false;
7749 |  |
       }
7750 |  |
7751 | 354 |
       final private boolean jj_3R_124() {
7752 | 354 |
         if (jj_scan_token(BYTE)) return true;
7753 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7754 | 0 |
         return false;
7755 |  |
       }
7756 |  |
7757 | 354 |
       final private boolean jj_3R_123() {
7758 | 354 |
         if (jj_scan_token(CHAR)) return true;
7759 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7760 | 0 |
         return false;
7761 |  |
       }
7762 |  |
7763 | 354 |
       final private boolean jj_3R_122() {
7764 | 354 |
         if (jj_scan_token(BOOLEAN)) return true;
7765 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7766 | 0 |
         return false;
7767 |  |
       }
7768 |  |
7769 | 354 |
       final private boolean jj_3R_66() {
7770 | 354 |
         Token xsp;
7771 | 354 |
         xsp = jj_scanpos;
7772 | 354 |
         if (jj_3R_122()) {
7773 | 354 |
         jj_scanpos = xsp;
7774 | 354 |
         if (jj_3R_123()) {
7775 | 354 |
         jj_scanpos = xsp;
7776 | 354 |
         if (jj_3R_124()) {
7777 | 354 |
         jj_scanpos = xsp;
7778 | 354 |
         if (jj_3R_125()) {
7779 | 354 |
         jj_scanpos = xsp;
7780 | 354 |
         if (jj_3R_126()) {
7781 | 300 |
         jj_scanpos = xsp;
7782 | 300 |
         if (jj_3R_127()) {
7783 | 300 |
         jj_scanpos = xsp;
7784 | 300 |
         if (jj_3R_128()) {
7785 | 300 |
         jj_scanpos = xsp;
7786 | 300 |
         if (jj_3R_129()) return true;
7787 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7788 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7789 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7790 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7791 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7792 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7793 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7794 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7795 | 54 |
         return false;
7796 |  |
       }
7797 |  |
7798 | 62 |
       final private boolean jj_3R_139() {
7799 | 62 |
         if (jj_scan_token(LBRACKET)) return true;
7800 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7801 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
7802 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7803 | 0 |
         return false;
7804 |  |
       }
7805 |  |
7806 | 114 |
       final private boolean jj_3R_137() {
7807 | 96 |
         if (jj_3R_66()) return true;
7808 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7809 | 18 |
         return false;
7810 |  |
       }
7811 |  |
7812 | 114 |
       final private boolean jj_3R_73() {
7813 | 114 |
         Token xsp;
7814 | 114 |
         xsp = jj_scanpos;
7815 | 114 |
         if (jj_3R_137()) {
7816 | 96 |
         jj_scanpos = xsp;
7817 | 52 |
         if (jj_3R_138()) return true;
7818 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7819 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7820 | 62 |
         while (true) {
7821 | 62 |
           xsp = jj_scanpos;
7822 | 62 |
           if (jj_3R_139()) { jj_scanpos = xsp; break; }
7823 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7824 |  |
         }
7825 | 62 |
         return false;
7826 |  |
       }
7827 |  |
7828 | 0 |
       final private boolean jj_3R_401() {
7829 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
7830 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7831 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
7832 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7833 | 0 |
         return false;
7834 |  |
       }
7835 |  |
7836 | 0 |
       final private boolean jj_3R_400() {
7837 | 0 |
         if (jj_3R_57()) return true;
7838 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7839 | 0 |
         return false;
7840 |  |
       }
7841 |  |
7842 | 0 |
       final private boolean jj_3R_399() {
7843 | 0 |
         if (jj_3R_66()) return true;
7844 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7845 | 0 |
         return false;
7846 |  |
       }
7847 |  |
7848 | 0 |
       final private boolean jj_3R_392() {
7849 | 0 |
         Token xsp;
7850 | 0 |
         xsp = jj_scanpos;
7851 | 0 |
         if (jj_3R_399()) {
7852 | 0 |
         jj_scanpos = xsp;
7853 | 0 |
         if (jj_3R_400()) return true;
7854 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7855 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7856 | 0 |
         while (true) {
7857 | 0 |
           xsp = jj_scanpos;
7858 | 0 |
           if (jj_3R_401()) { jj_scanpos = xsp; break; }
7859 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7860 |  |
         }
7861 | 0 |
         return false;
7862 |  |
       }
7863 |  |
7864 | 132 |
       final private boolean jj_3R_174() {
7865 | 124 |
         if (jj_scan_token(LBRACKET)) return true;
7866 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7867 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
7868 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7869 | 8 |
         return false;
7870 |  |
       }
7871 |  |
7872 | 156 |
       final private boolean jj_3R_173() {
7873 | 36 |
         if (jj_3R_57()) return true;
7874 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7875 | 120 |
         return false;
7876 |  |
       }
7877 |  |
7878 | 160 |
       final private boolean jj_3R_172() {
7879 | 156 |
         if (jj_3R_66()) return true;
7880 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7881 | 4 |
         return false;
7882 |  |
       }
7883 |  |
7884 | 160 |
       final private boolean jj_3R_167() {
7885 | 160 |
         Token xsp;
7886 | 160 |
         xsp = jj_scanpos;
7887 | 160 |
         if (jj_3R_172()) {
7888 | 156 |
         jj_scanpos = xsp;
7889 | 36 |
         if (jj_3R_173()) return true;
7890 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7891 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7892 | 124 |
         while (true) {
7893 | 132 |
           xsp = jj_scanpos;
7894 | 124 |
           if (jj_3R_174()) { jj_scanpos = xsp; break; }
7895 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7896 |  |
         }
7897 | 124 |
         return false;
7898 |  |
       }
7899 |  |
7900 | 0 |
       final private boolean jj_3R_422() {
7901 | 0 |
         if (jj_scan_token(COLON)) return true;
7902 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7903 | 0 |
         if (jj_3R_70()) return true;
7904 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7905 | 0 |
         return false;
7906 |  |
       }
7907 |  |
7908 | 0 |
       final private boolean jj_3R_360() {
7909 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
7910 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7911 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
7912 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7913 | 0 |
         return false;
7914 |  |
       }
7915 |  |
7916 | 0 |
       final private boolean jj_3R_359() {
7917 | 0 |
         if (jj_3R_57()) return true;
7918 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7919 | 0 |
         return false;
7920 |  |
       }
7921 |  |
7922 | 0 |
       final private boolean jj_3R_298() {
7923 | 0 |
         if (jj_scan_token(THROWS)) return true;
7924 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7925 | 0 |
         if (jj_3R_339()) return true;
7926 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7927 | 0 |
         return false;
7928 |  |
       }
7929 |  |
7930 | 0 |
       final private boolean jj_3R_242() {
7931 | 0 |
         if (jj_scan_token(ASSERT)) return true;
7932 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7933 | 0 |
         if (jj_3R_70()) return true;
7934 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7935 | 0 |
         Token xsp;
7936 | 0 |
         xsp = jj_scanpos;
7937 | 0 |
         if (jj_3R_422()) jj_scanpos = xsp;
7938 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7939 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
7940 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7941 | 0 |
         return false;
7942 |  |
       }
7943 |  |
7944 | 0 |
       final private boolean jj_3R_358() {
7945 | 0 |
         if (jj_3R_66()) return true;
7946 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7947 | 0 |
         return false;
7948 |  |
       }
7949 |  |
7950 | 0 |
       final private boolean jj_3R_307() {
7951 | 0 |
         Token xsp;
7952 | 0 |
         xsp = jj_scanpos;
7953 | 0 |
         if (jj_3R_358()) {
7954 | 0 |
         jj_scanpos = xsp;
7955 | 0 |
         if (jj_3R_359()) return true;
7956 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7957 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7958 | 0 |
         while (true) {
7959 | 0 |
           xsp = jj_scanpos;
7960 | 0 |
           if (jj_3R_360()) { jj_scanpos = xsp; break; }
7961 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7962 |  |
         }
7963 | 0 |
         return false;
7964 |  |
       }
7965 |  |
7966 | 0 |
       final private boolean jj_3R_421() {
7967 | 0 |
         if (jj_scan_token(FINALLY)) return true;
7968 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7969 | 0 |
         if (jj_3R_81()) return true;
7970 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7971 | 0 |
         return false;
7972 |  |
       }
7973 |  |
7974 | 0 |
       final private boolean jj_3R_420() {
7975 | 0 |
         if (jj_scan_token(CATCH)) return true;
7976 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7977 | 0 |
         if (jj_scan_token(LPAREN)) return true;
7978 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7979 | 0 |
         if (jj_3R_371()) return true;
7980 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7981 | 0 |
         if (jj_scan_token(RPAREN)) return true;
7982 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7983 | 0 |
         if (jj_3R_81()) return true;
7984 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7985 | 0 |
         return false;
7986 |  |
       }
7987 |  |
7988 | 0 |
       final private boolean jj_3R_241() {
7989 | 0 |
         if (jj_scan_token(TRY)) return true;
7990 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7991 | 0 |
         if (jj_3R_81()) return true;
7992 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7993 | 0 |
         Token xsp;
7994 | 0 |
         while (true) {
7995 | 0 |
           xsp = jj_scanpos;
7996 | 0 |
           if (jj_3R_420()) { jj_scanpos = xsp; break; }
7997 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7998 |  |
         }
7999 | 0 |
         xsp = jj_scanpos;
8000 | 0 |
         if (jj_3R_421()) jj_scanpos = xsp;
8001 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8002 | 0 |
         return false;
8003 |  |
       }
8004 |  |
8005 | 168 |
       final private boolean jj_3R_80() {
8006 | 164 |
         if (jj_scan_token(STATIC)) return true;
8007 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8008 | 4 |
         return false;
8009 |  |
       }
8010 |  |
8011 | 0 |
       final private boolean jj_3_13() {
8012 | 0 |
         if (jj_scan_token(THIS)) return true;
8013 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8014 | 0 |
         if (jj_3R_64()) return true;
8015 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8016 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8017 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8018 | 0 |
         return false;
8019 |  |
       }
8020 |  |
8021 | 168 |
       final private boolean jj_3R_53() {
8022 | 168 |
         Token xsp;
8023 | 168 |
         xsp = jj_scanpos;
8024 | 164 |
         if (jj_3R_80()) jj_scanpos = xsp;
8025 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8026 | 164 |
         if (jj_3R_81()) return true;
8027 | 4 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8028 | 0 |
         return false;
8029 |  |
       }
8030 |  |
8031 | 0 |
       final private boolean jj_3R_416() {
8032 | 0 |
         if (jj_3R_428()) return true;
8033 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8034 | 0 |
         return false;
8035 |  |
       }
8036 |  |
8037 | 0 |
       final private boolean jj_3R_240() {
8038 | 0 |
         if (jj_scan_token(SYNCHRONIZED)) return true;
8039 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8040 | 0 |
         if (jj_scan_token(LPAREN)) return true;
8041 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8042 | 0 |
         if (jj_3R_70()) return true;
8043 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8044 | 0 |
         if (jj_scan_token(RPAREN)) return true;
8045 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8046 | 0 |
         if (jj_3R_81()) return true;
8047 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8048 | 0 |
         return false;
8049 |  |
       }
8050 |  |
8051 | 0 |
       final private boolean jj_3R_419() {
8052 | 0 |
         if (jj_3R_70()) return true;
8053 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8054 | 0 |
         return false;
8055 |  |
       }
8056 |  |
8057 | 24 |
       final private boolean jj_3_12() {
8058 | 24 |
         if (jj_3R_63()) return true;
8059 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8060 | 0 |
         if (jj_scan_token(DOT)) return true;
8061 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8062 | 0 |
         return false;
8063 |  |
       }
8064 |  |
8065 | 0 |
       final private boolean jj_3R_418() {
8066 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
8067 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8068 | 0 |
         return false;
8069 |  |
       }
8070 |  |
8071 | 24 |
       final private boolean jj_3R_117() {
8072 | 24 |
         Token xsp;
8073 | 24 |
         xsp = jj_scanpos;
8074 | 24 |
         if (jj_3_12()) jj_scanpos = xsp;
8075 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8076 | 24 |
         if (jj_scan_token(SUPER)) return true;
8077 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8078 | 0 |
         if (jj_3R_64()) return true;
8079 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8080 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8081 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8082 | 0 |
         return false;
8083 |  |
       }
8084 |  |
8085 | 0 |
       final private boolean jj_3R_239() {
8086 | 0 |
         if (jj_scan_token(THROW)) return true;
8087 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8088 | 0 |
         if (jj_3R_70()) return true;
8089 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8090 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8091 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8092 | 0 |
         return false;
8093 |  |
       }
8094 |  |
8095 | 24 |
       final private boolean jj_3_11() {
8096 | 24 |
         if (jj_3R_62()) return true;
8097 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8098 | 0 |
         return false;
8099 |  |
       }
8100 |  |
8101 | 24 |
       final private boolean jj_3R_116() {
8102 | 24 |
         if (jj_scan_token(THIS)) return true;
8103 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8104 | 0 |
         if (jj_3R_64()) return true;
8105 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8106 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8107 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8108 | 0 |
         return false;
8109 |  |
       }
8110 |  |
8111 | 24 |
       final private boolean jj_3R_62() {
8112 | 24 |
         Token xsp;
8113 | 24 |
         xsp = jj_scanpos;
8114 | 24 |
         if (jj_3R_116()) {
8115 | 24 |
         jj_scanpos = xsp;
8116 | 24 |
         if (jj_3R_117()) return true;
8117 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8118 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8119 | 0 |
         return false;
8120 |  |
       }
8121 |  |
8122 | 0 |
       final private boolean jj_3R_439() {
8123 | 0 |
         if (jj_scan_token(COMMA)) return true;
8124 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8125 | 0 |
         if (jj_3R_230()) return true;
8126 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8127 | 0 |
         return false;
8128 |  |
       }
8129 |  |
8130 | 0 |
       final private boolean jj_3R_238() {
8131 | 0 |
         if (jj_scan_token(RETURN)) return true;
8132 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8133 | 0 |
         Token xsp;
8134 | 0 |
         xsp = jj_scanpos;
8135 | 0 |
         if (jj_3R_419()) jj_scanpos = xsp;
8136 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8137 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8138 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8139 | 0 |
         return false;
8140 |  |
       }
8141 |  |
8142 | 0 |
       final private boolean jj_3R_417() {
8143 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
8144 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8145 | 0 |
         return false;
8146 |  |
       }
8147 |  |
8148 | 0 |
       final private boolean jj_3R_300() {
8149 | 0 |
         if (jj_3R_169()) return true;
8150 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8151 | 0 |
         return false;
8152 |  |
       }
8153 |  |
8154 | 0 |
       final private boolean jj_3R_299() {
8155 | 0 |
         if (jj_3R_62()) return true;
8156 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8157 | 0 |
         return false;
8158 |  |
       }
8159 |  |
8160 | 0 |
       final private boolean jj_3R_237() {
8161 | 0 |
         if (jj_scan_token(CONTINUE)) return true;
8162 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8163 | 0 |
         Token xsp;
8164 | 0 |
         xsp = jj_scanpos;
8165 | 0 |
         if (jj_3R_418()) jj_scanpos = xsp;
8166 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8167 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8168 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8169 | 0 |
         return false;
8170 |  |
       }
8171 |  |
8172 | 0 |
       final private boolean jj_3R_415() {
8173 | 0 |
         if (jj_3R_70()) return true;
8174 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8175 | 0 |
         return false;
8176 |  |
       }
8177 |  |
8178 | 0 |
       final private boolean jj_3R_236() {
8179 | 0 |
         if (jj_scan_token(BREAK)) return true;
8180 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8181 | 0 |
         Token xsp;
8182 | 0 |
         xsp = jj_scanpos;
8183 | 0 |
         if (jj_3R_417()) jj_scanpos = xsp;
8184 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8185 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8186 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8187 | 0 |
         return false;
8188 |  |
       }
8189 |  |
8190 | 0 |
       final private boolean jj_3R_337() {
8191 | 0 |
         if (jj_scan_token(PRIVATE)) return true;
8192 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8193 | 0 |
         return false;
8194 |  |
       }
8195 |  |
8196 | 0 |
       final private boolean jj_3R_413() {
8197 | 0 |
         if (jj_scan_token(ELSE)) return true;
8198 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8199 | 0 |
         if (jj_3R_189()) return true;
8200 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8201 | 0 |
         return false;
8202 |  |
       }
8203 |  |
8204 | 0 |
       final private boolean jj_3R_428() {
8205 | 0 |
         if (jj_3R_438()) return true;
8206 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8207 | 0 |
         return false;
8208 |  |
       }
8209 |  |
8210 | 0 |
       final private boolean jj_3R_336() {
8211 | 0 |
         if (jj_scan_token(PROTECTED)) return true;
8212 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8213 | 0 |
         return false;
8214 |  |
       }
8215 |  |
8216 | 0 |
       final private boolean jj_3R_372() {
8217 | 0 |
         if (jj_scan_token(COMMA)) return true;
8218 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8219 | 0 |
         if (jj_3R_371()) return true;
8220 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8221 | 0 |
         return false;
8222 |  |
       }
8223 |  |
8224 | 0 |
       final private boolean jj_3R_75() {
8225 | 0 |
         if (jj_scan_token(FINAL)) return true;
8226 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8227 | 0 |
         return false;
8228 |  |
       }
8229 |  |
8230 | 0 |
       final private boolean jj_3_31() {
8231 | 0 |
         Token xsp;
8232 | 0 |
         xsp = jj_scanpos;
8233 | 0 |
         if (jj_3R_75()) jj_scanpos = xsp;
8234 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8235 | 0 |
         if (jj_3R_73()) return true;
8236 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8237 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
8238 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8239 | 0 |
         return false;
8240 |  |
       }
8241 |  |
8242 | 0 |
       final private boolean jj_3R_438() {
8243 | 0 |
         if (jj_3R_230()) return true;
8244 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8245 | 0 |
         Token xsp;
8246 | 0 |
         while (true) {
8247 | 0 |
           xsp = jj_scanpos;
8248 | 0 |
           if (jj_3R_439()) { jj_scanpos = xsp; break; }
8249 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8250 |  |
         }
8251 | 0 |
         return false;
8252 |  |
       }
8253 |  |
8254 | 0 |
       final private boolean jj_3R_335() {
8255 | 0 |
         if (jj_scan_token(PUBLIC)) return true;
8256 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8257 | 0 |
         return false;
8258 |  |
       }
8259 |  |
8260 | 0 |
       final private boolean jj_3R_296() {
8261 | 0 |
         Token xsp;
8262 | 0 |
         xsp = jj_scanpos;
8263 | 0 |
         if (jj_3R_335()) {
8264 | 0 |
         jj_scanpos = xsp;
8265 | 0 |
         if (jj_3R_336()) {
8266 | 0 |
         jj_scanpos = xsp;
8267 | 0 |
         if (jj_3R_337()) return true;
8268 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8269 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8270 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8271 | 0 |
         return false;
8272 |  |
       }
8273 |  |
8274 | 0 |
       final private boolean jj_3R_282() {
8275 | 0 |
         Token xsp;
8276 | 0 |
         xsp = jj_scanpos;
8277 | 0 |
         if (jj_3R_296()) jj_scanpos = xsp;
8278 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8279 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
8280 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8281 | 0 |
         if (jj_3R_297()) return true;
8282 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8283 | 0 |
         xsp = jj_scanpos;
8284 | 0 |
         if (jj_3R_298()) jj_scanpos = xsp;
8285 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8286 | 0 |
         if (jj_scan_token(LBRACE)) return true;
8287 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8288 | 0 |
         xsp = jj_scanpos;
8289 | 0 |
         if (jj_3R_299()) jj_scanpos = xsp;
8290 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8291 | 0 |
         while (true) {
8292 | 0 |
           xsp = jj_scanpos;
8293 | 0 |
           if (jj_3R_300()) { jj_scanpos = xsp; break; }
8294 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8295 |  |
         }
8296 | 0 |
         if (jj_scan_token(RBRACE)) return true;
8297 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8298 | 0 |
         return false;
8299 |  |
       }
8300 |  |
8301 | 0 |
       final private boolean jj_3R_414() {
8302 | 0 |
         if (jj_3R_427()) return true;
8303 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8304 | 0 |
         return false;
8305 |  |
       }
8306 |  |
8307 | 0 |
       final private boolean jj_3R_349() {
8308 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
8309 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8310 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
8311 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8312 | 0 |
         return false;
8313 |  |
       }
8314 |  |
8315 | 0 |
       final private boolean jj_3R_437() {
8316 | 0 |
         if (jj_3R_438()) return true;
8317 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8318 | 0 |
         return false;
8319 |  |
       }
8320 |  |
8321 | 0 |
       final private boolean jj_3R_436() {
8322 | 0 |
         if (jj_3R_188()) return true;
8323 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8324 | 0 |
         return false;
8325 |  |
       }
8326 |  |
8327 | 0 |
       final private boolean jj_3R_427() {
8328 | 0 |
         Token xsp;
8329 | 0 |
         xsp = jj_scanpos;
8330 | 0 |
         if (jj_3R_436()) {
8331 | 0 |
         jj_scanpos = xsp;
8332 | 0 |
         if (jj_3R_437()) return true;
8333 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8334 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8335 | 0 |
         return false;
8336 |  |
       }
8337 |  |
8338 | 0 |
       final private boolean jj_3R_391() {
8339 | 0 |
         if (jj_scan_token(FINAL)) return true;
8340 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8341 | 0 |
         return false;
8342 |  |
       }
8343 |  |
8344 | 0 |
       final private boolean jj_3R_235() {
8345 | 0 |
         if (jj_scan_token(FOR)) return true;
8346 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8347 | 0 |
         if (jj_scan_token(LPAREN)) return true;
8348 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8349 | 0 |
         Token xsp;
8350 | 0 |
         xsp = jj_scanpos;
8351 | 0 |
         if (jj_3R_414()) jj_scanpos = xsp;
8352 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8353 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8354 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8355 | 0 |
         xsp = jj_scanpos;
8356 | 0 |
         if (jj_3R_415()) jj_scanpos = xsp;
8357 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8358 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8359 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8360 | 0 |
         xsp = jj_scanpos;
8361 | 0 |
         if (jj_3R_416()) jj_scanpos = xsp;
8362 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8363 | 0 |
         if (jj_scan_token(RPAREN)) return true;
8364 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8365 | 0 |
         if (jj_3R_189()) return true;
8366 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8367 | 0 |
         return false;
8368 |  |
       }
8369 |  |
8370 | 0 |
       final private boolean jj_3R_371() {
8371 | 0 |
         Token xsp;
8372 | 0 |
         xsp = jj_scanpos;
8373 | 0 |
         if (jj_3R_391()) jj_scanpos = xsp;
8374 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8375 | 0 |
         if (jj_3R_392()) return true;
8376 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8377 | 0 |
         if (jj_3R_393()) return true;
8378 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8379 | 0 |
         return false;
8380 |  |
       }
8381 |  |
8382 | 0 |
       final private boolean jj_3R_338() {
8383 | 0 |
         if (jj_3R_371()) return true;
8384 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8385 | 0 |
         Token xsp;
8386 | 0 |
         while (true) {
8387 | 0 |
           xsp = jj_scanpos;
8388 | 0 |
           if (jj_3R_372()) { jj_scanpos = xsp; break; }
8389 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8390 |  |
         }
8391 | 0 |
         return false;
8392 |  |
       }
8393 |  |
8394 | 0 |
       final private boolean jj_3R_234() {
8395 | 0 |
         if (jj_scan_token(DO)) return true;
8396 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8397 | 0 |
         if (jj_3R_189()) return true;
8398 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8399 | 0 |
         if (jj_scan_token(WHILE)) return true;
8400 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8401 | 0 |
         if (jj_scan_token(LPAREN)) return true;
8402 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8403 | 0 |
         if (jj_3R_70()) return true;
8404 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8405 | 0 |
         if (jj_scan_token(RPAREN)) return true;
8406 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8407 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8408 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8409 | 0 |
         return false;
8410 |  |
       }
8411 |  |
8412 | 0 |
       final private boolean jj_3R_297() {
8413 | 0 |
         if (jj_scan_token(LPAREN)) return true;
8414 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8415 | 0 |
         Token xsp;
8416 | 0 |
         xsp = jj_scanpos;
8417 | 0 |
         if (jj_3R_338()) jj_scanpos = xsp;
8418 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8419 | 0 |
         if (jj_scan_token(RPAREN)) return true;
8420 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8421 | 0 |
         return false;
8422 |  |
       }
8423 |  |
8424 | 0 |
       final private boolean jj_3R_233() {
8425 | 0 |
         if (jj_scan_token(WHILE)) return true;
8426 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8427 | 0 |
         if (jj_scan_token(LPAREN)) return true;
8428 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8429 | 0 |
         if (jj_3R_70()) return true;
8430 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8431 | 0 |
         if (jj_scan_token(RPAREN)) return true;
8432 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8433 | 0 |
         if (jj_3R_189()) return true;
8434 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8435 | 0 |
         return false;
8436 |  |
       }
8437 |  |
8438 | 0 |
       final private boolean jj_3R_426() {
8439 | 0 |
         if (jj_3R_169()) return true;
8440 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8441 | 0 |
         return false;
8442 |  |
       }
8443 |  |
8444 | 0 |
       final private boolean jj_3R_232() {
8445 | 0 |
         if (jj_scan_token(IF)) return true;
8446 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8447 | 0 |
         if (jj_scan_token(LPAREN)) return true;
8448 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8449 | 0 |
         if (jj_3R_70()) return true;
8450 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8451 | 0 |
         if (jj_scan_token(RPAREN)) return true;
8452 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8453 | 0 |
         if (jj_3R_189()) return true;
8454 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8455 | 0 |
         Token xsp;
8456 | 0 |
         xsp = jj_scanpos;
8457 | 0 |
         if (jj_3R_413()) jj_scanpos = xsp;
8458 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8459 | 0 |
         return false;
8460 |  |
       }
8461 |  |
8462 | 0 |
       final private boolean jj_3R_305() {
8463 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8464 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8465 | 0 |
         return false;
8466 |  |
       }
8467 |  |
8468 | 0 |
       final private boolean jj_3R_302() {
8469 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
8470 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8471 | 0 |
         if (jj_3R_297()) return true;
8472 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8473 | 0 |
         Token xsp;
8474 | 0 |
         while (true) {
8475 | 0 |
           xsp = jj_scanpos;
8476 | 0 |
           if (jj_3R_349()) { jj_scanpos = xsp; break; }
8477 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8478 |  |
         }
8479 | 0 |
         return false;
8480 |  |
       }
8481 |  |
8482 | 0 |
       final private boolean jj_3R_435() {
8483 | 0 |
         if (jj_scan_token(_DEFAULT)) return true;
8484 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8485 | 0 |
         if (jj_scan_token(COLON)) return true;
8486 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8487 | 0 |
         return false;
8488 |  |
       }
8489 |  |
8490 | 0 |
       final private boolean jj_3R_434() {
8491 | 0 |
         if (jj_scan_token(CASE)) return true;
8492 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8493 | 0 |
         if (jj_3R_70()) return true;
8494 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8495 | 0 |
         if (jj_scan_token(COLON)) return true;
8496 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8497 | 0 |
         return false;
8498 |  |
       }
8499 |  |
8500 | 0 |
       final private boolean jj_3R_425() {
8501 | 0 |
         Token xsp;
8502 | 0 |
         xsp = jj_scanpos;
8503 | 0 |
         if (jj_3R_434()) {
8504 | 0 |
         jj_scanpos = xsp;
8505 | 0 |
         if (jj_3R_435()) return true;
8506 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8507 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8508 | 0 |
         return false;
8509 |  |
       }
8510 |  |
8511 | 0 |
       final private boolean jj_3R_404() {
8512 | 0 |
         if (jj_scan_token(COMMA)) return true;
8513 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8514 | 0 |
         if (jj_3R_403()) return true;
8515 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8516 | 0 |
         return false;
8517 |  |
       }
8518 |  |
8519 | 0 |
       final private boolean jj_3R_412() {
8520 | 0 |
         if (jj_3R_425()) return true;
8521 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8522 | 0 |
         Token xsp;
8523 | 0 |
         while (true) {
8524 | 0 |
           xsp = jj_scanpos;
8525 | 0 |
           if (jj_3R_426()) { jj_scanpos = xsp; break; }
8526 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8527 |  |
         }
8528 | 0 |
         return false;
8529 |  |
       }
8530 |  |
8531 | 0 |
       final private boolean jj_3R_304() {
8532 | 0 |
         if (jj_3R_350()) return true;
8533 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8534 | 0 |
         return false;
8535 |  |
       }
8536 |  |
8537 | 0 |
       final private boolean jj_3R_303() {
8538 | 0 |
         if (jj_scan_token(THROWS)) return true;
8539 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8540 | 0 |
         if (jj_3R_339()) return true;
8541 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8542 | 0 |
         return false;
8543 |  |
       }
8544 |  |
8545 | 0 |
       final private boolean jj_3R_231() {
8546 | 0 |
         if (jj_scan_token(SWITCH)) return true;
8547 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8548 | 0 |
         if (jj_scan_token(LPAREN)) return true;
8549 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8550 | 0 |
         if (jj_3R_70()) return true;
8551 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8552 | 0 |
         if (jj_scan_token(RPAREN)) return true;
8553 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8554 | 0 |
         if (jj_scan_token(LBRACE)) return true;
8555 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8556 | 0 |
         Token xsp;
8557 | 0 |
         while (true) {
8558 | 0 |
           xsp = jj_scanpos;
8559 | 0 |
           if (jj_3R_412()) { jj_scanpos = xsp; break; }
8560 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8561 |  |
         }
8562 | 0 |
         if (jj_scan_token(RBRACE)) return true;
8563 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8564 | 0 |
         return false;
8565 |  |
       }
8566 |  |
8567 | 0 |
       final private boolean jj_3R_264() {
8568 | 0 |
         if (jj_scan_token(COMMA)) return true;
8569 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8570 | 0 |
         return false;
8571 |  |
       }
8572 |  |
8573 | 0 |
       final private boolean jj_3R_433() {
8574 | 0 |
         if (jj_3R_195()) return true;
8575 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8576 | 0 |
         if (jj_3R_70()) return true;
8577 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8578 | 0 |
         return false;
8579 |  |
       }
8580 |  |
8581 | 0 |
       final private boolean jj_3R_432() {
8582 | 0 |
         if (jj_scan_token(DECR)) return true;
8583 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8584 | 0 |
         return false;
8585 |  |
       }
8586 |  |
8587 | 0 |
       final private boolean jj_3R_348() {
8588 | 0 |
         if (jj_scan_token(STRICTFP)) return true;
8589 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8590 | 0 |
         return false;
8591 |  |
       }
8592 |  |
8593 | 0 |
       final private boolean jj_3R_431() {
8594 | 0 |
         if (jj_scan_token(INCR)) return true;
8595 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8596 | 0 |
         return false;
8597 |  |
       }
8598 |  |
8599 | 0 |
       final private boolean jj_3R_424() {
8600 | 0 |
         Token xsp;
8601 | 0 |
         xsp = jj_scanpos;
8602 | 0 |
         if (jj_3R_431()) {
8603 | 0 |
         jj_scanpos = xsp;
8604 | 0 |
         if (jj_3R_432()) {
8605 | 0 |
         jj_scanpos = xsp;
8606 | 0 |
         if (jj_3R_433()) return true;
8607 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8608 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8609 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8610 | 0 |
         return false;
8611 |  |
       }
8612 |  |
8613 | 0 |
       final private boolean jj_3R_247() {
8614 | 0 |
         if (jj_3R_63()) return true;
8615 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8616 | 0 |
         Token xsp;
8617 | 0 |
         xsp = jj_scanpos;
8618 | 0 |
         if (jj_3R_424()) jj_scanpos = xsp;
8619 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8620 | 0 |
         return false;
8621 |  |
       }
8622 |  |
8623 | 0 |
       final private boolean jj_3R_347() {
8624 | 0 |
         if (jj_scan_token(SYNCHRONIZED)) return true;
8625 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8626 | 0 |
         return false;
8627 |  |
       }
8628 |  |
8629 | 0 |
       final private boolean jj_3R_246() {
8630 | 0 |
         if (jj_3R_254()) return true;
8631 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8632 | 0 |
         return false;
8633 |  |
       }
8634 |  |
8635 | 0 |
       final private boolean jj_3R_230() {
8636 | 0 |
         Token xsp;
8637 | 0 |
         xsp = jj_scanpos;
8638 | 0 |
         if (jj_3R_245()) {
8639 | 0 |
         jj_scanpos = xsp;
8640 | 0 |
         if (jj_3R_246()) {
8641 | 0 |
         jj_scanpos = xsp;
8642 | 0 |
         if (jj_3R_247()) return true;
8643 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8644 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8645 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8646 | 0 |
         return false;
8647 |  |
       }
8648 |  |
8649 | 0 |
       final private boolean jj_3R_245() {
8650 | 0 |
         if (jj_3R_253()) return true;
8651 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8652 | 0 |
         return false;
8653 |  |
       }
8654 |  |
8655 | 0 |
       final private boolean jj_3R_346() {
8656 | 0 |
         if (jj_scan_token(NATIVE)) return true;
8657 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8658 | 0 |
         return false;
8659 |  |
       }
8660 |  |
8661 | 0 |
       final private boolean jj_3R_345() {
8662 | 0 |
         if (jj_scan_token(FINAL)) return true;
8663 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8664 | 0 |
         return false;
8665 |  |
       }
8666 |  |
8667 | 0 |
       final private boolean jj_3R_229() {
8668 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8669 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8670 | 0 |
         return false;
8671 |  |
       }
8672 |  |
8673 | 0 |
       final private boolean jj_3R_344() {
8674 | 0 |
         if (jj_scan_token(ABSTRACT)) return true;
8675 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8676 | 0 |
         return false;
8677 |  |
       }
8678 |  |
8679 | 0 |
       final private boolean jj_3R_197() {
8680 | 0 |
         if (jj_scan_token(FINAL)) return true;
8681 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8682 | 0 |
         return false;
8683 |  |
       }
8684 |  |
8685 | 0 |
       final private boolean jj_3R_188() {
8686 | 0 |
         Token xsp;
8687 | 0 |
         xsp = jj_scanpos;
8688 | 0 |
         if (jj_3R_197()) jj_scanpos = xsp;
8689 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8690 | 0 |
         if (jj_3R_73()) return true;
8691 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8692 | 0 |
         if (jj_3R_403()) return true;
8693 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8694 | 0 |
         while (true) {
8695 | 0 |
           xsp = jj_scanpos;
8696 | 0 |
           if (jj_3R_404()) { jj_scanpos = xsp; break; }
8697 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8698 |  |
         }
8699 | 0 |
         return false;
8700 |  |
       }
8701 |  |
8702 | 0 |
       final private boolean jj_3R_343() {
8703 | 0 |
         if (jj_scan_token(STATIC)) return true;
8704 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8705 | 0 |
         return false;
8706 |  |
       }
8707 |  |
8708 | 0 |
       final private boolean jj_3R_342() {
8709 | 0 |
         if (jj_scan_token(PRIVATE)) return true;
8710 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8711 | 0 |
         return false;
8712 |  |
       }
8713 |  |
8714 | 0 |
       final private boolean jj_3R_408() {
8715 | 0 |
         if (jj_3R_191()) return true;
8716 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8717 | 0 |
         return false;
8718 |  |
       }
8719 |  |
8720 | 0 |
       final private boolean jj_3_10() {
8721 | 0 |
         if (jj_scan_token(COMMA)) return true;
8722 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8723 | 0 |
         if (jj_3R_61()) return true;
8724 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8725 | 0 |
         return false;
8726 |  |
       }
8727 |  |
8728 | 110 |
       final private boolean jj_3R_74() {
8729 | 110 |
         if (jj_scan_token(FINAL)) return true;
8730 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8731 | 0 |
         return false;
8732 |  |
       }
8733 |  |
8734 | 110 |
       final private boolean jj_3_30() {
8735 | 110 |
         Token xsp;
8736 | 110 |
         xsp = jj_scanpos;
8737 | 110 |
         if (jj_3R_74()) jj_scanpos = xsp;
8738 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8739 | 52 |
         if (jj_3R_73()) return true;
8740 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8741 | 20 |
         if (jj_scan_token(IDENTIFIER)) return true;
8742 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8743 | 38 |
         return false;
8744 |  |
       }
8745 |  |
8746 | 0 |
       final private boolean jj_3R_341() {
8747 | 0 |
         if (jj_scan_token(PROTECTED)) return true;
8748 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8749 | 0 |
         return false;
8750 |  |
       }
8751 |  |
8752 | 0 |
       final private boolean jj_3R_407() {
8753 | 0 |
         if (jj_3R_190()) return true;
8754 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8755 | 0 |
         return false;
8756 |  |
       }
8757 |  |
8758 | 0 |
       final private boolean jj_3R_406() {
8759 | 0 |
         if (jj_3R_189()) return true;
8760 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8761 | 0 |
         return false;
8762 |  |
       }
8763 |  |
8764 | 0 |
       final private boolean jj_3R_340() {
8765 | 0 |
         if (jj_scan_token(PUBLIC)) return true;
8766 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8767 | 0 |
         return false;
8768 |  |
       }
8769 |  |
8770 | 0 |
       final private boolean jj_3R_301() {
8771 | 0 |
         Token xsp;
8772 | 0 |
         xsp = jj_scanpos;
8773 | 0 |
         if (jj_3R_340()) {
8774 | 0 |
         jj_scanpos = xsp;
8775 | 0 |
         if (jj_3R_341()) {
8776 | 0 |
         jj_scanpos = xsp;
8777 | 0 |
         if (jj_3R_342()) {
8778 | 0 |
         jj_scanpos = xsp;
8779 | 0 |
         if (jj_3R_343()) {
8780 | 0 |
         jj_scanpos = xsp;
8781 | 0 |
         if (jj_3R_344()) {
8782 | 0 |
         jj_scanpos = xsp;
8783 | 0 |
         if (jj_3R_345()) {
8784 | 0 |
         jj_scanpos = xsp;
8785 | 0 |
         if (jj_3R_346()) {
8786 | 0 |
         jj_scanpos = xsp;
8787 | 0 |
         if (jj_3R_347()) {
8788 | 0 |
         jj_scanpos = xsp;
8789 | 0 |
         if (jj_3R_348()) return true;
8790 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8791 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8792 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8793 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8794 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8795 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8796 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8797 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8798 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8799 | 0 |
         return false;
8800 |  |
       }
8801 |  |
8802 | 0 |
       final private boolean jj_3R_405() {
8803 | 0 |
         if (jj_3R_188()) return true;
8804 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8805 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8806 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8807 | 0 |
         return false;
8808 |  |
       }
8809 |  |
8810 | 0 |
       final private boolean jj_3R_395() {
8811 | 0 |
         Token xsp;
8812 | 0 |
         xsp = jj_scanpos;
8813 | 0 |
         if (jj_3R_405()) {
8814 | 0 |
         jj_scanpos = xsp;
8815 | 0 |
         if (jj_3R_406()) {
8816 | 0 |
         jj_scanpos = xsp;
8817 | 0 |
         if (jj_3R_407()) {
8818 | 0 |
         jj_scanpos = xsp;
8819 | 0 |
         if (jj_3R_408()) return true;
8820 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8821 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8822 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8823 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8824 | 0 |
         return false;
8825 |  |
       }
8826 |  |
8827 | 0 |
       final private boolean jj_3R_283() {
8828 | 0 |
         Token xsp;
8829 | 0 |
         while (true) {
8830 | 0 |
           xsp = jj_scanpos;
8831 | 0 |
           if (jj_3R_301()) { jj_scanpos = xsp; break; }
8832 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8833 |  |
         }
8834 | 0 |
         if (jj_3R_68()) return true;
8835 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8836 | 0 |
         if (jj_3R_302()) return true;
8837 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8838 | 0 |
         xsp = jj_scanpos;
8839 | 0 |
         if (jj_3R_303()) jj_scanpos = xsp;
8840 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8841 | 0 |
         xsp = jj_scanpos;
8842 | 0 |
         if (jj_3R_304()) {
8843 | 0 |
         jj_scanpos = xsp;
8844 | 0 |
         if (jj_3R_305()) return true;
8845 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8846 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8847 | 0 |
         return false;
8848 |  |
       }
8849 |  |
8850 | 0 |
       final private boolean jj_3R_263() {
8851 | 0 |
         if (jj_3R_61()) return true;
8852 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8853 | 0 |
         Token xsp;
8854 | 0 |
         while (true) {
8855 | 0 |
           xsp = jj_scanpos;
8856 | 0 |
           if (jj_3_10()) { jj_scanpos = xsp; break; }
8857 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8858 |  |
         }
8859 | 0 |
         return false;
8860 |  |
       }
8861 |  |
8862 | 0 |
       final private boolean jj_3R_179() {
8863 | 0 |
         if (jj_3R_191()) return true;
8864 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8865 | 0 |
         return false;
8866 |  |
       }
8867 |  |
8868 | 4 |
       final private boolean jj_3R_72() {
8869 | 4 |
         if (jj_scan_token(FINAL)) return true;
8870 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8871 | 0 |
         return false;
8872 |  |
       }
8873 |  |
8874 | 4 |
       final private boolean jj_3_29() {
8875 | 4 |
         Token xsp;
8876 | 4 |
         xsp = jj_scanpos;
8877 | 4 |
         if (jj_3R_72()) jj_scanpos = xsp;
8878 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8879 | 0 |
         if (jj_3R_73()) return true;
8880 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8881 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
8882 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8883 | 4 |
         return false;
8884 |  |
       }
8885 |  |
8886 | 0 |
       final private boolean jj_3R_411() {
8887 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
8888 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8889 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
8890 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8891 | 0 |
         return false;
8892 |  |
       }
8893 |  |
8894 | 0 |
       final private boolean jj_3R_150() {
8895 | 0 |
         if (jj_scan_token(LBRACE)) return true;
8896 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8897 | 0 |
         Token xsp;
8898 | 0 |
         xsp = jj_scanpos;
8899 | 0 |
         if (jj_3R_263()) jj_scanpos = xsp;
8900 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8901 | 0 |
         xsp = jj_scanpos;
8902 | 0 |
         if (jj_3R_264()) jj_scanpos = xsp;
8903 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8904 | 0 |
         if (jj_scan_token(RBRACE)) return true;
8905 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8906 | 0 |
         return false;
8907 |  |
       }
8908 |  |
8909 | 0 |
       final private boolean jj_3R_178() {
8910 | 0 |
         if (jj_3R_190()) return true;
8911 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8912 | 0 |
         return false;
8913 |  |
       }
8914 |  |
8915 | 0 |
       final private boolean jj_3R_177() {
8916 | 0 |
         if (jj_3R_189()) return true;
8917 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8918 | 0 |
         return false;
8919 |  |
       }
8920 |  |
8921 | 0 |
       final private boolean jj_3R_402() {
8922 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
8923 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8924 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
8925 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8926 | 0 |
         return false;
8927 |  |
       }
8928 |  |
8929 | 0 |
       final private boolean jj_3R_115() {
8930 | 0 |
         if (jj_3R_70()) return true;
8931 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8932 | 0 |
         return false;
8933 |  |
       }
8934 |  |
8935 | 0 |
       final private boolean jj_3R_362() {
8936 | 0 |
         if (jj_scan_token(ASSIGN)) return true;
8937 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8938 | 0 |
         if (jj_3R_61()) return true;
8939 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8940 | 0 |
         return false;
8941 |  |
       }
8942 |  |
8943 | 0 |
       final private boolean jj_3R_114() {
8944 | 0 |
         if (jj_3R_150()) return true;
8945 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8946 | 0 |
         return false;
8947 |  |
       }
8948 |  |
8949 | 0 |
       final private boolean jj_3R_61() {
8950 | 0 |
         Token xsp;
8951 | 0 |
         xsp = jj_scanpos;
8952 | 0 |
         if (jj_3R_114()) {
8953 | 0 |
         jj_scanpos = xsp;
8954 | 0 |
         if (jj_3R_115()) return true;
8955 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8956 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8957 | 0 |
         return false;
8958 |  |
       }
8959 |  |
8960 | 0 |
       final private boolean jj_3R_169() {
8961 | 0 |
         Token xsp;
8962 | 0 |
         xsp = jj_scanpos;
8963 | 0 |
         if (jj_3R_176()) {
8964 | 0 |
         jj_scanpos = xsp;
8965 | 0 |
         if (jj_3R_177()) {
8966 | 0 |
         jj_scanpos = xsp;
8967 | 0 |
         if (jj_3R_178()) {
8968 | 0 |
         jj_scanpos = xsp;
8969 | 0 |
         if (jj_3R_179()) return true;
8970 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8971 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8972 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8973 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8974 | 0 |
         return false;
8975 |  |
       }
8976 |  |
8977 | 0 |
       final private boolean jj_3R_176() {
8978 | 0 |
         if (jj_3R_188()) return true;
8979 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8980 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8981 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8982 | 0 |
         return false;
8983 |  |
       }
8984 |  |
8985 | 0 |
       final private boolean jj_3R_409() {
8986 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
8987 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8988 | 0 |
         Token xsp;
8989 | 0 |
         while (true) {
8990 | 0 |
           xsp = jj_scanpos;
8991 | 0 |
           if (jj_3R_411()) { jj_scanpos = xsp; break; }
8992 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
8993 |  |
         }
8994 | 0 |
         return false;
8995 |  |
       }
8996 |  |
8997 | 0 |
       final private boolean jj_3R_376() {
8998 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
8999 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9000 | 0 |
         return false;
9001 |  |
       }
9002 |  |
9003 | 0 |
       final private boolean jj_3R_410() {
9004 | 0 |
         if (jj_scan_token(ASSIGN)) return true;
9005 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9006 | 0 |
         if (jj_3R_61()) return true;
9007 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9008 | 0 |
         return false;
9009 |  |
       }
9010 |  |
9011 | 0 |
       final private boolean jj_3R_377() {
9012 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
9013 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9014 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
9015 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9016 | 0 |
         return false;
9017 |  |
       }
9018 |  |
9019 | 0 |
       final private boolean jj_3R_375() {
9020 | 0 |
         if (jj_3R_395()) return true;
9021 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9022 | 0 |
         return false;
9023 |  |
       }
9024 |  |
9025 | 0 |
       final private boolean jj_3R_393() {
9026 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
9027 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9028 | 0 |
         Token xsp;
9029 | 0 |
         while (true) {
9030 | 0 |
           xsp = jj_scanpos;
9031 | 0 |
           if (jj_3R_402()) { jj_scanpos = xsp; break; }
9032 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9033 |  |
         }
9034 | 0 |
         return false;
9035 |  |
       }
9036 |  |
9037 | 0 |
       final private boolean jj_3R_350() {
9038 | 0 |
         if (jj_scan_token(LBRACE)) return true;
9039 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9040 | 0 |
         Token xsp;
9041 | 0 |
         while (true) {
9042 | 0 |
           xsp = jj_scanpos;
9043 | 0 |
           if (jj_3R_375()) { jj_scanpos = xsp; break; }
9044 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9045 |  |
         }
9046 | 0 |
         if (jj_scan_token(RBRACE)) return true;
9047 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9048 | 0 |
         xsp = jj_scanpos;
9049 | 0 |
         if (jj_3R_376()) jj_scanpos = xsp;
9050 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9051 | 0 |
         return false;
9052 |  |
       }
9053 |  |
9054 | 0 |
       final private boolean jj_3R_140() {
9055 | 0 |
         if (jj_3R_169()) return true;
9056 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9057 | 0 |
         return false;
9058 |  |
       }
9059 |  |
9060 | 168 |
       final private boolean jj_3R_81() {
9061 | 164 |
         if (jj_scan_token(LBRACE)) return true;
9062 | 4 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9063 | 0 |
         Token xsp;
9064 | 0 |
         while (true) {
9065 | 0 |
           xsp = jj_scanpos;
9066 | 0 |
           if (jj_3R_140()) { jj_scanpos = xsp; break; }
9067 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9068 |  |
         }
9069 | 0 |
         if (jj_scan_token(RBRACE)) return true;
9070 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9071 | 0 |
         return false;
9072 |  |
       }
9073 |  |
9074 | 0 |
       final private boolean jj_3R_361() {
9075 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
9076 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9077 | 0 |
         Token xsp;
9078 | 0 |
         while (true) {
9079 | 0 |
           xsp = jj_scanpos;
9080 | 0 |
           if (jj_3R_377()) { jj_scanpos = xsp; break; }
9081 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9082 |  |
         }
9083 | 0 |
         return false;
9084 |  |
       }
9085 |  |
9086 | 64 |
       final private boolean jj_3R_71() {
9087 | 44 |
         if (jj_scan_token(IDENTIFIER)) return true;
9088 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9089 | 20 |
         if (jj_scan_token(COLON)) return true;
9090 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9091 | 0 |
         if (jj_3R_189()) return true;
9092 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9093 | 0 |
         return false;
9094 |  |
       }
9095 |  |
9096 | 0 |
       final private boolean jj_3R_212() {
9097 | 0 |
         if (jj_3R_242()) return true;
9098 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9099 | 0 |
         return false;
9100 |  |
       }
9101 |  |
9102 | 0 |
       final private boolean jj_3R_403() {
9103 | 0 |
         if (jj_3R_409()) return true;
9104 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9105 | 0 |
         Token xsp;
9106 | 0 |
         xsp = jj_scanpos;
9107 | 0 |
         if (jj_3R_410()) jj_scanpos = xsp;
9108 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9109 | 0 |
         return false;
9110 |  |
       }
9111 |  |
9112 | 0 |
       final private boolean jj_3R_113() {
9113 | 0 |
         if (jj_scan_token(STRICTFP)) return true;
9114 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9115 | 0 |
         return false;
9116 |  |
       }
9117 |  |
9118 | 0 |
       final private boolean jj_3R_211() {
9119 | 0 |
         if (jj_3R_241()) return true;
9120 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9121 | 0 |
         return false;
9122 |  |
       }
9123 |  |
9124 | 0 |
       final private boolean jj_3_26() {
9125 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
9126 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9127 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
9128 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9129 | 0 |
         return false;
9130 |  |
       }
9131 |  |
9132 | 0 |
       final private boolean jj_3R_106() {
9133 | 0 |
         if (jj_scan_token(STRICTFP)) return true;
9134 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9135 | 0 |
         return false;
9136 |  |
       }
9137 |  |
9138 | 0 |
       final private boolean jj_3R_210() {
9139 | 0 |
         if (jj_3R_240()) return true;
9140 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9141 | 0 |
         return false;
9142 |  |
       }
9143 |  |
9144 | 0 |
       final private boolean jj_3R_209() {
9145 | 0 |
         if (jj_3R_239()) return true;
9146 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9147 | 0 |
         return false;
9148 |  |
       }
9149 |  |
9150 | 0 |
       final private boolean jj_3R_308() {
9151 | 0 |
         if (jj_3R_361()) return true;
9152 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9153 | 0 |
         Token xsp;
9154 | 0 |
         xsp = jj_scanpos;
9155 | 0 |
         if (jj_3R_362()) jj_scanpos = xsp;
9156 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9157 | 0 |
         return false;
9158 |  |
       }
9159 |  |
9160 | 0 |
       final private boolean jj_3R_208() {
9161 | 0 |
         if (jj_3R_238()) return true;
9162 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9163 | 0 |
         return false;
9164 |  |
       }
9165 |  |
9166 | 0 |
       final private boolean jj_3R_207() {
9167 | 0 |
         if (jj_3R_237()) return true;
9168 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9169 | 0 |
         return false;
9170 |  |
       }
9171 |  |
9172 | 0 |
       final private boolean jj_3R_206() {
9173 | 0 |
         if (jj_3R_236()) return true;
9174 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9175 | 0 |
         return false;
9176 |  |
       }
9177 |  |
9178 | 0 |
       final private boolean jj_3R_112() {
9179 | 0 |
         if (jj_scan_token(PRIVATE)) return true;
9180 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9181 | 0 |
         return false;
9182 |  |
       }
9183 |  |
9184 | 0 |
       final private boolean jj_3R_205() {
9185 | 0 |
         if (jj_3R_235()) return true;
9186 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9187 | 0 |
         return false;
9188 |  |
       }
9189 |  |
9190 | 0 |
       final private boolean jj_3R_105() {
9191 | 0 |
         if (jj_scan_token(PRIVATE)) return true;
9192 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9193 | 0 |
         return false;
9194 |  |
       }
9195 |  |
9196 | 0 |
       final private boolean jj_3R_204() {
9197 | 0 |
         if (jj_3R_234()) return true;
9198 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9199 | 0 |
         return false;
9200 |  |
       }
9201 |  |
9202 | 0 |
       final private boolean jj_3R_203() {
9203 | 0 |
         if (jj_3R_233()) return true;
9204 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9205 | 0 |
         return false;
9206 |  |
       }
9207 |  |
9208 | 0 |
       final private boolean jj_3R_202() {
9209 | 0 |
         if (jj_3R_232()) return true;
9210 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9211 | 0 |
         return false;
9212 |  |
       }
9213 |  |
9214 | 0 |
       final private boolean jj_3R_201() {
9215 | 0 |
         if (jj_3R_231()) return true;
9216 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9217 | 0 |
         return false;
9218 |  |
       }
9219 |  |
9220 | 0 |
       final private boolean jj_3R_200() {
9221 | 0 |
         if (jj_3R_230()) return true;
9222 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9223 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
9224 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9225 | 0 |
         return false;
9226 |  |
       }
9227 |  |
9228 | 0 |
       final private boolean jj_3R_309() {
9229 | 0 |
         if (jj_scan_token(COMMA)) return true;
9230 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9231 | 0 |
         if (jj_3R_308()) return true;
9232 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9233 | 0 |
         return false;
9234 |  |
       }
9235 |  |
9236 | 0 |
       final private boolean jj_3R_199() {
9237 | 0 |
         if (jj_3R_229()) return true;
9238 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9239 | 0 |
         return false;
9240 |  |
       }
9241 |  |
9242 | 0 |
       final private boolean jj_3R_111() {
9243 | 0 |
         if (jj_scan_token(PROTECTED)) return true;
9244 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9245 | 0 |
         return false;
9246 |  |
       }
9247 |  |
9248 | 0 |
       final private boolean jj_3R_198() {
9249 | 0 |
         if (jj_3R_81()) return true;
9250 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9251 | 0 |
         return false;
9252 |  |
       }
9253 |  |
9254 | 0 |
       final private boolean jj_3R_104() {
9255 | 0 |
         if (jj_scan_token(PROTECTED)) return true;
9256 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9257 | 0 |
         return false;
9258 |  |
       }
9259 |  |
9260 | 64 |
       final private boolean jj_3_28() {
9261 | 64 |
         if (jj_3R_71()) return true;
9262 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9263 | 0 |
         return false;
9264 |  |
       }
9265 |  |
9266 | 0 |
       final private boolean jj_3R_189() {
9267 | 0 |
         Token xsp;
9268 | 0 |
         xsp = jj_scanpos;
9269 | 0 |
         if (jj_3_28()) {
9270 | 0 |
         jj_scanpos = xsp;
9271 | 0 |
         if (jj_3R_198()) {
9272 | 0 |
         jj_scanpos = xsp;
9273 | 0 |
         if (jj_3R_199()) {
9274 | 0 |
         jj_scanpos = xsp;
9275 | 0 |
         if (jj_3R_200()) {
9276 | 0 |
         jj_scanpos = xsp;
9277 | 0 |
         if (jj_3R_201()) {
9278 | 0 |
         jj_scanpos = xsp;
9279 | 0 |
         if (jj_3R_202()) {
9280 | 0 |
         jj_scanpos = xsp;
9281 | 0 |
         if (jj_3R_203()) {
9282 | 0 |
         jj_scanpos = xsp;
9283 | 0 |
         if (jj_3R_204()) {
9284 | 0 |
         jj_scanpos = xsp;
9285 | 0 |
         if (jj_3R_205()) {
9286 | 0 |
         jj_scanpos = xsp;
9287 | 0 |
         if (jj_3R_206()) {
9288 | 0 |
         jj_scanpos = xsp;
9289 | 0 |
         if (jj_3R_207()) {
9290 | 0 |
         jj_scanpos = xsp;
9291 | 0 |
         if (jj_3R_208()) {
9292 | 0 |
         jj_scanpos = xsp;
9293 | 0 |
         if (jj_3R_209()) {
9294 | 0 |
         jj_scanpos = xsp;
9295 | 0 |
         if (jj_3R_210()) {
9296 | 0 |
         jj_scanpos = xsp;
9297 | 0 |
         if (jj_3R_211()) {
9298 | 0 |
         jj_scanpos = xsp;
9299 | 0 |
         if (jj_3R_212()) return true;
9300 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9301 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9302 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9303 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9304 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9305 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9306 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9307 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9308 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9309 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9310 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9311 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9312 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9313 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9314 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9315 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9316 | 0 |
         return false;
9317 |  |
       }
9318 |  |
9319 | 0 |
       final private boolean jj_3R_357() {
9320 | 0 |
         if (jj_scan_token(VOLATILE)) return true;
9321 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9322 | 0 |
         return false;
9323 |  |
       }
9324 |  |
9325 | 0 |
       final private boolean jj_3R_356() {
9326 | 0 |
         if (jj_scan_token(TRANSIENT)) return true;
9327 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9328 | 0 |
         return false;
9329 |  |
       }
9330 |  |
9331 | 0 |
       final private boolean jj_3R_110() {
9332 | 0 |
         if (jj_scan_token(PUBLIC)) return true;
9333 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9334 | 0 |
         return false;
9335 |  |
       }
9336 |  |
9337 | 0 |
       final private boolean jj_3R_259() {
9338 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
9339 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9340 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
9341 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9342 | 0 |
         return false;
9343 |  |
       }
9344 |  |
9345 | 0 |
       final private boolean jj_3R_355() {
9346 | 0 |
         if (jj_scan_token(FINAL)) return true;
9347 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9348 | 0 |
         return false;
9349 |  |
       }
9350 |  |
9351 | 0 |
       final private boolean jj_3R_103() {
9352 | 0 |
         if (jj_scan_token(PUBLIC)) return true;
9353 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9354 | 0 |
         return false;
9355 |  |
       }
9356 |  |
9357 | 0 |
       final private boolean jj_3_25() {
9358 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
9359 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9360 | 0 |
         if (jj_3R_70()) return true;
9361 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9362 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
9363 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9364 | 0 |
         return false;
9365 |  |
       }
9366 |  |
9367 | 0 |
       final private boolean jj_3R_255() {
9368 | 0 |
         Token xsp;
9369 | 0 |
         if (jj_3R_259()) return true;
9370 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9371 | 0 |
         while (true) {
9372 | 0 |
           xsp = jj_scanpos;
9373 | 0 |
           if (jj_3R_259()) { jj_scanpos = xsp; break; }
9374 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9375 |  |
         }
9376 | 0 |
         if (jj_3R_150()) return true;
9377 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9378 | 0 |
         return false;
9379 |  |
       }
9380 |  |
9381 | 0 |
       final private boolean jj_3R_354() {
9382 | 0 |
         if (jj_scan_token(STATIC)) return true;
9383 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9384 | 0 |
         return false;
9385 |  |
       }
9386 |  |
9387 | 0 |
       final private boolean jj_3_27() {
9388 | 0 |
         Token xsp;
9389 | 0 |
         if (jj_3_25()) return true;
9390 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9391 | 0 |
         while (true) {
9392 | 0 |
           xsp = jj_scanpos;
9393 | 0 |
           if (jj_3_25()) { jj_scanpos = xsp; break; }
9394 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9395 |  |
         }
9396 | 0 |
         while (true) {
9397 | 0 |
           xsp = jj_scanpos;
9398 | 0 |
           if (jj_3_26()) { jj_scanpos = xsp; break; }
9399 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9400 |  |
         }
9401 | 0 |
         return false;
9402 |  |
       }
9403 |  |
9404 | 0 |
       final private boolean jj_3R_248() {
9405 | 0 |
         Token xsp;
9406 | 0 |
         xsp = jj_scanpos;
9407 | 0 |
         if (jj_3_27()) {
9408 | 0 |
         jj_scanpos = xsp;
9409 | 0 |
         if (jj_3R_255()) return true;
9410 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9411 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9412 | 0 |
         return false;
9413 |  |
       }
9414 |  |
9415 | 0 |
       final private boolean jj_3R_109() {
9416 | 0 |
         if (jj_scan_token(FINAL)) return true;
9417 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9418 | 0 |
         return false;
9419 |  |
       }
9420 |  |
9421 | 0 |
       final private boolean jj_3R_353() {
9422 | 0 |
         if (jj_scan_token(PRIVATE)) return true;
9423 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9424 | 0 |
         return false;
9425 |  |
       }
9426 |  |
9427 | 0 |
       final private boolean jj_3R_102() {
9428 | 0 |
         if (jj_scan_token(FINAL)) return true;
9429 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9430 | 0 |
         return false;
9431 |  |
       }
9432 |  |
9433 | 0 |
       final private boolean jj_3R_352() {
9434 | 0 |
         if (jj_scan_token(PROTECTED)) return true;
9435 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9436 | 0 |
         return false;
9437 |  |
       }
9438 |  |
9439 | 0 |
       final private boolean jj_3R_351() {
9440 | 0 |
         if (jj_scan_token(PUBLIC)) return true;
9441 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9442 | 0 |
         return false;
9443 |  |
       }
9444 |  |
9445 | 0 |
       final private boolean jj_3R_306() {
9446 | 0 |
         Token xsp;
9447 | 0 |
         xsp = jj_scanpos;
9448 | 0 |
         if (jj_3R_351()) {
9449 | 0 |
         jj_scanpos = xsp;
9450 | 0 |
         if (jj_3R_352()) {
9451 | 0 |
         jj_scanpos = xsp;
9452 | 0 |
         if (jj_3R_353()) {
9453 | 0 |
         jj_scanpos = xsp;
9454 | 0 |
         if (jj_3R_354()) {
9455 | 0 |
         jj_scanpos = xsp;
9456 | 0 |
         if (jj_3R_355()) {
9457 | 0 |
         jj_scanpos = xsp;
9458 | 0 |
         if (jj_3R_356()) {
9459 | 0 |
         jj_scanpos = xsp;
9460 | 0 |
         if (jj_3R_357()) return true;
9461 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9462 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9463 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9464 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9465 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9466 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9467 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9468 | 0 |
         return false;
9469 |  |
       }
9470 |  |
9471 | 0 |
       final private boolean jj_3R_284() {
9472 | 0 |
         Token xsp;
9473 | 0 |
         while (true) {
9474 | 0 |
           xsp = jj_scanpos;
9475 | 0 |
           if (jj_3R_306()) { jj_scanpos = xsp; break; }
9476 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9477 |  |
         }
9478 | 0 |
         if (jj_3R_307()) return true;
9479 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9480 | 0 |
         if (jj_3R_308()) return true;
9481 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9482 | 0 |
         while (true) {
9483 | 0 |
           xsp = jj_scanpos;
9484 | 0 |
           if (jj_3R_309()) { jj_scanpos = xsp; break; }
9485 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9486 |  |
         }
9487 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
9488 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9489 | 0 |
         return false;
9490 |  |
       }
9491 |  |
9492 | 0 |
       final private boolean jj_3R_108() {
9493 | 0 |
         if (jj_scan_token(ABSTRACT)) return true;
9494 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9495 | 0 |
         return false;
9496 |  |
       }
9497 |  |
9498 | 0 |
       final private boolean jj_3R_101() {
9499 | 0 |
         if (jj_scan_token(ABSTRACT)) return true;
9500 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9501 | 0 |
         return false;
9502 |  |
       }
9503 |  |
9504 | 0 |
       final private boolean jj_3R_256() {
9505 | 0 |
         if (jj_3R_260()) return true;
9506 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9507 | 0 |
         return false;
9508 |  |
       }
9509 |  |
9510 | 0 |
       final private boolean jj_3R_250() {
9511 | 0 |
         if (jj_3R_64()) return true;
9512 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9513 | 0 |
         Token xsp;
9514 | 0 |
         xsp = jj_scanpos;
9515 | 0 |
         if (jj_3R_256()) jj_scanpos = xsp;
9516 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9517 | 0 |
         return false;
9518 |  |
       }
9519 |  |
9520 | 0 |
       final private boolean jj_3R_249() {
9521 | 0 |
         if (jj_3R_248()) return true;
9522 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9523 | 0 |
         return false;
9524 |  |
       }
9525 |  |
9526 | 0 |
       final private boolean jj_3_9() {
9527 | 0 |
         if (jj_3R_58()) return true;
9528 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9529 | 0 |
         return false;
9530 |  |
       }
9531 |  |
9532 | 0 |
       final private boolean jj_3R_107() {
9533 | 0 |
         if (jj_scan_token(STATIC)) return true;
9534 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9535 | 0 |
         return false;
9536 |  |
       }
9537 |  |
9538 | 0 |
       final private boolean jj_3R_60() {
9539 | 0 |
         Token xsp;
9540 | 0 |
         xsp = jj_scanpos;
9541 | 0 |
         if (jj_3R_107()) {
9542 | 0 |
         jj_scanpos = xsp;
9543 | 0 |
         if (jj_3R_108()) {
9544 | 0 |
         jj_scanpos = xsp;
9545 | 0 |
         if (jj_3R_109()) {
9546 | 0 |
         jj_scanpos = xsp;
9547 | 0 |
         if (jj_3R_110()) {
9548 | 0 |
         jj_scanpos = xsp;
9549 | 0 |
         if (jj_3R_111()) {
9550 | 0 |
         jj_scanpos = xsp;
9551 | 0 |
         if (jj_3R_112()) {
9552 | 0 |
         jj_scanpos = xsp;
9553 | 0 |
         if (jj_3R_113()) return true;
9554 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9555 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9556 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9557 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9558 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9559 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9560 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9561 | 0 |
         return false;
9562 |  |
       }
9563 |  |
9564 | 0 |
       final private boolean jj_3_8() {
9565 | 0 |
         Token xsp;
9566 | 0 |
         while (true) {
9567 | 0 |
           xsp = jj_scanpos;
9568 | 0 |
           if (jj_3R_60()) { jj_scanpos = xsp; break; }
9569 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9570 |  |
         }
9571 | 0 |
         if (jj_scan_token(INTERFACE)) return true;
9572 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9573 | 0 |
         return false;
9574 |  |
       }
9575 |  |
9576 | 0 |
       final private boolean jj_3R_171() {
9577 | 0 |
         if (jj_scan_token(COMMA)) return true;
9578 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9579 | 0 |
         if (jj_3R_70()) return true;
9580 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9581 | 0 |
         return false;
9582 |  |
       }
9583 |  |
9584 | 0 |
       final private boolean jj_3R_100() {
9585 | 0 |
         if (jj_scan_token(STATIC)) return true;
9586 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9587 | 0 |
         return false;
9588 |  |
       }
9589 |  |
9590 | 0 |
       final private boolean jj_3R_59() {
9591 | 0 |
         Token xsp;
9592 | 0 |
         xsp = jj_scanpos;
9593 | 0 |
         if (jj_3R_100()) {
9594 | 0 |
         jj_scanpos = xsp;
9595 | 0 |
         if (jj_3R_101()) {
9596 | 0 |
         jj_scanpos = xsp;
9597 | 0 |
         if (jj_3R_102()) {
9598 | 0 |
         jj_scanpos = xsp;
9599 | 0 |
         if (jj_3R_103()) {
9600 | 0 |
         jj_scanpos = xsp;
9601 | 0 |
         if (jj_3R_104()) {
9602 | 0 |
         jj_scanpos = xsp;
9603 | 0 |
         if (jj_3R_105()) {
9604 | 0 |
         jj_scanpos = xsp;
9605 | 0 |
         if (jj_3R_106()) return true;
9606 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9607 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9608 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9609 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9610 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9611 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9612 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9613 | 0 |
         return false;
9614 |  |
       }
9615 |  |
9616 | 44 |
       final private boolean jj_3R_135() {
9617 | 44 |
         if (jj_scan_token(NEW)) return true;
9618 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9619 | 0 |
         if (jj_3R_57()) return true;
9620 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9621 | 0 |
         Token xsp;
9622 | 0 |
         xsp = jj_scanpos;
9623 | 0 |
         if (jj_3R_249()) {
9624 | 0 |
         jj_scanpos = xsp;
9625 | 0 |
         if (jj_3R_250()) return true;
9626 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9627 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9628 | 0 |
         return false;
9629 |  |
       }
9630 |  |
9631 | 0 |
       final private boolean jj_3_7() {
9632 | 0 |
         Token xsp;
9633 | 0 |
         while (true) {
9634 | 0 |
           xsp = jj_scanpos;
9635 | 0 |
           if (jj_3R_59()) { jj_scanpos = xsp; break; }
9636 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9637 |  |
         }
9638 | 0 |
         if (jj_scan_token(CLASS)) return true;
9639 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9640 | 0 |
         return false;
9641 |  |
       }
9642 |  |
9643 | 64 |
       final private boolean jj_3_24() {
9644 | 44 |
         if (jj_scan_token(NEW)) return true;
9645 | 8 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9646 | 12 |
         if (jj_3R_66()) return true;
9647 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9648 | 0 |
         if (jj_3R_248()) return true;
9649 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9650 | 0 |
         return false;
9651 |  |
       }
9652 |  |
9653 | 52 |
       final private boolean jj_3R_69() {
9654 | 52 |
         Token xsp;
9655 | 52 |
         xsp = jj_scanpos;
9656 | 52 |
         if (jj_3_24()) {
9657 | 44 |
         jj_scanpos = xsp;
9658 | 44 |
         if (jj_3R_135()) return true;
9659 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9660 | 8 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9661 | 0 |
         return false;
9662 |  |
       }
9663 |  |
9664 | 0 |
       final private boolean jj_3R_390() {
9665 | 0 |
         if (jj_3R_284()) return true;
9666 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9667 | 0 |
         return false;
9668 |  |
       }
9669 |  |
9670 | 0 |
       final private boolean jj_3R_389() {
9671 | 0 |
         if (jj_3R_283()) return true;
9672 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9673 | 0 |
         return false;
9674 |  |
       }
9675 |  |
9676 | 0 |
       final private boolean jj_3R_388() {
9677 | 0 |
         if (jj_3R_281()) return true;
9678 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9679 | 0 |
         return false;
9680 |  |
       }
9681 |  |
9682 | 0 |
       final private boolean jj_3R_387() {
9683 | 0 |
         if (jj_3R_280()) return true;
9684 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9685 | 0 |
         return false;
9686 |  |
       }
9687 |  |
9688 | 0 |
       final private boolean jj_3R_370() {
9689 | 0 |
         Token xsp;
9690 | 0 |
         xsp = jj_scanpos;
9691 | 0 |
         if (jj_3R_387()) {
9692 | 0 |
         jj_scanpos = xsp;
9693 | 0 |
         if (jj_3R_388()) {
9694 | 0 |
         jj_scanpos = xsp;
9695 | 0 |
         if (jj_3R_389()) {
9696 | 0 |
         jj_scanpos = xsp;
9697 | 0 |
         if (jj_3R_390()) return true;
9698 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9699 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9700 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9701 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9702 | 0 |
         return false;
9703 |  |
       }
9704 |  |
9705 | 24 |
       final private boolean jj_3R_158() {
9706 | 12 |
         if (jj_3R_70()) return true;
9707 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9708 | 0 |
         Token xsp;
9709 | 0 |
         while (true) {
9710 | 0 |
           xsp = jj_scanpos;
9711 | 0 |
           if (jj_3R_171()) { jj_scanpos = xsp; break; }
9712 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9713 |  |
         }
9714 | 0 |
         return false;
9715 |  |
       }
9716 |  |
9717 | 24 |
       final private boolean jj_3R_119() {
9718 | 12 |
         if (jj_3R_158()) return true;
9719 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9720 | 0 |
         return false;
9721 |  |
       }
9722 |  |
9723 | 214 |
       final private boolean jj_3R_64() {
9724 | 190 |
         if (jj_scan_token(LPAREN)) return true;
9725 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9726 | 24 |
         Token xsp;
9727 | 24 |
         xsp = jj_scanpos;
9728 | 12 |
         if (jj_3R_119()) jj_scanpos = xsp;
9729 | 12 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9730 | 0 |
         if (jj_scan_token(RPAREN)) return true;
9731 | 12 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9732 | 0 |
         return false;
9733 |  |
       }
9734 |  |
9735 | 0 |
       final private boolean jj_3R_334() {
9736 | 0 |
         if (jj_3R_370()) return true;
9737 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9738 | 0 |
         return false;
9739 |  |
       }
9740 |  |
9741 | 48 |
       final private boolean jj_3R_193() {
9742 | 48 |
         if (jj_scan_token(NULL)) return true;
9743 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9744 | 0 |
         return false;
9745 |  |
       }
9746 |  |
9747 | 0 |
       final private boolean jj_3R_333() {
9748 | 0 |
         if (jj_scan_token(EXTENDS)) return true;
9749 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9750 | 0 |
         if (jj_3R_369()) return true;
9751 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9752 | 0 |
         return false;
9753 |  |
       }
9754 |  |
9755 | 124 |
       final private boolean jj_3R_149() {
9756 | 124 |
         if (jj_scan_token(STRICTFP)) return true;
9757 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9758 | 0 |
         return false;
9759 |  |
       }
9760 |  |
9761 | 48 |
       final private boolean jj_3R_214() {
9762 | 48 |
         if (jj_scan_token(FALSE)) return true;
9763 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9764 | 0 |
         return false;
9765 |  |
       }
9766 |  |
9767 | 48 |
       final private boolean jj_3R_192() {
9768 | 48 |
         Token xsp;
9769 | 48 |
         xsp = jj_scanpos;
9770 | 48 |
         if (jj_3R_213()) {
9771 | 48 |
         jj_scanpos = xsp;
9772 | 48 |
         if (jj_3R_214()) return true;
9773 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9774 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9775 | 0 |
         return false;
9776 |  |
       }
9777 |  |
9778 | 48 |
       final private boolean jj_3R_213() {
9779 | 48 |
         if (jj_scan_token(TRUE)) return true;
9780 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9781 | 0 |
         return false;
9782 |  |
       }
9783 |  |
9784 | 16 |
       final private boolean jj_3R_166() {
9785 | 12 |
         if (jj_3R_170()) return true;
9786 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9787 | 4 |
         return false;
9788 |  |
       }
9789 |  |
9790 | 48 |
       final private boolean jj_3R_185() {
9791 | 48 |
         if (jj_3R_193()) return true;
9792 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9793 | 0 |
         return false;
9794 |  |
       }
9795 |  |
9796 | 48 |
       final private boolean jj_3R_184() {
9797 | 48 |
         if (jj_3R_192()) return true;
9798 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9799 | 0 |
         return false;
9800 |  |
       }
9801 |  |
9802 | 60 |
       final private boolean jj_3R_183() {
9803 | 48 |
         if (jj_scan_token(STRING_LITERAL)) return true;
9804 | 8 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9805 | 4 |
         return false;
9806 |  |
       }
9807 |  |
9808 | 124 |
       final private boolean jj_3R_148() {
9809 | 124 |
         if (jj_scan_token(SYNCHRONIZED)) return true;
9810 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9811 | 0 |
         return false;
9812 |  |
       }
9813 |  |
9814 | 60 |
       final private boolean jj_3R_182() {
9815 | 60 |
         if (jj_scan_token(CHARACTER_LITERAL)) return true;
9816 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9817 | 0 |
         return false;
9818 |  |
       }
9819 |  |
9820 | 16 |
       final private boolean jj_3R_165() {
9821 | 16 |
         if (jj_scan_token(NEW)) return true;
9822 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9823 | 0 |
         return false;
9824 |  |
       }
9825 |  |
9826 | 60 |
       final private boolean jj_3R_181() {
9827 | 60 |
         if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
9828 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9829 | 0 |
         return false;
9830 |  |
       }
9831 |  |
9832 | 0 |
       final private boolean jj_3R_191() {
9833 | 0 |
         if (jj_scan_token(INTERFACE)) return true;
9834 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9835 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
9836 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9837 | 0 |
         Token xsp;
9838 | 0 |
         xsp = jj_scanpos;
9839 | 0 |
         if (jj_3R_333()) jj_scanpos = xsp;
9840 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9841 | 0 |
         if (jj_scan_token(LBRACE)) return true;
9842 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9843 | 0 |
         while (true) {
9844 | 0 |
           xsp = jj_scanpos;
9845 | 0 |
           if (jj_3R_334()) { jj_scanpos = xsp; break; }
9846 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9847 |  |
         }
9848 | 0 |
         if (jj_scan_token(RBRACE)) return true;
9849 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
9850 | 0 |
         return false;
9851 |  |
       }
9852 |  |
9853 |  |
       public NodeParserTokenManager token_source;
9854 |  |
       JavaCharStream jj_input_stream;
9855 |  |
       public Token token, jj_nt;
9856 |  |
       private Token jj_scanpos, jj_lastpos;
9857 |  |
       private int jj_la;
9858 |  |
       public boolean lookingAhead = false;
9859 |  |
       private boolean jj_semLA;
9860 |  |
       private int jj_gen;
9861 |  |
       final private int[] jj_la1 = new int[129];
9862 |  |
       final private int[] jj_la1_0 = {0x0,0x0,0x20102000,0x0,0x2000,0x20002000,0x20002000,0x8000000,0x0,0xa2196000,0x20002000,0x20002000,0xa2094000,0x20002000,0x20002000,0x2000,0x2000,0x20002000,0x20002000,0x8000000,0xa2196000,0xa2094000,0x20000000,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x92094000,0x92094000,0x0,0x20002000,0x20002000,0x0,0x0,0x0,0x0,0xa2094000,0x20000000,0x0,0x0,0x0,0xb359c000,0x92094000,0x0,0x82094000,0x0,0x82094000,0x0,0x82094000,0x0,0x82094000,0x0,0x82094000,0x82094000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x92094000,0x0,0x0,0x92094000,0x10000000,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x10000000,0x10000000,0x92094000,0x0,0x0,0x0,0x0,0x0,0x0,0x9349c000,0xb359c000,0xb359c000,0x0,0x9359c000,0x9359c000,0x20000000,0x0,0x0,0x0,0x92094000,0x820000,0xb359c000,0x820000,0x4000000,0xb2094000,0x92094000,0x92094000,0x92094000,0x0,0x0,0x0,0x92094000,0x40000,0x40000000,0x0,};
9863 |  |
       final private int[] jj_la1_1 = {0x1000,0x10,0x80008080,0x0,0x80008080,0x80008000,0x80008000,0x0,0x8,0xb226e3c0,0x8004e000,0x8004e000,0x2206e140,0x8024e200,0x8024e200,0x80008000,0x80008000,0x8004e000,0x8004e000,0x0,0xb226e3c0,0x2206e140,0x2204e000,0x2204e000,0x0,0x0,0x0,0x0,0x0,0x0,0x144a0d40,0x144a0d40,0x0,0x8024e200,0x8024e200,0x1000000,0x0,0x0,0x0,0x20140,0x0,0xe000,0xe000,0x1000000,0x5cfb0dc5,0x144a0d40,0x40000,0x20140,0x0,0x20140,0x0,0x20140,0x0,0x20140,0x0,0x20140,0x10020140,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x144a0d40,0x0,0x0,0x144a0d40,0x4480c00,0x0,0x0,0x0,0x0,0x4480c00,0x0,0x0,0x4000800,0x4000000,0x144a0d40,0x0,0x0,0x0,0x400,0x0,0x0,0x5cfb0d45,0x5cfb0dc5,0x5cfb0dc5,0x0,0x5cfb0dc5,0x5cfb0dc5,0x0,0x0,0x0,0x0,0x144a0d40,0x0,0x5cfb0dc5,0x0,0x0,0x144a0d40,0x144a0d40,0x144a0d40,0x144a0d40,0x0,0x0,0x0,0x144a0d40,0x0,0x0,0x0,};
9864 |  |
       final private int[] jj_la1_2 = {0x0,0x0,0x40000,0x100000,0x40000,0x0,0x0,0x0,0x0,0x4200,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x200,0x0,0x0,0x80000,0x200000,0x200000,0x10000,0x10000,0x10000,0x30053a2,0x30053a2,0x80000,0x0,0x0,0x0,0x44000,0x10000,0x80000,0x200,0x0,0x0,0x0,0x0,0x453a3,0x13a2,0x0,0x200,0x10000,0x200,0x10000,0x200,0x10000,0x200,0x10000,0x0,0x200,0x100000,0x100000,0x80000,0x80000,0x80000,0x200000,0x200000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x90000000,0x90000000,0x0,0x60c00000,0x60c00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30013a2,0x3000000,0x3000000,0x13a2,0x30013a2,0x1000,0x0,0x0,0x1000,0x11a2,0x200,0x111000,0x1a2,0x0,0x30013a2,0x80000,0x4000,0x11000,0x0,0x10000,0x10000,0x453a3,0x453a3,0x453a3,0x40000,0x453a3,0x453a3,0x0,0x80000,0x200000,0x200000,0x13a2,0x0,0x453a3,0x0,0x0,0x13a2,0x30013a2,0x13a2,0x13a2,0x80000,0x200,0x200,0x30013a2,0x0,0x0,0x8000000,};
9865 |  |
       final private int[] jj_la1_3 = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3ff8000,0x3ff8000,0x0,0x1,0x2,0x200,0x400,0x100,0x0,0x0,0x0,0x0,0x0,0x7000,0x7000,0x30,0x30,0x8c0,0x8c0,0x30,0x3c,0x0,0x0,0x0,0x0,0x0,0xc,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0xc,0xc,0xc,0x0,0xc,0xc,0x0,0x0,0x3ff800c,0x3ff800c,0xc,0x0,0xc,0x0,0x0,0xc,0x3c,0xc,0xc,0x0,0x0,0x0,0x3c,0x0,0x0,0x0,};
9866 |  |
       final private JJCalls[] jj_2_rtns = new JJCalls[31];
9867 |  |
       private boolean jj_rescan = false;
9868 |  |
       private int jj_gc = 0;
9869 |  |
9870 | 12 |
       public NodeParser(java.io.InputStream stream) {
9871 | 12 |
         jj_input_stream = new JavaCharStream(stream, 1, 1);
9872 | 12 |
         token_source = new NodeParserTokenManager(jj_input_stream);
9873 | 12 |
         token = new Token();
9874 | 12 |
         token.next = jj_nt = token_source.getNextToken();
9875 | 12 |
         jj_gen = 0;
9876 | 1548 |
         for (int i = 0; i < 129; i++) jj_la1[i] = -1;
9877 | 372 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9878 |  |
       }
9879 |  |
9880 | 0 |
       public void ReInit(java.io.InputStream stream) {
9881 | 0 |
         jj_input_stream.ReInit(stream, 1, 1);
9882 | 0 |
         token_source.ReInit(jj_input_stream);
9883 | 0 |
         token = new Token();
9884 | 0 |
         token.next = jj_nt = token_source.getNextToken();
9885 | 0 |
         jjtree.reset();
9886 | 0 |
         jj_gen = 0;
9887 | 0 |
         for (int i = 0; i < 129; i++) jj_la1[i] = -1;
9888 | 0 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9889 |  |
       }
9890 |  |
9891 | 0 |
       public NodeParser(java.io.Reader stream) {
9892 | 0 |
         jj_input_stream = new JavaCharStream(stream, 1, 1);
9893 | 0 |
         token_source = new NodeParserTokenManager(jj_input_stream);
9894 | 0 |
         token = new Token();
9895 | 0 |
         token.next = jj_nt = token_source.getNextToken();
9896 | 0 |
         jj_gen = 0;
9897 | 0 |
         for (int i = 0; i < 129; i++) jj_la1[i] = -1;
9898 | 0 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9899 |  |
       }
9900 |  |
9901 | 12 |
       public void ReInit(java.io.Reader stream) {
9902 | 12 |
         jj_input_stream.ReInit(stream, 1, 1);
9903 | 12 |
         token_source.ReInit(jj_input_stream);
9904 | 12 |
         token = new Token();
9905 | 12 |
         token.next = jj_nt = token_source.getNextToken();
9906 | 12 |
         jjtree.reset();
9907 | 12 |
         jj_gen = 0;
9908 | 1548 |
         for (int i = 0; i < 129; i++) jj_la1[i] = -1;
9909 | 372 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9910 |  |
       }
9911 |  |
9912 | 0 |
       public NodeParser(NodeParserTokenManager tm) {
9913 | 0 |
         token_source = tm;
9914 | 0 |
         token = new Token();
9915 | 0 |
         token.next = jj_nt = token_source.getNextToken();
9916 | 0 |
         jj_gen = 0;
9917 | 0 |
         for (int i = 0; i < 129; i++) jj_la1[i] = -1;
9918 | 0 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9919 |  |
       }
9920 |  |
9921 | 0 |
       public void ReInit(NodeParserTokenManager tm) {
9922 | 0 |
         token_source = tm;
9923 | 0 |
         token = new Token();
9924 | 0 |
         token.next = jj_nt = token_source.getNextToken();
9925 | 0 |
         jjtree.reset();
9926 | 0 |
         jj_gen = 0;
9927 | 0 |
         for (int i = 0; i < 129; i++) jj_la1[i] = -1;
9928 | 0 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9929 |  |
       }
9930 |  |
9931 | 2530 |
       final private Token jj_consume_token(int kind) throws ParseException {
9932 | 2530 |
         Token oldToken = token;
9933 | ? |
         if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
9934 | 1696 |
         else jj_nt = jj_nt.next = token_source.getNextToken();
9935 | 2530 |
         if (token.kind == kind) {
9936 | 2530 |
           jj_gen++;
9937 | 2530 |
           if (++jj_gc > 100) {
9938 | 20 |
             jj_gc = 0;
9939 | 20 |
             for (int i = 0; i < jj_2_rtns.length; i++) {
9940 | 620 |
               JJCalls c = jj_2_rtns[i];
9941 | 620 |
               while (c != null) {
9942 | 556 |
                 if (c.gen < jj_gen) c.first = null;
9943 | 624 |
                 c = c.next;
9944 |  |
               }
9945 |  |
             }
9946 |  |
           }
9947 | 2530 |
           return token;
9948 |  |
         }
9949 | 0 |
         jj_nt = token;
9950 | 0 |
         token = oldToken;
9951 | 0 |
         jj_kind = kind;
9952 | 0 |
         throw generateParseException();
9953 |  |
       }
9954 |  |
9955 | 14422 |
       final private boolean jj_scan_token(int kind) {
9956 | 14422 |
         if (jj_scanpos == jj_lastpos) {
9957 | 3436 |
           jj_la--;
9958 | 3436 |
           if (jj_scanpos.next == null) {
9959 | 834 |
             jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
9960 |  |
           } else {
9961 | 2602 |
             jj_lastpos = jj_scanpos = jj_scanpos.next;
9962 |  |
           }
9963 |  |
         } else {
9964 | 10986 |
           jj_scanpos = jj_scanpos.next;
9965 |  |
         }
9966 | 14422 |
         if (jj_rescan) {
9967 | 0 |
           int i = 0; Token tok = token;
9968 | 0 |
           while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
9969 | 0 |
           if (tok != null) jj_add_error_token(kind, i);
9970 |  |
         }
9971 | 14422 |
         return (jj_scanpos.kind != kind);
9972 |  |
       }
9973 |  |
9974 | 0 |
       final public Token getNextToken() {
9975 | 0 |
         if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
9976 | 0 |
         else jj_nt = jj_nt.next = token_source.getNextToken();
9977 | 0 |
         jj_gen++;
9978 | 0 |
         return token;
9979 |  |
       }
9980 |  |
9981 | 10000 |
       final public Token getToken(int index) {
9982 | 10000 |
         Token t = lookingAhead ? jj_scanpos : token;
9983 | 10000 |
         for (int i = 0; i < index; i++) {
9984 | 5000 |
           if (t.next != null) t = t.next;
9985 | 0 |
           else t = t.next = token_source.getNextToken();
9986 |  |
         }
9987 | 10000 |
         return t;
9988 |  |
       }
9989 |  |
9990 |  |
       private java.util.Vector jj_expentries = new java.util.Vector();
9991 |  |
       private int[] jj_expentry;
9992 |  |
       private int jj_kind = -1;
9993 |  |
       private int[] jj_lasttokens = new int[100];
9994 |  |
       private int jj_endpos;
9995 |  |
9996 | 0 |
       private void jj_add_error_token(int kind, int pos) {
9997 | 0 |
         if (pos >= 100) return;
9998 | 0 |
         if (pos == jj_endpos + 1) {
9999 | 0 |
           jj_lasttokens[jj_endpos++] = kind;
10000 | 0 |
         } else if (jj_endpos != 0) {
10001 | 0 |
           jj_expentry = new int[jj_endpos];
10002 | 0 |
           for (int i = 0; i < jj_endpos; i++) {
10003 | 0 |
             jj_expentry[i] = jj_lasttokens[i];
10004 |  |
           }
10005 | 0 |
           boolean exists = false;
10006 | 0 |
           for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
10007 | 0 |
             int[] oldentry = (int[])(enum.nextElement());
10008 | 0 |
             if (oldentry.length == jj_expentry.length) {
10009 | 0 |
               exists = true;
10010 | 0 |
               for (int i = 0; i < jj_expentry.length; i++) {
10011 | 0 |
                 if (oldentry[i] != jj_expentry[i]) {
10012 | 0 |
                   exists = false;
10013 | 0 |
                   break;
10014 |  |
                 }
10015 |  |
               }
10016 | 0 |
               if (exists) break;
10017 |  |
             }
10018 |  |
           }
10019 | 0 |
           if (!exists) jj_expentries.addElement(jj_expentry);
10020 | 0 |
           if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
10021 |  |
         }
10022 |  |
       }
10023 |  |
10024 | 0 |
       final public ParseException generateParseException() {
10025 | 0 |
         jj_expentries.removeAllElements();
10026 | 0 |
         boolean[] la1tokens = new boolean[122];
10027 | 0 |
         for (int i = 0; i < 122; i++) {
10028 | 0 |
           la1tokens[i] = false;
10029 |  |
         }
10030 | 0 |
         if (jj_kind >= 0) {
10031 | 0 |
           la1tokens[jj_kind] = true;
10032 | 0 |
           jj_kind = -1;
10033 |  |
         }
10034 | 0 |
         for (int i = 0; i < 129; i++) {
10035 | 0 |
           if (jj_la1[i] == jj_gen) {
10036 | 0 |
             for (int j = 0; j < 32; j++) {
10037 | 0 |
               if ((jj_la1_0[i] & (1<<j)) != 0) {
10038 | 0 |
                 la1tokens[j] = true;
10039 |  |
               }
10040 | 0 |
               if ((jj_la1_1[i] & (1<<j)) != 0) {
10041 | 0 |
                 la1tokens[32+j] = true;
10042 |  |
               }
10043 | 0 |
               if ((jj_la1_2[i] & (1<<j)) != 0) {
10044 | 0 |
                 la1tokens[64+j] = true;
10045 |  |
               }
10046 | 0 |
               if ((jj_la1_3[i] & (1<<j)) != 0) {
10047 | 0 |
                 la1tokens[96+j] = true;
10048 |  |
               }
10049 |  |
             }
10050 |  |
           }
10051 |  |
         }
10052 | 0 |
         for (int i = 0; i < 122; i++) {
10053 | 0 |
           if (la1tokens[i]) {
10054 | 0 |
             jj_expentry = new int[1];
10055 | 0 |
             jj_expentry[0] = i;
10056 | 0 |
             jj_expentries.addElement(jj_expentry);
10057 |  |
           }
10058 |  |
         }
10059 | 0 |
         jj_endpos = 0;
10060 | 0 |
         jj_rescan_token();
10061 | 0 |
         jj_add_error_token(0, 0);
10062 | 0 |
         int[][] exptokseq = new int[jj_expentries.size()][];
10063 | 0 |
         for (int i = 0; i < jj_expentries.size(); i++) {
10064 | 0 |
           exptokseq[i] = (int[])jj_expentries.elementAt(i);
10065 |  |
         }
10066 | 0 |
         return new ParseException(token, exptokseq, tokenImage);
10067 |  |
       }
10068 |  |
10069 | 0 |
       final public void enable_tracing() {
10070 |  |
       }
10071 |  |
10072 | 0 |
       final public void disable_tracing() {
10073 |  |
       }
10074 |  |
10075 | 0 |
       final private void jj_rescan_token() {
10076 | 0 |
         jj_rescan = true;
10077 | 0 |
         for (int i = 0; i < 31; i++) {
10078 | 0 |
           JJCalls p = jj_2_rtns[i];
10079 | 0 |
           do {
10080 | 0 |
             if (p.gen > jj_gen) {
10081 | 0 |
               jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
10082 | 0 |
               switch (i) {
10083 | 0 |
                 case 0: jj_3_1(); break;
10084 | 0 |
                 case 1: jj_3_2(); break;
10085 | 0 |
                 case 2: jj_3_3(); break;
10086 | 0 |
                 case 3: jj_3_4(); break;
10087 | 0 |
                 case 4: jj_3_5(); break;
10088 | 0 |
                 case 5: jj_3_6(); break;
10089 | 0 |
                 case 6: jj_3_7(); break;
10090 | 0 |
                 case 7: jj_3_8(); break;
10091 | 0 |
                 case 8: jj_3_9(); break;
10092 | 0 |
                 case 9: jj_3_10(); break;
10093 | 0 |
                 case 10: jj_3_11(); break;
10094 | 0 |
                 case 11: jj_3_12(); break;
10095 | 0 |
                 case 12: jj_3_13(); break;
10096 | 0 |
                 case 13: jj_3_14(); break;
10097 | 0 |
                 case 14: jj_3_15(); break;
10098 | 0 |
                 case 15: jj_3_16(); break;
10099 | 0 |
                 case 16: jj_3_17(); break;
10100 | 0 |
                 case 17: jj_3_18(); break;
10101 | 0 |
                 case 18: jj_3_19(); break;
10102 | 0 |
                 case 19: jj_3_20(); break;
10103 | 0 |
                 case 20: jj_3_21(); break;
10104 | 0 |
                 case 21: jj_3_22(); break;
10105 | 0 |
                 case 22: jj_3_23(); break;
10106 | 0 |
                 case 23: jj_3_24(); break;
10107 | 0 |
                 case 24: jj_3_25(); break;
10108 | 0 |
                 case 25: jj_3_26(); break;
10109 | 0 |
                 case 26: jj_3_27(); break;
10110 | 0 |
                 case 27: jj_3_28(); break;
10111 | 0 |
                 case 28: jj_3_29(); break;
10112 | 0 |
                 case 29: jj_3_30(); break;
10113 | 0 |
                 case 30: jj_3_31(); break;
10114 |  |
               }
10115 |  |
             }
10116 | 0 |
             p = p.next;
10117 | 0 |
           } while (p != null);
10118 |  |
         }
10119 | 0 |
         jj_rescan = false;
10120 |  |
       }
10121 |  |
10122 | 1938 |
       final private void jj_save(int index, int xla) {
10123 | 1938 |
         JJCalls p = jj_2_rtns[index];
10124 | 1938 |
         while (p.gen > jj_gen) {
10125 | 4 |
           if (p.next == null) { p = p.next = new JJCalls(); break; }
10126 | 24 |
           p = p.next;
10127 |  |
         }
10128 | 1938 |
         p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
10129 |  |
       }
10130 |  |
10131 |  |
       static final class JJCalls {
10132 |  |
         int gen;
10133 |  |
         Token first;
10134 |  |
         int arg;
10135 |  |
         JJCalls next;
10136 |  |
       }
10137 |  |
10138 |  |
     }
10139 |  |