Clover coverage report - XJavaDoc - 1.1 Coverage timestamp: Sun Oct 3 2004 19:56:54 BST FRAMES NO FRAMES |
file stats: | LOC: | 7,948 |  | Methods: | 570
| NCLOC: | 7,245 |  | 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
SimpleParser.java | 29.2% | 44.3% | 64.7% | 40.1% |

1 |  |
     /* Generated By:JavaCC: Do not edit this line. SimpleParser.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 SimpleParser implements JavaParser, SimpleParserConstants {
10 |  |
        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 | 21398 |
        private static final void setToken(AbstractProgramElement element, Token token) {
24 | 21398 |
            element.setToken( token );
25 |  |
            //element.setDoc(getJavaDocSpecialToken( token ));
26 |  |
        }
27 |  |
28 | 55348 |
        private final void clearNameBuffer() {
29 | 55348 |
           if( _nameBuffer.length() > 0 ) {
30 | 54004 |
              _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 | 940 |
        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 | 940 |
            SourceClass clazz = null;
54 | 940 |
            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 | 712 |
               if( !_hasParsedMain ) {
58 |  |
                  // the usual case
59 | 672 |
                  clazz = _sourceClass;
60 |  |
               } else {
61 |  |
                  // the source contains more than one classes
62 | 40 |
                  clazz = new SourceClass(_sourceClass, 0, _tagFactory);
63 |  |
               }
64 |  |
            } else {
65 | 228 |
               clazz = new SourceClass(currentClass(), _tagFactory);
66 |  |
            }
67 | 940 |
            _sourceClassStack.push(clazz);
68 | 940 |
            return clazz;
69 |  |
        }
70 |  |
71 |  |
        /**
72 |  |
         * Should be called after UnmodifiedClassDeclaration or UnmodifiedInterfaceDeclaration
73 |  |
         */
74 | 940 |
        private void popAndAddInner() {
75 | 940 |
         SourceClass clazz = (SourceClass) _sourceClassStack.pop();
76 | 940 |
         if( clazz.getContainingClass() != null ) {
77 |  |
             // Add the class as an inner class
78 | 228 |
             currentClass().addInnerClass(clazz);
79 | 228 |
             _xJavaDoc.addSourceClass(clazz);
80 |  |
         }
81 |  |
        }
82 |  |
83 | 20336 |
        private SourceClass currentClass() {
84 | 20336 |
            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 | 672 |
         public SimpleParser( XJavaDoc xJavaDoc, XTagFactory tagFactory )
95 |  |
         {
96 | 672 |
             this(new ByteArrayInputStream("\n".getBytes()));
97 | 672 |
             _xJavaDoc = xJavaDoc;
98 | 672 |
             _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 | 672 |
         public void populate(SourceClass sourceClass)
111 |  |
             throws ParseException
112 |  |
         {
113 | 672 |
             _sourceClass = sourceClass;
114 |  |
115 |  |
             // Reset state
116 | 672 |
             _sourceClassStack.clear();
117 | 672 |
             _packageName = "";
118 | 672 |
             _parameter = new Parameter();
119 | 672 |
             _nameToken = null;
120 | 672 |
             clearNameBuffer();
121 |  |
122 | 672 |
             try
123 |  |
             {
124 |  |
125 |  |
                 // now reinit the Parser with this CharStream
126 |  |
                 //
127 | 672 |
                 ReInit(sourceClass.getReader());
128 |  |
129 |  |
                 // Start the parsing.
130 | 672 |
                 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 | 672 |
       final public void CompilationUnit(SourceClass sourceClass) throws ParseException {
151 | 672 |
         switch (jj_nt.kind) {
152 |  |
         case PACKAGE:
153 | 616 |
           PackageDeclaration();
154 | 616 |
           break;
155 |  |
         default:
156 | 56 |
           jj_la1[0] = jj_gen;
157 |  |
           ;
158 |  |
         }
159 | 672 |
         label_1:
160 |  |
         while (true) {
161 | 2466 |
           switch (jj_nt.kind) {
162 |  |
           case IMPORT:
163 |  |
             ;
164 | 1794 |
             break;
165 |  |
           default:
166 | 672 |
             jj_la1[1] = jj_gen;
167 | 672 |
             break label_1;
168 |  |
           }
169 | 1794 |
           ImportDeclaration();
170 |  |
         }
171 | 672 |
         label_2:
172 |  |
         while (true) {
173 | 1384 |
           switch (jj_nt.kind) {
174 |  |
           case ABSTRACT:
175 |  |
           case CLASS:
176 |  |
           case FINAL:
177 |  |
           case INTERFACE:
178 |  |
           case PUBLIC:
179 |  |
           case STRICTFP:
180 |  |
           case SEMICOLON:
181 |  |
             ;
182 | 712 |
             break;
183 |  |
           default:
184 | 672 |
             jj_la1[2] = jj_gen;
185 | 672 |
             break label_2;
186 |  |
           }
187 | 712 |
           TypeDeclaration();
188 |  |
         }
189 | 672 |
         jj_consume_token(0);
190 |  |
           // sourceClass must know about the CompilationUnit node
191 |  |
           // if it wants to mutate or print the code
192 |  |
           // In SimpleParser we can't use nodes
193 |  |
194 | 672 |
         if( _sourceClassStack.size() != 0 ) {
195 | 0 |
            {if (true) throw new IllegalStateException("There should be no more classes on the stack:" + _sourceClassStack.size());}
196 |  |
         }
197 |  |
       }
198 |  |
199 | 616 |
       final public void PackageDeclaration() throws ParseException {
200 | 616 |
         jj_consume_token(PACKAGE);
201 | 616 |
         _packageName = Name();
202 | 616 |
         jj_consume_token(SEMICOLON);
203 | 616 |
          _sourceClass.setContainingPackage( _packageName );
204 |  |
       }
205 |  |
206 | 1794 |
       final public void ImportDeclaration() throws ParseException {
207 | 1794 |
        String importedElement;
208 | 1794 |
        boolean isPackage = false;
209 | 1794 |
         jj_consume_token(IMPORT);
210 | 1794 |
         importedElement = Name();
211 | 1794 |
         switch (jj_nt.kind) {
212 |  |
         case DOT:
213 | 248 |
           jj_consume_token(DOT);
214 | 248 |
           jj_consume_token(STAR);
215 | 248 |
          isPackage = true;
216 | 248 |
           break;
217 |  |
         default:
218 | 1546 |
           jj_la1[3] = jj_gen;
219 |  |
           ;
220 |  |
         }
221 | 1794 |
         jj_consume_token(SEMICOLON);
222 | 1794 |
          if( isPackage ) {
223 | 248 |
             _sourceClass.addImportedPackage(importedElement);
224 |  |
          } else {
225 | 1546 |
             _sourceClass.addImportedClass(importedElement);
226 |  |
          }
227 |  |
       }
228 |  |
229 | 712 |
       final public void TypeDeclaration() throws ParseException {
230 | 712 |
         if (jj_2_1(2147483647)) {
231 | 342 |
           ClassDeclaration();
232 | 342 |
         _hasParsedMain = true;
233 |  |
         } else {
234 | 370 |
           switch (jj_nt.kind) {
235 |  |
           case ABSTRACT:
236 |  |
           case INTERFACE:
237 |  |
           case PUBLIC:
238 |  |
           case STRICTFP:
239 | 370 |
             InterfaceDeclaration();
240 | 370 |
         _hasParsedMain = true;
241 | 370 |
             break;
242 |  |
           case SEMICOLON:
243 | 0 |
             jj_consume_token(SEMICOLON);
244 | 0 |
             break;
245 |  |
           default:
246 | 0 |
             jj_la1[4] = jj_gen;
247 | 0 |
             jj_consume_token(-1);
248 | 0 |
             throw new ParseException();
249 |  |
           }
250 |  |
         }
251 |  |
       }
252 |  |
253 |  |
     /*
254 |  |
      * Declaration syntax follows.
255 |  |
      */
256 |  |
257 |  |
     /*
258 |  |
     Javadoc is stored in special tokens, and will either be
259 |  |
     attached to the first modifier token (if there are any modifiers)
260 |  |
     or to the first token in UnmodifiedClassDeclaration
261 |  |
     */
262 | 342 |
       final public void ClassDeclaration() throws ParseException {
263 | 342 |
        SourceClass sourceClass = pushAndGet();
264 | 342 |
        Token t = null;
265 | 342 |
         label_3:
266 |  |
         while (true) {
267 | 710 |
           switch (jj_nt.kind) {
268 |  |
           case ABSTRACT:
269 |  |
           case FINAL:
270 |  |
           case PUBLIC:
271 |  |
           case STRICTFP:
272 |  |
             ;
273 | 368 |
             break;
274 |  |
           default:
275 | 342 |
             jj_la1[5] = jj_gen;
276 | 342 |
             break label_3;
277 |  |
           }
278 | 368 |
           switch (jj_nt.kind) {
279 |  |
           case ABSTRACT:
280 | 76 |
             t = jj_consume_token(ABSTRACT);
281 | 76 |
            setToken(sourceClass, t);
282 | 76 |
            sourceClass.addModifier( Modifier.ABSTRACT );
283 | 76 |
             break;
284 |  |
           case FINAL:
285 | 78 |
             t = jj_consume_token(FINAL);
286 | 78 |
            setToken(sourceClass, t);
287 | 78 |
            sourceClass.addModifier( Modifier.FINAL );
288 | 78 |
             break;
289 |  |
           case PUBLIC:
290 | 214 |
             t = jj_consume_token(PUBLIC);
291 | 214 |
            setToken(sourceClass, t);
292 | 214 |
            sourceClass.addModifier( Modifier.PUBLIC );
293 | 214 |
             break;
294 |  |
           case STRICTFP:
295 | 0 |
             t = jj_consume_token(STRICTFP);
296 | 0 |
            setToken(sourceClass, t);
297 | 0 |
            sourceClass.addModifier( Modifier.STRICT );
298 | 0 |
             break;
299 |  |
           default:
300 | 0 |
             jj_la1[6] = jj_gen;
301 | 0 |
             jj_consume_token(-1);
302 | 0 |
             throw new ParseException();
303 |  |
           }
304 |  |
         }
305 | 342 |
         UnmodifiedClassDeclaration();
306 | 342 |
          popAndAddInner();
307 |  |
       }
308 |  |
309 | 502 |
       final public void UnmodifiedClassDeclaration() throws ParseException {
310 |  |
        // Get a ref to the containing class
311 | 502 |
        SourceClass sourceClass = currentClass();
312 |  |
313 | 502 |
        Token ct;
314 | 502 |
        Token name = null;
315 | 502 |
        String superclass = null;
316 | 502 |
         ct = jj_consume_token(CLASS);
317 | 502 |
             if(sourceClass!=null) {
318 | 502 |
                 setToken( sourceClass, ct );
319 | 502 |
                 sourceClass.setInterface( false );
320 |  |
             }
321 | 502 |
         name = jj_consume_token(IDENTIFIER);
322 | 502 |
         if(sourceClass.isInner()) {
323 | 160 |
             sourceClass.setName(name.image);
324 | 160 |
             _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
325 | 160 |
             _xJavaDoc.addSourceClass( sourceClass );
326 |  |
         } else {
327 | 342 |
             sourceClass.setQualifiedName(Util.getQualifiedNameFor(_packageName,name.image));
328 | 342 |
             _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
329 | 342 |
             _xJavaDoc.addSourceClass( sourceClass );
330 | 342 |
             sourceClass.resolveImportedClasses();
331 |  |
332 |  |
             // we're adding to xjavadoc in case we're an "extra" class (XJD-8).
333 | 342 |
             _xJavaDoc.addSourceClass(sourceClass);
334 |  |
         }
335 | 502 |
         switch (jj_nt.kind) {
336 |  |
         case EXTENDS:
337 | 234 |
           jj_consume_token(EXTENDS);
338 | 234 |
           superclass = Name();
339 | 234 |
           break;
340 |  |
         default:
341 | 268 |
           jj_la1[7] = jj_gen;
342 |  |
           ;
343 |  |
         }
344 | 502 |
         switch (jj_nt.kind) {
345 |  |
         case IMPLEMENTS:
346 | 212 |
           jj_consume_token(IMPLEMENTS);
347 | 212 |
           Interfaces_NameList();
348 | 212 |
           break;
349 |  |
         default:
350 | 290 |
           jj_la1[8] = jj_gen;
351 |  |
           ;
352 |  |
         }
353 | 502 |
         ClassBody();
354 | 502 |
         if( superclass != null ) {
355 | 234 |
             sourceClass.setSuperclass(superclass);
356 |  |
         } else {
357 | 268 |
             sourceClass.setSuperclass("java.lang.Object");
358 |  |
         }
359 |  |
       }
360 |  |
361 | 542 |
       final public void ClassBody() throws ParseException {
362 | 542 |
         jj_consume_token(LBRACE);
363 | 542 |
         label_4:
364 |  |
         while (true) {
365 | 8106 |
           switch (jj_nt.kind) {
366 |  |
           case ABSTRACT:
367 |  |
           case BOOLEAN:
368 |  |
           case BYTE:
369 |  |
           case CHAR:
370 |  |
           case CLASS:
371 |  |
           case DOUBLE:
372 |  |
           case FINAL:
373 |  |
           case FLOAT:
374 |  |
           case INT:
375 |  |
           case INTERFACE:
376 |  |
           case LONG:
377 |  |
           case NATIVE:
378 |  |
           case PRIVATE:
379 |  |
           case PROTECTED:
380 |  |
           case PUBLIC:
381 |  |
           case SHORT:
382 |  |
           case STATIC:
383 |  |
           case SYNCHRONIZED:
384 |  |
           case TRANSIENT:
385 |  |
           case VOID:
386 |  |
           case VOLATILE:
387 |  |
           case STRICTFP:
388 |  |
           case IDENTIFIER:
389 |  |
           case LBRACE:
390 |  |
             ;
391 | 7564 |
             break;
392 |  |
           default:
393 | 542 |
             jj_la1[9] = jj_gen;
394 | 542 |
             break label_4;
395 |  |
           }
396 | 7564 |
           ClassBodyDeclaration();
397 |  |
         }
398 | 542 |
         jj_consume_token(RBRACE);
399 |  |
       }
400 |  |
401 | 128 |
       final public void NestedClassDeclaration() throws ParseException {
402 | 128 |
        SourceClass sourceClass = pushAndGet();
403 | 128 |
        Token t;
404 | 128 |
         label_5:
405 |  |
         while (true) {
406 | 284 |
           switch (jj_nt.kind) {
407 |  |
           case ABSTRACT:
408 |  |
           case FINAL:
409 |  |
           case PRIVATE:
410 |  |
           case PROTECTED:
411 |  |
           case PUBLIC:
412 |  |
           case STATIC:
413 |  |
           case STRICTFP:
414 |  |
             ;
415 | 156 |
             break;
416 |  |
           default:
417 | 128 |
             jj_la1[10] = jj_gen;
418 | 128 |
             break label_5;
419 |  |
           }
420 | 156 |
           switch (jj_nt.kind) {
421 |  |
           case STATIC:
422 | 44 |
             t = jj_consume_token(STATIC);
423 | 44 |
            sourceClass.addModifier( Modifier.STATIC );
424 | 44 |
            sourceClass.setToken( t );
425 | 44 |
             break;
426 |  |
           case ABSTRACT:
427 | 4 |
             t = jj_consume_token(ABSTRACT);
428 | 4 |
            sourceClass.addModifier( Modifier.ABSTRACT );
429 | 4 |
            sourceClass.setToken( t );
430 | 4 |
             break;
431 |  |
           case FINAL:
432 | 12 |
             t = jj_consume_token(FINAL);
433 | 12 |
            sourceClass.addModifier( Modifier.FINAL );
434 | 12 |
            sourceClass.setToken( t );
435 | 12 |
             break;
436 |  |
           case PUBLIC:
437 | 96 |
             t = jj_consume_token(PUBLIC);
438 | 96 |
            sourceClass.addModifier( Modifier.PUBLIC );
439 | 96 |
            sourceClass.setToken( t );
440 | 96 |
             break;
441 |  |
           case PROTECTED:
442 | 0 |
             t = jj_consume_token(PROTECTED);
443 | 0 |
            sourceClass.addModifier( Modifier.PROTECTED );
444 | 0 |
            sourceClass.setToken( t );
445 | 0 |
             break;
446 |  |
           case PRIVATE:
447 | 0 |
             t = jj_consume_token(PRIVATE);
448 | 0 |
            sourceClass.addModifier( Modifier.PRIVATE );
449 | 0 |
            sourceClass.setToken( t );
450 | 0 |
             break;
451 |  |
           case STRICTFP:
452 | 0 |
             t = jj_consume_token(STRICTFP);
453 | 0 |
            sourceClass.addModifier( Modifier.STRICT );
454 | 0 |
            sourceClass.setToken( t );
455 | 0 |
             break;
456 |  |
           default:
457 | 0 |
             jj_la1[11] = jj_gen;
458 | 0 |
             jj_consume_token(-1);
459 | 0 |
             throw new ParseException();
460 |  |
           }
461 |  |
         }
462 | 128 |
         UnmodifiedClassDeclaration();
463 | 128 |
         popAndAddInner();
464 |  |
       }
465 |  |
466 | 7564 |
       final public void ClassBodyDeclaration() throws ParseException {
467 | 7564 |
        SourceClass sourceClass = currentClass();
468 | 7564 |
         if (jj_2_2(2)) {
469 | 32 |
           Initializer();
470 | 7532 |
         } else if (jj_2_3(2147483647)) {
471 | 108 |
           NestedClassDeclaration();
472 | 7424 |
         } else if (jj_2_4(2147483647)) {
473 | 8 |
           NestedInterfaceDeclaration();
474 | 7416 |
         } else if (jj_2_5(2147483647)) {
475 | 466 |
           ConstructorDeclaration();
476 | 6950 |
         } else if (jj_2_6(2147483647)) {
477 | 4948 |
           MethodDeclaration();
478 |  |
         } else {
479 | 2002 |
           switch (jj_nt.kind) {
480 |  |
           case BOOLEAN:
481 |  |
           case BYTE:
482 |  |
           case CHAR:
483 |  |
           case DOUBLE:
484 |  |
           case FINAL:
485 |  |
           case FLOAT:
486 |  |
           case INT:
487 |  |
           case LONG:
488 |  |
           case PRIVATE:
489 |  |
           case PROTECTED:
490 |  |
           case PUBLIC:
491 |  |
           case SHORT:
492 |  |
           case STATIC:
493 |  |
           case TRANSIENT:
494 |  |
           case VOLATILE:
495 |  |
           case IDENTIFIER:
496 | 2002 |
             FieldDeclaration();
497 | 2002 |
             break;
498 |  |
           default:
499 | 0 |
             jj_la1[12] = jj_gen;
500 | 0 |
             jj_consume_token(-1);
501 | 0 |
             throw new ParseException();
502 |  |
           }
503 |  |
         }
504 |  |
       }
505 |  |
506 |  |
     // This production is to determine lookahead only.
507 | 0 |
       final public void MethodDeclarationLookahead() throws ParseException {
508 | 0 |
         label_6:
509 |  |
         while (true) {
510 | 0 |
           switch (jj_nt.kind) {
511 |  |
           case ABSTRACT:
512 |  |
           case FINAL:
513 |  |
           case NATIVE:
514 |  |
           case PRIVATE:
515 |  |
           case PROTECTED:
516 |  |
           case PUBLIC:
517 |  |
           case STATIC:
518 |  |
           case SYNCHRONIZED:
519 |  |
           case STRICTFP:
520 |  |
             ;
521 | 0 |
             break;
522 |  |
           default:
523 | 0 |
             jj_la1[13] = jj_gen;
524 | 0 |
             break label_6;
525 |  |
           }
526 | 0 |
           switch (jj_nt.kind) {
527 |  |
           case PUBLIC:
528 | 0 |
             jj_consume_token(PUBLIC);
529 | 0 |
             break;
530 |  |
           case PROTECTED:
531 | 0 |
             jj_consume_token(PROTECTED);
532 | 0 |
             break;
533 |  |
           case PRIVATE:
534 | 0 |
             jj_consume_token(PRIVATE);
535 | 0 |
             break;
536 |  |
           case STATIC:
537 | 0 |
             jj_consume_token(STATIC);
538 | 0 |
             break;
539 |  |
           case ABSTRACT:
540 | 0 |
             jj_consume_token(ABSTRACT);
541 | 0 |
             break;
542 |  |
           case FINAL:
543 | 0 |
             jj_consume_token(FINAL);
544 | 0 |
             break;
545 |  |
           case NATIVE:
546 | 0 |
             jj_consume_token(NATIVE);
547 | 0 |
             break;
548 |  |
           case SYNCHRONIZED:
549 | 0 |
             jj_consume_token(SYNCHRONIZED);
550 | 0 |
             break;
551 |  |
           case STRICTFP:
552 | 0 |
             jj_consume_token(STRICTFP);
553 | 0 |
             break;
554 |  |
           default:
555 | 0 |
             jj_la1[14] = jj_gen;
556 | 0 |
             jj_consume_token(-1);
557 | 0 |
             throw new ParseException();
558 |  |
           }
559 |  |
         }
560 | 0 |
         ResultType(null);
561 | 0 |
         jj_consume_token(IDENTIFIER);
562 | 0 |
         jj_consume_token(LPAREN);
563 |  |
       }
564 |  |
565 | 370 |
       final public void InterfaceDeclaration() throws ParseException {
566 | 370 |
        SourceClass sourceClass = pushAndGet();
567 | 370 |
        Token t = null;
568 | 370 |
         label_7:
569 |  |
         while (true) {
570 | 720 |
           switch (jj_nt.kind) {
571 |  |
           case ABSTRACT:
572 |  |
           case PUBLIC:
573 |  |
           case STRICTFP:
574 |  |
             ;
575 | 350 |
             break;
576 |  |
           default:
577 | 370 |
             jj_la1[15] = jj_gen;
578 | 370 |
             break label_7;
579 |  |
           }
580 | 350 |
           switch (jj_nt.kind) {
581 |  |
           case ABSTRACT:
582 | 0 |
             t = jj_consume_token(ABSTRACT);
583 | 0 |
            sourceClass.addModifier( Modifier.ABSTRACT );
584 | 0 |
            sourceClass.setToken( t );
585 | 0 |
             break;
586 |  |
           case PUBLIC:
587 | 350 |
             t = jj_consume_token(PUBLIC);
588 | 350 |
            sourceClass.addModifier( Modifier.PUBLIC );
589 | 350 |
            sourceClass.setToken( t );
590 | 350 |
             break;
591 |  |
           case STRICTFP:
592 | 0 |
             t = jj_consume_token(STRICTFP);
593 | 0 |
            sourceClass.addModifier( Modifier.STRICT );
594 | 0 |
            sourceClass.setToken( t );
595 | 0 |
             break;
596 |  |
           default:
597 | 0 |
             jj_la1[16] = jj_gen;
598 | 0 |
             jj_consume_token(-1);
599 | 0 |
             throw new ParseException();
600 |  |
           }
601 |  |
         }
602 | 370 |
         UnmodifiedInterfaceDeclaration();
603 | 370 |
          popAndAddInner();
604 |  |
       }
605 |  |
606 | 28 |
       final public void NestedInterfaceDeclaration() throws ParseException {
607 | 28 |
        SourceClass sourceClass = pushAndGet();
608 | 28 |
        Token t;
609 | 28 |
         label_8:
610 |  |
         while (true) {
611 | 48 |
           switch (jj_nt.kind) {
612 |  |
           case ABSTRACT:
613 |  |
           case FINAL:
614 |  |
           case PRIVATE:
615 |  |
           case PROTECTED:
616 |  |
           case PUBLIC:
617 |  |
           case STATIC:
618 |  |
           case STRICTFP:
619 |  |
             ;
620 | 20 |
             break;
621 |  |
           default:
622 | 28 |
             jj_la1[17] = jj_gen;
623 | 28 |
             break label_8;
624 |  |
           }
625 | 20 |
           switch (jj_nt.kind) {
626 |  |
           case STATIC:
627 | 0 |
             t = jj_consume_token(STATIC);
628 | 0 |
            sourceClass.addModifier( Modifier.STATIC );
629 | 0 |
            sourceClass.setToken( t );
630 | 0 |
             break;
631 |  |
           case ABSTRACT:
632 | 0 |
             t = jj_consume_token(ABSTRACT);
633 | 0 |
            sourceClass.addModifier( Modifier.ABSTRACT );
634 | 0 |
            sourceClass.setToken( t );
635 | 0 |
             break;
636 |  |
           case FINAL:
637 | 0 |
             t = jj_consume_token(FINAL);
638 | 0 |
            sourceClass.addModifier( Modifier.FINAL );
639 | 0 |
            sourceClass.setToken( t );
640 | 0 |
             break;
641 |  |
           case PUBLIC:
642 | 20 |
             t = jj_consume_token(PUBLIC);
643 | 20 |
            sourceClass.addModifier( Modifier.PUBLIC );
644 | 20 |
            sourceClass.setToken( t );
645 | 20 |
             break;
646 |  |
           case PROTECTED:
647 | 0 |
             t = jj_consume_token(PROTECTED);
648 | 0 |
            sourceClass.addModifier( Modifier.PROTECTED );
649 | 0 |
            sourceClass.setToken( t );
650 | 0 |
             break;
651 |  |
           case PRIVATE:
652 | 0 |
             t = jj_consume_token(PRIVATE);
653 | 0 |
            sourceClass.addModifier( Modifier.PRIVATE );
654 | 0 |
            sourceClass.setToken( t );
655 | 0 |
             break;
656 |  |
           case STRICTFP:
657 | 0 |
             t = jj_consume_token(STRICTFP);
658 | 0 |
            sourceClass.addModifier( Modifier.STRICT );
659 | 0 |
            sourceClass.setToken( t );
660 | 0 |
             break;
661 |  |
           default:
662 | 0 |
             jj_la1[18] = jj_gen;
663 | 0 |
             jj_consume_token(-1);
664 | 0 |
             throw new ParseException();
665 |  |
           }
666 |  |
         }
667 | 28 |
         UnmodifiedInterfaceDeclaration();
668 | 28 |
         popAndAddInner();
669 |  |
       }
670 |  |
671 | 398 |
       final public void UnmodifiedInterfaceDeclaration() throws ParseException {
672 | 398 |
        SourceClass sourceClass = currentClass();
673 | 398 |
        Token it;
674 | 398 |
        Token name = null;
675 | 398 |
         it = jj_consume_token(INTERFACE);
676 | 398 |
         name = jj_consume_token(IDENTIFIER);
677 |  |
           // interfaces are always abstract
678 | 398 |
           sourceClass.addModifier( Modifier.ABSTRACT );
679 |  |
680 | 398 |
           if(sourceClass.isInner()) {
681 | 28 |
             sourceClass.setName(name.image);
682 | 28 |
             _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
683 | 28 |
             _xJavaDoc.addSourceClass( sourceClass );
684 |  |
           } else {
685 | 370 |
             sourceClass.setQualifiedName(Util.getQualifiedNameFor(_packageName,name.image));
686 | 370 |
             _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
687 | 370 |
             _xJavaDoc.addSourceClass( sourceClass );
688 | 370 |
             sourceClass.resolveImportedClasses();
689 |  |
           }
690 |  |
691 | 398 |
           sourceClass.setInterface( true );
692 | 398 |
           setToken(sourceClass,it);
693 | 398 |
         switch (jj_nt.kind) {
694 |  |
         case EXTENDS:
695 | 244 |
           jj_consume_token(EXTENDS);
696 | 244 |
           Interfaces_NameList();
697 | 244 |
           break;
698 |  |
         default:
699 | 154 |
           jj_la1[19] = jj_gen;
700 |  |
           ;
701 |  |
         }
702 | 398 |
         jj_consume_token(LBRACE);
703 | 398 |
         label_9:
704 |  |
         while (true) {
705 | 3742 |
           switch (jj_nt.kind) {
706 |  |
           case ABSTRACT:
707 |  |
           case BOOLEAN:
708 |  |
           case BYTE:
709 |  |
           case CHAR:
710 |  |
           case CLASS:
711 |  |
           case DOUBLE:
712 |  |
           case FINAL:
713 |  |
           case FLOAT:
714 |  |
           case INT:
715 |  |
           case INTERFACE:
716 |  |
           case LONG:
717 |  |
           case NATIVE:
718 |  |
           case PRIVATE:
719 |  |
           case PROTECTED:
720 |  |
           case PUBLIC:
721 |  |
           case SHORT:
722 |  |
           case STATIC:
723 |  |
           case SYNCHRONIZED:
724 |  |
           case TRANSIENT:
725 |  |
           case VOID:
726 |  |
           case VOLATILE:
727 |  |
           case STRICTFP:
728 |  |
           case IDENTIFIER:
729 |  |
             ;
730 | 3344 |
             break;
731 |  |
           default:
732 | 398 |
             jj_la1[20] = jj_gen;
733 | 398 |
             break label_9;
734 |  |
           }
735 | 3344 |
           InterfaceMemberDeclaration();
736 |  |
         }
737 | 398 |
         jj_consume_token(RBRACE);
738 | 398 |
         if(sourceClass.isInner()) {
739 | 28 |
             sourceClass.setName(name.image);
740 |  |
         }
741 |  |
       }
742 |  |
743 | 3344 |
       final public void InterfaceMemberDeclaration() throws ParseException {
744 | 3344 |
         if (jj_2_7(2147483647)) {
745 | 20 |
           NestedClassDeclaration();
746 | 3324 |
         } else if (jj_2_8(2147483647)) {
747 | 20 |
           NestedInterfaceDeclaration();
748 | 3304 |
         } else if (jj_2_9(2147483647)) {
749 | 3252 |
           MethodDeclaration();
750 |  |
         } else {
751 | 52 |
           switch (jj_nt.kind) {
752 |  |
           case BOOLEAN:
753 |  |
           case BYTE:
754 |  |
           case CHAR:
755 |  |
           case DOUBLE:
756 |  |
           case FINAL:
757 |  |
           case FLOAT:
758 |  |
           case INT:
759 |  |
           case LONG:
760 |  |
           case PRIVATE:
761 |  |
           case PROTECTED:
762 |  |
           case PUBLIC:
763 |  |
           case SHORT:
764 |  |
           case STATIC:
765 |  |
           case TRANSIENT:
766 |  |
           case VOLATILE:
767 |  |
           case IDENTIFIER:
768 | 52 |
             FieldDeclaration();
769 | 52 |
             break;
770 |  |
           default:
771 | 0 |
             jj_la1[21] = jj_gen;
772 | 0 |
             jj_consume_token(-1);
773 | 0 |
             throw new ParseException();
774 |  |
           }
775 |  |
         }
776 |  |
       }
777 |  |
778 | 2054 |
       final public void FieldDeclaration() throws ParseException {
779 | 2054 |
        SourceClass sourceClass = currentClass();
780 |  |
781 |  |
        /* NOTE: We also support lame style like
782 |  |
783 |  |
        private static int a,b,c,d;
784 |  |
785 |  |
        They should share the same javadoc, type and modifiers
786 |  |
        */
787 |  |
788 | 2054 |
        Token t = null;
789 | 2054 |
        FieldImpl fieldImpl = null;
790 | 2054 |
        fieldImpl = new FieldImpl(sourceClass, _tagFactory);
791 | 2054 |
         label_10:
792 |  |
         while (true) {
793 | 4866 |
           switch (jj_nt.kind) {
794 |  |
           case FINAL:
795 |  |
           case PRIVATE:
796 |  |
           case PROTECTED:
797 |  |
           case PUBLIC:
798 |  |
           case STATIC:
799 |  |
           case TRANSIENT:
800 |  |
           case VOLATILE:
801 |  |
             ;
802 | 2812 |
             break;
803 |  |
           default:
804 | 2054 |
             jj_la1[22] = jj_gen;
805 | 2054 |
             break label_10;
806 |  |
           }
807 | 2812 |
           switch (jj_nt.kind) {
808 |  |
           case PUBLIC:
809 | 174 |
             t = jj_consume_token(PUBLIC);
810 | 174 |
            fieldImpl.addModifier( Modifier.PUBLIC );
811 | 174 |
            setToken(fieldImpl,t);
812 | 174 |
             break;
813 |  |
           case PROTECTED:
814 | 60 |
             t = jj_consume_token(PROTECTED);
815 | 60 |
            fieldImpl.addModifier( Modifier.PROTECTED );
816 | 60 |
            setToken(fieldImpl,t);
817 | 60 |
             break;
818 |  |
           case PRIVATE:
819 | 1788 |
             t = jj_consume_token(PRIVATE);
820 | 1788 |
            fieldImpl.addModifier( Modifier.PRIVATE );
821 | 1788 |
            setToken(fieldImpl,t);
822 | 1788 |
             break;
823 |  |
           case STATIC:
824 | 232 |
             t = jj_consume_token(STATIC);
825 | 232 |
            fieldImpl.addModifier( Modifier.STATIC );
826 | 232 |
            setToken(fieldImpl,t);
827 | 232 |
             break;
828 |  |
           case FINAL:
829 | 558 |
             t = jj_consume_token(FINAL);
830 | 558 |
            fieldImpl.addModifier( Modifier.FINAL );
831 | 558 |
            setToken(fieldImpl,t);
832 | 558 |
             break;
833 |  |
           case TRANSIENT:
834 | 0 |
             t = jj_consume_token(TRANSIENT);
835 | 0 |
            fieldImpl.addModifier( Modifier.TRANSIENT );
836 | 0 |
            setToken(fieldImpl,t);
837 | 0 |
             break;
838 |  |
           case VOLATILE:
839 | 0 |
             t = jj_consume_token(VOLATILE);
840 | 0 |
            fieldImpl.addModifier( Modifier.VOLATILE );
841 | 0 |
            setToken(fieldImpl,t);
842 | 0 |
             break;
843 |  |
           default:
844 | 0 |
             jj_la1[23] = jj_gen;
845 | 0 |
             jj_consume_token(-1);
846 | 0 |
             throw new ParseException();
847 |  |
           }
848 |  |
         }
849 | 2054 |
         Field_Type(fieldImpl);
850 | 2054 |
         FieldDeclarator(fieldImpl);
851 | 2054 |
         label_11:
852 |  |
         while (true) {
853 | 2058 |
           switch (jj_nt.kind) {
854 |  |
           case COMMA:
855 |  |
             ;
856 | 4 |
             break;
857 |  |
           default:
858 | 2054 |
             jj_la1[24] = jj_gen;
859 | 2054 |
             break label_11;
860 |  |
           }
861 | 4 |
           jj_consume_token(COMMA);
862 | 4 |
             FieldImpl badProgrammingStyleFieldImpl = new FieldImpl(sourceClass, _tagFactory);
863 | 4 |
             badProgrammingStyleFieldImpl.setType(fieldImpl.getTypeAsString());
864 | 4 |
           FieldDeclarator(badProgrammingStyleFieldImpl);
865 | 4 |
             sourceClass.addField(badProgrammingStyleFieldImpl);
866 |  |
         }
867 | 2054 |
         jj_consume_token(SEMICOLON);
868 |  |
         // we must add the field after parsing the field because the name must be set
869 | 2054 |
         sourceClass.addField(fieldImpl);
870 |  |
       }
871 |  |
872 | 2058 |
       final public void FieldDeclarator(FieldImpl fieldImpl) throws ParseException {
873 | 2058 |
         Field_VariableDeclaratorId(fieldImpl);
874 | 2058 |
         switch (jj_nt.kind) {
875 |  |
         case ASSIGN:
876 | 768 |
           jj_consume_token(ASSIGN);
877 | 768 |
           VariableInitializer();
878 | 768 |
           break;
879 |  |
         default:
880 | 1290 |
           jj_la1[25] = jj_gen;
881 |  |
           ;
882 |  |
         }
883 |  |
       }
884 |  |
885 | 4446 |
       final public void VariableDeclarator() throws ParseException {
886 | 4446 |
         VariableDeclaratorId();
887 | 4446 |
         switch (jj_nt.kind) {
888 |  |
         case ASSIGN:
889 | 4286 |
           jj_consume_token(ASSIGN);
890 | 4286 |
           VariableInitializer();
891 | 4286 |
           break;
892 |  |
         default:
893 | 160 |
           jj_la1[26] = jj_gen;
894 |  |
           ;
895 |  |
         }
896 |  |
       }
897 |  |
898 | 2058 |
       final public void Field_VariableDeclaratorId(FieldImpl fieldImpl) throws ParseException {
899 | 2058 |
        Token t = null;
900 | 2058 |
         t = jj_consume_token(IDENTIFIER);
901 | 2058 |
         label_12:
902 |  |
         while (true) {
903 | 2058 |
           switch (jj_nt.kind) {
904 |  |
           case LBRACKET:
905 |  |
             ;
906 | 0 |
             break;
907 |  |
           default:
908 | 2058 |
             jj_la1[27] = jj_gen;
909 | 2058 |
             break label_12;
910 |  |
           }
911 | 0 |
           jj_consume_token(LBRACKET);
912 | 0 |
           jj_consume_token(RBRACKET);
913 | 0 |
                                  fieldImpl.setDimension(fieldImpl.getDimension() + 1);
914 |  |
         }
915 | 2058 |
          fieldImpl.setName( t.image );
916 |  |
       }
917 |  |
918 | 5246 |
       final public void Parameter_VariableDeclaratorId() throws ParseException {
919 | 5246 |
        Token t = null;
920 | 5246 |
         t = jj_consume_token(IDENTIFIER);
921 | 5246 |
         label_13:
922 |  |
         while (true) {
923 | 5278 |
           switch (jj_nt.kind) {
924 |  |
           case LBRACKET:
925 |  |
             ;
926 | 32 |
             break;
927 |  |
           default:
928 | 5246 |
             jj_la1[28] = jj_gen;
929 | 5246 |
             break label_13;
930 |  |
           }
931 | 32 |
           jj_consume_token(LBRACKET);
932 | 32 |
           jj_consume_token(RBRACKET);
933 | 32 |
                                  _parameter.dimension++;
934 |  |
         }
935 | 5246 |
          _parameter.name = t.image;
936 |  |
       }
937 |  |
938 | 4446 |
       final public void VariableDeclaratorId() throws ParseException {
939 | 4446 |
         jj_consume_token(IDENTIFIER);
940 | 4446 |
         label_14:
941 |  |
         while (true) {
942 | 4450 |
           switch (jj_nt.kind) {
943 |  |
           case LBRACKET:
944 |  |
             ;
945 | 4 |
             break;
946 |  |
           default:
947 | 4446 |
             jj_la1[29] = jj_gen;
948 | 4446 |
             break label_14;
949 |  |
           }
950 | 4 |
           jj_consume_token(LBRACKET);
951 | 4 |
           jj_consume_token(RBRACKET);
952 |  |
         }
953 |  |
       }
954 |  |
955 | 5282 |
       final public void VariableInitializer() throws ParseException {
956 | 5282 |
         switch (jj_nt.kind) {
957 |  |
         case LBRACE:
958 | 0 |
           ArrayInitializer();
959 | 0 |
           break;
960 |  |
         case BOOLEAN:
961 |  |
         case BYTE:
962 |  |
         case CHAR:
963 |  |
         case DOUBLE:
964 |  |
         case FALSE:
965 |  |
         case FLOAT:
966 |  |
         case INT:
967 |  |
         case LONG:
968 |  |
         case NEW:
969 |  |
         case NULL:
970 |  |
         case SHORT:
971 |  |
         case SUPER:
972 |  |
         case THIS:
973 |  |
         case TRUE:
974 |  |
         case VOID:
975 |  |
         case INTEGER_LITERAL:
976 |  |
         case FLOATING_POINT_LITERAL:
977 |  |
         case CHARACTER_LITERAL:
978 |  |
         case STRING_LITERAL:
979 |  |
         case IDENTIFIER:
980 |  |
         case LPAREN:
981 |  |
         case BANG:
982 |  |
         case TILDE:
983 |  |
         case INCR:
984 |  |
         case DECR:
985 |  |
         case PLUS:
986 |  |
         case MINUS:
987 | 5282 |
           Expression();
988 | 5282 |
           break;
989 |  |
         default:
990 | 0 |
           jj_la1[30] = jj_gen;
991 | 0 |
           jj_consume_token(-1);
992 | 0 |
           throw new ParseException();
993 |  |
         }
994 |  |
       }
995 |  |
996 | 24 |
       final public void ArrayInitializer() throws ParseException {
997 | 24 |
         jj_consume_token(LBRACE);
998 | 24 |
         switch (jj_nt.kind) {
999 |  |
         case BOOLEAN:
1000 |  |
         case BYTE:
1001 |  |
         case CHAR:
1002 |  |
         case DOUBLE:
1003 |  |
         case FALSE:
1004 |  |
         case FLOAT:
1005 |  |
         case INT:
1006 |  |
         case LONG:
1007 |  |
         case NEW:
1008 |  |
         case NULL:
1009 |  |
         case SHORT:
1010 |  |
         case SUPER:
1011 |  |
         case THIS:
1012 |  |
         case TRUE:
1013 |  |
         case VOID:
1014 |  |
         case INTEGER_LITERAL:
1015 |  |
         case FLOATING_POINT_LITERAL:
1016 |  |
         case CHARACTER_LITERAL:
1017 |  |
         case STRING_LITERAL:
1018 |  |
         case IDENTIFIER:
1019 |  |
         case LPAREN:
1020 |  |
         case LBRACE:
1021 |  |
         case BANG:
1022 |  |
         case TILDE:
1023 |  |
         case INCR:
1024 |  |
         case DECR:
1025 |  |
         case PLUS:
1026 |  |
         case MINUS:
1027 | 24 |
           VariableInitializer();
1028 | 24 |
           label_15:
1029 |  |
           while (true) {
1030 | 228 |
             if (jj_2_10(2)) {
1031 |  |
               ;
1032 |  |
             } else {
1033 | 24 |
               break label_15;
1034 |  |
             }
1035 | 204 |
             jj_consume_token(COMMA);
1036 | 204 |
             VariableInitializer();
1037 |  |
           }
1038 | 24 |
           break;
1039 |  |
         default:
1040 | 0 |
           jj_la1[31] = jj_gen;
1041 |  |
           ;
1042 |  |
         }
1043 | 24 |
         switch (jj_nt.kind) {
1044 |  |
         case COMMA:
1045 | 0 |
           jj_consume_token(COMMA);
1046 | 0 |
           break;
1047 |  |
         default:
1048 | 24 |
           jj_la1[32] = jj_gen;
1049 |  |
           ;
1050 |  |
         }
1051 | 24 |
         jj_consume_token(RBRACE);
1052 |  |
       }
1053 |  |
1054 | 8200 |
       final public void MethodDeclaration() throws ParseException {
1055 | 8200 |
        SourceClass sourceClass = currentClass();
1056 |  |
1057 | 8200 |
        Token t = null;
1058 | 8200 |
        String exceptions = null;
1059 |  |
1060 |  |
        //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
1061 | 8200 |
        MethodImpl methodImpl = null;
1062 |  |
1063 | 8200 |
         if(sourceClass!=null) {
1064 | 8200 |
            methodImpl = new MethodImpl(sourceClass, _tagFactory);
1065 |  |
         }
1066 | 8200 |
         label_16:
1067 |  |
         while (true) {
1068 | 14842 |
           switch (jj_nt.kind) {
1069 |  |
           case ABSTRACT:
1070 |  |
           case FINAL:
1071 |  |
           case NATIVE:
1072 |  |
           case PRIVATE:
1073 |  |
           case PROTECTED:
1074 |  |
           case PUBLIC:
1075 |  |
           case STATIC:
1076 |  |
           case SYNCHRONIZED:
1077 |  |
           case STRICTFP:
1078 |  |
             ;
1079 | 6642 |
             break;
1080 |  |
           default:
1081 | 8200 |
             jj_la1[33] = jj_gen;
1082 | 8200 |
             break label_16;
1083 |  |
           }
1084 | 6642 |
           switch (jj_nt.kind) {
1085 |  |
           case PUBLIC:
1086 | 3948 |
             t = jj_consume_token(PUBLIC);
1087 | 3948 |
             if(methodImpl!=null) {
1088 | 3948 |
                 methodImpl.addModifier( Modifier.PUBLIC );
1089 | 3948 |
                 setToken( methodImpl, t );
1090 |  |
             }
1091 | 3948 |
             break;
1092 |  |
           case PROTECTED:
1093 | 174 |
             t = jj_consume_token(PROTECTED);
1094 | 174 |
             if(methodImpl!=null) {
1095 | 174 |
                 methodImpl.addModifier( Modifier.PROTECTED );
1096 | 174 |
                 setToken( methodImpl, t );
1097 |  |
             }
1098 | 174 |
             break;
1099 |  |
           case PRIVATE:
1100 | 682 |
             t = jj_consume_token(PRIVATE);
1101 | 682 |
             if(methodImpl!=null) {
1102 | 682 |
                 methodImpl.addModifier( Modifier.PRIVATE );
1103 | 682 |
                 setToken( methodImpl, t );
1104 |  |
             }
1105 | 682 |
             break;
1106 |  |
           case STATIC:
1107 | 122 |
             t = jj_consume_token(STATIC);
1108 | 122 |
             if(methodImpl!=null) {
1109 | 122 |
                 methodImpl.addModifier( Modifier.STATIC );
1110 | 122 |
                 setToken( methodImpl, t );
1111 |  |
             }
1112 | 122 |
             break;
1113 |  |
           case ABSTRACT:
1114 | 14 |
             t = jj_consume_token(ABSTRACT);
1115 | 14 |
             if(methodImpl!=null) {
1116 | 14 |
                 methodImpl.addModifier( Modifier.ABSTRACT );
1117 | 14 |
                 setToken( methodImpl, t );
1118 |  |
             }
1119 | 14 |
             break;
1120 |  |
           case FINAL:
1121 | 1702 |
             t = jj_consume_token(FINAL);
1122 | 1702 |
             if(methodImpl!=null) {
1123 | 1702 |
                 methodImpl.addModifier( Modifier.FINAL );
1124 | 1702 |
                 setToken( methodImpl, t );
1125 |  |
             }
1126 | 1702 |
             break;
1127 |  |
           case NATIVE:
1128 | 0 |
             t = jj_consume_token(NATIVE);
1129 | 0 |
             if(methodImpl!=null) {
1130 | 0 |
                 methodImpl.addModifier( Modifier.NATIVE );
1131 | 0 |
                 setToken( methodImpl, t );
1132 |  |
             }
1133 | 0 |
             break;
1134 |  |
           case SYNCHRONIZED:
1135 | 0 |
             t = jj_consume_token(SYNCHRONIZED);
1136 | 0 |
             if(methodImpl!=null) {
1137 | 0 |
                 methodImpl.addModifier( Modifier.SYNCHRONIZED );
1138 | 0 |
                 setToken( methodImpl, t );
1139 |  |
             }
1140 | 0 |
             break;
1141 |  |
           case STRICTFP:
1142 | 0 |
             t = jj_consume_token(STRICTFP);
1143 | 0 |
             if(methodImpl!=null) {
1144 | 0 |
                 methodImpl.addModifier( Modifier.STRICT );
1145 | 0 |
                 setToken( methodImpl, t );
1146 |  |
             }
1147 | 0 |
             break;
1148 |  |
           default:
1149 | 0 |
             jj_la1[34] = jj_gen;
1150 | 0 |
             jj_consume_token(-1);
1151 | 0 |
             throw new ParseException();
1152 |  |
           }
1153 |  |
         }
1154 | 8200 |
         ResultType(methodImpl);
1155 | 8200 |
         MethodDeclarator(methodImpl);
1156 | 8200 |
         switch (jj_nt.kind) {
1157 |  |
         case THROWS:
1158 | 456 |
           jj_consume_token(THROWS);
1159 | 456 |
           ExecutableMemberThrows_NameList(methodImpl);
1160 | 456 |
           break;
1161 |  |
         default:
1162 | 7744 |
           jj_la1[35] = jj_gen;
1163 |  |
           ;
1164 |  |
         }
1165 | 8200 |
         switch (jj_nt.kind) {
1166 |  |
         case LBRACE:
1167 | 4934 |
           Method_Block();
1168 | 4934 |
           break;
1169 |  |
         case SEMICOLON:
1170 | 3266 |
           jj_consume_token(SEMICOLON);
1171 | 3266 |
           break;
1172 |  |
         default:
1173 | 0 |
           jj_la1[36] = jj_gen;
1174 | 0 |
           jj_consume_token(-1);
1175 | 0 |
           throw new ParseException();
1176 |  |
         }
1177 |  |
         // we must add the method after the fields are in, because the
1178 |  |
         // signature must be complete when adding
1179 | 8200 |
         sourceClass.addMethod(methodImpl);
1180 |  |
       }
1181 |  |
1182 | 8200 |
       final public void MethodDeclarator(MethodImpl methodImpl) throws ParseException {
1183 | 8200 |
        Token t = null;
1184 | 8200 |
         t = jj_consume_token(IDENTIFIER);
1185 | 8200 |
          if( methodImpl != null ) {
1186 | 8200 |
             methodImpl.setName( t.image );
1187 |  |
          }
1188 | 8200 |
         FormalParameters(methodImpl);
1189 | 8200 |
         label_17:
1190 |  |
         while (true) {
1191 | 8200 |
           switch (jj_nt.kind) {
1192 |  |
           case LBRACKET:
1193 |  |
             ;
1194 | 0 |
             break;
1195 |  |
           default:
1196 | 8200 |
             jj_la1[37] = jj_gen;
1197 | 8200 |
             break label_17;
1198 |  |
           }
1199 | 0 |
           jj_consume_token(LBRACKET);
1200 | 0 |
           jj_consume_token(RBRACKET);
1201 | 0 |
          methodImpl.setReturnDimension( methodImpl.getReturnType().getDimension() + 1 );
1202 |  |
         }
1203 |  |
       }
1204 |  |
1205 | 8666 |
       final public void FormalParameters(AbstractExecutableMember member) throws ParseException {
1206 | 8666 |
         jj_consume_token(LPAREN);
1207 | 8666 |
         switch (jj_nt.kind) {
1208 |  |
         case BOOLEAN:
1209 |  |
         case BYTE:
1210 |  |
         case CHAR:
1211 |  |
         case DOUBLE:
1212 |  |
         case FINAL:
1213 |  |
         case FLOAT:
1214 |  |
         case INT:
1215 |  |
         case LONG:
1216 |  |
         case SHORT:
1217 |  |
         case IDENTIFIER:
1218 | 3580 |
           FormalParameter(member);
1219 | 3580 |
           label_18:
1220 |  |
           while (true) {
1221 | 5072 |
             switch (jj_nt.kind) {
1222 |  |
             case COMMA:
1223 |  |
               ;
1224 | 1492 |
               break;
1225 |  |
             default:
1226 | 3580 |
               jj_la1[38] = jj_gen;
1227 | 3580 |
               break label_18;
1228 |  |
             }
1229 | 1492 |
             jj_consume_token(COMMA);
1230 | 1492 |
             FormalParameter(member);
1231 |  |
           }
1232 | 3580 |
           break;
1233 |  |
         default:
1234 | 5086 |
           jj_la1[39] = jj_gen;
1235 |  |
           ;
1236 |  |
         }
1237 | 8666 |
         jj_consume_token(RPAREN);
1238 |  |
       }
1239 |  |
1240 | 5246 |
       final public void FormalParameter(AbstractExecutableMember member) throws ParseException {
1241 | 5246 |
        if(member != null) {
1242 |  |
           // reset the _parameter helper's dimension
1243 | 5072 |
           _parameter.dimension = 0;
1244 |  |
        }
1245 | 5246 |
         switch (jj_nt.kind) {
1246 |  |
         case FINAL:
1247 | 208 |
           jj_consume_token(FINAL);
1248 | 208 |
           break;
1249 |  |
         default:
1250 | 5038 |
           jj_la1[40] = jj_gen;
1251 |  |
           ;
1252 |  |
         }
1253 | 5246 |
         Parameter_Type();
1254 | 5246 |
         Parameter_VariableDeclaratorId();
1255 | 5246 |
          if( member != null ) {
1256 | 5072 |
             member.addParameterData(_parameter.type, _parameter.name, _parameter.dimension);
1257 |  |
          }
1258 |  |
       }
1259 |  |
1260 | 466 |
       final public void ConstructorDeclaration() throws ParseException {
1261 | 466 |
        SourceClass sourceClass = currentClass();
1262 | 466 |
        Token t = null;
1263 | 466 |
        ConstructorImpl constructor = constructor = new ConstructorImpl(sourceClass, _tagFactory);
1264 | 466 |
         switch (jj_nt.kind) {
1265 |  |
         case PRIVATE:
1266 |  |
         case PROTECTED:
1267 |  |
         case PUBLIC:
1268 | 422 |
           switch (jj_nt.kind) {
1269 |  |
           case PUBLIC:
1270 | 262 |
             t = jj_consume_token(PUBLIC);
1271 | 262 |
            constructor.addModifier( Modifier.PUBLIC );
1272 | 262 |
            setToken( constructor, t );
1273 | 262 |
             break;
1274 |  |
           case PROTECTED:
1275 | 160 |
             t = jj_consume_token(PROTECTED);
1276 | 160 |
            constructor.addModifier( Modifier.PROTECTED );
1277 | 160 |
            setToken( constructor, t );
1278 | 160 |
             break;
1279 |  |
           case PRIVATE:
1280 | 0 |
             t = jj_consume_token(PRIVATE);
1281 | 0 |
            constructor.addModifier( Modifier.PRIVATE );
1282 | 0 |
            setToken( constructor, t );
1283 | 0 |
             break;
1284 |  |
           default:
1285 | 0 |
             jj_la1[41] = jj_gen;
1286 | 0 |
             jj_consume_token(-1);
1287 | 0 |
             throw new ParseException();
1288 |  |
           }
1289 | 422 |
           break;
1290 |  |
         default:
1291 | 44 |
           jj_la1[42] = jj_gen;
1292 |  |
           ;
1293 |  |
         }
1294 | 466 |
         jj_consume_token(IDENTIFIER);
1295 | 466 |
         FormalParameters(constructor);
1296 | 466 |
         switch (jj_nt.kind) {
1297 |  |
         case THROWS:
1298 | 0 |
           jj_consume_token(THROWS);
1299 | 0 |
           ExecutableMemberThrows_NameList(constructor);
1300 | 0 |
           break;
1301 |  |
         default:
1302 | 466 |
           jj_la1[43] = jj_gen;
1303 |  |
           ;
1304 |  |
         }
1305 | 466 |
         jj_consume_token(LBRACE);
1306 | 466 |
         if (jj_2_11(2147483647)) {
1307 | 180 |
           ExplicitConstructorInvocation();
1308 |  |
         } else {
1309 |  |
           ;
1310 |  |
         }
1311 | 466 |
         label_19:
1312 |  |
         while (true) {
1313 | 1050 |
           switch (jj_nt.kind) {
1314 |  |
           case BOOLEAN:
1315 |  |
           case BREAK:
1316 |  |
           case BYTE:
1317 |  |
           case CHAR:
1318 |  |
           case CLASS:
1319 |  |
           case CONTINUE:
1320 |  |
           case DO:
1321 |  |
           case DOUBLE:
1322 |  |
           case FALSE:
1323 |  |
           case FINAL:
1324 |  |
           case FLOAT:
1325 |  |
           case FOR:
1326 |  |
           case IF:
1327 |  |
           case INT:
1328 |  |
           case INTERFACE:
1329 |  |
           case LONG:
1330 |  |
           case NEW:
1331 |  |
           case NULL:
1332 |  |
           case RETURN:
1333 |  |
           case SHORT:
1334 |  |
           case SUPER:
1335 |  |
           case SWITCH:
1336 |  |
           case SYNCHRONIZED:
1337 |  |
           case THIS:
1338 |  |
           case THROW:
1339 |  |
           case TRUE:
1340 |  |
           case TRY:
1341 |  |
           case VOID:
1342 |  |
           case WHILE:
1343 |  |
           case ASSERT:
1344 |  |
           case INTEGER_LITERAL:
1345 |  |
           case FLOATING_POINT_LITERAL:
1346 |  |
           case CHARACTER_LITERAL:
1347 |  |
           case STRING_LITERAL:
1348 |  |
           case IDENTIFIER:
1349 |  |
           case LPAREN:
1350 |  |
           case LBRACE:
1351 |  |
           case SEMICOLON:
1352 |  |
           case INCR:
1353 |  |
           case DECR:
1354 |  |
             ;
1355 | 584 |
             break;
1356 |  |
           default:
1357 | 466 |
             jj_la1[44] = jj_gen;
1358 | 466 |
             break label_19;
1359 |  |
           }
1360 | 584 |
           BlockStatement();
1361 |  |
         }
1362 | 466 |
         jj_consume_token(RBRACE);
1363 |  |
         // we must add the method after the fields are in, because the
1364 |  |
         // signature must be complete when adding
1365 | 466 |
         sourceClass.addConstructor(constructor);
1366 |  |
       }
1367 |  |
1368 | 180 |
       final public void ExplicitConstructorInvocation() throws ParseException {
1369 | 180 |
         if (jj_2_13(2147483647)) {
1370 | 40 |
           jj_consume_token(THIS);
1371 | 40 |
           Arguments();
1372 | 40 |
           jj_consume_token(SEMICOLON);
1373 |  |
         } else {
1374 | 140 |
           switch (jj_nt.kind) {
1375 |  |
           case BOOLEAN:
1376 |  |
           case BYTE:
1377 |  |
           case CHAR:
1378 |  |
           case DOUBLE:
1379 |  |
           case FALSE:
1380 |  |
           case FLOAT:
1381 |  |
           case INT:
1382 |  |
           case LONG:
1383 |  |
           case NEW:
1384 |  |
           case NULL:
1385 |  |
           case SHORT:
1386 |  |
           case SUPER:
1387 |  |
           case THIS:
1388 |  |
           case TRUE:
1389 |  |
           case VOID:
1390 |  |
           case INTEGER_LITERAL:
1391 |  |
           case FLOATING_POINT_LITERAL:
1392 |  |
           case CHARACTER_LITERAL:
1393 |  |
           case STRING_LITERAL:
1394 |  |
           case IDENTIFIER:
1395 |  |
           case LPAREN:
1396 | 140 |
             if (jj_2_12(2)) {
1397 | 0 |
               PrimaryExpression();
1398 | 0 |
               jj_consume_token(DOT);
1399 |  |
             } else {
1400 |  |
               ;
1401 |  |
             }
1402 | 140 |
             jj_consume_token(SUPER);
1403 | 140 |
             Arguments();
1404 | 140 |
             jj_consume_token(SEMICOLON);
1405 | 140 |
             break;
1406 |  |
           default:
1407 | 0 |
             jj_la1[45] = jj_gen;
1408 | 0 |
             jj_consume_token(-1);
1409 | 0 |
             throw new ParseException();
1410 |  |
           }
1411 |  |
         }
1412 |  |
       }
1413 |  |
1414 | 32 |
       final public void Initializer() throws ParseException {
1415 | 32 |
         switch (jj_nt.kind) {
1416 |  |
         case STATIC:
1417 | 32 |
           jj_consume_token(STATIC);
1418 | 32 |
           break;
1419 |  |
         default:
1420 | 0 |
           jj_la1[46] = jj_gen;
1421 |  |
           ;
1422 |  |
         }
1423 | 32 |
         Block();
1424 |  |
       }
1425 |  |
1426 |  |
     /*
1427 |  |
      * Type, name and expression syntax follows.
1428 |  |
      */
1429 | 2054 |
       final public void Field_Type(FieldImpl fieldImpl) throws ParseException {
1430 | 2054 |
        Token typeToken;
1431 | 2054 |
        String type;
1432 | 2054 |
         switch (jj_nt.kind) {
1433 |  |
         case BOOLEAN:
1434 |  |
         case BYTE:
1435 |  |
         case CHAR:
1436 |  |
         case DOUBLE:
1437 |  |
         case FLOAT:
1438 |  |
         case INT:
1439 |  |
         case LONG:
1440 |  |
         case SHORT:
1441 | 340 |
           typeToken = PrimitiveType();
1442 | 340 |
           if( fieldImpl != null ) {
1443 | 340 |
             fieldImpl.setType(typeToken.image);
1444 | 340 |
             setToken( fieldImpl, typeToken );
1445 |  |
           }
1446 | 340 |
           break;
1447 |  |
         case IDENTIFIER:
1448 | 1714 |
           type = Name();
1449 | 1714 |
           if( fieldImpl != null ) {
1450 | 1714 |
             fieldImpl.setType(type);
1451 | 1714 |
             setToken( fieldImpl, _nameToken );
1452 |  |
           }
1453 | 1714 |
           break;
1454 |  |
         default:
1455 | 0 |
           jj_la1[47] = jj_gen;
1456 | 0 |
           jj_consume_token(-1);
1457 | 0 |
           throw new ParseException();
1458 |  |
         }
1459 | 2054 |
         label_20:
1460 |  |
         while (true) {
1461 | 2078 |
           switch (jj_nt.kind) {
1462 |  |
           case LBRACKET:
1463 |  |
             ;
1464 | 24 |
             break;
1465 |  |
           default:
1466 | 2054 |
             jj_la1[48] = jj_gen;
1467 | 2054 |
             break label_20;
1468 |  |
           }
1469 | 24 |
           jj_consume_token(LBRACKET);
1470 | 24 |
           jj_consume_token(RBRACKET);
1471 | 24 |
          if( fieldImpl != null ) {
1472 | 24 |
             fieldImpl.setDimension(fieldImpl.getDimension() + 1);
1473 |  |
          }
1474 |  |
         }
1475 |  |
       }
1476 |  |
1477 | 6384 |
       final public void MethodResult_Type(MethodImpl methodImpl) throws ParseException {
1478 | 6384 |
        Token typeToken;
1479 | 6384 |
        String type;
1480 | 6384 |
         switch (jj_nt.kind) {
1481 |  |
         case BOOLEAN:
1482 |  |
         case BYTE:
1483 |  |
         case CHAR:
1484 |  |
         case DOUBLE:
1485 |  |
         case FLOAT:
1486 |  |
         case INT:
1487 |  |
         case LONG:
1488 |  |
         case SHORT:
1489 | 2176 |
           typeToken = PrimitiveType();
1490 | 2176 |
           if( methodImpl != null ) {
1491 | 2164 |
             methodImpl.setReturnType(typeToken.image);
1492 | 2164 |
             setToken( methodImpl, typeToken );
1493 |  |
           }
1494 | 2176 |
           break;
1495 |  |
         case IDENTIFIER:
1496 | 4208 |
           type = Name();
1497 | 4208 |
           if( methodImpl != null ) {
1498 | 4166 |
             methodImpl.setReturnType(type);
1499 | 4166 |
             setToken( methodImpl, _nameToken );
1500 |  |
           }
1501 | 4208 |
           break;
1502 |  |
         default:
1503 | 0 |
           jj_la1[49] = jj_gen;
1504 | 0 |
           jj_consume_token(-1);
1505 | 0 |
           throw new ParseException();
1506 |  |
         }
1507 | 6384 |
         label_21:
1508 |  |
         while (true) {
1509 | 6426 |
           switch (jj_nt.kind) {
1510 |  |
           case LBRACKET:
1511 |  |
             ;
1512 | 42 |
             break;
1513 |  |
           default:
1514 | 6384 |
             jj_la1[50] = jj_gen;
1515 | 6384 |
             break label_21;
1516 |  |
           }
1517 | 42 |
           jj_consume_token(LBRACKET);
1518 | 42 |
           jj_consume_token(RBRACKET);
1519 | 42 |
          if( methodImpl != null ) {
1520 | 18 |
             methodImpl.setReturnDimension(methodImpl.getReturnType().getDimension() + 1);
1521 |  |
          }
1522 |  |
         }
1523 |  |
       }
1524 |  |
1525 | 5246 |
       final public void Parameter_Type() throws ParseException {
1526 | 5246 |
        Token primitive;
1527 | 5246 |
        String name;
1528 | 5246 |
         switch (jj_nt.kind) {
1529 |  |
         case BOOLEAN:
1530 |  |
         case BYTE:
1531 |  |
         case CHAR:
1532 |  |
         case DOUBLE:
1533 |  |
         case FLOAT:
1534 |  |
         case INT:
1535 |  |
         case LONG:
1536 |  |
         case SHORT:
1537 | 1056 |
           primitive = PrimitiveType();
1538 | 1056 |
            _parameter.type = primitive.image;
1539 | 1056 |
           break;
1540 |  |
         case IDENTIFIER:
1541 | 4190 |
           name = Name();
1542 | 4190 |
            _parameter.type = name;
1543 | 4190 |
           break;
1544 |  |
         default:
1545 | 0 |
           jj_la1[51] = jj_gen;
1546 | 0 |
           jj_consume_token(-1);
1547 | 0 |
           throw new ParseException();
1548 |  |
         }
1549 | 5246 |
         label_22:
1550 |  |
         while (true) {
1551 | 5326 |
           switch (jj_nt.kind) {
1552 |  |
           case LBRACKET:
1553 |  |
             ;
1554 | 80 |
             break;
1555 |  |
           default:
1556 | 5246 |
             jj_la1[52] = jj_gen;
1557 | 5246 |
             break label_22;
1558 |  |
           }
1559 | 80 |
           jj_consume_token(LBRACKET);
1560 | 80 |
           jj_consume_token(RBRACKET);
1561 | 80 |
                   _parameter.dimension++;
1562 |  |
         }
1563 |  |
       }
1564 |  |
1565 | 6064 |
       final public void Type() throws ParseException {
1566 | 6064 |
         switch (jj_nt.kind) {
1567 |  |
         case BOOLEAN:
1568 |  |
         case BYTE:
1569 |  |
         case CHAR:
1570 |  |
         case DOUBLE:
1571 |  |
         case FLOAT:
1572 |  |
         case INT:
1573 |  |
         case LONG:
1574 |  |
         case SHORT:
1575 | 540 |
           PrimitiveType();
1576 | 540 |
           break;
1577 |  |
         case IDENTIFIER:
1578 | 5524 |
           Name();
1579 | 5524 |
           break;
1580 |  |
         default:
1581 | 0 |
           jj_la1[53] = jj_gen;
1582 | 0 |
           jj_consume_token(-1);
1583 | 0 |
           throw new ParseException();
1584 |  |
         }
1585 | 6064 |
         label_23:
1586 |  |
         while (true) {
1587 | 6082 |
           switch (jj_nt.kind) {
1588 |  |
           case LBRACKET:
1589 |  |
             ;
1590 | 18 |
             break;
1591 |  |
           default:
1592 | 6064 |
             jj_la1[54] = jj_gen;
1593 | 6064 |
             break label_23;
1594 |  |
           }
1595 | 18 |
           jj_consume_token(LBRACKET);
1596 | 18 |
           jj_consume_token(RBRACKET);
1597 |  |
         }
1598 |  |
       }
1599 |  |
1600 | 4112 |
       final public Token PrimitiveType() throws ParseException {
1601 | 4112 |
        Token t = null;
1602 | 4112 |
         switch (jj_nt.kind) {
1603 |  |
         case BOOLEAN:
1604 | 2716 |
           t = jj_consume_token(BOOLEAN);
1605 | 2716 |
                     {if (true) return t;}
1606 | 0 |
           break;
1607 |  |
         case CHAR:
1608 | 0 |
           t = jj_consume_token(CHAR);
1609 | 0 |
                  {if (true) return t;}
1610 | 0 |
           break;
1611 |  |
         case BYTE:
1612 | 0 |
           t = jj_consume_token(BYTE);
1613 | 0 |
                  {if (true) return t;}
1614 | 0 |
           break;
1615 |  |
         case SHORT:
1616 | 0 |
           t = jj_consume_token(SHORT);
1617 | 0 |
                   {if (true) return t;}
1618 | 0 |
           break;
1619 |  |
         case INT:
1620 | 1264 |
           t = jj_consume_token(INT);
1621 | 1264 |
                 {if (true) return t;}
1622 | 0 |
           break;
1623 |  |
         case LONG:
1624 | 132 |
           t = jj_consume_token(LONG);
1625 | 132 |
                  {if (true) return t;}
1626 | 0 |
           break;
1627 |  |
         case FLOAT:
1628 | 0 |
           t = jj_consume_token(FLOAT);
1629 | 0 |
                   {if (true) return t;}
1630 | 0 |
           break;
1631 |  |
         case DOUBLE:
1632 | 0 |
           t = jj_consume_token(DOUBLE);
1633 | 0 |
                    {if (true) return t;}
1634 | 0 |
           break;
1635 |  |
         default:
1636 | 0 |
           jj_la1[55] = jj_gen;
1637 | 0 |
           jj_consume_token(-1);
1638 | 0 |
           throw new ParseException();
1639 |  |
         }
1640 | 0 |
         throw new Error("Missing return statement in function");
1641 |  |
       }
1642 |  |
1643 | 8254 |
       final public void ResultType(MethodImpl methodImpl) throws ParseException {
1644 | 8254 |
        Token t = null;
1645 | 8254 |
         switch (jj_nt.kind) {
1646 |  |
         case VOID:
1647 | 1870 |
           t = jj_consume_token(VOID);
1648 | 1870 |
          if( methodImpl != null ) {
1649 | 1870 |
             methodImpl.setReturnType( "void" );
1650 | 1870 |
             methodImpl.setReturnDimension( 0 );
1651 | 1870 |
             setToken( methodImpl, t );
1652 |  |
          }
1653 | 1870 |
           break;
1654 |  |
         case BOOLEAN:
1655 |  |
         case BYTE:
1656 |  |
         case CHAR:
1657 |  |
         case DOUBLE:
1658 |  |
         case FLOAT:
1659 |  |
         case INT:
1660 |  |
         case LONG:
1661 |  |
         case SHORT:
1662 |  |
         case IDENTIFIER:
1663 | 6384 |
           MethodResult_Type(methodImpl);
1664 | 6384 |
           break;
1665 |  |
         default:
1666 | 0 |
           jj_la1[56] = jj_gen;
1667 | 0 |
           jj_consume_token(-1);
1668 | 0 |
           throw new ParseException();
1669 |  |
         }
1670 |  |
       }
1671 |  |
1672 | 53590 |
       final public String Name() throws ParseException {
1673 |  |
        // reset the buffer
1674 | 53590 |
        clearNameBuffer();
1675 | 53590 |
        Token t = null;
1676 | 53590 |
         _nameToken = jj_consume_token(IDENTIFIER);
1677 | 53590 |
          _nameBuffer.append(_nameToken.image);
1678 | 53590 |
         label_24:
1679 |  |
         while (true) {
1680 | 68354 |
           if (jj_2_14(2)) {
1681 |  |
             ;
1682 |  |
           } else {
1683 | 53590 |
             break label_24;
1684 |  |
           }
1685 | 14764 |
           jj_consume_token(DOT);
1686 | 14764 |
           t = jj_consume_token(IDENTIFIER);
1687 | 14764 |
          _nameBuffer.append(".").append(t.image);
1688 |  |
         }
1689 | 53590 |
          {if (true) return _nameBuffer.toString();}
1690 | 0 |
         throw new Error("Missing return statement in function");
1691 |  |
       }
1692 |  |
1693 | 510 |
       final public void ExecutableMemberThrows_Name(AbstractExecutableMember member) throws ParseException {
1694 |  |
        // reset the buffer
1695 | 510 |
        clearNameBuffer();
1696 | 510 |
        Token t = null;
1697 | 510 |
         t = jj_consume_token(IDENTIFIER);
1698 | 510 |
          _nameBuffer.append(t.image);
1699 | 510 |
         label_25:
1700 |  |
         while (true) {
1701 | 510 |
           switch (jj_nt.kind) {
1702 |  |
           case DOT:
1703 |  |
             ;
1704 | 0 |
             break;
1705 |  |
           default:
1706 | 510 |
             jj_la1[57] = jj_gen;
1707 | 510 |
             break label_25;
1708 |  |
           }
1709 | 0 |
           jj_consume_token(DOT);
1710 | 0 |
           t = jj_consume_token(IDENTIFIER);
1711 | 0 |
          _nameBuffer.append(".").append(t.image);
1712 |  |
         }
1713 | 510 |
          if( member != null ) {
1714 | 510 |
             member.addThrownException( _nameBuffer.toString() );
1715 |  |
          }
1716 |  |
       }
1717 |  |
1718 | 576 |
       final public void Interfaces_Name() throws ParseException {
1719 | 576 |
        SourceClass sourceClass = currentClass();
1720 |  |
1721 |  |
        // reset the buffer
1722 | 576 |
        clearNameBuffer();
1723 | 576 |
        Token t = null;
1724 | 576 |
         t = jj_consume_token(IDENTIFIER);
1725 | 576 |
          _nameBuffer.append(t.image);
1726 | 576 |
         label_26:
1727 |  |
         while (true) {
1728 | 728 |
           switch (jj_nt.kind) {
1729 |  |
           case DOT:
1730 |  |
             ;
1731 | 152 |
             break;
1732 |  |
           default:
1733 | 576 |
             jj_la1[58] = jj_gen;
1734 | 576 |
             break label_26;
1735 |  |
           }
1736 | 152 |
           jj_consume_token(DOT);
1737 | 152 |
           t = jj_consume_token(IDENTIFIER);
1738 | 152 |
          _nameBuffer.append(".").append(t.image);
1739 |  |
         }
1740 | 576 |
          sourceClass.addInterface( _nameBuffer.toString() );
1741 |  |
       }
1742 |  |
1743 | 0 |
       final public void NameList() throws ParseException {
1744 | 0 |
         Name();
1745 | 0 |
         label_27:
1746 |  |
         while (true) {
1747 | 0 |
           switch (jj_nt.kind) {
1748 |  |
           case COMMA:
1749 |  |
             ;
1750 | 0 |
             break;
1751 |  |
           default:
1752 | 0 |
             jj_la1[59] = jj_gen;
1753 | 0 |
             break label_27;
1754 |  |
           }
1755 | 0 |
           jj_consume_token(COMMA);
1756 | 0 |
           Name();
1757 |  |
         }
1758 |  |
       }
1759 |  |
1760 | 456 |
       final public void ExecutableMemberThrows_NameList(AbstractExecutableMember member) throws ParseException {
1761 | 456 |
         ExecutableMemberThrows_Name(member);
1762 | 456 |
         label_28:
1763 |  |
         while (true) {
1764 | 510 |
           switch (jj_nt.kind) {
1765 |  |
           case COMMA:
1766 |  |
             ;
1767 | 54 |
             break;
1768 |  |
           default:
1769 | 456 |
             jj_la1[60] = jj_gen;
1770 | 456 |
             break label_28;
1771 |  |
           }
1772 | 54 |
           jj_consume_token(COMMA);
1773 | 54 |
           ExecutableMemberThrows_Name(member);
1774 |  |
         }
1775 |  |
       }
1776 |  |
1777 | 456 |
       final public void Interfaces_NameList() throws ParseException {
1778 | 456 |
         Interfaces_Name();
1779 | 456 |
         label_29:
1780 |  |
         while (true) {
1781 | 576 |
           switch (jj_nt.kind) {
1782 |  |
           case COMMA:
1783 |  |
             ;
1784 | 120 |
             break;
1785 |  |
           default:
1786 | 456 |
             jj_la1[61] = jj_gen;
1787 | 456 |
             break label_29;
1788 |  |
           }
1789 | 120 |
           jj_consume_token(COMMA);
1790 | 120 |
           Interfaces_Name();
1791 |  |
         }
1792 |  |
       }
1793 |  |
1794 |  |
     /*
1795 |  |
      * Expression syntax follows.
1796 |  |
      */
1797 | 31358 |
       final public void Expression() throws ParseException {
1798 | 31358 |
         ConditionalExpression();
1799 | 31358 |
         switch (jj_nt.kind) {
1800 |  |
         case ASSIGN:
1801 |  |
         case PLUSASSIGN:
1802 |  |
         case MINUSASSIGN:
1803 |  |
         case STARASSIGN:
1804 |  |
         case SLASHASSIGN:
1805 |  |
         case ANDASSIGN:
1806 |  |
         case ORASSIGN:
1807 |  |
         case XORASSIGN:
1808 |  |
         case REMASSIGN:
1809 |  |
         case LSHIFTASSIGN:
1810 |  |
         case RSIGNEDSHIFTASSIGN:
1811 |  |
         case RUNSIGNEDSHIFTASSIGN:
1812 | 182 |
           AssignmentOperator();
1813 | 182 |
           Expression();
1814 | 182 |
           break;
1815 |  |
         default:
1816 | 31176 |
           jj_la1[62] = jj_gen;
1817 |  |
           ;
1818 |  |
         }
1819 |  |
       }
1820 |  |
1821 | 4198 |
       final public void AssignmentOperator() throws ParseException {
1822 | 4198 |
         switch (jj_nt.kind) {
1823 |  |
         case ASSIGN:
1824 | 4120 |
           jj_consume_token(ASSIGN);
1825 | 4120 |
           break;
1826 |  |
         case STARASSIGN:
1827 | 0 |
           jj_consume_token(STARASSIGN);
1828 | 0 |
           break;
1829 |  |
         case SLASHASSIGN:
1830 | 0 |
           jj_consume_token(SLASHASSIGN);
1831 | 0 |
           break;
1832 |  |
         case REMASSIGN:
1833 | 0 |
           jj_consume_token(REMASSIGN);
1834 | 0 |
           break;
1835 |  |
         case PLUSASSIGN:
1836 | 46 |
           jj_consume_token(PLUSASSIGN);
1837 | 46 |
           break;
1838 |  |
         case MINUSASSIGN:
1839 | 0 |
           jj_consume_token(MINUSASSIGN);
1840 | 0 |
           break;
1841 |  |
         case LSHIFTASSIGN:
1842 | 0 |
           jj_consume_token(LSHIFTASSIGN);
1843 | 0 |
           break;
1844 |  |
         case RSIGNEDSHIFTASSIGN:
1845 | 0 |
           jj_consume_token(RSIGNEDSHIFTASSIGN);
1846 | 0 |
           break;
1847 |  |
         case RUNSIGNEDSHIFTASSIGN:
1848 | 0 |
           jj_consume_token(RUNSIGNEDSHIFTASSIGN);
1849 | 0 |
           break;
1850 |  |
         case ANDASSIGN:
1851 | 0 |
           jj_consume_token(ANDASSIGN);
1852 | 0 |
           break;
1853 |  |
         case XORASSIGN:
1854 | 0 |
           jj_consume_token(XORASSIGN);
1855 | 0 |
           break;
1856 |  |
         case ORASSIGN:
1857 | 32 |
           jj_consume_token(ORASSIGN);
1858 | 32 |
           break;
1859 |  |
         default:
1860 | 0 |
           jj_la1[63] = jj_gen;
1861 | 0 |
           jj_consume_token(-1);
1862 | 0 |
           throw new ParseException();
1863 |  |
         }
1864 |  |
       }
1865 |  |
1866 | 31642 |
       final public void ConditionalExpression() throws ParseException {
1867 | 31642 |
         ConditionalOrExpression();
1868 | 31642 |
         switch (jj_nt.kind) {
1869 |  |
         case HOOK:
1870 | 284 |
           jj_consume_token(HOOK);
1871 | 284 |
           Expression();
1872 | 284 |
           jj_consume_token(COLON);
1873 | 284 |
           ConditionalExpression();
1874 | 284 |
           break;
1875 |  |
         default:
1876 | 31358 |
           jj_la1[64] = jj_gen;
1877 |  |
           ;
1878 |  |
         }
1879 |  |
       }
1880 |  |
1881 | 31642 |
       final public void ConditionalOrExpression() throws ParseException {
1882 | 31642 |
         ConditionalAndExpression();
1883 | 31642 |
         label_30:
1884 |  |
         while (true) {
1885 | 31810 |
           switch (jj_nt.kind) {
1886 |  |
           case SC_OR:
1887 |  |
             ;
1888 | 168 |
             break;
1889 |  |
           default:
1890 | 31642 |
             jj_la1[65] = jj_gen;
1891 | 31642 |
             break label_30;
1892 |  |
           }
1893 | 168 |
           jj_consume_token(SC_OR);
1894 | 168 |
           ConditionalAndExpression();
1895 |  |
         }
1896 |  |
       }
1897 |  |
1898 | 31810 |
       final public void ConditionalAndExpression() throws ParseException {
1899 | 31810 |
         InclusiveOrExpression();
1900 | 31810 |
         label_31:
1901 |  |
         while (true) {
1902 | 32192 |
           switch (jj_nt.kind) {
1903 |  |
           case SC_AND:
1904 |  |
             ;
1905 | 382 |
             break;
1906 |  |
           default:
1907 | 31810 |
             jj_la1[66] = jj_gen;
1908 | 31810 |
             break label_31;
1909 |  |
           }
1910 | 382 |
           jj_consume_token(SC_AND);
1911 | 382 |
           InclusiveOrExpression();
1912 |  |
         }
1913 |  |
       }
1914 |  |
1915 | 32192 |
       final public void InclusiveOrExpression() throws ParseException {
1916 | 32192 |
         ExclusiveOrExpression();
1917 | 32192 |
         label_32:
1918 |  |
         while (true) {
1919 | 32192 |
           switch (jj_nt.kind) {
1920 |  |
           case BIT_OR:
1921 |  |
             ;
1922 | 0 |
             break;
1923 |  |
           default:
1924 | 32192 |
             jj_la1[67] = jj_gen;
1925 | 32192 |
             break label_32;
1926 |  |
           }
1927 | 0 |
           jj_consume_token(BIT_OR);
1928 | 0 |
           ExclusiveOrExpression();
1929 |  |
         }
1930 |  |
       }
1931 |  |
1932 | 32192 |
       final public void ExclusiveOrExpression() throws ParseException {
1933 | 32192 |
         AndExpression();
1934 | 32192 |
         label_33:
1935 |  |
         while (true) {
1936 | 32192 |
           switch (jj_nt.kind) {
1937 |  |
           case XOR:
1938 |  |
             ;
1939 | 0 |
             break;
1940 |  |
           default:
1941 | 32192 |
             jj_la1[68] = jj_gen;
1942 | 32192 |
             break label_33;
1943 |  |
           }
1944 | 0 |
           jj_consume_token(XOR);
1945 | 0 |
           AndExpression();
1946 |  |
         }
1947 |  |
       }
1948 |  |
1949 | 32192 |
       final public void AndExpression() throws ParseException {
1950 | 32192 |
         EqualityExpression();
1951 | 32192 |
         label_34:
1952 |  |
         while (true) {
1953 | 32404 |
           switch (jj_nt.kind) {
1954 |  |
           case BIT_AND:
1955 |  |
             ;
1956 | 212 |
             break;
1957 |  |
           default:
1958 | 32192 |
             jj_la1[69] = jj_gen;
1959 | 32192 |
             break label_34;
1960 |  |
           }
1961 | 212 |
           jj_consume_token(BIT_AND);
1962 | 212 |
           EqualityExpression();
1963 |  |
         }
1964 |  |
       }
1965 |  |
1966 | 32404 |
       final public void EqualityExpression() throws ParseException {
1967 | 32404 |
         InstanceOfExpression();
1968 | 32404 |
         label_35:
1969 |  |
         while (true) {
1970 | 35828 |
           switch (jj_nt.kind) {
1971 |  |
           case EQ:
1972 |  |
           case NE:
1973 |  |
             ;
1974 | 3424 |
             break;
1975 |  |
           default:
1976 | 32404 |
             jj_la1[70] = jj_gen;
1977 | 32404 |
             break label_35;
1978 |  |
           }
1979 | 3424 |
           switch (jj_nt.kind) {
1980 |  |
           case EQ:
1981 | 1674 |
             jj_consume_token(EQ);
1982 | 1674 |
             break;
1983 |  |
           case NE:
1984 | 1750 |
             jj_consume_token(NE);
1985 | 1750 |
             break;
1986 |  |
           default:
1987 | 0 |
             jj_la1[71] = jj_gen;
1988 | 0 |
             jj_consume_token(-1);
1989 | 0 |
             throw new ParseException();
1990 |  |
           }
1991 | 3424 |
           InstanceOfExpression();
1992 |  |
         }
1993 |  |
       }
1994 |  |
1995 | 35828 |
       final public void InstanceOfExpression() throws ParseException {
1996 | 35828 |
         RelationalExpression();
1997 | 35828 |
         switch (jj_nt.kind) {
1998 |  |
         case INSTANCEOF:
1999 | 86 |
           jj_consume_token(INSTANCEOF);
2000 | 86 |
           Type();
2001 | 86 |
           break;
2002 |  |
         default:
2003 | 35742 |
           jj_la1[72] = jj_gen;
2004 |  |
           ;
2005 |  |
         }
2006 |  |
       }
2007 |  |
2008 | 35828 |
       final public void RelationalExpression() throws ParseException {
2009 | 35828 |
         ShiftExpression();
2010 | 35828 |
         label_36:
2011 |  |
         while (true) {
2012 | 36212 |
           switch (jj_nt.kind) {
2013 |  |
           case GT:
2014 |  |
           case LT:
2015 |  |
           case LE:
2016 |  |
           case GE:
2017 |  |
             ;
2018 | 384 |
             break;
2019 |  |
           default:
2020 | 35828 |
             jj_la1[73] = jj_gen;
2021 | 35828 |
             break label_36;
2022 |  |
           }
2023 | 384 |
           switch (jj_nt.kind) {
2024 |  |
           case LT:
2025 | 306 |
             jj_consume_token(LT);
2026 | 306 |
             break;
2027 |  |
           case GT:
2028 | 24 |
             jj_consume_token(GT);
2029 | 24 |
             break;
2030 |  |
           case LE:
2031 | 14 |
             jj_consume_token(LE);
2032 | 14 |
             break;
2033 |  |
           case GE:
2034 | 40 |
             jj_consume_token(GE);
2035 | 40 |
             break;
2036 |  |
           default:
2037 | 0 |
             jj_la1[74] = jj_gen;
2038 | 0 |
             jj_consume_token(-1);
2039 | 0 |
             throw new ParseException();
2040 |  |
           }
2041 | 384 |
           ShiftExpression();
2042 |  |
         }
2043 |  |
       }
2044 |  |
2045 | 36212 |
       final public void ShiftExpression() throws ParseException {
2046 | 36212 |
         AdditiveExpression();
2047 | 36212 |
         label_37:
2048 |  |
         while (true) {
2049 | 36212 |
           switch (jj_nt.kind) {
2050 |  |
           case LSHIFT:
2051 |  |
           case RSIGNEDSHIFT:
2052 |  |
           case RUNSIGNEDSHIFT:
2053 |  |
             ;
2054 | 0 |
             break;
2055 |  |
           default:
2056 | 36212 |
             jj_la1[75] = jj_gen;
2057 | 36212 |
             break label_37;
2058 |  |
           }
2059 | 0 |
           switch (jj_nt.kind) {
2060 |  |
           case LSHIFT:
2061 | 0 |
             jj_consume_token(LSHIFT);
2062 | 0 |
             break;
2063 |  |
           case RSIGNEDSHIFT:
2064 | 0 |
             jj_consume_token(RSIGNEDSHIFT);
2065 | 0 |
             break;
2066 |  |
           case RUNSIGNEDSHIFT:
2067 | 0 |
             jj_consume_token(RUNSIGNEDSHIFT);
2068 | 0 |
             break;
2069 |  |
           default:
2070 | 0 |
             jj_la1[76] = jj_gen;
2071 | 0 |
             jj_consume_token(-1);
2072 | 0 |
             throw new ParseException();
2073 |  |
           }
2074 | 0 |
           AdditiveExpression();
2075 |  |
         }
2076 |  |
       }
2077 |  |
2078 | 36212 |
       final public void AdditiveExpression() throws ParseException {
2079 | 36212 |
         MultiplicativeExpression();
2080 | 36212 |
         label_38:
2081 |  |
         while (true) {
2082 | 38456 |
           switch (jj_nt.kind) {
2083 |  |
           case PLUS:
2084 |  |
           case MINUS:
2085 |  |
             ;
2086 | 2244 |
             break;
2087 |  |
           default:
2088 | 36212 |
             jj_la1[77] = jj_gen;
2089 | 36212 |
             break label_38;
2090 |  |
           }
2091 | 2244 |
           switch (jj_nt.kind) {
2092 |  |
           case PLUS:
2093 | 2168 |
             jj_consume_token(PLUS);
2094 | 2168 |
             break;
2095 |  |
           case MINUS:
2096 | 76 |
             jj_consume_token(MINUS);
2097 | 76 |
             break;
2098 |  |
           default:
2099 | 0 |
             jj_la1[78] = jj_gen;
2100 | 0 |
             jj_consume_token(-1);
2101 | 0 |
             throw new ParseException();
2102 |  |
           }
2103 | 2244 |
           MultiplicativeExpression();
2104 |  |
         }
2105 |  |
       }
2106 |  |
2107 | 38456 |
       final public void MultiplicativeExpression() throws ParseException {
2108 | 38456 |
         UnaryExpression();
2109 | 38456 |
         label_39:
2110 |  |
         while (true) {
2111 | 38578 |
           switch (jj_nt.kind) {
2112 |  |
           case STAR:
2113 |  |
           case SLASH:
2114 |  |
           case REM:
2115 |  |
             ;
2116 | 122 |
             break;
2117 |  |
           default:
2118 | 38456 |
             jj_la1[79] = jj_gen;
2119 | 38456 |
             break label_39;
2120 |  |
           }
2121 | 122 |
           switch (jj_nt.kind) {
2122 |  |
           case STAR:
2123 | 88 |
             jj_consume_token(STAR);
2124 | 88 |
             break;
2125 |  |
           case SLASH:
2126 | 34 |
             jj_consume_token(SLASH);
2127 | 34 |
             break;
2128 |  |
           case REM:
2129 | 0 |
             jj_consume_token(REM);
2130 | 0 |
             break;
2131 |  |
           default:
2132 | 0 |
             jj_la1[80] = jj_gen;
2133 | 0 |
             jj_consume_token(-1);
2134 | 0 |
             throw new ParseException();
2135 |  |
           }
2136 | 122 |
           UnaryExpression();
2137 |  |
         }
2138 |  |
       }
2139 |  |
2140 | 39368 |
       final public void UnaryExpression() throws ParseException {
2141 | 39368 |
         switch (jj_nt.kind) {
2142 |  |
         case PLUS:
2143 |  |
         case MINUS:
2144 | 108 |
           switch (jj_nt.kind) {
2145 |  |
           case PLUS:
2146 | 12 |
             jj_consume_token(PLUS);
2147 | 12 |
             break;
2148 |  |
           case MINUS:
2149 | 96 |
             jj_consume_token(MINUS);
2150 | 96 |
             break;
2151 |  |
           default:
2152 | 0 |
             jj_la1[81] = jj_gen;
2153 | 0 |
             jj_consume_token(-1);
2154 | 0 |
             throw new ParseException();
2155 |  |
           }
2156 | 108 |
           UnaryExpression();
2157 | 108 |
           break;
2158 |  |
         case INCR:
2159 | 0 |
           PreIncrementExpression();
2160 | 0 |
           break;
2161 |  |
         case DECR:
2162 | 0 |
           PreDecrementExpression();
2163 | 0 |
           break;
2164 |  |
         case BOOLEAN:
2165 |  |
         case BYTE:
2166 |  |
         case CHAR:
2167 |  |
         case DOUBLE:
2168 |  |
         case FALSE:
2169 |  |
         case FLOAT:
2170 |  |
         case INT:
2171 |  |
         case LONG:
2172 |  |
         case NEW:
2173 |  |
         case NULL:
2174 |  |
         case SHORT:
2175 |  |
         case SUPER:
2176 |  |
         case THIS:
2177 |  |
         case TRUE:
2178 |  |
         case VOID:
2179 |  |
         case INTEGER_LITERAL:
2180 |  |
         case FLOATING_POINT_LITERAL:
2181 |  |
         case CHARACTER_LITERAL:
2182 |  |
         case STRING_LITERAL:
2183 |  |
         case IDENTIFIER:
2184 |  |
         case LPAREN:
2185 |  |
         case BANG:
2186 |  |
         case TILDE:
2187 | 39260 |
           UnaryExpressionNotPlusMinus();
2188 | 39260 |
           break;
2189 |  |
         default:
2190 | 0 |
           jj_la1[82] = jj_gen;
2191 | 0 |
           jj_consume_token(-1);
2192 | 0 |
           throw new ParseException();
2193 |  |
         }
2194 |  |
       }
2195 |  |
2196 | 4 |
       final public void PreIncrementExpression() throws ParseException {
2197 | 4 |
         jj_consume_token(INCR);
2198 | 4 |
         PrimaryExpression();
2199 |  |
       }
2200 |  |
2201 | 0 |
       final public void PreDecrementExpression() throws ParseException {
2202 | 0 |
         jj_consume_token(DECR);
2203 | 0 |
         PrimaryExpression();
2204 |  |
       }
2205 |  |
2206 | 40744 |
       final public void UnaryExpressionNotPlusMinus() throws ParseException {
2207 | 40744 |
         switch (jj_nt.kind) {
2208 |  |
         case BANG:
2209 |  |
         case TILDE:
2210 | 634 |
           switch (jj_nt.kind) {
2211 |  |
           case TILDE:
2212 | 0 |
             jj_consume_token(TILDE);
2213 | 0 |
             break;
2214 |  |
           case BANG:
2215 | 634 |
             jj_consume_token(BANG);
2216 | 634 |
             break;
2217 |  |
           default:
2218 | 0 |
             jj_la1[83] = jj_gen;
2219 | 0 |
             jj_consume_token(-1);
2220 | 0 |
             throw new ParseException();
2221 |  |
           }
2222 | 634 |
           UnaryExpression();
2223 | 634 |
           break;
2224 |  |
         default:
2225 | 40110 |
           jj_la1[84] = jj_gen;
2226 | 40110 |
           if (jj_2_15(2147483647)) {
2227 | 1532 |
             CastExpression();
2228 |  |
           } else {
2229 | 38578 |
             switch (jj_nt.kind) {
2230 |  |
             case BOOLEAN:
2231 |  |
             case BYTE:
2232 |  |
             case CHAR:
2233 |  |
             case DOUBLE:
2234 |  |
             case FALSE:
2235 |  |
             case FLOAT:
2236 |  |
             case INT:
2237 |  |
             case LONG:
2238 |  |
             case NEW:
2239 |  |
             case NULL:
2240 |  |
             case SHORT:
2241 |  |
             case SUPER:
2242 |  |
             case THIS:
2243 |  |
             case TRUE:
2244 |  |
             case VOID:
2245 |  |
             case INTEGER_LITERAL:
2246 |  |
             case FLOATING_POINT_LITERAL:
2247 |  |
             case CHARACTER_LITERAL:
2248 |  |
             case STRING_LITERAL:
2249 |  |
             case IDENTIFIER:
2250 |  |
             case LPAREN:
2251 | 38578 |
               PostfixExpression();
2252 | 38578 |
               break;
2253 |  |
             default:
2254 | 0 |
               jj_la1[85] = jj_gen;
2255 | 0 |
               jj_consume_token(-1);
2256 | 0 |
               throw new ParseException();
2257 |  |
             }
2258 |  |
           }
2259 |  |
         }
2260 |  |
       }
2261 |  |
2262 |  |
     // This production is to determine lookahead only.  The LOOKAHEAD specifications
2263 |  |
     // below are not used, but they are there just to indicate that we know about
2264 |  |
     // this.
2265 | 0 |
       final public void CastLookahead() throws ParseException {
2266 | 0 |
         if (jj_2_16(2)) {
2267 | 0 |
           jj_consume_token(LPAREN);
2268 | 0 |
           PrimitiveType();
2269 | 0 |
         } else if (jj_2_17(2147483647)) {
2270 | 0 |
           jj_consume_token(LPAREN);
2271 | 0 |
           Name();
2272 | 0 |
           jj_consume_token(LBRACKET);
2273 | 0 |
           jj_consume_token(RBRACKET);
2274 |  |
         } else {
2275 | 0 |
           switch (jj_nt.kind) {
2276 |  |
           case LPAREN:
2277 | 0 |
             jj_consume_token(LPAREN);
2278 | 0 |
             Name();
2279 | 0 |
             jj_consume_token(RPAREN);
2280 | 0 |
             switch (jj_nt.kind) {
2281 |  |
             case TILDE:
2282 | 0 |
               jj_consume_token(TILDE);
2283 | 0 |
               break;
2284 |  |
             case BANG:
2285 | 0 |
               jj_consume_token(BANG);
2286 | 0 |
               break;
2287 |  |
             case LPAREN:
2288 | 0 |
               jj_consume_token(LPAREN);
2289 | 0 |
               break;
2290 |  |
             case IDENTIFIER:
2291 | 0 |
               jj_consume_token(IDENTIFIER);
2292 | 0 |
               break;
2293 |  |
             case THIS:
2294 | 0 |
               jj_consume_token(THIS);
2295 | 0 |
               break;
2296 |  |
             case SUPER:
2297 | 0 |
               jj_consume_token(SUPER);
2298 | 0 |
               break;
2299 |  |
             case NEW:
2300 | 0 |
               jj_consume_token(NEW);
2301 | 0 |
               break;
2302 |  |
             case FALSE:
2303 |  |
             case NULL:
2304 |  |
             case TRUE:
2305 |  |
             case INTEGER_LITERAL:
2306 |  |
             case FLOATING_POINT_LITERAL:
2307 |  |
             case CHARACTER_LITERAL:
2308 |  |
             case STRING_LITERAL:
2309 | 0 |
               Literal();
2310 | 0 |
               break;
2311 |  |
             default:
2312 | 0 |
               jj_la1[86] = jj_gen;
2313 | 0 |
               jj_consume_token(-1);
2314 | 0 |
               throw new ParseException();
2315 |  |
             }
2316 | 0 |
             break;
2317 |  |
           default:
2318 | 0 |
             jj_la1[87] = jj_gen;
2319 | 0 |
             jj_consume_token(-1);
2320 | 0 |
             throw new ParseException();
2321 |  |
           }
2322 |  |
         }
2323 |  |
       }
2324 |  |
2325 | 38578 |
       final public void PostfixExpression() throws ParseException {
2326 | 38578 |
         PrimaryExpression();
2327 | 38578 |
         switch (jj_nt.kind) {
2328 |  |
         case INCR:
2329 |  |
         case DECR:
2330 | 0 |
           switch (jj_nt.kind) {
2331 |  |
           case INCR:
2332 | 0 |
             jj_consume_token(INCR);
2333 | 0 |
             break;
2334 |  |
           case DECR:
2335 | 0 |
             jj_consume_token(DECR);
2336 | 0 |
             break;
2337 |  |
           default:
2338 | 0 |
             jj_la1[88] = jj_gen;
2339 | 0 |
             jj_consume_token(-1);
2340 | 0 |
             throw new ParseException();
2341 |  |
           }
2342 | 0 |
           break;
2343 |  |
         default:
2344 | 38578 |
           jj_la1[89] = jj_gen;
2345 |  |
           ;
2346 |  |
         }
2347 |  |
       }
2348 |  |
2349 | 1532 |
       final public void CastExpression() throws ParseException {
2350 | 1532 |
         if (jj_2_18(2147483647)) {
2351 | 48 |
           jj_consume_token(LPAREN);
2352 | 48 |
           Type();
2353 | 48 |
           jj_consume_token(RPAREN);
2354 | 48 |
           UnaryExpression();
2355 |  |
         } else {
2356 | 1484 |
           switch (jj_nt.kind) {
2357 |  |
           case LPAREN:
2358 | 1484 |
             jj_consume_token(LPAREN);
2359 | 1484 |
             Type();
2360 | 1484 |
             jj_consume_token(RPAREN);
2361 | 1484 |
             UnaryExpressionNotPlusMinus();
2362 | 1484 |
             break;
2363 |  |
           default:
2364 | 0 |
             jj_la1[90] = jj_gen;
2365 | 0 |
             jj_consume_token(-1);
2366 | 0 |
             throw new ParseException();
2367 |  |
           }
2368 |  |
         }
2369 |  |
       }
2370 |  |
2371 | 46454 |
       final public void PrimaryExpression() throws ParseException {
2372 | 46454 |
         PrimaryPrefix();
2373 | 46454 |
         label_40:
2374 |  |
         while (true) {
2375 | 65064 |
           if (jj_2_19(2)) {
2376 |  |
             ;
2377 |  |
           } else {
2378 | 46454 |
             break label_40;
2379 |  |
           }
2380 | 18610 |
           PrimarySuffix();
2381 |  |
         }
2382 |  |
       }
2383 |  |
2384 | 46454 |
       final public void PrimaryPrefix() throws ParseException {
2385 | 46454 |
         switch (jj_nt.kind) {
2386 |  |
         case FALSE:
2387 |  |
         case NULL:
2388 |  |
         case TRUE:
2389 |  |
         case INTEGER_LITERAL:
2390 |  |
         case FLOATING_POINT_LITERAL:
2391 |  |
         case CHARACTER_LITERAL:
2392 |  |
         case STRING_LITERAL:
2393 | 9764 |
           Literal();
2394 | 9764 |
           break;
2395 |  |
         case THIS:
2396 | 500 |
           jj_consume_token(THIS);
2397 | 500 |
           break;
2398 |  |
         case SUPER:
2399 | 68 |
           jj_consume_token(SUPER);
2400 | 68 |
           jj_consume_token(DOT);
2401 | 68 |
           jj_consume_token(IDENTIFIER);
2402 | 68 |
           break;
2403 |  |
         case LPAREN:
2404 | 770 |
           jj_consume_token(LPAREN);
2405 | 770 |
           Expression();
2406 | 770 |
           jj_consume_token(RPAREN);
2407 | 770 |
           break;
2408 |  |
         case NEW:
2409 | 2524 |
           AllocationExpression();
2410 | 2524 |
           break;
2411 |  |
         default:
2412 | 32828 |
           jj_la1[91] = jj_gen;
2413 | 32828 |
           if (jj_2_20(2147483647)) {
2414 | 54 |
             ResultType(null);
2415 | 54 |
             jj_consume_token(DOT);
2416 | 54 |
             jj_consume_token(CLASS);
2417 |  |
           } else {
2418 | 32774 |
             switch (jj_nt.kind) {
2419 |  |
             case IDENTIFIER:
2420 | 32774 |
               Name();
2421 | 32774 |
               break;
2422 |  |
             default:
2423 | 0 |
               jj_la1[92] = jj_gen;
2424 | 0 |
               jj_consume_token(-1);
2425 | 0 |
               throw new ParseException();
2426 |  |
             }
2427 |  |
           }
2428 |  |
         }
2429 |  |
       }
2430 |  |
2431 | 18610 |
       final public void PrimarySuffix() throws ParseException {
2432 | 18610 |
         if (jj_2_21(2)) {
2433 | 0 |
           jj_consume_token(DOT);
2434 | 0 |
           jj_consume_token(THIS);
2435 | 18610 |
         } else if (jj_2_22(2)) {
2436 | 0 |
           jj_consume_token(DOT);
2437 | 0 |
           jj_consume_token(SUPER);
2438 | 18610 |
         } else if (jj_2_23(2)) {
2439 | 12 |
           jj_consume_token(DOT);
2440 | 12 |
           AllocationExpression();
2441 |  |
         } else {
2442 | 18598 |
           switch (jj_nt.kind) {
2443 |  |
           case LBRACKET:
2444 | 84 |
             jj_consume_token(LBRACKET);
2445 | 84 |
             Expression();
2446 | 84 |
             jj_consume_token(RBRACKET);
2447 | 84 |
             break;
2448 |  |
           case DOT:
2449 | 2536 |
             jj_consume_token(DOT);
2450 | 2536 |
             jj_consume_token(IDENTIFIER);
2451 | 2536 |
             break;
2452 |  |
           case LPAREN:
2453 | 15978 |
             Arguments();
2454 | 15978 |
             break;
2455 |  |
           default:
2456 | 0 |
             jj_la1[93] = jj_gen;
2457 | 0 |
             jj_consume_token(-1);
2458 | 0 |
             throw new ParseException();
2459 |  |
           }
2460 |  |
         }
2461 |  |
       }
2462 |  |
2463 | 9764 |
       final public void Literal() throws ParseException {
2464 | 9764 |
         switch (jj_nt.kind) {
2465 |  |
         case INTEGER_LITERAL:
2466 | 1318 |
           jj_consume_token(INTEGER_LITERAL);
2467 | 1318 |
           break;
2468 |  |
         case FLOATING_POINT_LITERAL:
2469 | 0 |
           jj_consume_token(FLOATING_POINT_LITERAL);
2470 | 0 |
           break;
2471 |  |
         case CHARACTER_LITERAL:
2472 | 502 |
           jj_consume_token(CHARACTER_LITERAL);
2473 | 502 |
           break;
2474 |  |
         case STRING_LITERAL:
2475 | 2642 |
           jj_consume_token(STRING_LITERAL);
2476 | 2642 |
           break;
2477 |  |
         case FALSE:
2478 |  |
         case TRUE:
2479 | 1176 |
           BooleanLiteral();
2480 | 1176 |
           break;
2481 |  |
         case NULL:
2482 | 4126 |
           NullLiteral();
2483 | 4126 |
           break;
2484 |  |
         default:
2485 | 0 |
           jj_la1[94] = jj_gen;
2486 | 0 |
           jj_consume_token(-1);
2487 | 0 |
           throw new ParseException();
2488 |  |
         }
2489 |  |
       }
2490 |  |
2491 | 1176 |
       final public void BooleanLiteral() throws ParseException {
2492 | 1176 |
         switch (jj_nt.kind) {
2493 |  |
         case TRUE:
2494 | 548 |
           jj_consume_token(TRUE);
2495 | 548 |
           break;
2496 |  |
         case FALSE:
2497 | 628 |
           jj_consume_token(FALSE);
2498 | 628 |
           break;
2499 |  |
         default:
2500 | 0 |
           jj_la1[95] = jj_gen;
2501 | 0 |
           jj_consume_token(-1);
2502 | 0 |
           throw new ParseException();
2503 |  |
         }
2504 |  |
       }
2505 |  |
2506 | 4126 |
       final public void NullLiteral() throws ParseException {
2507 | 4126 |
         jj_consume_token(NULL);
2508 |  |
       }
2509 |  |
2510 | 18624 |
       final public void Arguments() throws ParseException {
2511 | 18624 |
         jj_consume_token(LPAREN);
2512 | 18624 |
         switch (jj_nt.kind) {
2513 |  |
         case BOOLEAN:
2514 |  |
         case BYTE:
2515 |  |
         case CHAR:
2516 |  |
         case DOUBLE:
2517 |  |
         case FALSE:
2518 |  |
         case FLOAT:
2519 |  |
         case INT:
2520 |  |
         case LONG:
2521 |  |
         case NEW:
2522 |  |
         case NULL:
2523 |  |
         case SHORT:
2524 |  |
         case SUPER:
2525 |  |
         case THIS:
2526 |  |
         case TRUE:
2527 |  |
         case VOID:
2528 |  |
         case INTEGER_LITERAL:
2529 |  |
         case FLOATING_POINT_LITERAL:
2530 |  |
         case CHARACTER_LITERAL:
2531 |  |
         case STRING_LITERAL:
2532 |  |
         case IDENTIFIER:
2533 |  |
         case LPAREN:
2534 |  |
         case BANG:
2535 |  |
         case TILDE:
2536 |  |
         case INCR:
2537 |  |
         case DECR:
2538 |  |
         case PLUS:
2539 |  |
         case MINUS:
2540 | 8530 |
           ArgumentList();
2541 | 8530 |
           break;
2542 |  |
         default:
2543 | 10094 |
           jj_la1[96] = jj_gen;
2544 |  |
           ;
2545 |  |
         }
2546 | 18624 |
         jj_consume_token(RPAREN);
2547 |  |
       }
2548 |  |
2549 | 8530 |
       final public void ArgumentList() throws ParseException {
2550 | 8530 |
         Expression();
2551 | 8530 |
         label_41:
2552 |  |
         while (true) {
2553 | 10826 |
           switch (jj_nt.kind) {
2554 |  |
           case COMMA:
2555 |  |
             ;
2556 | 2296 |
             break;
2557 |  |
           default:
2558 | 8530 |
             jj_la1[97] = jj_gen;
2559 | 8530 |
             break label_41;
2560 |  |
           }
2561 | 2296 |
           jj_consume_token(COMMA);
2562 | 2296 |
           Expression();
2563 |  |
         }
2564 |  |
       }
2565 |  |
2566 |  |
     /**
2567 |  |
      * @todo Anonymous classes will cause NPE. Need to check for nullity in a lot of places
2568 |  |
      */
2569 | 2536 |
       final public void AllocationExpression() throws ParseException {
2570 | 2536 |
        String realisedClass;
2571 | 2536 |
         if (jj_2_24(2)) {
2572 | 0 |
           jj_consume_token(NEW);
2573 | 0 |
           PrimitiveType();
2574 | 0 |
           ArrayDimsAndInits();
2575 |  |
         } else {
2576 | 2536 |
           switch (jj_nt.kind) {
2577 |  |
           case NEW:
2578 | 2536 |
             jj_consume_token(NEW);
2579 | 2536 |
             realisedClass = Name();
2580 | 2536 |
             switch (jj_nt.kind) {
2581 |  |
             case LBRACKET:
2582 | 70 |
               ArrayDimsAndInits();
2583 | 70 |
               break;
2584 |  |
             case LPAREN:
2585 | 2466 |
               Arguments();
2586 | 2466 |
               switch (jj_nt.kind) {
2587 |  |
               case LBRACE:
2588 |  |
                 // ANONYMOUS CLASS
2589 | 40 |
                 SourceClass containingClass = currentClass();
2590 | 40 |
             pushAndGet();
2591 | 40 |
                 ClassBody();
2592 |  |
             // Don't care about anonymous classes. They don't have javadocs
2593 |  |
             // _xJavaDoc.addSourceClass(anonymousClass);
2594 | 40 |
             currentClass().setName(containingClass.getNextAnonymousClassName());
2595 | 40 |
             currentClass().setRealised(realisedClass);
2596 | 40 |
             popAndAddInner();
2597 | 40 |
                 break;
2598 |  |
               default:
2599 | 2426 |
                 jj_la1[98] = jj_gen;
2600 |  |
                 ;
2601 |  |
               }
2602 | 2466 |
               break;
2603 |  |
             default:
2604 | 0 |
               jj_la1[99] = jj_gen;
2605 | 0 |
               jj_consume_token(-1);
2606 | 0 |
               throw new ParseException();
2607 |  |
             }
2608 | 2536 |
             break;
2609 |  |
           default:
2610 | 0 |
             jj_la1[100] = jj_gen;
2611 | 0 |
             jj_consume_token(-1);
2612 | 0 |
             throw new ParseException();
2613 |  |
           }
2614 |  |
         }
2615 |  |
       }
2616 |  |
2617 |  |
     /*
2618 |  |
      * The second LOOKAHEAD specification below is to parse to PrimarySuffix
2619 |  |
      * if there is an expression between the "[...]".
2620 |  |
      */
2621 | 70 |
       final public void ArrayDimsAndInits() throws ParseException {
2622 | 70 |
         if (jj_2_27(2)) {
2623 | 46 |
           label_42:
2624 |  |
           while (true) {
2625 | 46 |
             jj_consume_token(LBRACKET);
2626 | 46 |
             Expression();
2627 | 46 |
             jj_consume_token(RBRACKET);
2628 | 46 |
             if (jj_2_25(2)) {
2629 |  |
               ;
2630 |  |
             } else {
2631 | 46 |
               break label_42;
2632 |  |
             }
2633 |  |
           }
2634 | 46 |
           label_43:
2635 |  |
           while (true) {
2636 | 46 |
             if (jj_2_26(2)) {
2637 |  |
               ;
2638 |  |
             } else {
2639 | 46 |
               break label_43;
2640 |  |
             }
2641 | 0 |
             jj_consume_token(LBRACKET);
2642 | 0 |
             jj_consume_token(RBRACKET);
2643 |  |
           }
2644 |  |
         } else {
2645 | 24 |
           switch (jj_nt.kind) {
2646 |  |
           case LBRACKET:
2647 | 24 |
             label_44:
2648 |  |
             while (true) {
2649 | 24 |
               jj_consume_token(LBRACKET);
2650 | 24 |
               jj_consume_token(RBRACKET);
2651 | 24 |
               switch (jj_nt.kind) {
2652 |  |
               case LBRACKET:
2653 |  |
                 ;
2654 | 0 |
                 break;
2655 |  |
               default:
2656 | 24 |
                 jj_la1[101] = jj_gen;
2657 | 24 |
                 break label_44;
2658 |  |
               }
2659 |  |
             }
2660 | 24 |
             ArrayInitializer();
2661 | 24 |
             break;
2662 |  |
           default:
2663 | 0 |
             jj_la1[102] = jj_gen;
2664 | 0 |
             jj_consume_token(-1);
2665 | 0 |
             throw new ParseException();
2666 |  |
           }
2667 |  |
         }
2668 |  |
       }
2669 |  |
2670 |  |
     /*
2671 |  |
      * Statement syntax follows.
2672 |  |
      */
2673 | 23702 |
       final public void Statement() throws ParseException {
2674 | 23702 |
         if (jj_2_28(2)) {
2675 | 0 |
           LabeledStatement();
2676 |  |
         } else {
2677 | 23702 |
           switch (jj_nt.kind) {
2678 |  |
           case LBRACE:
2679 | 5820 |
             Block();
2680 | 5820 |
             break;
2681 |  |
           case SEMICOLON:
2682 | 0 |
             EmptyStatement();
2683 | 0 |
             break;
2684 |  |
           case BOOLEAN:
2685 |  |
           case BYTE:
2686 |  |
           case CHAR:
2687 |  |
           case DOUBLE:
2688 |  |
           case FALSE:
2689 |  |
           case FLOAT:
2690 |  |
           case INT:
2691 |  |
           case LONG:
2692 |  |
           case NEW:
2693 |  |
           case NULL:
2694 |  |
           case SHORT:
2695 |  |
           case SUPER:
2696 |  |
           case THIS:
2697 |  |
           case TRUE:
2698 |  |
           case VOID:
2699 |  |
           case INTEGER_LITERAL:
2700 |  |
           case FLOATING_POINT_LITERAL:
2701 |  |
           case CHARACTER_LITERAL:
2702 |  |
           case STRING_LITERAL:
2703 |  |
           case IDENTIFIER:
2704 |  |
           case LPAREN:
2705 |  |
           case INCR:
2706 |  |
           case DECR:
2707 | 7712 |
             StatementExpression();
2708 | 7712 |
             jj_consume_token(SEMICOLON);
2709 | 7712 |
             break;
2710 |  |
           case SWITCH:
2711 | 0 |
             SwitchStatement();
2712 | 0 |
             break;
2713 |  |
           case IF:
2714 | 3904 |
             IfStatement();
2715 | 3904 |
             break;
2716 |  |
           case WHILE:
2717 | 326 |
             WhileStatement();
2718 | 326 |
             break;
2719 |  |
           case DO:
2720 | 44 |
             DoStatement();
2721 | 44 |
             break;
2722 |  |
           case FOR:
2723 | 900 |
             ForStatement();
2724 | 900 |
             break;
2725 |  |
           case BREAK:
2726 | 74 |
             BreakStatement();
2727 | 74 |
             break;
2728 |  |
           case CONTINUE:
2729 | 12 |
             ContinueStatement();
2730 | 12 |
             break;
2731 |  |
           case RETURN:
2732 | 4060 |
             ReturnStatement();
2733 | 4060 |
             break;
2734 |  |
           case THROW:
2735 | 652 |
             ThrowStatement();
2736 | 652 |
             break;
2737 |  |
           case SYNCHRONIZED:
2738 | 0 |
             SynchronizedStatement();
2739 | 0 |
             break;
2740 |  |
           case TRY:
2741 | 134 |
             TryStatement();
2742 | 134 |
             break;
2743 |  |
           case ASSERT:
2744 | 64 |
             AssertStatement();
2745 | 64 |
             break;
2746 |  |
           default:
2747 | 0 |
             jj_la1[103] = jj_gen;
2748 | 0 |
             jj_consume_token(-1);
2749 | 0 |
             throw new ParseException();
2750 |  |
           }
2751 |  |
         }
2752 |  |
       }
2753 |  |
2754 | 0 |
       final public void LabeledStatement() throws ParseException {
2755 | 0 |
         jj_consume_token(IDENTIFIER);
2756 | 0 |
         jj_consume_token(COLON);
2757 | 0 |
         Statement();
2758 |  |
       }
2759 |  |
2760 | 6160 |
       final public void Block() throws ParseException {
2761 | 6160 |
         jj_consume_token(LBRACE);
2762 | 6160 |
         label_45:
2763 |  |
         while (true) {
2764 | 16552 |
           switch (jj_nt.kind) {
2765 |  |
           case BOOLEAN:
2766 |  |
           case BREAK:
2767 |  |
           case BYTE:
2768 |  |
           case CHAR:
2769 |  |
           case CLASS:
2770 |  |
           case CONTINUE:
2771 |  |
           case DO:
2772 |  |
           case DOUBLE:
2773 |  |
           case FALSE:
2774 |  |
           case FINAL:
2775 |  |
           case FLOAT:
2776 |  |
           case FOR:
2777 |  |
           case IF:
2778 |  |
           case INT:
2779 |  |
           case INTERFACE:
2780 |  |
           case LONG:
2781 |  |
           case NEW:
2782 |  |
           case NULL:
2783 |  |
           case RETURN:
2784 |  |
           case SHORT:
2785 |  |
           case SUPER:
2786 |  |
           case SWITCH:
2787 |  |
           case SYNCHRONIZED:
2788 |  |
           case THIS:
2789 |  |
           case THROW:
2790 |  |
           case TRUE:
2791 |  |
           case TRY:
2792 |  |
           case VOID:
2793 |  |
           case WHILE:
2794 |  |
           case ASSERT:
2795 |  |
           case INTEGER_LITERAL:
2796 |  |
           case FLOATING_POINT_LITERAL:
2797 |  |
           case CHARACTER_LITERAL:
2798 |  |
           case STRING_LITERAL:
2799 |  |
           case IDENTIFIER:
2800 |  |
           case LPAREN:
2801 |  |
           case LBRACE:
2802 |  |
           case SEMICOLON:
2803 |  |
           case INCR:
2804 |  |
           case DECR:
2805 |  |
             ;
2806 | 10392 |
             break;
2807 |  |
           default:
2808 | 6160 |
             jj_la1[104] = jj_gen;
2809 | 6160 |
             break label_45;
2810 |  |
           }
2811 | 10392 |
           BlockStatement();
2812 |  |
         }
2813 | 6160 |
         jj_consume_token(RBRACE);
2814 |  |
       }
2815 |  |
2816 | 4934 |
       final public void Method_Block() throws ParseException {
2817 | 4934 |
         jj_consume_token(LBRACE);
2818 | 4934 |
         label_46:
2819 |  |
         while (true) {
2820 | 14932 |
           switch (jj_nt.kind) {
2821 |  |
           case BOOLEAN:
2822 |  |
           case BREAK:
2823 |  |
           case BYTE:
2824 |  |
           case CHAR:
2825 |  |
           case CLASS:
2826 |  |
           case CONTINUE:
2827 |  |
           case DO:
2828 |  |
           case DOUBLE:
2829 |  |
           case FALSE:
2830 |  |
           case FINAL:
2831 |  |
           case FLOAT:
2832 |  |
           case FOR:
2833 |  |
           case IF:
2834 |  |
           case INT:
2835 |  |
           case INTERFACE:
2836 |  |
           case LONG:
2837 |  |
           case NEW:
2838 |  |
           case NULL:
2839 |  |
           case RETURN:
2840 |  |
           case SHORT:
2841 |  |
           case SUPER:
2842 |  |
           case SWITCH:
2843 |  |
           case SYNCHRONIZED:
2844 |  |
           case THIS:
2845 |  |
           case THROW:
2846 |  |
           case TRUE:
2847 |  |
           case TRY:
2848 |  |
           case VOID:
2849 |  |
           case WHILE:
2850 |  |
           case ASSERT:
2851 |  |
           case INTEGER_LITERAL:
2852 |  |
           case FLOATING_POINT_LITERAL:
2853 |  |
           case CHARACTER_LITERAL:
2854 |  |
           case STRING_LITERAL:
2855 |  |
           case IDENTIFIER:
2856 |  |
           case LPAREN:
2857 |  |
           case LBRACE:
2858 |  |
           case SEMICOLON:
2859 |  |
           case INCR:
2860 |  |
           case DECR:
2861 |  |
             ;
2862 | 9998 |
             break;
2863 |  |
           default:
2864 | 4934 |
             jj_la1[105] = jj_gen;
2865 | 4934 |
             break label_46;
2866 |  |
           }
2867 | 9998 |
           Method_BlockStatement();
2868 |  |
         }
2869 | 4934 |
         jj_consume_token(RBRACE);
2870 | 4934 |
         switch (jj_nt.kind) {
2871 |  |
         case SEMICOLON:
2872 | 32 |
           jj_consume_token(SEMICOLON);
2873 | 32 |
           break;
2874 |  |
         default:
2875 | 4902 |
           jj_la1[106] = jj_gen;
2876 |  |
           ;
2877 |  |
         }
2878 |  |
       }
2879 |  |
2880 |  |
     /**
2881 |  |
      * @todo not sure if the UnmodifiedClassDeclaration/UnmodifiedInterfaceDeclaration
2882 |  |
      * ever get called, now that we have two different blocks. It would be nice to remove them
2883 |  |
      */
2884 | 10976 |
       final public void BlockStatement() throws ParseException {
2885 | 10976 |
         if (jj_2_29(2147483647)) {
2886 | 2064 |
           LocalVariableDeclaration();
2887 | 2064 |
           jj_consume_token(SEMICOLON);
2888 |  |
         } else {
2889 | 8912 |
           switch (jj_nt.kind) {
2890 |  |
           case BOOLEAN:
2891 |  |
           case BREAK:
2892 |  |
           case BYTE:
2893 |  |
           case CHAR:
2894 |  |
           case CONTINUE:
2895 |  |
           case DO:
2896 |  |
           case DOUBLE:
2897 |  |
           case FALSE:
2898 |  |
           case FLOAT:
2899 |  |
           case FOR:
2900 |  |
           case IF:
2901 |  |
           case INT:
2902 |  |
           case LONG:
2903 |  |
           case NEW:
2904 |  |
           case NULL:
2905 |  |
           case RETURN:
2906 |  |
           case SHORT:
2907 |  |
           case SUPER:
2908 |  |
           case SWITCH:
2909 |  |
           case SYNCHRONIZED:
2910 |  |
           case THIS:
2911 |  |
           case THROW:
2912 |  |
           case TRUE:
2913 |  |
           case TRY:
2914 |  |
           case VOID:
2915 |  |
           case WHILE:
2916 |  |
           case ASSERT:
2917 |  |
           case INTEGER_LITERAL:
2918 |  |
           case FLOATING_POINT_LITERAL:
2919 |  |
           case CHARACTER_LITERAL:
2920 |  |
           case STRING_LITERAL:
2921 |  |
           case IDENTIFIER:
2922 |  |
           case LPAREN:
2923 |  |
           case LBRACE:
2924 |  |
           case SEMICOLON:
2925 |  |
           case INCR:
2926 |  |
           case DECR:
2927 | 8912 |
             Statement();
2928 | 8912 |
             break;
2929 |  |
           case CLASS:
2930 | 0 |
          pushAndGet();
2931 | 0 |
             UnmodifiedClassDeclaration();
2932 | 0 |
          popAndAddInner();
2933 | 0 |
             break;
2934 |  |
           case INTERFACE:
2935 | 0 |
          pushAndGet();
2936 | 0 |
             UnmodifiedInterfaceDeclaration();
2937 | 0 |
          popAndAddInner();
2938 | 0 |
             break;
2939 |  |
           default:
2940 | 0 |
             jj_la1[107] = jj_gen;
2941 | 0 |
             jj_consume_token(-1);
2942 | 0 |
             throw new ParseException();
2943 |  |
           }
2944 |  |
         }
2945 |  |
       }
2946 |  |
2947 | 9998 |
       final public void Method_BlockStatement() throws ParseException {
2948 | 9998 |
         if (jj_2_30(2147483647)) {
2949 | 1486 |
           LocalVariableDeclaration();
2950 | 1486 |
           jj_consume_token(SEMICOLON);
2951 |  |
         } else {
2952 | 8512 |
           switch (jj_nt.kind) {
2953 |  |
           case BOOLEAN:
2954 |  |
           case BREAK:
2955 |  |
           case BYTE:
2956 |  |
           case CHAR:
2957 |  |
           case CONTINUE:
2958 |  |
           case DO:
2959 |  |
           case DOUBLE:
2960 |  |
           case FALSE:
2961 |  |
           case FLOAT:
2962 |  |
           case FOR:
2963 |  |
           case IF:
2964 |  |
           case INT:
2965 |  |
           case LONG:
2966 |  |
           case NEW:
2967 |  |
           case NULL:
2968 |  |
           case RETURN:
2969 |  |
           case SHORT:
2970 |  |
           case SUPER:
2971 |  |
           case SWITCH:
2972 |  |
           case SYNCHRONIZED:
2973 |  |
           case THIS:
2974 |  |
           case THROW:
2975 |  |
           case TRUE:
2976 |  |
           case TRY:
2977 |  |
           case VOID:
2978 |  |
           case WHILE:
2979 |  |
           case ASSERT:
2980 |  |
           case INTEGER_LITERAL:
2981 |  |
           case FLOATING_POINT_LITERAL:
2982 |  |
           case CHARACTER_LITERAL:
2983 |  |
           case STRING_LITERAL:
2984 |  |
           case IDENTIFIER:
2985 |  |
           case LPAREN:
2986 |  |
           case LBRACE:
2987 |  |
           case SEMICOLON:
2988 |  |
           case INCR:
2989 |  |
           case DECR:
2990 | 8480 |
             Statement();
2991 | 8480 |
             break;
2992 |  |
           case CLASS:
2993 | 32 |
          pushAndGet();
2994 | 32 |
             UnmodifiedClassDeclaration();
2995 | 32 |
          popAndAddInner();
2996 | 32 |
             break;
2997 |  |
           case INTERFACE:
2998 | 0 |
          pushAndGet();
2999 | 0 |
             UnmodifiedInterfaceDeclaration();
3000 | 0 |
          popAndAddInner();
3001 | 0 |
             break;
3002 |  |
           default:
3003 | 0 |
             jj_la1[108] = jj_gen;
3004 | 0 |
             jj_consume_token(-1);
3005 | 0 |
             throw new ParseException();
3006 |  |
           }
3007 |  |
         }
3008 |  |
       }
3009 |  |
3010 | 4446 |
       final public void LocalVariableDeclaration() throws ParseException {
3011 | 4446 |
         switch (jj_nt.kind) {
3012 |  |
         case FINAL:
3013 | 102 |
           jj_consume_token(FINAL);
3014 | 102 |
           break;
3015 |  |
         default:
3016 | 4344 |
           jj_la1[109] = jj_gen;
3017 |  |
           ;
3018 |  |
         }
3019 | 4446 |
         Type();
3020 | 4446 |
         VariableDeclarator();
3021 | 4446 |
         label_47:
3022 |  |
         while (true) {
3023 | 4446 |
           switch (jj_nt.kind) {
3024 |  |
           case COMMA:
3025 |  |
             ;
3026 | 0 |
             break;
3027 |  |
           default:
3028 | 4446 |
             jj_la1[110] = jj_gen;
3029 | 4446 |
             break label_47;
3030 |  |
           }
3031 | 0 |
           jj_consume_token(COMMA);
3032 | 0 |
           VariableDeclarator();
3033 |  |
         }
3034 |  |
       }
3035 |  |
3036 | 0 |
       final public void EmptyStatement() throws ParseException {
3037 | 0 |
         jj_consume_token(SEMICOLON);
3038 |  |
       }
3039 |  |
3040 | 7876 |
       final public void StatementExpression() throws ParseException {
3041 | 7876 |
         switch (jj_nt.kind) {
3042 |  |
         case INCR:
3043 | 4 |
           PreIncrementExpression();
3044 | 4 |
           break;
3045 |  |
         case DECR:
3046 | 0 |
           PreDecrementExpression();
3047 | 0 |
           break;
3048 |  |
         case BOOLEAN:
3049 |  |
         case BYTE:
3050 |  |
         case CHAR:
3051 |  |
         case DOUBLE:
3052 |  |
         case FALSE:
3053 |  |
         case FLOAT:
3054 |  |
         case INT:
3055 |  |
         case LONG:
3056 |  |
         case NEW:
3057 |  |
         case NULL:
3058 |  |
         case SHORT:
3059 |  |
         case SUPER:
3060 |  |
         case THIS:
3061 |  |
         case TRUE:
3062 |  |
         case VOID:
3063 |  |
         case INTEGER_LITERAL:
3064 |  |
         case FLOATING_POINT_LITERAL:
3065 |  |
         case CHARACTER_LITERAL:
3066 |  |
         case STRING_LITERAL:
3067 |  |
         case IDENTIFIER:
3068 |  |
         case LPAREN:
3069 | 7872 |
           PrimaryExpression();
3070 | 7872 |
           switch (jj_nt.kind) {
3071 |  |
           case ASSIGN:
3072 |  |
           case INCR:
3073 |  |
           case DECR:
3074 |  |
           case PLUSASSIGN:
3075 |  |
           case MINUSASSIGN:
3076 |  |
           case STARASSIGN:
3077 |  |
           case SLASHASSIGN:
3078 |  |
           case ANDASSIGN:
3079 |  |
           case ORASSIGN:
3080 |  |
           case XORASSIGN:
3081 |  |
           case REMASSIGN:
3082 |  |
           case LSHIFTASSIGN:
3083 |  |
           case RSIGNEDSHIFTASSIGN:
3084 |  |
           case RUNSIGNEDSHIFTASSIGN:
3085 | 4278 |
             switch (jj_nt.kind) {
3086 |  |
             case INCR:
3087 | 262 |
               jj_consume_token(INCR);
3088 | 262 |
               break;
3089 |  |
             case DECR:
3090 | 0 |
               jj_consume_token(DECR);
3091 | 0 |
               break;
3092 |  |
             case ASSIGN:
3093 |  |
             case PLUSASSIGN:
3094 |  |
             case MINUSASSIGN:
3095 |  |
             case STARASSIGN:
3096 |  |
             case SLASHASSIGN:
3097 |  |
             case ANDASSIGN:
3098 |  |
             case ORASSIGN:
3099 |  |
             case XORASSIGN:
3100 |  |
             case REMASSIGN:
3101 |  |
             case LSHIFTASSIGN:
3102 |  |
             case RSIGNEDSHIFTASSIGN:
3103 |  |
             case RUNSIGNEDSHIFTASSIGN:
3104 | 4016 |
               AssignmentOperator();
3105 | 4016 |
               Expression();
3106 | 4016 |
               break;
3107 |  |
             default:
3108 | 0 |
               jj_la1[111] = jj_gen;
3109 | 0 |
               jj_consume_token(-1);
3110 | 0 |
               throw new ParseException();
3111 |  |
             }
3112 | 4278 |
             break;
3113 |  |
           default:
3114 | 3594 |
             jj_la1[112] = jj_gen;
3115 |  |
             ;
3116 |  |
           }
3117 | 7872 |
           break;
3118 |  |
         default:
3119 | 0 |
           jj_la1[113] = jj_gen;
3120 | 0 |
           jj_consume_token(-1);
3121 | 0 |
           throw new ParseException();
3122 |  |
         }
3123 |  |
       }
3124 |  |
3125 | 0 |
       final public void SwitchStatement() throws ParseException {
3126 | 0 |
         jj_consume_token(SWITCH);
3127 | 0 |
         jj_consume_token(LPAREN);
3128 | 0 |
         Expression();
3129 | 0 |
         jj_consume_token(RPAREN);
3130 | 0 |
         jj_consume_token(LBRACE);
3131 | 0 |
         label_48:
3132 |  |
         while (true) {
3133 | 0 |
           switch (jj_nt.kind) {
3134 |  |
           case CASE:
3135 |  |
           case _DEFAULT:
3136 |  |
             ;
3137 | 0 |
             break;
3138 |  |
           default:
3139 | 0 |
             jj_la1[114] = jj_gen;
3140 | 0 |
             break label_48;
3141 |  |
           }
3142 | 0 |
           SwitchLabel();
3143 | 0 |
           label_49:
3144 |  |
           while (true) {
3145 | 0 |
             switch (jj_nt.kind) {
3146 |  |
             case BOOLEAN:
3147 |  |
             case BREAK:
3148 |  |
             case BYTE:
3149 |  |
             case CHAR:
3150 |  |
             case CLASS:
3151 |  |
             case CONTINUE:
3152 |  |
             case DO:
3153 |  |
             case DOUBLE:
3154 |  |
             case FALSE:
3155 |  |
             case FINAL:
3156 |  |
             case FLOAT:
3157 |  |
             case FOR:
3158 |  |
             case IF:
3159 |  |
             case INT:
3160 |  |
             case INTERFACE:
3161 |  |
             case LONG:
3162 |  |
             case NEW:
3163 |  |
             case NULL:
3164 |  |
             case RETURN:
3165 |  |
             case SHORT:
3166 |  |
             case SUPER:
3167 |  |
             case SWITCH:
3168 |  |
             case SYNCHRONIZED:
3169 |  |
             case THIS:
3170 |  |
             case THROW:
3171 |  |
             case TRUE:
3172 |  |
             case TRY:
3173 |  |
             case VOID:
3174 |  |
             case WHILE:
3175 |  |
             case ASSERT:
3176 |  |
             case INTEGER_LITERAL:
3177 |  |
             case FLOATING_POINT_LITERAL:
3178 |  |
             case CHARACTER_LITERAL:
3179 |  |
             case STRING_LITERAL:
3180 |  |
             case IDENTIFIER:
3181 |  |
             case LPAREN:
3182 |  |
             case LBRACE:
3183 |  |
             case SEMICOLON:
3184 |  |
             case INCR:
3185 |  |
             case DECR:
3186 |  |
               ;
3187 | 0 |
               break;
3188 |  |
             default:
3189 | 0 |
               jj_la1[115] = jj_gen;
3190 | 0 |
               break label_49;
3191 |  |
             }
3192 | 0 |
             BlockStatement();
3193 |  |
           }
3194 |  |
         }
3195 | 0 |
         jj_consume_token(RBRACE);
3196 |  |
       }
3197 |  |
3198 | 0 |
       final public void SwitchLabel() throws ParseException {
3199 | 0 |
         switch (jj_nt.kind) {
3200 |  |
         case CASE:
3201 | 0 |
           jj_consume_token(CASE);
3202 | 0 |
           Expression();
3203 | 0 |
           jj_consume_token(COLON);
3204 | 0 |
           break;
3205 |  |
         case _DEFAULT:
3206 | 0 |
           jj_consume_token(_DEFAULT);
3207 | 0 |
           jj_consume_token(COLON);
3208 | 0 |
           break;
3209 |  |
         default:
3210 | 0 |
           jj_la1[116] = jj_gen;
3211 | 0 |
           jj_consume_token(-1);
3212 | 0 |
           throw new ParseException();
3213 |  |
         }
3214 |  |
       }
3215 |  |
3216 | 3904 |
       final public void IfStatement() throws ParseException {
3217 | 3904 |
         jj_consume_token(IF);
3218 | 3904 |
         jj_consume_token(LPAREN);
3219 | 3904 |
         Expression();
3220 | 3904 |
         jj_consume_token(RPAREN);
3221 | 3904 |
         Statement();
3222 | 3904 |
         switch (jj_nt.kind) {
3223 |  |
         case ELSE:
3224 | 1136 |
           jj_consume_token(ELSE);
3225 | 1136 |
           Statement();
3226 | 1136 |
           break;
3227 |  |
         default:
3228 | 2768 |
           jj_la1[117] = jj_gen;
3229 |  |
           ;
3230 |  |
         }
3231 |  |
       }
3232 |  |
3233 | 326 |
       final public void WhileStatement() throws ParseException {
3234 | 326 |
         jj_consume_token(WHILE);
3235 | 326 |
         jj_consume_token(LPAREN);
3236 | 326 |
         Expression();
3237 | 326 |
         jj_consume_token(RPAREN);
3238 | 326 |
         Statement();
3239 |  |
       }
3240 |  |
3241 | 44 |
       final public void DoStatement() throws ParseException {
3242 | 44 |
         jj_consume_token(DO);
3243 | 44 |
         Statement();
3244 | 44 |
         jj_consume_token(WHILE);
3245 | 44 |
         jj_consume_token(LPAREN);
3246 | 44 |
         Expression();
3247 | 44 |
         jj_consume_token(RPAREN);
3248 | 44 |
         jj_consume_token(SEMICOLON);
3249 |  |
       }
3250 |  |
3251 | 900 |
       final public void ForStatement() throws ParseException {
3252 | 900 |
         jj_consume_token(FOR);
3253 | 900 |
         jj_consume_token(LPAREN);
3254 | 900 |
         switch (jj_nt.kind) {
3255 |  |
         case BOOLEAN:
3256 |  |
         case BYTE:
3257 |  |
         case CHAR:
3258 |  |
         case DOUBLE:
3259 |  |
         case FALSE:
3260 |  |
         case FINAL:
3261 |  |
         case FLOAT:
3262 |  |
         case INT:
3263 |  |
         case LONG:
3264 |  |
         case NEW:
3265 |  |
         case NULL:
3266 |  |
         case SHORT:
3267 |  |
         case SUPER:
3268 |  |
         case THIS:
3269 |  |
         case TRUE:
3270 |  |
         case VOID:
3271 |  |
         case INTEGER_LITERAL:
3272 |  |
         case FLOATING_POINT_LITERAL:
3273 |  |
         case CHARACTER_LITERAL:
3274 |  |
         case STRING_LITERAL:
3275 |  |
         case IDENTIFIER:
3276 |  |
         case LPAREN:
3277 |  |
         case INCR:
3278 |  |
         case DECR:
3279 | 900 |
           ForInit();
3280 | 900 |
           break;
3281 |  |
         default:
3282 | 0 |
           jj_la1[118] = jj_gen;
3283 |  |
           ;
3284 |  |
         }
3285 | 900 |
         jj_consume_token(SEMICOLON);
3286 | 900 |
         switch (jj_nt.kind) {
3287 |  |
         case BOOLEAN:
3288 |  |
         case BYTE:
3289 |  |
         case CHAR:
3290 |  |
         case DOUBLE:
3291 |  |
         case FALSE:
3292 |  |
         case FLOAT:
3293 |  |
         case INT:
3294 |  |
         case LONG:
3295 |  |
         case NEW:
3296 |  |
         case NULL:
3297 |  |
         case SHORT:
3298 |  |
         case SUPER:
3299 |  |
         case THIS:
3300 |  |
         case TRUE:
3301 |  |
         case VOID:
3302 |  |
         case INTEGER_LITERAL:
3303 |  |
         case FLOATING_POINT_LITERAL:
3304 |  |
         case CHARACTER_LITERAL:
3305 |  |
         case STRING_LITERAL:
3306 |  |
         case IDENTIFIER:
3307 |  |
         case LPAREN:
3308 |  |
         case BANG:
3309 |  |
         case TILDE:
3310 |  |
         case INCR:
3311 |  |
         case DECR:
3312 |  |
         case PLUS:
3313 |  |
         case MINUS:
3314 | 900 |
           Expression();
3315 | 900 |
           break;
3316 |  |
         default:
3317 | 0 |
           jj_la1[119] = jj_gen;
3318 |  |
           ;
3319 |  |
         }
3320 | 900 |
         jj_consume_token(SEMICOLON);
3321 | 900 |
         switch (jj_nt.kind) {
3322 |  |
         case BOOLEAN:
3323 |  |
         case BYTE:
3324 |  |
         case CHAR:
3325 |  |
         case DOUBLE:
3326 |  |
         case FALSE:
3327 |  |
         case FLOAT:
3328 |  |
         case INT:
3329 |  |
         case LONG:
3330 |  |
         case NEW:
3331 |  |
         case NULL:
3332 |  |
         case SHORT:
3333 |  |
         case SUPER:
3334 |  |
         case THIS:
3335 |  |
         case TRUE:
3336 |  |
         case VOID:
3337 |  |
         case INTEGER_LITERAL:
3338 |  |
         case FLOATING_POINT_LITERAL:
3339 |  |
         case CHARACTER_LITERAL:
3340 |  |
         case STRING_LITERAL:
3341 |  |
         case IDENTIFIER:
3342 |  |
         case LPAREN:
3343 |  |
         case INCR:
3344 |  |
         case DECR:
3345 | 160 |
           ForUpdate();
3346 | 160 |
           break;
3347 |  |
         default:
3348 | 740 |
           jj_la1[120] = jj_gen;
3349 |  |
           ;
3350 |  |
         }
3351 | 900 |
         jj_consume_token(RPAREN);
3352 | 900 |
         Statement();
3353 |  |
       }
3354 |  |
3355 | 900 |
       final public void ForInit() throws ParseException {
3356 | 900 |
         if (jj_2_31(2147483647)) {
3357 | 896 |
           LocalVariableDeclaration();
3358 |  |
         } else {
3359 | 4 |
           switch (jj_nt.kind) {
3360 |  |
           case BOOLEAN:
3361 |  |
           case BYTE:
3362 |  |
           case CHAR:
3363 |  |
           case DOUBLE:
3364 |  |
           case FALSE:
3365 |  |
           case FLOAT:
3366 |  |
           case INT:
3367 |  |
           case LONG:
3368 |  |
           case NEW:
3369 |  |
           case NULL:
3370 |  |
           case SHORT:
3371 |  |
           case SUPER:
3372 |  |
           case THIS:
3373 |  |
           case TRUE:
3374 |  |
           case VOID:
3375 |  |
           case INTEGER_LITERAL:
3376 |  |
           case FLOATING_POINT_LITERAL:
3377 |  |
           case CHARACTER_LITERAL:
3378 |  |
           case STRING_LITERAL:
3379 |  |
           case IDENTIFIER:
3380 |  |
           case LPAREN:
3381 |  |
           case INCR:
3382 |  |
           case DECR:
3383 | 4 |
             StatementExpressionList();
3384 | 4 |
             break;
3385 |  |
           default:
3386 | 0 |
             jj_la1[121] = jj_gen;
3387 | 0 |
             jj_consume_token(-1);
3388 | 0 |
             throw new ParseException();
3389 |  |
           }
3390 |  |
         }
3391 |  |
       }
3392 |  |
3393 | 164 |
       final public void StatementExpressionList() throws ParseException {
3394 | 164 |
         StatementExpression();
3395 | 164 |
         label_50:
3396 |  |
         while (true) {
3397 | 164 |
           switch (jj_nt.kind) {
3398 |  |
           case COMMA:
3399 |  |
             ;
3400 | 0 |
             break;
3401 |  |
           default:
3402 | 164 |
             jj_la1[122] = jj_gen;
3403 | 164 |
             break label_50;
3404 |  |
           }
3405 | 0 |
           jj_consume_token(COMMA);
3406 | 0 |
           StatementExpression();
3407 |  |
         }
3408 |  |
       }
3409 |  |
3410 | 160 |
       final public void ForUpdate() throws ParseException {
3411 | 160 |
         StatementExpressionList();
3412 |  |
       }
3413 |  |
3414 | 74 |
       final public void BreakStatement() throws ParseException {
3415 | 74 |
         jj_consume_token(BREAK);
3416 | 74 |
         switch (jj_nt.kind) {
3417 |  |
         case IDENTIFIER:
3418 | 0 |
           jj_consume_token(IDENTIFIER);
3419 | 0 |
           break;
3420 |  |
         default:
3421 | 74 |
           jj_la1[123] = jj_gen;
3422 |  |
           ;
3423 |  |
         }
3424 | 74 |
         jj_consume_token(SEMICOLON);
3425 |  |
       }
3426 |  |
3427 | 12 |
       final public void ContinueStatement() throws ParseException {
3428 | 12 |
         jj_consume_token(CONTINUE);
3429 | 12 |
         switch (jj_nt.kind) {
3430 |  |
         case IDENTIFIER:
3431 | 0 |
           jj_consume_token(IDENTIFIER);
3432 | 0 |
           break;
3433 |  |
         default:
3434 | 12 |
           jj_la1[124] = jj_gen;
3435 |  |
           ;
3436 |  |
         }
3437 | 12 |
         jj_consume_token(SEMICOLON);
3438 |  |
       }
3439 |  |
3440 | 4060 |
       final public void ReturnStatement() throws ParseException {
3441 | 4060 |
         jj_consume_token(RETURN);
3442 | 4060 |
         switch (jj_nt.kind) {
3443 |  |
         case BOOLEAN:
3444 |  |
         case BYTE:
3445 |  |
         case CHAR:
3446 |  |
         case DOUBLE:
3447 |  |
         case FALSE:
3448 |  |
         case FLOAT:
3449 |  |
         case INT:
3450 |  |
         case LONG:
3451 |  |
         case NEW:
3452 |  |
         case NULL:
3453 |  |
         case SHORT:
3454 |  |
         case SUPER:
3455 |  |
         case THIS:
3456 |  |
         case TRUE:
3457 |  |
         case VOID:
3458 |  |
         case INTEGER_LITERAL:
3459 |  |
         case FLOATING_POINT_LITERAL:
3460 |  |
         case CHARACTER_LITERAL:
3461 |  |
         case STRING_LITERAL:
3462 |  |
         case IDENTIFIER:
3463 |  |
         case LPAREN:
3464 |  |
         case BANG:
3465 |  |
         case TILDE:
3466 |  |
         case INCR:
3467 |  |
         case DECR:
3468 |  |
         case PLUS:
3469 |  |
         case MINUS:
3470 | 3946 |
           Expression();
3471 | 3946 |
           break;
3472 |  |
         default:
3473 | 114 |
           jj_la1[125] = jj_gen;
3474 |  |
           ;
3475 |  |
         }
3476 | 4060 |
         jj_consume_token(SEMICOLON);
3477 |  |
       }
3478 |  |
3479 | 652 |
       final public void ThrowStatement() throws ParseException {
3480 | 652 |
         jj_consume_token(THROW);
3481 | 652 |
         Expression();
3482 | 652 |
         jj_consume_token(SEMICOLON);
3483 |  |
       }
3484 |  |
3485 | 0 |
       final public void SynchronizedStatement() throws ParseException {
3486 | 0 |
         jj_consume_token(SYNCHRONIZED);
3487 | 0 |
         jj_consume_token(LPAREN);
3488 | 0 |
         Expression();
3489 | 0 |
         jj_consume_token(RPAREN);
3490 | 0 |
         Block();
3491 |  |
       }
3492 |  |
3493 | 134 |
       final public void TryStatement() throws ParseException {
3494 | 134 |
         jj_consume_token(TRY);
3495 | 134 |
         Block();
3496 | 134 |
         label_51:
3497 |  |
         while (true) {
3498 | 308 |
           switch (jj_nt.kind) {
3499 |  |
           case CATCH:
3500 |  |
             ;
3501 | 174 |
             break;
3502 |  |
           default:
3503 | 134 |
             jj_la1[126] = jj_gen;
3504 | 134 |
             break label_51;
3505 |  |
           }
3506 | 174 |
           jj_consume_token(CATCH);
3507 | 174 |
           jj_consume_token(LPAREN);
3508 | 174 |
           FormalParameter(null);
3509 | 174 |
           jj_consume_token(RPAREN);
3510 | 174 |
           Block();
3511 |  |
         }
3512 | 134 |
         switch (jj_nt.kind) {
3513 |  |
         case FINALLY:
3514 | 0 |
           jj_consume_token(FINALLY);
3515 | 0 |
           Block();
3516 | 0 |
           break;
3517 |  |
         default:
3518 | 134 |
           jj_la1[127] = jj_gen;
3519 |  |
           ;
3520 |  |
         }
3521 |  |
       }
3522 |  |
3523 | 64 |
       final public void AssertStatement() throws ParseException {
3524 | 64 |
         jj_consume_token(ASSERT);
3525 | 64 |
         Expression();
3526 | 64 |
         switch (jj_nt.kind) {
3527 |  |
         case COLON:
3528 | 32 |
           jj_consume_token(COLON);
3529 | 32 |
           Expression();
3530 | 32 |
           break;
3531 |  |
         default:
3532 | 32 |
           jj_la1[128] = jj_gen;
3533 |  |
           ;
3534 |  |
         }
3535 | 64 |
         jj_consume_token(SEMICOLON);
3536 |  |
       }
3537 |  |
3538 | 712 |
       final private boolean jj_2_1(int xla) {
3539 | 712 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3540 | 712 |
         boolean retval = !jj_3_1();
3541 | 712 |
         jj_save(0, xla);
3542 | 712 |
         return retval;
3543 |  |
       }
3544 |  |
3545 | 7564 |
       final private boolean jj_2_2(int xla) {
3546 | 7564 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3547 | 7564 |
         boolean retval = !jj_3_2();
3548 | 7564 |
         jj_save(1, xla);
3549 | 7564 |
         return retval;
3550 |  |
       }
3551 |  |
3552 | 7532 |
       final private boolean jj_2_3(int xla) {
3553 | 7532 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3554 | 7532 |
         boolean retval = !jj_3_3();
3555 | 7532 |
         jj_save(2, xla);
3556 | 7532 |
         return retval;
3557 |  |
       }
3558 |  |
3559 | 7424 |
       final private boolean jj_2_4(int xla) {
3560 | 7424 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3561 | 7424 |
         boolean retval = !jj_3_4();
3562 | 7424 |
         jj_save(3, xla);
3563 | 7424 |
         return retval;
3564 |  |
       }
3565 |  |
3566 | 7416 |
       final private boolean jj_2_5(int xla) {
3567 | 7416 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3568 | 7416 |
         boolean retval = !jj_3_5();
3569 | 7416 |
         jj_save(4, xla);
3570 | 7416 |
         return retval;
3571 |  |
       }
3572 |  |
3573 | 6950 |
       final private boolean jj_2_6(int xla) {
3574 | 6950 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3575 | 6950 |
         boolean retval = !jj_3_6();
3576 | 6950 |
         jj_save(5, xla);
3577 | 6950 |
         return retval;
3578 |  |
       }
3579 |  |
3580 | 3344 |
       final private boolean jj_2_7(int xla) {
3581 | 3344 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3582 | 3344 |
         boolean retval = !jj_3_7();
3583 | 3344 |
         jj_save(6, xla);
3584 | 3344 |
         return retval;
3585 |  |
       }
3586 |  |
3587 | 3324 |
       final private boolean jj_2_8(int xla) {
3588 | 3324 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3589 | 3324 |
         boolean retval = !jj_3_8();
3590 | 3324 |
         jj_save(7, xla);
3591 | 3324 |
         return retval;
3592 |  |
       }
3593 |  |
3594 | 3304 |
       final private boolean jj_2_9(int xla) {
3595 | 3304 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3596 | 3304 |
         boolean retval = !jj_3_9();
3597 | 3304 |
         jj_save(8, xla);
3598 | 3304 |
         return retval;
3599 |  |
       }
3600 |  |
3601 | 228 |
       final private boolean jj_2_10(int xla) {
3602 | 228 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3603 | 228 |
         boolean retval = !jj_3_10();
3604 | 228 |
         jj_save(9, xla);
3605 | 228 |
         return retval;
3606 |  |
       }
3607 |  |
3608 | 466 |
       final private boolean jj_2_11(int xla) {
3609 | 466 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3610 | 466 |
         boolean retval = !jj_3_11();
3611 | 466 |
         jj_save(10, xla);
3612 | 466 |
         return retval;
3613 |  |
       }
3614 |  |
3615 | 140 |
       final private boolean jj_2_12(int xla) {
3616 | 140 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3617 | 140 |
         boolean retval = !jj_3_12();
3618 | 140 |
         jj_save(11, xla);
3619 | 140 |
         return retval;
3620 |  |
       }
3621 |  |
3622 | 180 |
       final private boolean jj_2_13(int xla) {
3623 | 180 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3624 | 180 |
         boolean retval = !jj_3_13();
3625 | 180 |
         jj_save(12, xla);
3626 | 180 |
         return retval;
3627 |  |
       }
3628 |  |
3629 | 68354 |
       final private boolean jj_2_14(int xla) {
3630 | 68354 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3631 | 68354 |
         boolean retval = !jj_3_14();
3632 | 68354 |
         jj_save(13, xla);
3633 | 68354 |
         return retval;
3634 |  |
       }
3635 |  |
3636 | 40110 |
       final private boolean jj_2_15(int xla) {
3637 | 40110 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3638 | 40110 |
         boolean retval = !jj_3_15();
3639 | 40110 |
         jj_save(14, xla);
3640 | 40110 |
         return retval;
3641 |  |
       }
3642 |  |
3643 | 0 |
       final private boolean jj_2_16(int xla) {
3644 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3645 | 0 |
         boolean retval = !jj_3_16();
3646 | 0 |
         jj_save(15, xla);
3647 | 0 |
         return retval;
3648 |  |
       }
3649 |  |
3650 | 0 |
       final private boolean jj_2_17(int xla) {
3651 | 0 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3652 | 0 |
         boolean retval = !jj_3_17();
3653 | 0 |
         jj_save(16, xla);
3654 | 0 |
         return retval;
3655 |  |
       }
3656 |  |
3657 | 1532 |
       final private boolean jj_2_18(int xla) {
3658 | 1532 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3659 | 1532 |
         boolean retval = !jj_3_18();
3660 | 1532 |
         jj_save(17, xla);
3661 | 1532 |
         return retval;
3662 |  |
       }
3663 |  |
3664 | 65064 |
       final private boolean jj_2_19(int xla) {
3665 | 65064 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3666 | 65064 |
         boolean retval = !jj_3_19();
3667 | 65064 |
         jj_save(18, xla);
3668 | 65064 |
         return retval;
3669 |  |
       }
3670 |  |
3671 | 32828 |
       final private boolean jj_2_20(int xla) {
3672 | 32828 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3673 | 32828 |
         boolean retval = !jj_3_20();
3674 | 32828 |
         jj_save(19, xla);
3675 | 32828 |
         return retval;
3676 |  |
       }
3677 |  |
3678 | 18610 |
       final private boolean jj_2_21(int xla) {
3679 | 18610 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3680 | 18610 |
         boolean retval = !jj_3_21();
3681 | 18610 |
         jj_save(20, xla);
3682 | 18610 |
         return retval;
3683 |  |
       }
3684 |  |
3685 | 18610 |
       final private boolean jj_2_22(int xla) {
3686 | 18610 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3687 | 18610 |
         boolean retval = !jj_3_22();
3688 | 18610 |
         jj_save(21, xla);
3689 | 18610 |
         return retval;
3690 |  |
       }
3691 |  |
3692 | 18610 |
       final private boolean jj_2_23(int xla) {
3693 | 18610 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3694 | 18610 |
         boolean retval = !jj_3_23();
3695 | 18610 |
         jj_save(22, xla);
3696 | 18610 |
         return retval;
3697 |  |
       }
3698 |  |
3699 | 2536 |
       final private boolean jj_2_24(int xla) {
3700 | 2536 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3701 | 2536 |
         boolean retval = !jj_3_24();
3702 | 2536 |
         jj_save(23, xla);
3703 | 2536 |
         return retval;
3704 |  |
       }
3705 |  |
3706 | 46 |
       final private boolean jj_2_25(int xla) {
3707 | 46 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3708 | 46 |
         boolean retval = !jj_3_25();
3709 | 46 |
         jj_save(24, xla);
3710 | 46 |
         return retval;
3711 |  |
       }
3712 |  |
3713 | 46 |
       final private boolean jj_2_26(int xla) {
3714 | 46 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3715 | 46 |
         boolean retval = !jj_3_26();
3716 | 46 |
         jj_save(25, xla);
3717 | 46 |
         return retval;
3718 |  |
       }
3719 |  |
3720 | 70 |
       final private boolean jj_2_27(int xla) {
3721 | 70 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3722 | 70 |
         boolean retval = !jj_3_27();
3723 | 70 |
         jj_save(26, xla);
3724 | 70 |
         return retval;
3725 |  |
       }
3726 |  |
3727 | 23702 |
       final private boolean jj_2_28(int xla) {
3728 | 23702 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3729 | 23702 |
         boolean retval = !jj_3_28();
3730 | 23702 |
         jj_save(27, xla);
3731 | 23702 |
         return retval;
3732 |  |
       }
3733 |  |
3734 | 10976 |
       final private boolean jj_2_29(int xla) {
3735 | 10976 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3736 | 10976 |
         boolean retval = !jj_3_29();
3737 | 10976 |
         jj_save(28, xla);
3738 | 10976 |
         return retval;
3739 |  |
       }
3740 |  |
3741 | 9998 |
       final private boolean jj_2_30(int xla) {
3742 | 9998 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3743 | 9998 |
         boolean retval = !jj_3_30();
3744 | 9998 |
         jj_save(29, xla);
3745 | 9998 |
         return retval;
3746 |  |
       }
3747 |  |
3748 | 900 |
       final private boolean jj_2_31(int xla) {
3749 | 900 |
         jj_la = xla; jj_lastpos = jj_scanpos = token;
3750 | 900 |
         boolean retval = !jj_3_31();
3751 | 900 |
         jj_save(30, xla);
3752 | 900 |
         return retval;
3753 |  |
       }
3754 |  |
3755 | 17614 |
       final private boolean jj_3R_170() {
3756 | 17614 |
         Token xsp;
3757 | 17614 |
         xsp = jj_scanpos;
3758 | 17614 |
         if (jj_3R_180()) {
3759 | 17536 |
         jj_scanpos = xsp;
3760 | 17536 |
         if (jj_3R_181()) {
3761 | 17536 |
         jj_scanpos = xsp;
3762 | 17536 |
         if (jj_3R_182()) {
3763 | 17352 |
         jj_scanpos = xsp;
3764 | 17352 |
         if (jj_3R_183()) {
3765 | 16328 |
         jj_scanpos = xsp;
3766 | 16328 |
         if (jj_3R_184()) {
3767 | 16108 |
         jj_scanpos = xsp;
3768 | 16016 |
         if (jj_3R_185()) return true;
3769 | 16 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3770 | 172 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3771 | 998 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3772 | 184 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3773 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3774 | 78 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3775 | 150 |
         return false;
3776 |  |
       }
3777 |  |
3778 | 17614 |
       final private boolean jj_3R_180() {
3779 | 17536 |
         if (jj_scan_token(INTEGER_LITERAL)) return true;
3780 | 78 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3781 | 0 |
         return false;
3782 |  |
       }
3783 |  |
3784 | 10254 |
       final private boolean jj_3R_147() {
3785 | 10254 |
         if (jj_scan_token(NATIVE)) return true;
3786 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3787 | 0 |
         return false;
3788 |  |
       }
3789 |  |
3790 | 63358 |
       final private boolean jj_3R_132() {
3791 | 47342 |
         if (jj_3R_64()) return true;
3792 | 15978 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3793 | 38 |
         return false;
3794 |  |
       }
3795 |  |
3796 | 48 |
       final private boolean jj_3R_164() {
3797 | 48 |
         if (jj_scan_token(SUPER)) return true;
3798 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3799 | 0 |
         return false;
3800 |  |
       }
3801 |  |
3802 | 65918 |
       final private boolean jj_3R_131() {
3803 | 63358 |
         if (jj_scan_token(DOT)) return true;
3804 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3805 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
3806 | 2536 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3807 | 24 |
         return false;
3808 |  |
       }
3809 |  |
3810 | 66002 |
       final private boolean jj_3R_130() {
3811 | 65918 |
         if (jj_scan_token(LBRACKET)) return true;
3812 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3813 | 0 |
         if (jj_3R_70()) return true;
3814 | 84 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3815 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
3816 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3817 | 0 |
         return false;
3818 |  |
       }
3819 |  |
3820 | 7424 |
       final private boolean jj_3R_95() {
3821 | 7424 |
         if (jj_scan_token(STRICTFP)) return true;
3822 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3823 | 0 |
         return false;
3824 |  |
       }
3825 |  |
3826 | 84624 |
       final private boolean jj_3_23() {
3827 | 79504 |
         if (jj_scan_token(DOT)) return true;
3828 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3829 | 5096 |
         if (jj_3R_69()) return true;
3830 | 24 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3831 | 0 |
         return false;
3832 |  |
       }
3833 |  |
3834 | 7532 |
       final private boolean jj_3R_88() {
3835 | 7532 |
         if (jj_scan_token(STRICTFP)) return true;
3836 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3837 | 0 |
         return false;
3838 |  |
       }
3839 |  |
3840 | 0 |
       final private boolean jj_3R_332() {
3841 | 0 |
         if (jj_scan_token(STRICTFP)) return true;
3842 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3843 | 0 |
         return false;
3844 |  |
       }
3845 |  |
3846 | 12514 |
       final private boolean jj_3R_146() {
3847 | 10254 |
         if (jj_scan_token(FINAL)) return true;
3848 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3849 | 2260 |
         return false;
3850 |  |
       }
3851 |  |
3852 | 48 |
       final private boolean jj_3R_163() {
3853 | 48 |
         if (jj_scan_token(THIS)) return true;
3854 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3855 | 0 |
         return false;
3856 |  |
       }
3857 |  |
3858 | 84624 |
       final private boolean jj_3_22() {
3859 | 79504 |
         if (jj_scan_token(DOT)) return true;
3860 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3861 | 5120 |
         if (jj_scan_token(SUPER)) return true;
3862 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3863 | 0 |
         return false;
3864 |  |
       }
3865 |  |
3866 | 32828 |
       final private boolean jj_3_20() {
3867 | 0 |
         if (jj_3R_68()) return true;
3868 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3869 | 32762 |
         if (jj_scan_token(DOT)) return true;
3870 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3871 | 12 |
         if (jj_scan_token(CLASS)) return true;
3872 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3873 | 54 |
         return false;
3874 |  |
       }
3875 |  |
3876 | 0 |
       final private boolean jj_3R_331() {
3877 | 0 |
         if (jj_scan_token(PRIVATE)) return true;
3878 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3879 | 0 |
         return false;
3880 |  |
       }
3881 |  |
3882 | 84624 |
       final private boolean jj_3_21() {
3883 | 79504 |
         if (jj_scan_token(DOT)) return true;
3884 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3885 | 5120 |
         if (jj_scan_token(THIS)) return true;
3886 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3887 | 0 |
         return false;
3888 |  |
       }
3889 |  |
3890 | 66014 |
       final private boolean jj_3R_67() {
3891 | 66014 |
         Token xsp;
3892 | 66014 |
         xsp = jj_scanpos;
3893 | 66014 |
         if (jj_3_21()) {
3894 | 66014 |
         jj_scanpos = xsp;
3895 | 66014 |
         if (jj_3_22()) {
3896 | 66014 |
         jj_scanpos = xsp;
3897 | 66014 |
         if (jj_3_23()) {
3898 | 66002 |
         jj_scanpos = xsp;
3899 | 66002 |
         if (jj_3R_130()) {
3900 | 65918 |
         jj_scanpos = xsp;
3901 | 65918 |
         if (jj_3R_131()) {
3902 | 63358 |
         jj_scanpos = xsp;
3903 | 47342 |
         if (jj_3R_132()) return true;
3904 | 15978 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3905 | 2536 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3906 | 84 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3907 | 12 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3908 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3909 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3910 | 62 |
         return false;
3911 |  |
       }
3912 |  |
3913 | 0 |
       final private boolean jj_3R_330() {
3914 | 0 |
         if (jj_scan_token(PROTECTED)) return true;
3915 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3916 | 0 |
         return false;
3917 |  |
       }
3918 |  |
3919 | 9854 |
       final private boolean jj_3R_94() {
3920 | 7424 |
         if (jj_scan_token(PRIVATE)) return true;
3921 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3922 | 2430 |
         return false;
3923 |  |
       }
3924 |  |
3925 | 10112 |
       final private boolean jj_3R_157() {
3926 | 9458 |
         if (jj_3R_57()) return true;
3927 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3928 | 654 |
         return false;
3929 |  |
       }
3930 |  |
3931 | 9962 |
       final private boolean jj_3R_87() {
3932 | 7532 |
         if (jj_scan_token(PRIVATE)) return true;
3933 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3934 | 2430 |
         return false;
3935 |  |
       }
3936 |  |
3937 | 66014 |
       final private boolean jj_3_19() {
3938 | 47342 |
         if (jj_3R_67()) return true;
3939 | 18610 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3940 | 62 |
         return false;
3941 |  |
       }
3942 |  |
3943 | 0 |
       final private boolean jj_3R_329() {
3944 | 0 |
         if (jj_scan_token(PUBLIC)) return true;
3945 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3946 | 0 |
         return false;
3947 |  |
       }
3948 |  |
3949 | 15586 |
       final private boolean jj_3R_156() {
3950 | 9458 |
         if (jj_3R_68()) return true;
3951 | 5474 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3952 | 654 |
         if (jj_scan_token(DOT)) return true;
3953 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3954 | 0 |
         if (jj_scan_token(CLASS)) return true;
3955 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3956 | 0 |
         return false;
3957 |  |
       }
3958 |  |
3959 | 12528 |
       final private boolean jj_3R_145() {
3960 | 12514 |
         if (jj_scan_token(ABSTRACT)) return true;
3961 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3962 | 14 |
         return false;
3963 |  |
       }
3964 |  |
3965 | 15824 |
       final private boolean jj_3R_155() {
3966 | 15586 |
         if (jj_3R_69()) return true;
3967 | 166 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3968 | 72 |
         return false;
3969 |  |
       }
3970 |  |
3971 | 710 |
       final private boolean jj_3R_430() {
3972 | 710 |
         if (jj_scan_token(DECR)) return true;
3973 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3974 | 0 |
         return false;
3975 |  |
       }
3976 |  |
3977 | 0 |
       final private boolean jj_3R_328() {
3978 | 0 |
         if (jj_scan_token(FINAL)) return true;
3979 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3980 | 0 |
         return false;
3981 |  |
       }
3982 |  |
3983 | 1512 |
       final private boolean jj_3R_162() {
3984 | 48 |
         if (jj_scan_token(IDENTIFIER)) return true;
3985 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3986 | 1464 |
         return false;
3987 |  |
       }
3988 |  |
3989 | 15824 |
       final private boolean jj_3R_154() {
3990 | 15824 |
         if (jj_scan_token(LPAREN)) return true;
3991 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3992 | 0 |
         if (jj_3R_70()) return true;
3993 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3994 | 0 |
         if (jj_scan_token(RPAREN)) return true;
3995 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3996 | 0 |
         return false;
3997 |  |
       }
3998 |  |
3999 | 15824 |
       final private boolean jj_3R_153() {
4000 | 15544 |
         if (jj_scan_token(SUPER)) return true;
4001 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4002 | 280 |
         if (jj_scan_token(DOT)) return true;
4003 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4004 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
4005 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4006 | 0 |
         return false;
4007 |  |
       }
4008 |  |
4009 | 0 |
       final private boolean jj_3R_327() {
4010 | 0 |
         if (jj_scan_token(ABSTRACT)) return true;
4011 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4012 | 0 |
         return false;
4013 |  |
       }
4014 |  |
4015 | 15980 |
       final private boolean jj_3R_152() {
4016 | 15824 |
         if (jj_scan_token(THIS)) return true;
4017 | 132 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4018 | 24 |
         return false;
4019 |  |
       }
4020 |  |
4021 | 10248 |
       final private boolean jj_3R_93() {
4022 | 9854 |
         if (jj_scan_token(PROTECTED)) return true;
4023 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4024 | 394 |
         return false;
4025 |  |
       }
4026 |  |
4027 | 1512 |
       final private boolean jj_3R_161() {
4028 | 1512 |
         if (jj_scan_token(LPAREN)) return true;
4029 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4030 | 0 |
         return false;
4031 |  |
       }
4032 |  |
4033 | 710 |
       final private boolean jj_3R_429() {
4034 | 710 |
         if (jj_scan_token(INCR)) return true;
4035 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4036 | 0 |
         return false;
4037 |  |
       }
4038 |  |
4039 | 710 |
       final private boolean jj_3R_423() {
4040 | 710 |
         Token xsp;
4041 | 710 |
         xsp = jj_scanpos;
4042 | 710 |
         if (jj_3R_429()) {
4043 | 710 |
         jj_scanpos = xsp;
4044 | 710 |
         if (jj_3R_430()) return true;
4045 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4046 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4047 | 0 |
         return false;
4048 |  |
       }
4049 |  |
4050 | 17566 |
       final private boolean jj_3R_151() {
4051 | 15980 |
         if (jj_3R_170()) return true;
4052 | 1448 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4053 | 138 |
         return false;
4054 |  |
       }
4055 |  |
4056 | 17566 |
       final private boolean jj_3R_118() {
4057 | 17566 |
         Token xsp;
4058 | 17566 |
         xsp = jj_scanpos;
4059 | 17566 |
         if (jj_3R_151()) {
4060 | 15980 |
         jj_scanpos = xsp;
4061 | 15980 |
         if (jj_3R_152()) {
4062 | 15824 |
         jj_scanpos = xsp;
4063 | 15824 |
         if (jj_3R_153()) {
4064 | 15824 |
         jj_scanpos = xsp;
4065 | 15824 |
         if (jj_3R_154()) {
4066 | 15824 |
         jj_scanpos = xsp;
4067 | 15824 |
         if (jj_3R_155()) {
4068 | 15586 |
         jj_scanpos = xsp;
4069 | 15586 |
         if (jj_3R_156()) {
4070 | 10112 |
         jj_scanpos = xsp;
4071 | 9458 |
         if (jj_3R_157()) return true;
4072 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4073 | 5474 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4074 | 166 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4075 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4076 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4077 | 132 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4078 | 1448 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4079 | 888 |
         return false;
4080 |  |
       }
4081 |  |
4082 | 0 |
       final private boolean jj_3R_326() {
4083 | 0 |
         if (jj_scan_token(STATIC)) return true;
4084 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4085 | 0 |
         return false;
4086 |  |
       }
4087 |  |
4088 | 0 |
       final private boolean jj_3R_295() {
4089 | 0 |
         Token xsp;
4090 | 0 |
         xsp = jj_scanpos;
4091 | 0 |
         if (jj_3R_326()) {
4092 | 0 |
         jj_scanpos = xsp;
4093 | 0 |
         if (jj_3R_327()) {
4094 | 0 |
         jj_scanpos = xsp;
4095 | 0 |
         if (jj_3R_328()) {
4096 | 0 |
         jj_scanpos = xsp;
4097 | 0 |
         if (jj_3R_329()) {
4098 | 0 |
         jj_scanpos = xsp;
4099 | 0 |
         if (jj_3R_330()) {
4100 | 0 |
         jj_scanpos = xsp;
4101 | 0 |
         if (jj_3R_331()) {
4102 | 0 |
         jj_scanpos = xsp;
4103 | 0 |
         if (jj_3R_332()) return true;
4104 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4105 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4106 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4107 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4108 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4109 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4110 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4111 | 0 |
         return false;
4112 |  |
       }
4113 |  |
4114 | 12882 |
       final private boolean jj_3R_144() {
4115 | 12528 |
         if (jj_scan_token(STATIC)) return true;
4116 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4117 | 354 |
         return false;
4118 |  |
       }
4119 |  |
4120 | 10356 |
       final private boolean jj_3R_86() {
4121 | 9962 |
         if (jj_scan_token(PROTECTED)) return true;
4122 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4123 | 394 |
         return false;
4124 |  |
       }
4125 |  |
4126 | 0 |
       final private boolean jj_3R_281() {
4127 | 0 |
         Token xsp;
4128 | 0 |
         while (true) {
4129 | 0 |
           xsp = jj_scanpos;
4130 | 0 |
           if (jj_3R_295()) { jj_scanpos = xsp; break; }
4131 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4132 |  |
         }
4133 | 0 |
         if (jj_3R_191()) return true;
4134 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4135 | 0 |
         return false;
4136 |  |
       }
4137 |  |
4138 | 1512 |
       final private boolean jj_3R_160() {
4139 | 1512 |
         if (jj_scan_token(BANG)) return true;
4140 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4141 | 0 |
         return false;
4142 |  |
       }
4143 |  |
4144 | 1532 |
       final private boolean jj_3_18() {
4145 | 0 |
         if (jj_scan_token(LPAREN)) return true;
4146 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4147 | 1484 |
         if (jj_3R_66()) return true;
4148 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4149 | 48 |
         return false;
4150 |  |
       }
4151 |  |
4152 | 17566 |
       final private boolean jj_3R_63() {
4153 | 9458 |
         if (jj_3R_118()) return true;
4154 | 7220 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4155 | 888 |
         Token xsp;
4156 | 888 |
         while (true) {
4157 | 950 |
           xsp = jj_scanpos;
4158 | 888 |
           if (jj_3_19()) { jj_scanpos = xsp; break; }
4159 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4160 |  |
         }
4161 | 888 |
         return false;
4162 |  |
       }
4163 |  |
4164 | 14252 |
       final private boolean jj_3R_92() {
4165 | 10248 |
         if (jj_scan_token(PUBLIC)) return true;
4166 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4167 | 4004 |
         return false;
4168 |  |
       }
4169 |  |
4170 | 1512 |
       final private boolean jj_3R_159() {
4171 | 1512 |
         if (jj_scan_token(TILDE)) return true;
4172 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4173 | 0 |
         return false;
4174 |  |
       }
4175 |  |
4176 | 17000 |
       final private boolean jj_3R_397() {
4177 | 17000 |
         if (jj_scan_token(LPAREN)) return true;
4178 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4179 | 0 |
         if (jj_3R_73()) return true;
4180 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4181 | 0 |
         if (jj_scan_token(RPAREN)) return true;
4182 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4183 | 0 |
         if (jj_3R_316()) return true;
4184 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4185 | 0 |
         return false;
4186 |  |
       }
4187 |  |
4188 | 14456 |
       final private boolean jj_3R_85() {
4189 | 10356 |
         if (jj_scan_token(PUBLIC)) return true;
4190 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4191 | 4100 |
         return false;
4192 |  |
       }
4193 |  |
4194 | 15352 |
       final private boolean jj_3R_143() {
4195 | 12882 |
         if (jj_scan_token(PRIVATE)) return true;
4196 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4197 | 2470 |
         return false;
4198 |  |
       }
4199 |  |
4200 | 17058 |
       final private boolean jj_3R_396() {
4201 | 17000 |
         if (jj_scan_token(LPAREN)) return true;
4202 | 58 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4203 | 0 |
         if (jj_3R_73()) return true;
4204 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4205 | 0 |
         if (jj_scan_token(RPAREN)) return true;
4206 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4207 | 0 |
         if (jj_3R_279()) return true;
4208 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4209 | 0 |
         return false;
4210 |  |
       }
4211 |  |
4212 | 17058 |
       final private boolean jj_3R_383() {
4213 | 17058 |
         Token xsp;
4214 | 17058 |
         xsp = jj_scanpos;
4215 | 17058 |
         if (jj_3R_396()) {
4216 | 17000 |
         jj_scanpos = xsp;
4217 | 17000 |
         if (jj_3R_397()) return true;
4218 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4219 | 58 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4220 | 0 |
         return false;
4221 |  |
       }
4222 |  |
4223 | 3018 |
       final private boolean jj_3R_98() {
4224 | 588 |
         if (jj_scan_token(PRIVATE)) return true;
4225 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4226 | 2430 |
         return false;
4227 |  |
       }
4228 |  |
4229 | 16500 |
       final private boolean jj_3R_91() {
4230 | 14252 |
         if (jj_scan_token(FINAL)) return true;
4231 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4232 | 2248 |
         return false;
4233 |  |
       }
4234 |  |
4235 | 0 |
       final private boolean jj_3_17() {
4236 | 0 |
         if (jj_scan_token(LPAREN)) return true;
4237 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4238 | 0 |
         if (jj_3R_57()) return true;
4239 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4240 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
4241 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4242 | 0 |
         return false;
4243 |  |
       }
4244 |  |
4245 | 17000 |
       final private boolean jj_3R_384() {
4246 | 9070 |
         if (jj_3R_63()) return true;
4247 | 7220 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4248 | 710 |
         Token xsp;
4249 | 710 |
         xsp = jj_scanpos;
4250 | 710 |
         if (jj_3R_423()) jj_scanpos = xsp;
4251 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4252 | 710 |
         return false;
4253 |  |
       }
4254 |  |
4255 | 16716 |
       final private boolean jj_3R_84() {
4256 | 14456 |
         if (jj_scan_token(FINAL)) return true;
4257 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4258 | 2260 |
         return false;
4259 |  |
       }
4260 |  |
4261 | 15586 |
       final private boolean jj_3R_142() {
4262 | 15352 |
         if (jj_scan_token(PROTECTED)) return true;
4263 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4264 | 234 |
         return false;
4265 |  |
       }
4266 |  |
4267 | 40054 |
       final private boolean jj_3R_121() {
4268 | 37940 |
         if (jj_scan_token(LPAREN)) return true;
4269 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4270 | 84 |
         if (jj_3R_57()) return true;
4271 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4272 | 518 |
         if (jj_scan_token(RPAREN)) return true;
4273 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4274 | 1512 |
         Token xsp;
4275 | 1512 |
         xsp = jj_scanpos;
4276 | 1512 |
         if (jj_3R_159()) {
4277 | 1512 |
         jj_scanpos = xsp;
4278 | 1512 |
         if (jj_3R_160()) {
4279 | 1512 |
         jj_scanpos = xsp;
4280 | 1512 |
         if (jj_3R_161()) {
4281 | 1512 |
         jj_scanpos = xsp;
4282 | 1512 |
         if (jj_3R_162()) {
4283 | 48 |
         jj_scanpos = xsp;
4284 | 48 |
         if (jj_3R_163()) {
4285 | 48 |
         jj_scanpos = xsp;
4286 | 48 |
         if (jj_3R_164()) {
4287 | 48 |
         jj_scanpos = xsp;
4288 | 48 |
         if (jj_3R_165()) {
4289 | 48 |
         jj_scanpos = xsp;
4290 | 36 |
         if (jj_3R_166()) return true;
4291 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4292 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4293 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4294 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4295 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4296 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4297 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4298 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4299 | 1476 |
         return false;
4300 |  |
       }
4301 |  |
4302 | 3412 |
       final private boolean jj_3R_97() {
4303 | 3018 |
         if (jj_scan_token(PROTECTED)) return true;
4304 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4305 | 394 |
         return false;
4306 |  |
       }
4307 |  |
4308 | 40062 |
       final private boolean jj_3R_120() {
4309 | 37940 |
         if (jj_scan_token(LPAREN)) return true;
4310 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4311 | 84 |
         if (jj_3R_57()) return true;
4312 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4313 | 2030 |
         if (jj_scan_token(LBRACKET)) return true;
4314 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4315 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
4316 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4317 | 8 |
         return false;
4318 |  |
       }
4319 |  |
4320 | 16514 |
       final private boolean jj_3R_90() {
4321 | 16500 |
         if (jj_scan_token(ABSTRACT)) return true;
4322 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4323 | 14 |
         return false;
4324 |  |
       }
4325 |  |
4326 | 40110 |
       final private boolean jj_3_16() {
4327 | 37940 |
         if (jj_scan_token(LPAREN)) return true;
4328 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4329 | 2122 |
         if (jj_3R_66()) return true;
4330 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4331 | 48 |
         return false;
4332 |  |
       }
4333 |  |
4334 | 40110 |
       final private boolean jj_3R_65() {
4335 | 40110 |
         Token xsp;
4336 | 40110 |
         xsp = jj_scanpos;
4337 | 40110 |
         if (jj_3_16()) {
4338 | 40062 |
         jj_scanpos = xsp;
4339 | 40062 |
         if (jj_3R_120()) {
4340 | 40054 |
         jj_scanpos = xsp;
4341 | 38578 |
         if (jj_3R_121()) return true;
4342 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4343 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4344 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4345 | 1532 |
         return false;
4346 |  |
       }
4347 |  |
4348 | 40110 |
       final private boolean jj_3_15() {
4349 | 38578 |
         if (jj_3R_65()) return true;
4350 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4351 | 1532 |
         return false;
4352 |  |
       }
4353 |  |
4354 | 16734 |
       final private boolean jj_3R_83() {
4355 | 16716 |
         if (jj_scan_token(ABSTRACT)) return true;
4356 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4357 | 18 |
         return false;
4358 |  |
       }
4359 |  |
4360 | 19708 |
       final private boolean jj_3R_141() {
4361 | 15586 |
         if (jj_scan_token(PUBLIC)) return true;
4362 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4363 | 4122 |
         return false;
4364 |  |
       }
4365 |  |
4366 | 19708 |
       final private boolean jj_3R_99() {
4367 | 19708 |
         Token xsp;
4368 | 19708 |
         xsp = jj_scanpos;
4369 | 19708 |
         if (jj_3R_141()) {
4370 | 15586 |
         jj_scanpos = xsp;
4371 | 15586 |
         if (jj_3R_142()) {
4372 | 15352 |
         jj_scanpos = xsp;
4373 | 15352 |
         if (jj_3R_143()) {
4374 | 12882 |
         jj_scanpos = xsp;
4375 | 12882 |
         if (jj_3R_144()) {
4376 | 12528 |
         jj_scanpos = xsp;
4377 | 12528 |
         if (jj_3R_145()) {
4378 | 12514 |
         jj_scanpos = xsp;
4379 | 12514 |
         if (jj_3R_146()) {
4380 | 10254 |
         jj_scanpos = xsp;
4381 | 10254 |
         if (jj_3R_147()) {
4382 | 10254 |
         jj_scanpos = xsp;
4383 | 10254 |
         if (jj_3R_148()) {
4384 | 10254 |
         jj_scanpos = xsp;
4385 | 10254 |
         if (jj_3R_149()) return true;
4386 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4387 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4388 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4389 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4390 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4391 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4392 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4393 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4394 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4395 | 9454 |
         return false;
4396 |  |
       }
4397 |  |
4398 | 17058 |
       final private boolean jj_3R_382() {
4399 | 17058 |
         if (jj_scan_token(BANG)) return true;
4400 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4401 | 0 |
         return false;
4402 |  |
       }
4403 |  |
4404 | 6950 |
       final private boolean jj_3_6() {
4405 | 2002 |
         if (jj_3R_58()) return true;
4406 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4407 | 4948 |
         return false;
4408 |  |
       }
4409 |  |
4410 | 7416 |
       final private boolean jj_3R_96() {
4411 | 3412 |
         if (jj_scan_token(PUBLIC)) return true;
4412 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4413 | 4004 |
         return false;
4414 |  |
       }
4415 |  |
4416 | 7416 |
       final private boolean jj_3R_56() {
4417 | 7416 |
         Token xsp;
4418 | 7416 |
         xsp = jj_scanpos;
4419 | 7416 |
         if (jj_3R_96()) {
4420 | 3412 |
         jj_scanpos = xsp;
4421 | 3412 |
         if (jj_3R_97()) {
4422 | 3018 |
         jj_scanpos = xsp;
4423 | 588 |
         if (jj_3R_98()) return true;
4424 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4425 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4426 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4427 | 6828 |
         return false;
4428 |  |
       }
4429 |  |
4430 | 10254 |
       final private boolean jj_3R_58() {
4431 | 10254 |
         Token xsp;
4432 | 10254 |
         while (true) {
4433 | 19708 |
           xsp = jj_scanpos;
4434 | 10254 |
           if (jj_3R_99()) { jj_scanpos = xsp; break; }
4435 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4436 |  |
         }
4437 | 0 |
         if (jj_3R_68()) return true;
4438 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4439 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
4440 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4441 | 2054 |
         if (jj_scan_token(LPAREN)) return true;
4442 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4443 | 8200 |
         return false;
4444 |  |
       }
4445 |  |
4446 | 17000 |
       final private boolean jj_3R_368() {
4447 | 9070 |
         if (jj_3R_384()) return true;
4448 | 7220 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4449 | 710 |
         return false;
4450 |  |
       }
4451 |  |
4452 | 7416 |
       final private boolean jj_3_5() {
4453 | 7416 |
         Token xsp;
4454 | 7416 |
         xsp = jj_scanpos;
4455 | 588 |
         if (jj_3R_56()) jj_scanpos = xsp;
4456 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4457 | 4280 |
         if (jj_3R_57()) return true;
4458 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4459 | 2670 |
         if (jj_scan_token(LPAREN)) return true;
4460 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4461 | 466 |
         return false;
4462 |  |
       }
4463 |  |
4464 | 710 |
       final private boolean jj_3R_380() {
4465 | 710 |
         if (jj_scan_token(REM)) return true;
4466 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4467 | 0 |
         return false;
4468 |  |
       }
4469 |  |
4470 | 16856 |
       final private boolean jj_3R_55() {
4471 | 16856 |
         Token xsp;
4472 | 16856 |
         xsp = jj_scanpos;
4473 | 16856 |
         if (jj_3R_89()) {
4474 | 16514 |
         jj_scanpos = xsp;
4475 | 16514 |
         if (jj_3R_90()) {
4476 | 16500 |
         jj_scanpos = xsp;
4477 | 16500 |
         if (jj_3R_91()) {
4478 | 14252 |
         jj_scanpos = xsp;
4479 | 14252 |
         if (jj_3R_92()) {
4480 | 10248 |
         jj_scanpos = xsp;
4481 | 10248 |
         if (jj_3R_93()) {
4482 | 9854 |
         jj_scanpos = xsp;
4483 | 9854 |
         if (jj_3R_94()) {
4484 | 7424 |
         jj_scanpos = xsp;
4485 | 7424 |
         if (jj_3R_95()) return true;
4486 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4487 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4488 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4489 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4490 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4491 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4492 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4493 | 9432 |
         return false;
4494 |  |
       }
4495 |  |
4496 | 16856 |
       final private boolean jj_3R_89() {
4497 | 16514 |
         if (jj_scan_token(STATIC)) return true;
4498 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4499 | 342 |
         return false;
4500 |  |
       }
4501 |  |
4502 | 17058 |
       final private boolean jj_3R_381() {
4503 | 17058 |
         if (jj_scan_token(TILDE)) return true;
4504 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4505 | 0 |
         return false;
4506 |  |
       }
4507 |  |
4508 | 17058 |
       final private boolean jj_3R_367() {
4509 | 17000 |
         if (jj_3R_383()) return true;
4510 | 58 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4511 | 0 |
         return false;
4512 |  |
       }
4513 |  |
4514 | 7424 |
       final private boolean jj_3_4() {
4515 | 7424 |
         Token xsp;
4516 | 7424 |
         while (true) {
4517 | 16856 |
           xsp = jj_scanpos;
4518 | 7424 |
           if (jj_3R_55()) { jj_scanpos = xsp; break; }
4519 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4520 |  |
         }
4521 | 7416 |
         if (jj_scan_token(INTERFACE)) return true;
4522 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4523 | 8 |
         return false;
4524 |  |
       }
4525 |  |
4526 | 710 |
       final private boolean jj_3R_365() {
4527 | 710 |
         if (jj_scan_token(MINUS)) return true;
4528 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4529 | 0 |
         return false;
4530 |  |
       }
4531 |  |
4532 | 17108 |
       final private boolean jj_3R_54() {
4533 | 17108 |
         Token xsp;
4534 | 17108 |
         xsp = jj_scanpos;
4535 | 17108 |
         if (jj_3R_82()) {
4536 | 16734 |
         jj_scanpos = xsp;
4537 | 16734 |
         if (jj_3R_83()) {
4538 | 16716 |
         jj_scanpos = xsp;
4539 | 16716 |
         if (jj_3R_84()) {
4540 | 14456 |
         jj_scanpos = xsp;
4541 | 14456 |
         if (jj_3R_85()) {
4542 | 10356 |
         jj_scanpos = xsp;
4543 | 10356 |
         if (jj_3R_86()) {
4544 | 9962 |
         jj_scanpos = xsp;
4545 | 9962 |
         if (jj_3R_87()) {
4546 | 7532 |
         jj_scanpos = xsp;
4547 | 7532 |
         if (jj_3R_88()) return true;
4548 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4549 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4550 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4551 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4552 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4553 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4554 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4555 | 9576 |
         return false;
4556 |  |
       }
4557 |  |
4558 | 17108 |
       final private boolean jj_3R_82() {
4559 | 16734 |
         if (jj_scan_token(STATIC)) return true;
4560 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4561 | 374 |
         return false;
4562 |  |
       }
4563 |  |
4564 | 17058 |
       final private boolean jj_3R_366() {
4565 | 17058 |
         Token xsp;
4566 | 17058 |
         xsp = jj_scanpos;
4567 | 17058 |
         if (jj_3R_381()) {
4568 | 17058 |
         jj_scanpos = xsp;
4569 | 17058 |
         if (jj_3R_382()) return true;
4570 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4571 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4572 | 0 |
         if (jj_3R_279()) return true;
4573 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4574 | 0 |
         return false;
4575 |  |
       }
4576 |  |
4577 | 17058 |
       final private boolean jj_3R_316() {
4578 | 17058 |
         Token xsp;
4579 | 17058 |
         xsp = jj_scanpos;
4580 | 17058 |
         if (jj_3R_366()) {
4581 | 17058 |
         jj_scanpos = xsp;
4582 | 17058 |
         if (jj_3R_367()) {
4583 | 17000 |
         jj_scanpos = xsp;
4584 | 9070 |
         if (jj_3R_368()) return true;
4585 | 7220 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4586 | 58 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4587 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4588 | 710 |
         return false;
4589 |  |
       }
4590 |  |
4591 | 0 |
       final private boolean jj_3R_277() {
4592 | 0 |
         if (jj_3R_284()) return true;
4593 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4594 | 0 |
         return false;
4595 |  |
       }
4596 |  |
4597 | 7532 |
       final private boolean jj_3_3() {
4598 | 7532 |
         Token xsp;
4599 | 7532 |
         while (true) {
4600 | 17108 |
           xsp = jj_scanpos;
4601 | 7532 |
           if (jj_3R_54()) { jj_scanpos = xsp; break; }
4602 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4603 |  |
         }
4604 | 7424 |
         if (jj_scan_token(CLASS)) return true;
4605 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4606 | 108 |
         return false;
4607 |  |
       }
4608 |  |
4609 | 710 |
       final private boolean jj_3R_379() {
4610 | 710 |
         if (jj_scan_token(SLASH)) return true;
4611 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4612 | 0 |
         return false;
4613 |  |
       }
4614 |  |
4615 | 710 |
       final private boolean jj_3R_313() {
4616 | 710 |
         if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
4617 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4618 | 0 |
         return false;
4619 |  |
       }
4620 |  |
4621 | 0 |
       final private boolean jj_3R_276() {
4622 | 0 |
         if (jj_3R_283()) return true;
4623 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4624 | 0 |
         return false;
4625 |  |
       }
4626 |  |
4627 | 710 |
       final private boolean jj_3R_364() {
4628 | 710 |
         if (jj_scan_token(PLUS)) return true;
4629 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4630 | 0 |
         return false;
4631 |  |
       }
4632 |  |
4633 | 0 |
       final private boolean jj_3R_275() {
4634 | 0 |
         if (jj_3R_282()) return true;
4635 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4636 | 0 |
         return false;
4637 |  |
       }
4638 |  |
4639 | 17058 |
       final private boolean jj_3R_254() {
4640 | 17058 |
         if (jj_scan_token(DECR)) return true;
4641 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4642 | 0 |
         if (jj_3R_63()) return true;
4643 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4644 | 0 |
         return false;
4645 |  |
       }
4646 |  |
4647 | 710 |
       final private boolean jj_3R_310() {
4648 | 710 |
         Token xsp;
4649 | 710 |
         xsp = jj_scanpos;
4650 | 710 |
         if (jj_3R_364()) {
4651 | 710 |
         jj_scanpos = xsp;
4652 | 710 |
         if (jj_3R_365()) return true;
4653 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4654 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4655 | 0 |
         if (jj_3R_272()) return true;
4656 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4657 | 0 |
         return false;
4658 |  |
       }
4659 |  |
4660 | 710 |
       final private boolean jj_3R_289() {
4661 | 710 |
         if (jj_scan_token(GE)) return true;
4662 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4663 | 0 |
         return false;
4664 |  |
       }
4665 |  |
4666 | 710 |
       final private boolean jj_3R_378() {
4667 | 710 |
         if (jj_scan_token(STAR)) return true;
4668 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4669 | 0 |
         return false;
4670 |  |
       }
4671 |  |
4672 | 0 |
       final private boolean jj_3R_274() {
4673 | 0 |
         if (jj_3R_281()) return true;
4674 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4675 | 0 |
         return false;
4676 |  |
       }
4677 |  |
4678 | 710 |
       final private boolean jj_3R_363() {
4679 | 710 |
         Token xsp;
4680 | 710 |
         xsp = jj_scanpos;
4681 | 710 |
         if (jj_3R_378()) {
4682 | 710 |
         jj_scanpos = xsp;
4683 | 710 |
         if (jj_3R_379()) {
4684 | 710 |
         jj_scanpos = xsp;
4685 | 710 |
         if (jj_3R_380()) return true;
4686 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4687 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4688 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4689 | 0 |
         if (jj_3R_279()) return true;
4690 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4691 | 0 |
         return false;
4692 |  |
       }
4693 |  |
4694 | 710 |
       final private boolean jj_3R_312() {
4695 | 710 |
         if (jj_scan_token(RSIGNEDSHIFT)) return true;
4696 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4697 | 0 |
         return false;
4698 |  |
       }
4699 |  |
4700 | 0 |
       final private boolean jj_3R_273() {
4701 | 0 |
         if (jj_3R_280()) return true;
4702 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4703 | 0 |
         return false;
4704 |  |
       }
4705 |  |
4706 | 17058 |
       final private boolean jj_3R_253() {
4707 | 17058 |
         if (jj_scan_token(INCR)) return true;
4708 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4709 | 0 |
         if (jj_3R_63()) return true;
4710 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4711 | 0 |
         return false;
4712 |  |
       }
4713 |  |
4714 | 710 |
       final private boolean jj_3R_288() {
4715 | 710 |
         if (jj_scan_token(LE)) return true;
4716 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4717 | 0 |
         return false;
4718 |  |
       }
4719 |  |
4720 | 7564 |
       final private boolean jj_3_2() {
4721 | 7532 |
         if (jj_3R_53()) return true;
4722 | 32 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4723 | 0 |
         return false;
4724 |  |
       }
4725 |  |
4726 | 0 |
       final private boolean jj_3R_268() {
4727 | 0 |
         Token xsp;
4728 | 0 |
         xsp = jj_scanpos;
4729 | 0 |
         if (jj_3_2()) {
4730 | 0 |
         jj_scanpos = xsp;
4731 | 0 |
         if (jj_3R_273()) {
4732 | 0 |
         jj_scanpos = xsp;
4733 | 0 |
         if (jj_3R_274()) {
4734 | 0 |
         jj_scanpos = xsp;
4735 | 0 |
         if (jj_3R_275()) {
4736 | 0 |
         jj_scanpos = xsp;
4737 | 0 |
         if (jj_3R_276()) {
4738 | 0 |
         jj_scanpos = xsp;
4739 | 0 |
         if (jj_3R_277()) return true;
4740 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4741 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4742 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4743 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4744 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4745 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4746 | 0 |
         return false;
4747 |  |
       }
4748 |  |
4749 | 17058 |
       final private boolean jj_3R_315() {
4750 | 17058 |
         if (jj_scan_token(MINUS)) return true;
4751 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4752 | 0 |
         return false;
4753 |  |
       }
4754 |  |
4755 | 710 |
       final private boolean jj_3R_311() {
4756 | 710 |
         if (jj_scan_token(LSHIFT)) return true;
4757 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4758 | 0 |
         return false;
4759 |  |
       }
4760 |  |
4761 | 17058 |
       final private boolean jj_3R_293() {
4762 | 9070 |
         if (jj_3R_316()) return true;
4763 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4764 | 710 |
         return false;
4765 |  |
       }
4766 |  |
4767 | 710 |
       final private boolean jj_3R_285() {
4768 | 710 |
         Token xsp;
4769 | 710 |
         xsp = jj_scanpos;
4770 | 710 |
         if (jj_3R_311()) {
4771 | 710 |
         jj_scanpos = xsp;
4772 | 710 |
         if (jj_3R_312()) {
4773 | 710 |
         jj_scanpos = xsp;
4774 | 710 |
         if (jj_3R_313()) return true;
4775 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4776 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4777 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4778 | 0 |
         if (jj_3R_267()) return true;
4779 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4780 | 0 |
         return false;
4781 |  |
       }
4782 |  |
4783 | 710 |
       final private boolean jj_3R_287() {
4784 | 710 |
         if (jj_scan_token(GT)) return true;
4785 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4786 | 0 |
         return false;
4787 |  |
       }
4788 |  |
4789 | 17058 |
       final private boolean jj_3R_292() {
4790 | 17058 |
         if (jj_3R_254()) return true;
4791 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4792 | 0 |
         return false;
4793 |  |
       }
4794 |  |
4795 | 17058 |
       final private boolean jj_3R_314() {
4796 | 17058 |
         if (jj_scan_token(PLUS)) return true;
4797 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4798 | 0 |
         return false;
4799 |  |
       }
4800 |  |
4801 | 710 |
       final private boolean jj_3R_227() {
4802 | 710 |
         if (jj_scan_token(ORASSIGN)) return true;
4803 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4804 | 0 |
         return false;
4805 |  |
       }
4806 |  |
4807 | 17058 |
       final private boolean jj_3R_291() {
4808 | 17058 |
         if (jj_3R_253()) return true;
4809 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4810 | 0 |
         return false;
4811 |  |
       }
4812 |  |
4813 | 17058 |
       final private boolean jj_3R_279() {
4814 | 17058 |
         Token xsp;
4815 | 17058 |
         xsp = jj_scanpos;
4816 | 17058 |
         if (jj_3R_290()) {
4817 | 17058 |
         jj_scanpos = xsp;
4818 | 17058 |
         if (jj_3R_291()) {
4819 | 17058 |
         jj_scanpos = xsp;
4820 | 17058 |
         if (jj_3R_292()) {
4821 | 17058 |
         jj_scanpos = xsp;
4822 | 9070 |
         if (jj_3R_293()) return true;
4823 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4824 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4825 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4826 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4827 | 710 |
         return false;
4828 |  |
       }
4829 |  |
4830 | 17058 |
       final private boolean jj_3R_290() {
4831 | 17058 |
         Token xsp;
4832 | 17058 |
         xsp = jj_scanpos;
4833 | 17058 |
         if (jj_3R_314()) {
4834 | 17058 |
         jj_scanpos = xsp;
4835 | 17058 |
         if (jj_3R_315()) return true;
4836 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4837 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4838 | 0 |
         if (jj_3R_279()) return true;
4839 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4840 | 0 |
         return false;
4841 |  |
       }
4842 |  |
4843 | 710 |
       final private boolean jj_3R_271() {
4844 | 710 |
         if (jj_scan_token(NE)) return true;
4845 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4846 | 0 |
         return false;
4847 |  |
       }
4848 |  |
4849 | 710 |
       final private boolean jj_3R_286() {
4850 | 710 |
         if (jj_scan_token(LT)) return true;
4851 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4852 | 0 |
         return false;
4853 |  |
       }
4854 |  |
4855 | 710 |
       final private boolean jj_3R_278() {
4856 | 710 |
         Token xsp;
4857 | 710 |
         xsp = jj_scanpos;
4858 | 710 |
         if (jj_3R_286()) {
4859 | 710 |
         jj_scanpos = xsp;
4860 | 710 |
         if (jj_3R_287()) {
4861 | 710 |
         jj_scanpos = xsp;
4862 | 710 |
         if (jj_3R_288()) {
4863 | 710 |
         jj_scanpos = xsp;
4864 | 710 |
         if (jj_3R_289()) return true;
4865 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4866 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4867 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4868 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4869 | 0 |
         if (jj_3R_262()) return true;
4870 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4871 | 0 |
         return false;
4872 |  |
       }
4873 |  |
4874 | 0 |
       final private boolean jj_3R_323() {
4875 | 0 |
         if (jj_scan_token(STRICTFP)) return true;
4876 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4877 | 0 |
         return false;
4878 |  |
       }
4879 |  |
4880 | 710 |
       final private boolean jj_3R_226() {
4881 | 710 |
         if (jj_scan_token(XORASSIGN)) return true;
4882 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4883 | 0 |
         return false;
4884 |  |
       }
4885 |  |
4886 | 710 |
       final private boolean jj_3R_269() {
4887 | 710 |
         if (jj_scan_token(INSTANCEOF)) return true;
4888 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4889 | 0 |
         if (jj_3R_73()) return true;
4890 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4891 | 0 |
         return false;
4892 |  |
       }
4893 |  |
4894 | 17058 |
       final private boolean jj_3R_272() {
4895 | 9070 |
         if (jj_3R_279()) return true;
4896 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4897 | 710 |
         Token xsp;
4898 | 710 |
         while (true) {
4899 | 710 |
           xsp = jj_scanpos;
4900 | 710 |
           if (jj_3R_363()) { jj_scanpos = xsp; break; }
4901 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4902 |  |
         }
4903 | 710 |
         return false;
4904 |  |
       }
4905 |  |
4906 | 0 |
       final private boolean jj_3R_322() {
4907 | 0 |
         if (jj_scan_token(PRIVATE)) return true;
4908 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4909 | 0 |
         return false;
4910 |  |
       }
4911 |  |
4912 | 710 |
       final private boolean jj_3R_270() {
4913 | 710 |
         if (jj_scan_token(EQ)) return true;
4914 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4915 | 0 |
         return false;
4916 |  |
       }
4917 |  |
4918 | 710 |
       final private boolean jj_3R_266() {
4919 | 710 |
         Token xsp;
4920 | 710 |
         xsp = jj_scanpos;
4921 | 710 |
         if (jj_3R_270()) {
4922 | 710 |
         jj_scanpos = xsp;
4923 | 710 |
         if (jj_3R_271()) return true;
4924 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4925 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4926 | 0 |
         if (jj_3R_252()) return true;
4927 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4928 | 0 |
         return false;
4929 |  |
       }
4930 |  |
4931 | 710 |
       final private boolean jj_3R_225() {
4932 | 710 |
         if (jj_scan_token(ANDASSIGN)) return true;
4933 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4934 | 0 |
         return false;
4935 |  |
       }
4936 |  |
4937 | 17058 |
       final private boolean jj_3R_267() {
4938 | 9070 |
         if (jj_3R_272()) return true;
4939 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4940 | 710 |
         Token xsp;
4941 | 710 |
         while (true) {
4942 | 710 |
           xsp = jj_scanpos;
4943 | 710 |
           if (jj_3R_310()) { jj_scanpos = xsp; break; }
4944 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4945 |  |
         }
4946 | 710 |
         return false;
4947 |  |
       }
4948 |  |
4949 | 0 |
       final private boolean jj_3R_321() {
4950 | 0 |
         if (jj_scan_token(PROTECTED)) return true;
4951 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4952 | 0 |
         return false;
4953 |  |
       }
4954 |  |
4955 | 0 |
       final private boolean jj_3R_320() {
4956 | 0 |
         if (jj_scan_token(PUBLIC)) return true;
4957 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4958 | 0 |
         return false;
4959 |  |
       }
4960 |  |
4961 | 17058 |
       final private boolean jj_3R_262() {
4962 | 9070 |
         if (jj_3R_267()) return true;
4963 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4964 | 710 |
         Token xsp;
4965 | 710 |
         while (true) {
4966 | 710 |
           xsp = jj_scanpos;
4967 | 710 |
           if (jj_3R_285()) { jj_scanpos = xsp; break; }
4968 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4969 |  |
         }
4970 | 710 |
         return false;
4971 |  |
       }
4972 |  |
4973 | 710 |
       final private boolean jj_3R_261() {
4974 | 710 |
         if (jj_scan_token(BIT_AND)) return true;
4975 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4976 | 0 |
         if (jj_3R_244()) return true;
4977 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4978 | 0 |
         return false;
4979 |  |
       }
4980 |  |
4981 | 0 |
       final private boolean jj_3R_319() {
4982 | 0 |
         if (jj_scan_token(FINAL)) return true;
4983 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4984 | 0 |
         return false;
4985 |  |
       }
4986 |  |
4987 | 710 |
       final private boolean jj_3R_224() {
4988 | 710 |
         if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
4989 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4990 | 0 |
         return false;
4991 |  |
       }
4992 |  |
4993 | 17058 |
       final private boolean jj_3R_258() {
4994 | 9070 |
         if (jj_3R_262()) return true;
4995 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4996 | 710 |
         Token xsp;
4997 | 710 |
         while (true) {
4998 | 710 |
           xsp = jj_scanpos;
4999 | 710 |
           if (jj_3R_278()) { jj_scanpos = xsp; break; }
5000 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5001 |  |
         }
5002 | 710 |
         return false;
5003 |  |
       }
5004 |  |
5005 | 0 |
       final private boolean jj_3R_318() {
5006 | 0 |
         if (jj_scan_token(ABSTRACT)) return true;
5007 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5008 | 0 |
         return false;
5009 |  |
       }
5010 |  |
5011 | 710 |
       final private boolean jj_3R_251() {
5012 | 710 |
         if (jj_scan_token(BIT_OR)) return true;
5013 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5014 | 0 |
         if (jj_3R_196()) return true;
5015 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5016 | 0 |
         return false;
5017 |  |
       }
5018 |  |
5019 | 0 |
       final private boolean jj_3R_317() {
5020 | 0 |
         if (jj_scan_token(STATIC)) return true;
5021 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5022 | 0 |
         return false;
5023 |  |
       }
5024 |  |
5025 | 0 |
       final private boolean jj_3R_294() {
5026 | 0 |
         Token xsp;
5027 | 0 |
         xsp = jj_scanpos;
5028 | 0 |
         if (jj_3R_317()) {
5029 | 0 |
         jj_scanpos = xsp;
5030 | 0 |
         if (jj_3R_318()) {
5031 | 0 |
         jj_scanpos = xsp;
5032 | 0 |
         if (jj_3R_319()) {
5033 | 0 |
         jj_scanpos = xsp;
5034 | 0 |
         if (jj_3R_320()) {
5035 | 0 |
         jj_scanpos = xsp;
5036 | 0 |
         if (jj_3R_321()) {
5037 | 0 |
         jj_scanpos = xsp;
5038 | 0 |
         if (jj_3R_322()) {
5039 | 0 |
         jj_scanpos = xsp;
5040 | 0 |
         if (jj_3R_323()) return true;
5041 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5042 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5043 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5044 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5045 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5046 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5047 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5048 | 0 |
         return false;
5049 |  |
       }
5050 |  |
5051 | 710 |
       final private boolean jj_3R_223() {
5052 | 710 |
         if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
5053 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5054 | 0 |
         return false;
5055 |  |
       }
5056 |  |
5057 | 17058 |
       final private boolean jj_3R_252() {
5058 | 9070 |
         if (jj_3R_258()) return true;
5059 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5060 | 710 |
         Token xsp;
5061 | 710 |
         xsp = jj_scanpos;
5062 | 710 |
         if (jj_3R_269()) jj_scanpos = xsp;
5063 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5064 | 710 |
         return false;
5065 |  |
       }
5066 |  |
5067 | 710 |
       final private boolean jj_3R_257() {
5068 | 710 |
         if (jj_scan_token(XOR)) return true;
5069 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5070 | 0 |
         if (jj_3R_228()) return true;
5071 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5072 | 0 |
         return false;
5073 |  |
       }
5074 |  |
5075 | 0 |
       final private boolean jj_3R_280() {
5076 | 0 |
         Token xsp;
5077 | 0 |
         while (true) {
5078 | 0 |
           xsp = jj_scanpos;
5079 | 0 |
           if (jj_3R_294()) { jj_scanpos = xsp; break; }
5080 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5081 |  |
         }
5082 | 0 |
         if (jj_3R_190()) return true;
5083 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5084 | 0 |
         return false;
5085 |  |
       }
5086 |  |
5087 | 710 |
       final private boolean jj_3R_243() {
5088 | 710 |
         if (jj_scan_token(SC_AND)) return true;
5089 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5090 | 0 |
         if (jj_3R_187()) return true;
5091 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5092 | 0 |
         return false;
5093 |  |
       }
5094 |  |
5095 | 0 |
       final private boolean jj_3R_265() {
5096 | 0 |
         if (jj_3R_268()) return true;
5097 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5098 | 0 |
         return false;
5099 |  |
       }
5100 |  |
5101 | 17058 |
       final private boolean jj_3R_244() {
5102 | 9070 |
         if (jj_3R_252()) return true;
5103 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5104 | 710 |
         Token xsp;
5105 | 710 |
         while (true) {
5106 | 710 |
           xsp = jj_scanpos;
5107 | 710 |
           if (jj_3R_266()) { jj_scanpos = xsp; break; }
5108 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5109 |  |
         }
5110 | 710 |
         return false;
5111 |  |
       }
5112 |  |
5113 | 710 |
       final private boolean jj_3R_215() {
5114 | 710 |
         if (jj_scan_token(SC_OR)) return true;
5115 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5116 | 0 |
         if (jj_3R_175()) return true;
5117 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5118 | 0 |
         return false;
5119 |  |
       }
5120 |  |
5121 | 710 |
       final private boolean jj_3R_222() {
5122 | 710 |
         if (jj_scan_token(LSHIFTASSIGN)) return true;
5123 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5124 | 0 |
         return false;
5125 |  |
       }
5126 |  |
5127 | 72 |
       final private boolean jj_3R_260() {
5128 | 72 |
         if (jj_scan_token(LBRACE)) return true;
5129 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5130 | 0 |
         Token xsp;
5131 | 0 |
         while (true) {
5132 | 0 |
           xsp = jj_scanpos;
5133 | 0 |
           if (jj_3R_265()) { jj_scanpos = xsp; break; }
5134 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5135 |  |
         }
5136 | 0 |
         if (jj_scan_token(RBRACE)) return true;
5137 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5138 | 0 |
         return false;
5139 |  |
       }
5140 |  |
5141 | 17058 |
       final private boolean jj_3R_228() {
5142 | 9070 |
         if (jj_3R_244()) return true;
5143 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5144 | 710 |
         Token xsp;
5145 | 710 |
         while (true) {
5146 | 710 |
           xsp = jj_scanpos;
5147 | 710 |
           if (jj_3R_261()) { jj_scanpos = xsp; break; }
5148 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5149 |  |
         }
5150 | 710 |
         return false;
5151 |  |
       }
5152 |  |
5153 | 710 |
       final private boolean jj_3R_194() {
5154 | 710 |
         if (jj_scan_token(HOOK)) return true;
5155 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5156 | 0 |
         if (jj_3R_70()) return true;
5157 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5158 | 0 |
         if (jj_scan_token(COLON)) return true;
5159 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5160 | 0 |
         if (jj_3R_136()) return true;
5161 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5162 | 0 |
         return false;
5163 |  |
       }
5164 |  |
5165 | 710 |
       final private boolean jj_3R_221() {
5166 | 710 |
         if (jj_scan_token(MINUSASSIGN)) return true;
5167 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5168 | 0 |
         return false;
5169 |  |
       }
5170 |  |
5171 | 17058 |
       final private boolean jj_3R_196() {
5172 | 9070 |
         if (jj_3R_228()) return true;
5173 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5174 | 710 |
         Token xsp;
5175 | 710 |
         while (true) {
5176 | 710 |
           xsp = jj_scanpos;
5177 | 710 |
           if (jj_3R_257()) { jj_scanpos = xsp; break; }
5178 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5179 |  |
         }
5180 | 710 |
         return false;
5181 |  |
       }
5182 |  |
5183 | 710 |
       final private boolean jj_3R_220() {
5184 | 710 |
         if (jj_scan_token(PLUSASSIGN)) return true;
5185 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5186 | 0 |
         return false;
5187 |  |
       }
5188 |  |
5189 | 0 |
       final private boolean jj_3R_325() {
5190 | 0 |
         if (jj_scan_token(IMPLEMENTS)) return true;
5191 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5192 | 0 |
         if (jj_3R_369()) return true;
5193 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5194 | 0 |
         return false;
5195 |  |
       }
5196 |  |
5197 | 0 |
       final private boolean jj_3R_324() {
5198 | 0 |
         if (jj_scan_token(EXTENDS)) return true;
5199 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5200 | 0 |
         if (jj_3R_57()) return true;
5201 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5202 | 0 |
         return false;
5203 |  |
       }
5204 |  |
5205 | 17058 |
       final private boolean jj_3R_187() {
5206 | 9070 |
         if (jj_3R_196()) return true;
5207 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5208 | 710 |
         Token xsp;
5209 | 710 |
         while (true) {
5210 | 710 |
           xsp = jj_scanpos;
5211 | 710 |
           if (jj_3R_251()) { jj_scanpos = xsp; break; }
5212 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5213 |  |
         }
5214 | 710 |
         return false;
5215 |  |
       }
5216 |  |
5217 | 710 |
       final private boolean jj_3R_219() {
5218 | 710 |
         if (jj_scan_token(REMASSIGN)) return true;
5219 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5220 | 0 |
         return false;
5221 |  |
       }
5222 |  |
5223 | 17058 |
       final private boolean jj_3R_175() {
5224 | 9070 |
         if (jj_3R_187()) return true;
5225 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5226 | 710 |
         Token xsp;
5227 | 710 |
         while (true) {
5228 | 710 |
           xsp = jj_scanpos;
5229 | 710 |
           if (jj_3R_243()) { jj_scanpos = xsp; break; }
5230 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5231 |  |
         }
5232 | 710 |
         return false;
5233 |  |
       }
5234 |  |
5235 | 710 |
       final private boolean jj_3R_218() {
5236 | 710 |
         if (jj_scan_token(SLASHASSIGN)) return true;
5237 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5238 | 0 |
         return false;
5239 |  |
       }
5240 |  |
5241 | 17058 |
       final private boolean jj_3R_168() {
5242 | 9070 |
         if (jj_3R_175()) return true;
5243 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5244 | 710 |
         Token xsp;
5245 | 710 |
         while (true) {
5246 | 710 |
           xsp = jj_scanpos;
5247 | 710 |
           if (jj_3R_215()) { jj_scanpos = xsp; break; }
5248 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5249 |  |
         }
5250 | 710 |
         return false;
5251 |  |
       }
5252 |  |
5253 | 17058 |
       final private boolean jj_3R_136() {
5254 | 9070 |
         if (jj_3R_168()) return true;
5255 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5256 | 710 |
         Token xsp;
5257 | 710 |
         xsp = jj_scanpos;
5258 | 710 |
         if (jj_3R_194()) jj_scanpos = xsp;
5259 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5260 | 710 |
         return false;
5261 |  |
       }
5262 |  |
5263 | 710 |
       final private boolean jj_3R_217() {
5264 | 710 |
         if (jj_scan_token(STARASSIGN)) return true;
5265 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5266 | 0 |
         return false;
5267 |  |
       }
5268 |  |
5269 | 0 |
       final private boolean jj_3R_190() {
5270 | 0 |
         if (jj_scan_token(CLASS)) return true;
5271 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5272 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
5273 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5274 | 0 |
         Token xsp;
5275 | 0 |
         xsp = jj_scanpos;
5276 | 0 |
         if (jj_3R_324()) jj_scanpos = xsp;
5277 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5278 | 0 |
         xsp = jj_scanpos;
5279 | 0 |
         if (jj_3R_325()) jj_scanpos = xsp;
5280 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5281 | 0 |
         if (jj_3R_260()) return true;
5282 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5283 | 0 |
         return false;
5284 |  |
       }
5285 |  |
5286 | 710 |
       final private boolean jj_3R_195() {
5287 | 710 |
         Token xsp;
5288 | 710 |
         xsp = jj_scanpos;
5289 | 710 |
         if (jj_3R_216()) {
5290 | 710 |
         jj_scanpos = xsp;
5291 | 710 |
         if (jj_3R_217()) {
5292 | 710 |
         jj_scanpos = xsp;
5293 | 710 |
         if (jj_3R_218()) {
5294 | 710 |
         jj_scanpos = xsp;
5295 | 710 |
         if (jj_3R_219()) {
5296 | 710 |
         jj_scanpos = xsp;
5297 | 710 |
         if (jj_3R_220()) {
5298 | 710 |
         jj_scanpos = xsp;
5299 | 710 |
         if (jj_3R_221()) {
5300 | 710 |
         jj_scanpos = xsp;
5301 | 710 |
         if (jj_3R_222()) {
5302 | 710 |
         jj_scanpos = xsp;
5303 | 710 |
         if (jj_3R_223()) {
5304 | 710 |
         jj_scanpos = xsp;
5305 | 710 |
         if (jj_3R_224()) {
5306 | 710 |
         jj_scanpos = xsp;
5307 | 710 |
         if (jj_3R_225()) {
5308 | 710 |
         jj_scanpos = xsp;
5309 | 710 |
         if (jj_3R_226()) {
5310 | 710 |
         jj_scanpos = xsp;
5311 | 710 |
         if (jj_3R_227()) return true;
5312 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5313 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5314 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5315 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5316 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5317 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5318 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5319 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5320 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5321 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5322 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5323 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5324 | 0 |
         return false;
5325 |  |
       }
5326 |  |
5327 | 710 |
       final private boolean jj_3R_216() {
5328 | 710 |
         if (jj_scan_token(ASSIGN)) return true;
5329 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5330 | 0 |
         return false;
5331 |  |
       }
5332 |  |
5333 | 710 |
       final private boolean jj_3R_186() {
5334 | 710 |
         if (jj_3R_195()) return true;
5335 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5336 | 0 |
         if (jj_3R_70()) return true;
5337 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5338 | 0 |
         return false;
5339 |  |
       }
5340 |  |
5341 | 17058 |
       final private boolean jj_3R_70() {
5342 | 9070 |
         if (jj_3R_136()) return true;
5343 | 7278 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5344 | 710 |
         Token xsp;
5345 | 710 |
         xsp = jj_scanpos;
5346 | 710 |
         if (jj_3R_186()) jj_scanpos = xsp;
5347 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5348 | 710 |
         return false;
5349 |  |
       }
5350 |  |
5351 | 712 |
       final private boolean jj_3R_79() {
5352 | 712 |
         if (jj_scan_token(STRICTFP)) return true;
5353 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5354 | 0 |
         return false;
5355 |  |
       }
5356 |  |
5357 | 0 |
       final private boolean jj_3R_386() {
5358 | 0 |
         if (jj_scan_token(COMMA)) return true;
5359 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5360 | 0 |
         if (jj_3R_385()) return true;
5361 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5362 | 0 |
         return false;
5363 |  |
       }
5364 |  |
5365 | 1276 |
       final private boolean jj_3R_78() {
5366 | 712 |
         if (jj_scan_token(PUBLIC)) return true;
5367 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5368 | 564 |
         return false;
5369 |  |
       }
5370 |  |
5371 | 0 |
       final private boolean jj_3R_369() {
5372 | 0 |
         if (jj_3R_385()) return true;
5373 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5374 | 0 |
         Token xsp;
5375 | 0 |
         while (true) {
5376 | 0 |
           xsp = jj_scanpos;
5377 | 0 |
           if (jj_3R_386()) { jj_scanpos = xsp; break; }
5378 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5379 |  |
         }
5380 | 0 |
         return false;
5381 |  |
       }
5382 |  |
5383 | 0 |
       final private boolean jj_3R_374() {
5384 | 0 |
         if (jj_scan_token(COMMA)) return true;
5385 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5386 | 0 |
         if (jj_3R_373()) return true;
5387 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5388 | 0 |
         return false;
5389 |  |
       }
5390 |  |
5391 | 0 |
       final private boolean jj_3R_339() {
5392 | 0 |
         if (jj_3R_373()) return true;
5393 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5394 | 0 |
         Token xsp;
5395 | 0 |
         while (true) {
5396 | 0 |
           xsp = jj_scanpos;
5397 | 0 |
           if (jj_3R_374()) { jj_scanpos = xsp; break; }
5398 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5399 |  |
         }
5400 | 0 |
         return false;
5401 |  |
       }
5402 |  |
5403 | 1354 |
       final private boolean jj_3R_77() {
5404 | 1276 |
         if (jj_scan_token(FINAL)) return true;
5405 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5406 | 78 |
         return false;
5407 |  |
       }
5408 |  |
5409 | 1430 |
       final private boolean jj_3R_52() {
5410 | 1430 |
         Token xsp;
5411 | 1430 |
         xsp = jj_scanpos;
5412 | 1430 |
         if (jj_3R_76()) {
5413 | 1354 |
         jj_scanpos = xsp;
5414 | 1354 |
         if (jj_3R_77()) {
5415 | 1276 |
         jj_scanpos = xsp;
5416 | 1276 |
         if (jj_3R_78()) {
5417 | 712 |
         jj_scanpos = xsp;
5418 | 712 |
         if (jj_3R_79()) return true;
5419 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5420 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5421 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5422 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5423 | 718 |
         return false;
5424 |  |
       }
5425 |  |
5426 | 1430 |
       final private boolean jj_3R_76() {
5427 | 1354 |
         if (jj_scan_token(ABSTRACT)) return true;
5428 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5429 | 76 |
         return false;
5430 |  |
       }
5431 |  |
5432 | 712 |
       final private boolean jj_3_1() {
5433 | 712 |
         Token xsp;
5434 | 712 |
         while (true) {
5435 | 1430 |
           xsp = jj_scanpos;
5436 | 712 |
           if (jj_3R_52()) { jj_scanpos = xsp; break; }
5437 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5438 |  |
         }
5439 | 370 |
         if (jj_scan_token(CLASS)) return true;
5440 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5441 | 342 |
         return false;
5442 |  |
       }
5443 |  |
5444 | 0 |
       final private boolean jj_3R_398() {
5445 | 0 |
         if (jj_scan_token(DOT)) return true;
5446 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5447 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
5448 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5449 | 0 |
         return false;
5450 |  |
       }
5451 |  |
5452 | 0 |
       final private boolean jj_3R_385() {
5453 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
5454 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5455 | 0 |
         Token xsp;
5456 | 0 |
         while (true) {
5457 | 0 |
           xsp = jj_scanpos;
5458 | 0 |
           if (jj_3R_398()) { jj_scanpos = xsp; break; }
5459 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5460 |  |
         }
5461 | 0 |
         return false;
5462 |  |
       }
5463 |  |
5464 | 0 |
       final private boolean jj_3R_394() {
5465 | 0 |
         if (jj_scan_token(DOT)) return true;
5466 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5467 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
5468 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5469 | 0 |
         return false;
5470 |  |
       }
5471 |  |
5472 | 0 |
       final private boolean jj_3R_373() {
5473 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
5474 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5475 | 0 |
         Token xsp;
5476 | 0 |
         while (true) {
5477 | 0 |
           xsp = jj_scanpos;
5478 | 0 |
           if (jj_3R_394()) { jj_scanpos = xsp; break; }
5479 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5480 |  |
         }
5481 | 0 |
         return false;
5482 |  |
       }
5483 |  |
5484 | 140808 |
       final private boolean jj_3_14() {
5485 | 111850 |
         if (jj_scan_token(DOT)) return true;
5486 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5487 | 344 |
         if (jj_scan_token(IDENTIFIER)) return true;
5488 | 14764 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5489 | 13850 |
         return false;
5490 |  |
       }
5491 |  |
5492 | 97500 |
       final private boolean jj_3R_57() {
5493 | 33422 |
         if (jj_scan_token(IDENTIFIER)) return true;
5494 | 5474 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5495 | 58604 |
         Token xsp;
5496 | 58604 |
         while (true) {
5497 | 72454 |
           xsp = jj_scanpos;
5498 | 58604 |
           if (jj_3_14()) { jj_scanpos = xsp; break; }
5499 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5500 |  |
         }
5501 | 58604 |
         return false;
5502 |  |
       }
5503 |  |
5504 | 56798 |
       final private boolean jj_3R_134() {
5505 | 9458 |
         if (jj_3R_167()) return true;
5506 | 5474 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5507 | 41866 |
         return false;
5508 |  |
       }
5509 |  |
5510 | 58668 |
       final private boolean jj_3R_133() {
5511 | 56798 |
         if (jj_scan_token(VOID)) return true;
5512 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5513 | 1870 |
         return false;
5514 |  |
       }
5515 |  |
5516 | 58668 |
       final private boolean jj_3R_68() {
5517 | 58668 |
         Token xsp;
5518 | 58668 |
         xsp = jj_scanpos;
5519 | 58668 |
         if (jj_3R_133()) {
5520 | 56798 |
         jj_scanpos = xsp;
5521 | 9458 |
         if (jj_3R_134()) return true;
5522 | 5474 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5523 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5524 | 43736 |
         return false;
5525 |  |
       }
5526 |  |
5527 | 81878 |
       final private boolean jj_3R_129() {
5528 | 81878 |
         if (jj_scan_token(DOUBLE)) return true;
5529 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5530 | 0 |
         return false;
5531 |  |
       }
5532 |  |
5533 | 81878 |
       final private boolean jj_3R_128() {
5534 | 81878 |
         if (jj_scan_token(FLOAT)) return true;
5535 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5536 | 0 |
         return false;
5537 |  |
       }
5538 |  |
5539 | 21382 |
       final private boolean jj_3R_138() {
5540 | 10058 |
         if (jj_3R_57()) return true;
5541 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5542 | 11324 |
         return false;
5543 |  |
       }
5544 |  |
5545 | 82010 |
       final private boolean jj_3R_127() {
5546 | 81878 |
         if (jj_scan_token(LONG)) return true;
5547 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5548 | 132 |
         return false;
5549 |  |
       }
5550 |  |
5551 | 83020 |
       final private boolean jj_3R_126() {
5552 | 82010 |
         if (jj_scan_token(INT)) return true;
5553 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5554 | 1010 |
         return false;
5555 |  |
       }
5556 |  |
5557 | 83020 |
       final private boolean jj_3R_125() {
5558 | 83020 |
         if (jj_scan_token(SHORT)) return true;
5559 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5560 | 0 |
         return false;
5561 |  |
       }
5562 |  |
5563 | 83020 |
       final private boolean jj_3R_124() {
5564 | 83020 |
         if (jj_scan_token(BYTE)) return true;
5565 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5566 | 0 |
         return false;
5567 |  |
       }
5568 |  |
5569 | 83020 |
       final private boolean jj_3R_123() {
5570 | 83020 |
         if (jj_scan_token(CHAR)) return true;
5571 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5572 | 0 |
         return false;
5573 |  |
       }
5574 |  |
5575 | 84982 |
       final private boolean jj_3R_122() {
5576 | 83020 |
         if (jj_scan_token(BOOLEAN)) return true;
5577 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5578 | 1962 |
         return false;
5579 |  |
       }
5580 |  |
5581 | 84982 |
       final private boolean jj_3R_66() {
5582 | 84982 |
         Token xsp;
5583 | 84982 |
         xsp = jj_scanpos;
5584 | 84982 |
         if (jj_3R_122()) {
5585 | 83020 |
         jj_scanpos = xsp;
5586 | 83020 |
         if (jj_3R_123()) {
5587 | 83020 |
         jj_scanpos = xsp;
5588 | 83020 |
         if (jj_3R_124()) {
5589 | 83020 |
         jj_scanpos = xsp;
5590 | 83020 |
         if (jj_3R_125()) {
5591 | 83020 |
         jj_scanpos = xsp;
5592 | 83020 |
         if (jj_3R_126()) {
5593 | 82010 |
         jj_scanpos = xsp;
5594 | 82010 |
         if (jj_3R_127()) {
5595 | 81878 |
         jj_scanpos = xsp;
5596 | 81878 |
         if (jj_3R_128()) {
5597 | 81878 |
         jj_scanpos = xsp;
5598 | 81878 |
         if (jj_3R_129()) return true;
5599 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5600 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5601 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5602 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5603 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5604 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5605 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5606 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5607 | 3104 |
         return false;
5608 |  |
       }
5609 |  |
5610 | 11826 |
       final private boolean jj_3R_139() {
5611 | 11772 |
         if (jj_scan_token(LBRACKET)) return true;
5612 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5613 | 44 |
         if (jj_scan_token(RBRACKET)) return true;
5614 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5615 | 10 |
         return false;
5616 |  |
       }
5617 |  |
5618 | 21874 |
       final private boolean jj_3R_137() {
5619 | 21382 |
         if (jj_3R_66()) return true;
5620 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5621 | 492 |
         return false;
5622 |  |
       }
5623 |  |
5624 | 21874 |
       final private boolean jj_3R_73() {
5625 | 21874 |
         Token xsp;
5626 | 21874 |
         xsp = jj_scanpos;
5627 | 21874 |
         if (jj_3R_137()) {
5628 | 21382 |
         jj_scanpos = xsp;
5629 | 10058 |
         if (jj_3R_138()) return true;
5630 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5631 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5632 | 11816 |
         while (true) {
5633 | 11826 |
           xsp = jj_scanpos;
5634 | 11816 |
           if (jj_3R_139()) { jj_scanpos = xsp; break; }
5635 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5636 |  |
         }
5637 | 11816 |
         return false;
5638 |  |
       }
5639 |  |
5640 | 0 |
       final private boolean jj_3R_401() {
5641 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
5642 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5643 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
5644 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5645 | 0 |
         return false;
5646 |  |
       }
5647 |  |
5648 | 0 |
       final private boolean jj_3R_400() {
5649 | 0 |
         if (jj_3R_57()) return true;
5650 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5651 | 0 |
         return false;
5652 |  |
       }
5653 |  |
5654 | 0 |
       final private boolean jj_3R_399() {
5655 | 0 |
         if (jj_3R_66()) return true;
5656 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5657 | 0 |
         return false;
5658 |  |
       }
5659 |  |
5660 | 0 |
       final private boolean jj_3R_392() {
5661 | 0 |
         Token xsp;
5662 | 0 |
         xsp = jj_scanpos;
5663 | 0 |
         if (jj_3R_399()) {
5664 | 0 |
         jj_scanpos = xsp;
5665 | 0 |
         if (jj_3R_400()) return true;
5666 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5667 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5668 | 0 |
         while (true) {
5669 | 0 |
           xsp = jj_scanpos;
5670 | 0 |
           if (jj_3R_401()) { jj_scanpos = xsp; break; }
5671 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5672 |  |
         }
5673 | 0 |
         return false;
5674 |  |
       }
5675 |  |
5676 | 41932 |
       final private boolean jj_3R_174() {
5677 | 41782 |
         if (jj_scan_token(LBRACKET)) return true;
5678 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5679 | 84 |
         if (jj_scan_token(RBRACKET)) return true;
5680 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5681 | 66 |
         return false;
5682 |  |
       }
5683 |  |
5684 | 54282 |
       final private boolean jj_3R_173() {
5685 | 9458 |
         if (jj_3R_57()) return true;
5686 | 5474 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5687 | 39350 |
         return false;
5688 |  |
       }
5689 |  |
5690 | 56798 |
       final private boolean jj_3R_172() {
5691 | 54282 |
         if (jj_3R_66()) return true;
5692 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5693 | 2516 |
         return false;
5694 |  |
       }
5695 |  |
5696 | 56798 |
       final private boolean jj_3R_167() {
5697 | 56798 |
         Token xsp;
5698 | 56798 |
         xsp = jj_scanpos;
5699 | 56798 |
         if (jj_3R_172()) {
5700 | 54282 |
         jj_scanpos = xsp;
5701 | 9458 |
         if (jj_3R_173()) return true;
5702 | 5474 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5703 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5704 | 41866 |
         while (true) {
5705 | 41932 |
           xsp = jj_scanpos;
5706 | 41866 |
           if (jj_3R_174()) { jj_scanpos = xsp; break; }
5707 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5708 |  |
         }
5709 | 41866 |
         return false;
5710 |  |
       }
5711 |  |
5712 | 0 |
       final private boolean jj_3R_422() {
5713 | 0 |
         if (jj_scan_token(COLON)) return true;
5714 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5715 | 0 |
         if (jj_3R_70()) return true;
5716 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5717 | 0 |
         return false;
5718 |  |
       }
5719 |  |
5720 | 0 |
       final private boolean jj_3R_360() {
5721 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
5722 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5723 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
5724 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5725 | 0 |
         return false;
5726 |  |
       }
5727 |  |
5728 | 0 |
       final private boolean jj_3R_359() {
5729 | 0 |
         if (jj_3R_57()) return true;
5730 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5731 | 0 |
         return false;
5732 |  |
       }
5733 |  |
5734 | 0 |
       final private boolean jj_3R_298() {
5735 | 0 |
         if (jj_scan_token(THROWS)) return true;
5736 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5737 | 0 |
         if (jj_3R_339()) return true;
5738 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5739 | 0 |
         return false;
5740 |  |
       }
5741 |  |
5742 | 0 |
       final private boolean jj_3R_242() {
5743 | 0 |
         if (jj_scan_token(ASSERT)) return true;
5744 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5745 | 0 |
         if (jj_3R_70()) return true;
5746 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5747 | 0 |
         Token xsp;
5748 | 0 |
         xsp = jj_scanpos;
5749 | 0 |
         if (jj_3R_422()) jj_scanpos = xsp;
5750 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5751 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
5752 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5753 | 0 |
         return false;
5754 |  |
       }
5755 |  |
5756 | 0 |
       final private boolean jj_3R_358() {
5757 | 0 |
         if (jj_3R_66()) return true;
5758 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5759 | 0 |
         return false;
5760 |  |
       }
5761 |  |
5762 | 0 |
       final private boolean jj_3R_307() {
5763 | 0 |
         Token xsp;
5764 | 0 |
         xsp = jj_scanpos;
5765 | 0 |
         if (jj_3R_358()) {
5766 | 0 |
         jj_scanpos = xsp;
5767 | 0 |
         if (jj_3R_359()) return true;
5768 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5769 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5770 | 0 |
         while (true) {
5771 | 0 |
           xsp = jj_scanpos;
5772 | 0 |
           if (jj_3R_360()) { jj_scanpos = xsp; break; }
5773 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5774 |  |
         }
5775 | 0 |
         return false;
5776 |  |
       }
5777 |  |
5778 | 0 |
       final private boolean jj_3R_421() {
5779 | 0 |
         if (jj_scan_token(FINALLY)) return true;
5780 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5781 | 0 |
         if (jj_3R_81()) return true;
5782 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5783 | 0 |
         return false;
5784 |  |
       }
5785 |  |
5786 | 0 |
       final private boolean jj_3R_420() {
5787 | 0 |
         if (jj_scan_token(CATCH)) return true;
5788 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5789 | 0 |
         if (jj_scan_token(LPAREN)) return true;
5790 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5791 | 0 |
         if (jj_3R_371()) return true;
5792 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5793 | 0 |
         if (jj_scan_token(RPAREN)) return true;
5794 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5795 | 0 |
         if (jj_3R_81()) return true;
5796 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5797 | 0 |
         return false;
5798 |  |
       }
5799 |  |
5800 | 0 |
       final private boolean jj_3R_241() {
5801 | 0 |
         if (jj_scan_token(TRY)) return true;
5802 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5803 | 0 |
         if (jj_3R_81()) return true;
5804 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5805 | 0 |
         Token xsp;
5806 | 0 |
         while (true) {
5807 | 0 |
           xsp = jj_scanpos;
5808 | 0 |
           if (jj_3R_420()) { jj_scanpos = xsp; break; }
5809 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5810 |  |
         }
5811 | 0 |
         xsp = jj_scanpos;
5812 | 0 |
         if (jj_3R_421()) jj_scanpos = xsp;
5813 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5814 | 0 |
         return false;
5815 |  |
       }
5816 |  |
5817 | 7564 |
       final private boolean jj_3R_80() {
5818 | 7508 |
         if (jj_scan_token(STATIC)) return true;
5819 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5820 | 56 |
         return false;
5821 |  |
       }
5822 |  |
5823 | 180 |
       final private boolean jj_3_13() {
5824 | 140 |
         if (jj_scan_token(THIS)) return true;
5825 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5826 | 0 |
         if (jj_3R_64()) return true;
5827 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5828 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
5829 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5830 | 40 |
         return false;
5831 |  |
       }
5832 |  |
5833 | 7564 |
       final private boolean jj_3R_53() {
5834 | 7564 |
         Token xsp;
5835 | 7564 |
         xsp = jj_scanpos;
5836 | 7508 |
         if (jj_3R_80()) jj_scanpos = xsp;
5837 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5838 | 7532 |
         if (jj_3R_81()) return true;
5839 | 32 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5840 | 0 |
         return false;
5841 |  |
       }
5842 |  |
5843 | 0 |
       final private boolean jj_3R_416() {
5844 | 0 |
         if (jj_3R_428()) return true;
5845 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5846 | 0 |
         return false;
5847 |  |
       }
5848 |  |
5849 | 0 |
       final private boolean jj_3R_240() {
5850 | 0 |
         if (jj_scan_token(SYNCHRONIZED)) return true;
5851 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5852 | 0 |
         if (jj_scan_token(LPAREN)) return true;
5853 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5854 | 0 |
         if (jj_3R_70()) return true;
5855 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5856 | 0 |
         if (jj_scan_token(RPAREN)) return true;
5857 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5858 | 0 |
         if (jj_3R_81()) return true;
5859 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5860 | 0 |
         return false;
5861 |  |
       }
5862 |  |
5863 | 0 |
       final private boolean jj_3R_419() {
5864 | 0 |
         if (jj_3R_70()) return true;
5865 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5866 | 0 |
         return false;
5867 |  |
       }
5868 |  |
5869 | 566 |
       final private boolean jj_3_12() {
5870 | 388 |
         if (jj_3R_63()) return true;
5871 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5872 | 178 |
         if (jj_scan_token(DOT)) return true;
5873 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5874 | 0 |
         return false;
5875 |  |
       }
5876 |  |
5877 | 0 |
       final private boolean jj_3R_418() {
5878 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
5879 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5880 | 0 |
         return false;
5881 |  |
       }
5882 |  |
5883 | 426 |
       final private boolean jj_3R_117() {
5884 | 426 |
         Token xsp;
5885 | 426 |
         xsp = jj_scanpos;
5886 | 426 |
         if (jj_3_12()) jj_scanpos = xsp;
5887 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5888 | 286 |
         if (jj_scan_token(SUPER)) return true;
5889 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5890 | 0 |
         if (jj_3R_64()) return true;
5891 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5892 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
5893 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5894 | 140 |
         return false;
5895 |  |
       }
5896 |  |
5897 | 0 |
       final private boolean jj_3R_239() {
5898 | 0 |
         if (jj_scan_token(THROW)) return true;
5899 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5900 | 0 |
         if (jj_3R_70()) return true;
5901 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5902 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
5903 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5904 | 0 |
         return false;
5905 |  |
       }
5906 |  |
5907 | 466 |
       final private boolean jj_3_11() {
5908 | 286 |
         if (jj_3R_62()) return true;
5909 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5910 | 180 |
         return false;
5911 |  |
       }
5912 |  |
5913 | 466 |
       final private boolean jj_3R_116() {
5914 | 402 |
         if (jj_scan_token(THIS)) return true;
5915 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5916 | 24 |
         if (jj_3R_64()) return true;
5917 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5918 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
5919 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5920 | 40 |
         return false;
5921 |  |
       }
5922 |  |
5923 | 466 |
       final private boolean jj_3R_62() {
5924 | 466 |
         Token xsp;
5925 | 466 |
         xsp = jj_scanpos;
5926 | 466 |
         if (jj_3R_116()) {
5927 | 426 |
         jj_scanpos = xsp;
5928 | 286 |
         if (jj_3R_117()) return true;
5929 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5930 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5931 | 180 |
         return false;
5932 |  |
       }
5933 |  |
5934 | 0 |
       final private boolean jj_3R_439() {
5935 | 0 |
         if (jj_scan_token(COMMA)) return true;
5936 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5937 | 0 |
         if (jj_3R_230()) return true;
5938 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5939 | 0 |
         return false;
5940 |  |
       }
5941 |  |
5942 | 0 |
       final private boolean jj_3R_238() {
5943 | 0 |
         if (jj_scan_token(RETURN)) return true;
5944 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5945 | 0 |
         Token xsp;
5946 | 0 |
         xsp = jj_scanpos;
5947 | 0 |
         if (jj_3R_419()) jj_scanpos = xsp;
5948 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5949 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
5950 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5951 | 0 |
         return false;
5952 |  |
       }
5953 |  |
5954 | 0 |
       final private boolean jj_3R_417() {
5955 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
5956 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5957 | 0 |
         return false;
5958 |  |
       }
5959 |  |
5960 | 0 |
       final private boolean jj_3R_300() {
5961 | 0 |
         if (jj_3R_169()) return true;
5962 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5963 | 0 |
         return false;
5964 |  |
       }
5965 |  |
5966 | 0 |
       final private boolean jj_3R_299() {
5967 | 0 |
         if (jj_3R_62()) return true;
5968 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5969 | 0 |
         return false;
5970 |  |
       }
5971 |  |
5972 | 0 |
       final private boolean jj_3R_237() {
5973 | 0 |
         if (jj_scan_token(CONTINUE)) return true;
5974 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5975 | 0 |
         Token xsp;
5976 | 0 |
         xsp = jj_scanpos;
5977 | 0 |
         if (jj_3R_418()) jj_scanpos = xsp;
5978 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5979 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
5980 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5981 | 0 |
         return false;
5982 |  |
       }
5983 |  |
5984 | 0 |
       final private boolean jj_3R_415() {
5985 | 0 |
         if (jj_3R_70()) return true;
5986 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5987 | 0 |
         return false;
5988 |  |
       }
5989 |  |
5990 | 0 |
       final private boolean jj_3R_236() {
5991 | 0 |
         if (jj_scan_token(BREAK)) return true;
5992 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5993 | 0 |
         Token xsp;
5994 | 0 |
         xsp = jj_scanpos;
5995 | 0 |
         if (jj_3R_417()) jj_scanpos = xsp;
5996 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5997 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
5998 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
5999 | 0 |
         return false;
6000 |  |
       }
6001 |  |
6002 | 0 |
       final private boolean jj_3R_337() {
6003 | 0 |
         if (jj_scan_token(PRIVATE)) return true;
6004 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6005 | 0 |
         return false;
6006 |  |
       }
6007 |  |
6008 | 0 |
       final private boolean jj_3R_413() {
6009 | 0 |
         if (jj_scan_token(ELSE)) return true;
6010 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6011 | 0 |
         if (jj_3R_189()) return true;
6012 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6013 | 0 |
         return false;
6014 |  |
       }
6015 |  |
6016 | 0 |
       final private boolean jj_3R_428() {
6017 | 0 |
         if (jj_3R_438()) return true;
6018 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6019 | 0 |
         return false;
6020 |  |
       }
6021 |  |
6022 | 0 |
       final private boolean jj_3R_336() {
6023 | 0 |
         if (jj_scan_token(PROTECTED)) 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_372() {
6029 | 0 |
         if (jj_scan_token(COMMA)) return true;
6030 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6031 | 0 |
         if (jj_3R_371()) return true;
6032 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6033 | 0 |
         return false;
6034 |  |
       }
6035 |  |
6036 | 900 |
       final private boolean jj_3R_75() {
6037 | 900 |
         if (jj_scan_token(FINAL)) return true;
6038 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6039 | 0 |
         return false;
6040 |  |
       }
6041 |  |
6042 | 900 |
       final private boolean jj_3_31() {
6043 | 900 |
         Token xsp;
6044 | 900 |
         xsp = jj_scanpos;
6045 | 900 |
         if (jj_3R_75()) jj_scanpos = xsp;
6046 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6047 | 0 |
         if (jj_3R_73()) return true;
6048 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6049 | 4 |
         if (jj_scan_token(IDENTIFIER)) return true;
6050 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6051 | 896 |
         return false;
6052 |  |
       }
6053 |  |
6054 | 0 |
       final private boolean jj_3R_438() {
6055 | 0 |
         if (jj_3R_230()) return true;
6056 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6057 | 0 |
         Token xsp;
6058 | 0 |
         while (true) {
6059 | 0 |
           xsp = jj_scanpos;
6060 | 0 |
           if (jj_3R_439()) { jj_scanpos = xsp; break; }
6061 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6062 |  |
         }
6063 | 0 |
         return false;
6064 |  |
       }
6065 |  |
6066 | 0 |
       final private boolean jj_3R_335() {
6067 | 0 |
         if (jj_scan_token(PUBLIC)) return true;
6068 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6069 | 0 |
         return false;
6070 |  |
       }
6071 |  |
6072 | 0 |
       final private boolean jj_3R_296() {
6073 | 0 |
         Token xsp;
6074 | 0 |
         xsp = jj_scanpos;
6075 | 0 |
         if (jj_3R_335()) {
6076 | 0 |
         jj_scanpos = xsp;
6077 | 0 |
         if (jj_3R_336()) {
6078 | 0 |
         jj_scanpos = xsp;
6079 | 0 |
         if (jj_3R_337()) return true;
6080 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6081 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6082 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6083 | 0 |
         return false;
6084 |  |
       }
6085 |  |
6086 | 0 |
       final private boolean jj_3R_282() {
6087 | 0 |
         Token xsp;
6088 | 0 |
         xsp = jj_scanpos;
6089 | 0 |
         if (jj_3R_296()) jj_scanpos = xsp;
6090 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6091 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
6092 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6093 | 0 |
         if (jj_3R_297()) return true;
6094 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6095 | 0 |
         xsp = jj_scanpos;
6096 | 0 |
         if (jj_3R_298()) jj_scanpos = xsp;
6097 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6098 | 0 |
         if (jj_scan_token(LBRACE)) return true;
6099 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6100 | 0 |
         xsp = jj_scanpos;
6101 | 0 |
         if (jj_3R_299()) jj_scanpos = xsp;
6102 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6103 | 0 |
         while (true) {
6104 | 0 |
           xsp = jj_scanpos;
6105 | 0 |
           if (jj_3R_300()) { jj_scanpos = xsp; break; }
6106 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6107 |  |
         }
6108 | 0 |
         if (jj_scan_token(RBRACE)) return true;
6109 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6110 | 0 |
         return false;
6111 |  |
       }
6112 |  |
6113 | 0 |
       final private boolean jj_3R_414() {
6114 | 0 |
         if (jj_3R_427()) return true;
6115 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6116 | 0 |
         return false;
6117 |  |
       }
6118 |  |
6119 | 0 |
       final private boolean jj_3R_349() {
6120 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
6121 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6122 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
6123 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6124 | 0 |
         return false;
6125 |  |
       }
6126 |  |
6127 | 0 |
       final private boolean jj_3R_437() {
6128 | 0 |
         if (jj_3R_438()) return true;
6129 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6130 | 0 |
         return false;
6131 |  |
       }
6132 |  |
6133 | 0 |
       final private boolean jj_3R_436() {
6134 | 0 |
         if (jj_3R_188()) return true;
6135 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6136 | 0 |
         return false;
6137 |  |
       }
6138 |  |
6139 | 0 |
       final private boolean jj_3R_427() {
6140 | 0 |
         Token xsp;
6141 | 0 |
         xsp = jj_scanpos;
6142 | 0 |
         if (jj_3R_436()) {
6143 | 0 |
         jj_scanpos = xsp;
6144 | 0 |
         if (jj_3R_437()) return true;
6145 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6146 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6147 | 0 |
         return false;
6148 |  |
       }
6149 |  |
6150 | 0 |
       final private boolean jj_3R_391() {
6151 | 0 |
         if (jj_scan_token(FINAL)) return true;
6152 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6153 | 0 |
         return false;
6154 |  |
       }
6155 |  |
6156 | 0 |
       final private boolean jj_3R_235() {
6157 | 0 |
         if (jj_scan_token(FOR)) return true;
6158 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6159 | 0 |
         if (jj_scan_token(LPAREN)) return true;
6160 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6161 | 0 |
         Token xsp;
6162 | 0 |
         xsp = jj_scanpos;
6163 | 0 |
         if (jj_3R_414()) jj_scanpos = xsp;
6164 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6165 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
6166 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6167 | 0 |
         xsp = jj_scanpos;
6168 | 0 |
         if (jj_3R_415()) jj_scanpos = xsp;
6169 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6170 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
6171 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6172 | 0 |
         xsp = jj_scanpos;
6173 | 0 |
         if (jj_3R_416()) jj_scanpos = xsp;
6174 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6175 | 0 |
         if (jj_scan_token(RPAREN)) return true;
6176 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6177 | 0 |
         if (jj_3R_189()) return true;
6178 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6179 | 0 |
         return false;
6180 |  |
       }
6181 |  |
6182 | 0 |
       final private boolean jj_3R_371() {
6183 | 0 |
         Token xsp;
6184 | 0 |
         xsp = jj_scanpos;
6185 | 0 |
         if (jj_3R_391()) jj_scanpos = xsp;
6186 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6187 | 0 |
         if (jj_3R_392()) return true;
6188 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6189 | 0 |
         if (jj_3R_393()) return true;
6190 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6191 | 0 |
         return false;
6192 |  |
       }
6193 |  |
6194 | 0 |
       final private boolean jj_3R_338() {
6195 | 0 |
         if (jj_3R_371()) return true;
6196 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6197 | 0 |
         Token xsp;
6198 | 0 |
         while (true) {
6199 | 0 |
           xsp = jj_scanpos;
6200 | 0 |
           if (jj_3R_372()) { jj_scanpos = xsp; break; }
6201 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6202 |  |
         }
6203 | 0 |
         return false;
6204 |  |
       }
6205 |  |
6206 | 0 |
       final private boolean jj_3R_234() {
6207 | 0 |
         if (jj_scan_token(DO)) return true;
6208 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6209 | 0 |
         if (jj_3R_189()) return true;
6210 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6211 | 0 |
         if (jj_scan_token(WHILE)) return true;
6212 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6213 | 0 |
         if (jj_scan_token(LPAREN)) return true;
6214 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6215 | 0 |
         if (jj_3R_70()) return true;
6216 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6217 | 0 |
         if (jj_scan_token(RPAREN)) return true;
6218 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6219 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
6220 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6221 | 0 |
         return false;
6222 |  |
       }
6223 |  |
6224 | 0 |
       final private boolean jj_3R_297() {
6225 | 0 |
         if (jj_scan_token(LPAREN)) return true;
6226 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6227 | 0 |
         Token xsp;
6228 | 0 |
         xsp = jj_scanpos;
6229 | 0 |
         if (jj_3R_338()) jj_scanpos = xsp;
6230 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6231 | 0 |
         if (jj_scan_token(RPAREN)) return true;
6232 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6233 | 0 |
         return false;
6234 |  |
       }
6235 |  |
6236 | 0 |
       final private boolean jj_3R_233() {
6237 | 0 |
         if (jj_scan_token(WHILE)) return true;
6238 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6239 | 0 |
         if (jj_scan_token(LPAREN)) return true;
6240 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6241 | 0 |
         if (jj_3R_70()) return true;
6242 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6243 | 0 |
         if (jj_scan_token(RPAREN)) return true;
6244 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6245 | 0 |
         if (jj_3R_189()) return true;
6246 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6247 | 0 |
         return false;
6248 |  |
       }
6249 |  |
6250 | 0 |
       final private boolean jj_3R_426() {
6251 | 0 |
         if (jj_3R_169()) return true;
6252 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6253 | 0 |
         return false;
6254 |  |
       }
6255 |  |
6256 | 0 |
       final private boolean jj_3R_232() {
6257 | 0 |
         if (jj_scan_token(IF)) return true;
6258 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6259 | 0 |
         if (jj_scan_token(LPAREN)) return true;
6260 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6261 | 0 |
         if (jj_3R_70()) return true;
6262 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6263 | 0 |
         if (jj_scan_token(RPAREN)) return true;
6264 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6265 | 0 |
         if (jj_3R_189()) return true;
6266 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6267 | 0 |
         Token xsp;
6268 | 0 |
         xsp = jj_scanpos;
6269 | 0 |
         if (jj_3R_413()) jj_scanpos = xsp;
6270 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6271 | 0 |
         return false;
6272 |  |
       }
6273 |  |
6274 | 0 |
       final private boolean jj_3R_305() {
6275 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
6276 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6277 | 0 |
         return false;
6278 |  |
       }
6279 |  |
6280 | 0 |
       final private boolean jj_3R_302() {
6281 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
6282 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6283 | 0 |
         if (jj_3R_297()) return true;
6284 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6285 | 0 |
         Token xsp;
6286 | 0 |
         while (true) {
6287 | 0 |
           xsp = jj_scanpos;
6288 | 0 |
           if (jj_3R_349()) { jj_scanpos = xsp; break; }
6289 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6290 |  |
         }
6291 | 0 |
         return false;
6292 |  |
       }
6293 |  |
6294 | 0 |
       final private boolean jj_3R_435() {
6295 | 0 |
         if (jj_scan_token(_DEFAULT)) return true;
6296 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6297 | 0 |
         if (jj_scan_token(COLON)) return true;
6298 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6299 | 0 |
         return false;
6300 |  |
       }
6301 |  |
6302 | 0 |
       final private boolean jj_3R_434() {
6303 | 0 |
         if (jj_scan_token(CASE)) return true;
6304 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6305 | 0 |
         if (jj_3R_70()) return true;
6306 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6307 | 0 |
         if (jj_scan_token(COLON)) return true;
6308 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6309 | 0 |
         return false;
6310 |  |
       }
6311 |  |
6312 | 0 |
       final private boolean jj_3R_425() {
6313 | 0 |
         Token xsp;
6314 | 0 |
         xsp = jj_scanpos;
6315 | 0 |
         if (jj_3R_434()) {
6316 | 0 |
         jj_scanpos = xsp;
6317 | 0 |
         if (jj_3R_435()) return true;
6318 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6319 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6320 | 0 |
         return false;
6321 |  |
       }
6322 |  |
6323 | 0 |
       final private boolean jj_3R_404() {
6324 | 0 |
         if (jj_scan_token(COMMA)) return true;
6325 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6326 | 0 |
         if (jj_3R_403()) return true;
6327 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6328 | 0 |
         return false;
6329 |  |
       }
6330 |  |
6331 | 0 |
       final private boolean jj_3R_412() {
6332 | 0 |
         if (jj_3R_425()) return true;
6333 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6334 | 0 |
         Token xsp;
6335 | 0 |
         while (true) {
6336 | 0 |
           xsp = jj_scanpos;
6337 | 0 |
           if (jj_3R_426()) { jj_scanpos = xsp; break; }
6338 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6339 |  |
         }
6340 | 0 |
         return false;
6341 |  |
       }
6342 |  |
6343 | 0 |
       final private boolean jj_3R_304() {
6344 | 0 |
         if (jj_3R_350()) return true;
6345 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6346 | 0 |
         return false;
6347 |  |
       }
6348 |  |
6349 | 0 |
       final private boolean jj_3R_303() {
6350 | 0 |
         if (jj_scan_token(THROWS)) return true;
6351 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6352 | 0 |
         if (jj_3R_339()) return true;
6353 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6354 | 0 |
         return false;
6355 |  |
       }
6356 |  |
6357 | 0 |
       final private boolean jj_3R_231() {
6358 | 0 |
         if (jj_scan_token(SWITCH)) return true;
6359 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6360 | 0 |
         if (jj_scan_token(LPAREN)) return true;
6361 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6362 | 0 |
         if (jj_3R_70()) return true;
6363 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6364 | 0 |
         if (jj_scan_token(RPAREN)) return true;
6365 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6366 | 0 |
         if (jj_scan_token(LBRACE)) return true;
6367 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6368 | 0 |
         Token xsp;
6369 | 0 |
         while (true) {
6370 | 0 |
           xsp = jj_scanpos;
6371 | 0 |
           if (jj_3R_412()) { jj_scanpos = xsp; break; }
6372 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6373 |  |
         }
6374 | 0 |
         if (jj_scan_token(RBRACE)) return true;
6375 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6376 | 0 |
         return false;
6377 |  |
       }
6378 |  |
6379 | 0 |
       final private boolean jj_3R_264() {
6380 | 0 |
         if (jj_scan_token(COMMA)) return true;
6381 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6382 | 0 |
         return false;
6383 |  |
       }
6384 |  |
6385 | 0 |
       final private boolean jj_3R_433() {
6386 | 0 |
         if (jj_3R_195()) return true;
6387 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6388 | 0 |
         if (jj_3R_70()) return true;
6389 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6390 | 0 |
         return false;
6391 |  |
       }
6392 |  |
6393 | 0 |
       final private boolean jj_3R_432() {
6394 | 0 |
         if (jj_scan_token(DECR)) return true;
6395 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6396 | 0 |
         return false;
6397 |  |
       }
6398 |  |
6399 | 0 |
       final private boolean jj_3R_348() {
6400 | 0 |
         if (jj_scan_token(STRICTFP)) return true;
6401 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6402 | 0 |
         return false;
6403 |  |
       }
6404 |  |
6405 | 0 |
       final private boolean jj_3R_431() {
6406 | 0 |
         if (jj_scan_token(INCR)) return true;
6407 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6408 | 0 |
         return false;
6409 |  |
       }
6410 |  |
6411 | 0 |
       final private boolean jj_3R_424() {
6412 | 0 |
         Token xsp;
6413 | 0 |
         xsp = jj_scanpos;
6414 | 0 |
         if (jj_3R_431()) {
6415 | 0 |
         jj_scanpos = xsp;
6416 | 0 |
         if (jj_3R_432()) {
6417 | 0 |
         jj_scanpos = xsp;
6418 | 0 |
         if (jj_3R_433()) return true;
6419 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6420 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6421 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6422 | 0 |
         return false;
6423 |  |
       }
6424 |  |
6425 | 0 |
       final private boolean jj_3R_247() {
6426 | 0 |
         if (jj_3R_63()) return true;
6427 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6428 | 0 |
         Token xsp;
6429 | 0 |
         xsp = jj_scanpos;
6430 | 0 |
         if (jj_3R_424()) jj_scanpos = xsp;
6431 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6432 | 0 |
         return false;
6433 |  |
       }
6434 |  |
6435 | 0 |
       final private boolean jj_3R_347() {
6436 | 0 |
         if (jj_scan_token(SYNCHRONIZED)) return true;
6437 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6438 | 0 |
         return false;
6439 |  |
       }
6440 |  |
6441 | 0 |
       final private boolean jj_3R_246() {
6442 | 0 |
         if (jj_3R_254()) return true;
6443 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6444 | 0 |
         return false;
6445 |  |
       }
6446 |  |
6447 | 0 |
       final private boolean jj_3R_230() {
6448 | 0 |
         Token xsp;
6449 | 0 |
         xsp = jj_scanpos;
6450 | 0 |
         if (jj_3R_245()) {
6451 | 0 |
         jj_scanpos = xsp;
6452 | 0 |
         if (jj_3R_246()) {
6453 | 0 |
         jj_scanpos = xsp;
6454 | 0 |
         if (jj_3R_247()) return true;
6455 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6456 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6457 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6458 | 0 |
         return false;
6459 |  |
       }
6460 |  |
6461 | 0 |
       final private boolean jj_3R_245() {
6462 | 0 |
         if (jj_3R_253()) return true;
6463 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6464 | 0 |
         return false;
6465 |  |
       }
6466 |  |
6467 | 0 |
       final private boolean jj_3R_346() {
6468 | 0 |
         if (jj_scan_token(NATIVE)) return true;
6469 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6470 | 0 |
         return false;
6471 |  |
       }
6472 |  |
6473 | 0 |
       final private boolean jj_3R_345() {
6474 | 0 |
         if (jj_scan_token(FINAL)) return true;
6475 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6476 | 0 |
         return false;
6477 |  |
       }
6478 |  |
6479 | 0 |
       final private boolean jj_3R_229() {
6480 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
6481 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6482 | 0 |
         return false;
6483 |  |
       }
6484 |  |
6485 | 0 |
       final private boolean jj_3R_344() {
6486 | 0 |
         if (jj_scan_token(ABSTRACT)) return true;
6487 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6488 | 0 |
         return false;
6489 |  |
       }
6490 |  |
6491 | 0 |
       final private boolean jj_3R_197() {
6492 | 0 |
         if (jj_scan_token(FINAL)) return true;
6493 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6494 | 0 |
         return false;
6495 |  |
       }
6496 |  |
6497 | 0 |
       final private boolean jj_3R_188() {
6498 | 0 |
         Token xsp;
6499 | 0 |
         xsp = jj_scanpos;
6500 | 0 |
         if (jj_3R_197()) jj_scanpos = xsp;
6501 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6502 | 0 |
         if (jj_3R_73()) return true;
6503 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6504 | 0 |
         if (jj_3R_403()) return true;
6505 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6506 | 0 |
         while (true) {
6507 | 0 |
           xsp = jj_scanpos;
6508 | 0 |
           if (jj_3R_404()) { jj_scanpos = xsp; break; }
6509 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6510 |  |
         }
6511 | 0 |
         return false;
6512 |  |
       }
6513 |  |
6514 | 0 |
       final private boolean jj_3R_343() {
6515 | 0 |
         if (jj_scan_token(STATIC)) return true;
6516 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6517 | 0 |
         return false;
6518 |  |
       }
6519 |  |
6520 | 0 |
       final private boolean jj_3R_342() {
6521 | 0 |
         if (jj_scan_token(PRIVATE)) return true;
6522 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6523 | 0 |
         return false;
6524 |  |
       }
6525 |  |
6526 | 0 |
       final private boolean jj_3R_408() {
6527 | 0 |
         if (jj_3R_191()) return true;
6528 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6529 | 0 |
         return false;
6530 |  |
       }
6531 |  |
6532 | 228 |
       final private boolean jj_3_10() {
6533 | 24 |
         if (jj_scan_token(COMMA)) return true;
6534 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6535 | 0 |
         if (jj_3R_61()) return true;
6536 | 204 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6537 | 0 |
         return false;
6538 |  |
       }
6539 |  |
6540 | 9998 |
       final private boolean jj_3R_74() {
6541 | 9896 |
         if (jj_scan_token(FINAL)) return true;
6542 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6543 | 102 |
         return false;
6544 |  |
       }
6545 |  |
6546 | 9998 |
       final private boolean jj_3_30() {
6547 | 9998 |
         Token xsp;
6548 | 9998 |
         xsp = jj_scanpos;
6549 | 9896 |
         if (jj_3R_74()) jj_scanpos = xsp;
6550 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6551 | 6220 |
         if (jj_3R_73()) return true;
6552 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6553 | 2292 |
         if (jj_scan_token(IDENTIFIER)) return true;
6554 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6555 | 1486 |
         return false;
6556 |  |
       }
6557 |  |
6558 | 0 |
       final private boolean jj_3R_341() {
6559 | 0 |
         if (jj_scan_token(PROTECTED)) return true;
6560 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6561 | 0 |
         return false;
6562 |  |
       }
6563 |  |
6564 | 0 |
       final private boolean jj_3R_407() {
6565 | 0 |
         if (jj_3R_190()) return true;
6566 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6567 | 0 |
         return false;
6568 |  |
       }
6569 |  |
6570 | 0 |
       final private boolean jj_3R_406() {
6571 | 0 |
         if (jj_3R_189()) return true;
6572 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6573 | 0 |
         return false;
6574 |  |
       }
6575 |  |
6576 | 0 |
       final private boolean jj_3R_340() {
6577 | 0 |
         if (jj_scan_token(PUBLIC)) return true;
6578 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6579 | 0 |
         return false;
6580 |  |
       }
6581 |  |
6582 | 0 |
       final private boolean jj_3R_301() {
6583 | 0 |
         Token xsp;
6584 | 0 |
         xsp = jj_scanpos;
6585 | 0 |
         if (jj_3R_340()) {
6586 | 0 |
         jj_scanpos = xsp;
6587 | 0 |
         if (jj_3R_341()) {
6588 | 0 |
         jj_scanpos = xsp;
6589 | 0 |
         if (jj_3R_342()) {
6590 | 0 |
         jj_scanpos = xsp;
6591 | 0 |
         if (jj_3R_343()) {
6592 | 0 |
         jj_scanpos = xsp;
6593 | 0 |
         if (jj_3R_344()) {
6594 | 0 |
         jj_scanpos = xsp;
6595 | 0 |
         if (jj_3R_345()) {
6596 | 0 |
         jj_scanpos = xsp;
6597 | 0 |
         if (jj_3R_346()) {
6598 | 0 |
         jj_scanpos = xsp;
6599 | 0 |
         if (jj_3R_347()) {
6600 | 0 |
         jj_scanpos = xsp;
6601 | 0 |
         if (jj_3R_348()) return true;
6602 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6603 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6604 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6605 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6606 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6607 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6608 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6609 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6610 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6611 | 0 |
         return false;
6612 |  |
       }
6613 |  |
6614 | 0 |
       final private boolean jj_3R_405() {
6615 | 0 |
         if (jj_3R_188()) return true;
6616 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6617 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
6618 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6619 | 0 |
         return false;
6620 |  |
       }
6621 |  |
6622 | 0 |
       final private boolean jj_3R_395() {
6623 | 0 |
         Token xsp;
6624 | 0 |
         xsp = jj_scanpos;
6625 | 0 |
         if (jj_3R_405()) {
6626 | 0 |
         jj_scanpos = xsp;
6627 | 0 |
         if (jj_3R_406()) {
6628 | 0 |
         jj_scanpos = xsp;
6629 | 0 |
         if (jj_3R_407()) {
6630 | 0 |
         jj_scanpos = xsp;
6631 | 0 |
         if (jj_3R_408()) return true;
6632 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6633 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6634 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6635 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6636 | 0 |
         return false;
6637 |  |
       }
6638 |  |
6639 | 0 |
       final private boolean jj_3R_283() {
6640 | 0 |
         Token xsp;
6641 | 0 |
         while (true) {
6642 | 0 |
           xsp = jj_scanpos;
6643 | 0 |
           if (jj_3R_301()) { jj_scanpos = xsp; break; }
6644 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6645 |  |
         }
6646 | 0 |
         if (jj_3R_68()) return true;
6647 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6648 | 0 |
         if (jj_3R_302()) return true;
6649 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6650 | 0 |
         xsp = jj_scanpos;
6651 | 0 |
         if (jj_3R_303()) jj_scanpos = xsp;
6652 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6653 | 0 |
         xsp = jj_scanpos;
6654 | 0 |
         if (jj_3R_304()) {
6655 | 0 |
         jj_scanpos = xsp;
6656 | 0 |
         if (jj_3R_305()) return true;
6657 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6658 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6659 | 0 |
         return false;
6660 |  |
       }
6661 |  |
6662 | 0 |
       final private boolean jj_3R_263() {
6663 | 0 |
         if (jj_3R_61()) return true;
6664 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6665 | 0 |
         Token xsp;
6666 | 0 |
         while (true) {
6667 | 0 |
           xsp = jj_scanpos;
6668 | 0 |
           if (jj_3_10()) { jj_scanpos = xsp; break; }
6669 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6670 |  |
         }
6671 | 0 |
         return false;
6672 |  |
       }
6673 |  |
6674 | 0 |
       final private boolean jj_3R_179() {
6675 | 0 |
         if (jj_3R_191()) return true;
6676 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6677 | 0 |
         return false;
6678 |  |
       }
6679 |  |
6680 | 10976 |
       final private boolean jj_3R_72() {
6681 | 10976 |
         if (jj_scan_token(FINAL)) return true;
6682 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6683 | 0 |
         return false;
6684 |  |
       }
6685 |  |
6686 | 10976 |
       final private boolean jj_3_29() {
6687 | 10976 |
         Token xsp;
6688 | 10976 |
         xsp = jj_scanpos;
6689 | 10976 |
         if (jj_3R_72()) jj_scanpos = xsp;
6690 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6691 | 3838 |
         if (jj_3R_73()) return true;
6692 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6693 | 5074 |
         if (jj_scan_token(IDENTIFIER)) return true;
6694 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6695 | 2064 |
         return false;
6696 |  |
       }
6697 |  |
6698 | 0 |
       final private boolean jj_3R_411() {
6699 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
6700 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6701 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
6702 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6703 | 0 |
         return false;
6704 |  |
       }
6705 |  |
6706 | 204 |
       final private boolean jj_3R_150() {
6707 | 204 |
         if (jj_scan_token(LBRACE)) return true;
6708 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6709 | 0 |
         Token xsp;
6710 | 0 |
         xsp = jj_scanpos;
6711 | 0 |
         if (jj_3R_263()) jj_scanpos = xsp;
6712 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6713 | 0 |
         xsp = jj_scanpos;
6714 | 0 |
         if (jj_3R_264()) jj_scanpos = xsp;
6715 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6716 | 0 |
         if (jj_scan_token(RBRACE)) return true;
6717 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6718 | 0 |
         return false;
6719 |  |
       }
6720 |  |
6721 | 0 |
       final private boolean jj_3R_178() {
6722 | 0 |
         if (jj_3R_190()) return true;
6723 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6724 | 0 |
         return false;
6725 |  |
       }
6726 |  |
6727 | 0 |
       final private boolean jj_3R_177() {
6728 | 0 |
         if (jj_3R_189()) return true;
6729 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6730 | 0 |
         return false;
6731 |  |
       }
6732 |  |
6733 | 0 |
       final private boolean jj_3R_402() {
6734 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
6735 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6736 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
6737 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6738 | 0 |
         return false;
6739 |  |
       }
6740 |  |
6741 | 204 |
       final private boolean jj_3R_115() {
6742 | 0 |
         if (jj_3R_70()) return true;
6743 | 204 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6744 | 0 |
         return false;
6745 |  |
       }
6746 |  |
6747 | 0 |
       final private boolean jj_3R_362() {
6748 | 0 |
         if (jj_scan_token(ASSIGN)) return true;
6749 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6750 | 0 |
         if (jj_3R_61()) return true;
6751 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6752 | 0 |
         return false;
6753 |  |
       }
6754 |  |
6755 | 204 |
       final private boolean jj_3R_114() {
6756 | 204 |
         if (jj_3R_150()) return true;
6757 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6758 | 0 |
         return false;
6759 |  |
       }
6760 |  |
6761 | 204 |
       final private boolean jj_3R_61() {
6762 | 204 |
         Token xsp;
6763 | 204 |
         xsp = jj_scanpos;
6764 | 204 |
         if (jj_3R_114()) {
6765 | 204 |
         jj_scanpos = xsp;
6766 | 0 |
         if (jj_3R_115()) return true;
6767 | 204 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6768 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6769 | 0 |
         return false;
6770 |  |
       }
6771 |  |
6772 | 0 |
       final private boolean jj_3R_169() {
6773 | 0 |
         Token xsp;
6774 | 0 |
         xsp = jj_scanpos;
6775 | 0 |
         if (jj_3R_176()) {
6776 | 0 |
         jj_scanpos = xsp;
6777 | 0 |
         if (jj_3R_177()) {
6778 | 0 |
         jj_scanpos = xsp;
6779 | 0 |
         if (jj_3R_178()) {
6780 | 0 |
         jj_scanpos = xsp;
6781 | 0 |
         if (jj_3R_179()) return true;
6782 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6783 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6784 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6785 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6786 | 0 |
         return false;
6787 |  |
       }
6788 |  |
6789 | 0 |
       final private boolean jj_3R_176() {
6790 | 0 |
         if (jj_3R_188()) return true;
6791 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6792 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
6793 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6794 | 0 |
         return false;
6795 |  |
       }
6796 |  |
6797 | 0 |
       final private boolean jj_3R_409() {
6798 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
6799 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6800 | 0 |
         Token xsp;
6801 | 0 |
         while (true) {
6802 | 0 |
           xsp = jj_scanpos;
6803 | 0 |
           if (jj_3R_411()) { jj_scanpos = xsp; break; }
6804 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6805 |  |
         }
6806 | 0 |
         return false;
6807 |  |
       }
6808 |  |
6809 | 0 |
       final private boolean jj_3R_376() {
6810 | 0 |
         if (jj_scan_token(SEMICOLON)) 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_410() {
6816 | 0 |
         if (jj_scan_token(ASSIGN)) return true;
6817 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6818 | 0 |
         if (jj_3R_61()) return true;
6819 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6820 | 0 |
         return false;
6821 |  |
       }
6822 |  |
6823 | 0 |
       final private boolean jj_3R_377() {
6824 | 0 |
         if (jj_scan_token(LBRACKET)) return true;
6825 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6826 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
6827 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6828 | 0 |
         return false;
6829 |  |
       }
6830 |  |
6831 | 0 |
       final private boolean jj_3R_375() {
6832 | 0 |
         if (jj_3R_395()) return true;
6833 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6834 | 0 |
         return false;
6835 |  |
       }
6836 |  |
6837 | 0 |
       final private boolean jj_3R_393() {
6838 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
6839 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6840 | 0 |
         Token xsp;
6841 | 0 |
         while (true) {
6842 | 0 |
           xsp = jj_scanpos;
6843 | 0 |
           if (jj_3R_402()) { jj_scanpos = xsp; break; }
6844 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6845 |  |
         }
6846 | 0 |
         return false;
6847 |  |
       }
6848 |  |
6849 | 0 |
       final private boolean jj_3R_350() {
6850 | 0 |
         if (jj_scan_token(LBRACE)) return true;
6851 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6852 | 0 |
         Token xsp;
6853 | 0 |
         while (true) {
6854 | 0 |
           xsp = jj_scanpos;
6855 | 0 |
           if (jj_3R_375()) { jj_scanpos = xsp; break; }
6856 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6857 |  |
         }
6858 | 0 |
         if (jj_scan_token(RBRACE)) return true;
6859 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6860 | 0 |
         xsp = jj_scanpos;
6861 | 0 |
         if (jj_3R_376()) jj_scanpos = xsp;
6862 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6863 | 0 |
         return false;
6864 |  |
       }
6865 |  |
6866 | 0 |
       final private boolean jj_3R_140() {
6867 | 0 |
         if (jj_3R_169()) return true;
6868 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6869 | 0 |
         return false;
6870 |  |
       }
6871 |  |
6872 | 7564 |
       final private boolean jj_3R_81() {
6873 | 7532 |
         if (jj_scan_token(LBRACE)) return true;
6874 | 32 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6875 | 0 |
         Token xsp;
6876 | 0 |
         while (true) {
6877 | 0 |
           xsp = jj_scanpos;
6878 | 0 |
           if (jj_3R_140()) { jj_scanpos = xsp; break; }
6879 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6880 |  |
         }
6881 | 0 |
         if (jj_scan_token(RBRACE)) return true;
6882 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6883 | 0 |
         return false;
6884 |  |
       }
6885 |  |
6886 | 0 |
       final private boolean jj_3R_361() {
6887 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
6888 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6889 | 0 |
         Token xsp;
6890 | 0 |
         while (true) {
6891 | 0 |
           xsp = jj_scanpos;
6892 | 0 |
           if (jj_3R_377()) { jj_scanpos = xsp; break; }
6893 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6894 |  |
         }
6895 | 0 |
         return false;
6896 |  |
       }
6897 |  |
6898 | 23702 |
       final private boolean jj_3R_71() {
6899 | 16278 |
         if (jj_scan_token(IDENTIFIER)) return true;
6900 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6901 | 7424 |
         if (jj_scan_token(COLON)) return true;
6902 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6903 | 0 |
         if (jj_3R_189()) return true;
6904 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6905 | 0 |
         return false;
6906 |  |
       }
6907 |  |
6908 | 0 |
       final private boolean jj_3R_212() {
6909 | 0 |
         if (jj_3R_242()) return true;
6910 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6911 | 0 |
         return false;
6912 |  |
       }
6913 |  |
6914 | 0 |
       final private boolean jj_3R_403() {
6915 | 0 |
         if (jj_3R_409()) return true;
6916 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6917 | 0 |
         Token xsp;
6918 | 0 |
         xsp = jj_scanpos;
6919 | 0 |
         if (jj_3R_410()) jj_scanpos = xsp;
6920 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6921 | 0 |
         return false;
6922 |  |
       }
6923 |  |
6924 | 3324 |
       final private boolean jj_3R_113() {
6925 | 3324 |
         if (jj_scan_token(STRICTFP)) return true;
6926 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6927 | 0 |
         return false;
6928 |  |
       }
6929 |  |
6930 | 0 |
       final private boolean jj_3R_211() {
6931 | 0 |
         if (jj_3R_241()) return true;
6932 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6933 | 0 |
         return false;
6934 |  |
       }
6935 |  |
6936 | 46 |
       final private boolean jj_3_26() {
6937 | 46 |
         if (jj_scan_token(LBRACKET)) return true;
6938 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6939 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
6940 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6941 | 0 |
         return false;
6942 |  |
       }
6943 |  |
6944 | 3344 |
       final private boolean jj_3R_106() {
6945 | 3344 |
         if (jj_scan_token(STRICTFP)) return true;
6946 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6947 | 0 |
         return false;
6948 |  |
       }
6949 |  |
6950 | 0 |
       final private boolean jj_3R_210() {
6951 | 0 |
         if (jj_3R_240()) return true;
6952 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6953 | 0 |
         return false;
6954 |  |
       }
6955 |  |
6956 | 0 |
       final private boolean jj_3R_209() {
6957 | 0 |
         if (jj_3R_239()) return true;
6958 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6959 | 0 |
         return false;
6960 |  |
       }
6961 |  |
6962 | 0 |
       final private boolean jj_3R_308() {
6963 | 0 |
         if (jj_3R_361()) return true;
6964 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6965 | 0 |
         Token xsp;
6966 | 0 |
         xsp = jj_scanpos;
6967 | 0 |
         if (jj_3R_362()) jj_scanpos = xsp;
6968 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6969 | 0 |
         return false;
6970 |  |
       }
6971 |  |
6972 | 0 |
       final private boolean jj_3R_208() {
6973 | 0 |
         if (jj_3R_238()) return true;
6974 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6975 | 0 |
         return false;
6976 |  |
       }
6977 |  |
6978 | 0 |
       final private boolean jj_3R_207() {
6979 | 0 |
         if (jj_3R_237()) return true;
6980 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6981 | 0 |
         return false;
6982 |  |
       }
6983 |  |
6984 | 0 |
       final private boolean jj_3R_206() {
6985 | 0 |
         if (jj_3R_236()) return true;
6986 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6987 | 0 |
         return false;
6988 |  |
       }
6989 |  |
6990 | 3364 |
       final private boolean jj_3R_112() {
6991 | 3324 |
         if (jj_scan_token(PRIVATE)) return true;
6992 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6993 | 40 |
         return false;
6994 |  |
       }
6995 |  |
6996 | 0 |
       final private boolean jj_3R_205() {
6997 | 0 |
         if (jj_3R_235()) return true;
6998 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
6999 | 0 |
         return false;
7000 |  |
       }
7001 |  |
7002 | 3384 |
       final private boolean jj_3R_105() {
7003 | 3344 |
         if (jj_scan_token(PRIVATE)) return true;
7004 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7005 | 40 |
         return false;
7006 |  |
       }
7007 |  |
7008 | 0 |
       final private boolean jj_3R_204() {
7009 | 0 |
         if (jj_3R_234()) return true;
7010 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7011 | 0 |
         return false;
7012 |  |
       }
7013 |  |
7014 | 0 |
       final private boolean jj_3R_203() {
7015 | 0 |
         if (jj_3R_233()) return true;
7016 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7017 | 0 |
         return false;
7018 |  |
       }
7019 |  |
7020 | 0 |
       final private boolean jj_3R_202() {
7021 | 0 |
         if (jj_3R_232()) return true;
7022 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7023 | 0 |
         return false;
7024 |  |
       }
7025 |  |
7026 | 0 |
       final private boolean jj_3R_201() {
7027 | 0 |
         if (jj_3R_231()) return true;
7028 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7029 | 0 |
         return false;
7030 |  |
       }
7031 |  |
7032 | 0 |
       final private boolean jj_3R_200() {
7033 | 0 |
         if (jj_3R_230()) return true;
7034 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7035 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
7036 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7037 | 0 |
         return false;
7038 |  |
       }
7039 |  |
7040 | 0 |
       final private boolean jj_3R_309() {
7041 | 0 |
         if (jj_scan_token(COMMA)) return true;
7042 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7043 | 0 |
         if (jj_3R_308()) return true;
7044 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7045 | 0 |
         return false;
7046 |  |
       }
7047 |  |
7048 | 0 |
       final private boolean jj_3R_199() {
7049 | 0 |
         if (jj_3R_229()) return true;
7050 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7051 | 0 |
         return false;
7052 |  |
       }
7053 |  |
7054 | 3364 |
       final private boolean jj_3R_111() {
7055 | 3364 |
         if (jj_scan_token(PROTECTED)) return true;
7056 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7057 | 0 |
         return false;
7058 |  |
       }
7059 |  |
7060 | 0 |
       final private boolean jj_3R_198() {
7061 | 0 |
         if (jj_3R_81()) return true;
7062 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7063 | 0 |
         return false;
7064 |  |
       }
7065 |  |
7066 | 3384 |
       final private boolean jj_3R_104() {
7067 | 3384 |
         if (jj_scan_token(PROTECTED)) return true;
7068 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7069 | 0 |
         return false;
7070 |  |
       }
7071 |  |
7072 | 23702 |
       final private boolean jj_3_28() {
7073 | 23702 |
         if (jj_3R_71()) return true;
7074 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7075 | 0 |
         return false;
7076 |  |
       }
7077 |  |
7078 | 0 |
       final private boolean jj_3R_189() {
7079 | 0 |
         Token xsp;
7080 | 0 |
         xsp = jj_scanpos;
7081 | 0 |
         if (jj_3_28()) {
7082 | 0 |
         jj_scanpos = xsp;
7083 | 0 |
         if (jj_3R_198()) {
7084 | 0 |
         jj_scanpos = xsp;
7085 | 0 |
         if (jj_3R_199()) {
7086 | 0 |
         jj_scanpos = xsp;
7087 | 0 |
         if (jj_3R_200()) {
7088 | 0 |
         jj_scanpos = xsp;
7089 | 0 |
         if (jj_3R_201()) {
7090 | 0 |
         jj_scanpos = xsp;
7091 | 0 |
         if (jj_3R_202()) {
7092 | 0 |
         jj_scanpos = xsp;
7093 | 0 |
         if (jj_3R_203()) {
7094 | 0 |
         jj_scanpos = xsp;
7095 | 0 |
         if (jj_3R_204()) {
7096 | 0 |
         jj_scanpos = xsp;
7097 | 0 |
         if (jj_3R_205()) {
7098 | 0 |
         jj_scanpos = xsp;
7099 | 0 |
         if (jj_3R_206()) {
7100 | 0 |
         jj_scanpos = xsp;
7101 | 0 |
         if (jj_3R_207()) {
7102 | 0 |
         jj_scanpos = xsp;
7103 | 0 |
         if (jj_3R_208()) {
7104 | 0 |
         jj_scanpos = xsp;
7105 | 0 |
         if (jj_3R_209()) {
7106 | 0 |
         jj_scanpos = xsp;
7107 | 0 |
         if (jj_3R_210()) {
7108 | 0 |
         jj_scanpos = xsp;
7109 | 0 |
         if (jj_3R_211()) {
7110 | 0 |
         jj_scanpos = xsp;
7111 | 0 |
         if (jj_3R_212()) 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 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7115 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7116 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7117 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7118 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7119 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7120 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7121 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7122 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7123 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7124 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7125 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7126 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7127 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7128 | 0 |
         return false;
7129 |  |
       }
7130 |  |
7131 | 0 |
       final private boolean jj_3R_357() {
7132 | 0 |
         if (jj_scan_token(VOLATILE)) return true;
7133 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7134 | 0 |
         return false;
7135 |  |
       }
7136 |  |
7137 | 0 |
       final private boolean jj_3R_356() {
7138 | 0 |
         if (jj_scan_token(TRANSIENT)) return true;
7139 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7140 | 0 |
         return false;
7141 |  |
       }
7142 |  |
7143 | 3764 |
       final private boolean jj_3R_110() {
7144 | 3364 |
         if (jj_scan_token(PUBLIC)) return true;
7145 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7146 | 400 |
         return false;
7147 |  |
       }
7148 |  |
7149 | 72 |
       final private boolean jj_3R_259() {
7150 | 72 |
         if (jj_scan_token(LBRACKET)) return true;
7151 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7152 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
7153 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7154 | 0 |
         return false;
7155 |  |
       }
7156 |  |
7157 | 0 |
       final private boolean jj_3R_355() {
7158 | 0 |
         if (jj_scan_token(FINAL)) return true;
7159 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7160 | 0 |
         return false;
7161 |  |
       }
7162 |  |
7163 | 3784 |
       final private boolean jj_3R_103() {
7164 | 3384 |
         if (jj_scan_token(PUBLIC)) return true;
7165 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7166 | 400 |
         return false;
7167 |  |
       }
7168 |  |
7169 | 188 |
       final private boolean jj_3_25() {
7170 | 118 |
         if (jj_scan_token(LBRACKET)) return true;
7171 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7172 | 24 |
         if (jj_3R_70()) return true;
7173 | 46 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7174 | 0 |
         if (jj_scan_token(RBRACKET)) return true;
7175 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7176 | 0 |
         return false;
7177 |  |
       }
7178 |  |
7179 | 72 |
       final private boolean jj_3R_255() {
7180 | 72 |
         Token xsp;
7181 | 72 |
         if (jj_3R_259()) return true;
7182 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7183 | 0 |
         while (true) {
7184 | 0 |
           xsp = jj_scanpos;
7185 | 0 |
           if (jj_3R_259()) { jj_scanpos = xsp; break; }
7186 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7187 |  |
         }
7188 | 0 |
         if (jj_3R_150()) return true;
7189 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7190 | 0 |
         return false;
7191 |  |
       }
7192 |  |
7193 | 0 |
       final private boolean jj_3R_354() {
7194 | 0 |
         if (jj_scan_token(STATIC)) return true;
7195 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7196 | 0 |
         return false;
7197 |  |
       }
7198 |  |
7199 | 142 |
       final private boolean jj_3_27() {
7200 | 142 |
         Token xsp;
7201 | 96 |
         if (jj_3_25()) return true;
7202 | 46 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7203 | 0 |
         while (true) {
7204 | 0 |
           xsp = jj_scanpos;
7205 | 0 |
           if (jj_3_25()) { jj_scanpos = xsp; break; }
7206 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7207 |  |
         }
7208 | 0 |
         while (true) {
7209 | 0 |
           xsp = jj_scanpos;
7210 | 0 |
           if (jj_3_26()) { jj_scanpos = xsp; break; }
7211 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7212 |  |
         }
7213 | 0 |
         return false;
7214 |  |
       }
7215 |  |
7216 | 72 |
       final private boolean jj_3R_248() {
7217 | 72 |
         Token xsp;
7218 | 72 |
         xsp = jj_scanpos;
7219 | 72 |
         if (jj_3_27()) {
7220 | 72 |
         jj_scanpos = xsp;
7221 | 72 |
         if (jj_3R_255()) return true;
7222 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7223 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7224 | 0 |
         return false;
7225 |  |
       }
7226 |  |
7227 | 3776 |
       final private boolean jj_3R_109() {
7228 | 3764 |
         if (jj_scan_token(FINAL)) return true;
7229 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7230 | 12 |
         return false;
7231 |  |
       }
7232 |  |
7233 | 0 |
       final private boolean jj_3R_353() {
7234 | 0 |
         if (jj_scan_token(PRIVATE)) return true;
7235 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7236 | 0 |
         return false;
7237 |  |
       }
7238 |  |
7239 | 3796 |
       final private boolean jj_3R_102() {
7240 | 3784 |
         if (jj_scan_token(FINAL)) return true;
7241 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7242 | 12 |
         return false;
7243 |  |
       }
7244 |  |
7245 | 0 |
       final private boolean jj_3R_352() {
7246 | 0 |
         if (jj_scan_token(PROTECTED)) return true;
7247 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7248 | 0 |
         return false;
7249 |  |
       }
7250 |  |
7251 | 0 |
       final private boolean jj_3R_351() {
7252 | 0 |
         if (jj_scan_token(PUBLIC)) return true;
7253 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7254 | 0 |
         return false;
7255 |  |
       }
7256 |  |
7257 | 0 |
       final private boolean jj_3R_306() {
7258 | 0 |
         Token xsp;
7259 | 0 |
         xsp = jj_scanpos;
7260 | 0 |
         if (jj_3R_351()) {
7261 | 0 |
         jj_scanpos = xsp;
7262 | 0 |
         if (jj_3R_352()) {
7263 | 0 |
         jj_scanpos = xsp;
7264 | 0 |
         if (jj_3R_353()) {
7265 | 0 |
         jj_scanpos = xsp;
7266 | 0 |
         if (jj_3R_354()) {
7267 | 0 |
         jj_scanpos = xsp;
7268 | 0 |
         if (jj_3R_355()) {
7269 | 0 |
         jj_scanpos = xsp;
7270 | 0 |
         if (jj_3R_356()) {
7271 | 0 |
         jj_scanpos = xsp;
7272 | 0 |
         if (jj_3R_357()) return true;
7273 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7274 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7275 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7276 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7277 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7278 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7279 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7280 | 0 |
         return false;
7281 |  |
       }
7282 |  |
7283 | 0 |
       final private boolean jj_3R_284() {
7284 | 0 |
         Token xsp;
7285 | 0 |
         while (true) {
7286 | 0 |
           xsp = jj_scanpos;
7287 | 0 |
           if (jj_3R_306()) { jj_scanpos = xsp; break; }
7288 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7289 |  |
         }
7290 | 0 |
         if (jj_3R_307()) return true;
7291 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7292 | 0 |
         if (jj_3R_308()) return true;
7293 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7294 | 0 |
         while (true) {
7295 | 0 |
           xsp = jj_scanpos;
7296 | 0 |
           if (jj_3R_309()) { jj_scanpos = xsp; break; }
7297 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7298 |  |
         }
7299 | 0 |
         if (jj_scan_token(SEMICOLON)) return true;
7300 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7301 | 0 |
         return false;
7302 |  |
       }
7303 |  |
7304 | 3776 |
       final private boolean jj_3R_108() {
7305 | 3776 |
         if (jj_scan_token(ABSTRACT)) return true;
7306 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7307 | 0 |
         return false;
7308 |  |
       }
7309 |  |
7310 | 3796 |
       final private boolean jj_3R_101() {
7311 | 3796 |
         if (jj_scan_token(ABSTRACT)) return true;
7312 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7313 | 0 |
         return false;
7314 |  |
       }
7315 |  |
7316 | 72 |
       final private boolean jj_3R_256() {
7317 | 72 |
         if (jj_3R_260()) return true;
7318 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7319 | 0 |
         return false;
7320 |  |
       }
7321 |  |
7322 | 72 |
       final private boolean jj_3R_250() {
7323 | 0 |
         if (jj_3R_64()) return true;
7324 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7325 | 72 |
         Token xsp;
7326 | 72 |
         xsp = jj_scanpos;
7327 | 72 |
         if (jj_3R_256()) jj_scanpos = xsp;
7328 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7329 | 72 |
         return false;
7330 |  |
       }
7331 |  |
7332 | 72 |
       final private boolean jj_3R_249() {
7333 | 72 |
         if (jj_3R_248()) return true;
7334 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7335 | 0 |
         return false;
7336 |  |
       }
7337 |  |
7338 | 3304 |
       final private boolean jj_3_9() {
7339 | 52 |
         if (jj_3R_58()) return true;
7340 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7341 | 3252 |
         return false;
7342 |  |
       }
7343 |  |
7344 | 3788 |
       final private boolean jj_3R_107() {
7345 | 3776 |
         if (jj_scan_token(STATIC)) return true;
7346 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7347 | 12 |
         return false;
7348 |  |
       }
7349 |  |
7350 | 3788 |
       final private boolean jj_3R_60() {
7351 | 3788 |
         Token xsp;
7352 | 3788 |
         xsp = jj_scanpos;
7353 | 3788 |
         if (jj_3R_107()) {
7354 | 3776 |
         jj_scanpos = xsp;
7355 | 3776 |
         if (jj_3R_108()) {
7356 | 3776 |
         jj_scanpos = xsp;
7357 | 3776 |
         if (jj_3R_109()) {
7358 | 3764 |
         jj_scanpos = xsp;
7359 | 3764 |
         if (jj_3R_110()) {
7360 | 3364 |
         jj_scanpos = xsp;
7361 | 3364 |
         if (jj_3R_111()) {
7362 | 3364 |
         jj_scanpos = xsp;
7363 | 3364 |
         if (jj_3R_112()) {
7364 | 3324 |
         jj_scanpos = xsp;
7365 | 3324 |
         if (jj_3R_113()) return true;
7366 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7367 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7368 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7369 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7370 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7371 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7372 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7373 | 464 |
         return false;
7374 |  |
       }
7375 |  |
7376 | 3324 |
       final private boolean jj_3_8() {
7377 | 3324 |
         Token xsp;
7378 | 3324 |
         while (true) {
7379 | 3788 |
           xsp = jj_scanpos;
7380 | 3324 |
           if (jj_3R_60()) { jj_scanpos = xsp; break; }
7381 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7382 |  |
         }
7383 | 3304 |
         if (jj_scan_token(INTERFACE)) return true;
7384 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7385 | 20 |
         return false;
7386 |  |
       }
7387 |  |
7388 | 710 |
       final private boolean jj_3R_171() {
7389 | 318 |
         if (jj_scan_token(COMMA)) return true;
7390 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7391 | 0 |
         if (jj_3R_70()) return true;
7392 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7393 | 392 |
         return false;
7394 |  |
       }
7395 |  |
7396 | 3820 |
       final private boolean jj_3R_100() {
7397 | 3796 |
         if (jj_scan_token(STATIC)) return true;
7398 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7399 | 24 |
         return false;
7400 |  |
       }
7401 |  |
7402 | 3820 |
       final private boolean jj_3R_59() {
7403 | 3820 |
         Token xsp;
7404 | 3820 |
         xsp = jj_scanpos;
7405 | 3820 |
         if (jj_3R_100()) {
7406 | 3796 |
         jj_scanpos = xsp;
7407 | 3796 |
         if (jj_3R_101()) {
7408 | 3796 |
         jj_scanpos = xsp;
7409 | 3796 |
         if (jj_3R_102()) {
7410 | 3784 |
         jj_scanpos = xsp;
7411 | 3784 |
         if (jj_3R_103()) {
7412 | 3384 |
         jj_scanpos = xsp;
7413 | 3384 |
         if (jj_3R_104()) {
7414 | 3384 |
         jj_scanpos = xsp;
7415 | 3384 |
         if (jj_3R_105()) {
7416 | 3344 |
         jj_scanpos = xsp;
7417 | 3344 |
         if (jj_3R_106()) return true;
7418 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7419 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7420 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7421 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7422 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7423 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7424 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7425 | 476 |
         return false;
7426 |  |
       }
7427 |  |
7428 | 20754 |
       final private boolean jj_3R_135() {
7429 | 20682 |
         if (jj_scan_token(NEW)) return true;
7430 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7431 | 0 |
         if (jj_3R_57()) return true;
7432 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7433 | 72 |
         Token xsp;
7434 | 72 |
         xsp = jj_scanpos;
7435 | 72 |
         if (jj_3R_249()) {
7436 | 72 |
         jj_scanpos = xsp;
7437 | 0 |
         if (jj_3R_250()) return true;
7438 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7439 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7440 | 72 |
         return false;
7441 |  |
       }
7442 |  |
7443 | 3344 |
       final private boolean jj_3_7() {
7444 | 3344 |
         Token xsp;
7445 | 3344 |
         while (true) {
7446 | 3820 |
           xsp = jj_scanpos;
7447 | 3344 |
           if (jj_3R_59()) { jj_scanpos = xsp; break; }
7448 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7449 |  |
         }
7450 | 3324 |
         if (jj_scan_token(CLASS)) return true;
7451 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7452 | 20 |
         return false;
7453 |  |
       }
7454 |  |
7455 | 23480 |
       final private boolean jj_3_24() {
7456 | 20682 |
         if (jj_scan_token(NEW)) return true;
7457 | 190 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7458 | 2608 |
         if (jj_3R_66()) return true;
7459 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7460 | 0 |
         if (jj_3R_248()) return true;
7461 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7462 | 0 |
         return false;
7463 |  |
       }
7464 |  |
7465 | 20944 |
       final private boolean jj_3R_69() {
7466 | 20944 |
         Token xsp;
7467 | 20944 |
         xsp = jj_scanpos;
7468 | 20944 |
         if (jj_3_24()) {
7469 | 20754 |
         jj_scanpos = xsp;
7470 | 20682 |
         if (jj_3R_135()) return true;
7471 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7472 | 190 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7473 | 72 |
         return false;
7474 |  |
       }
7475 |  |
7476 | 0 |
       final private boolean jj_3R_390() {
7477 | 0 |
         if (jj_3R_284()) return true;
7478 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7479 | 0 |
         return false;
7480 |  |
       }
7481 |  |
7482 | 0 |
       final private boolean jj_3R_389() {
7483 | 0 |
         if (jj_3R_283()) return true;
7484 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7485 | 0 |
         return false;
7486 |  |
       }
7487 |  |
7488 | 0 |
       final private boolean jj_3R_388() {
7489 | 0 |
         if (jj_3R_281()) return true;
7490 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7491 | 0 |
         return false;
7492 |  |
       }
7493 |  |
7494 | 0 |
       final private boolean jj_3R_387() {
7495 | 0 |
         if (jj_3R_280()) return true;
7496 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7497 | 0 |
         return false;
7498 |  |
       }
7499 |  |
7500 | 0 |
       final private boolean jj_3R_370() {
7501 | 0 |
         Token xsp;
7502 | 0 |
         xsp = jj_scanpos;
7503 | 0 |
         if (jj_3R_387()) {
7504 | 0 |
         jj_scanpos = xsp;
7505 | 0 |
         if (jj_3R_388()) {
7506 | 0 |
         jj_scanpos = xsp;
7507 | 0 |
         if (jj_3R_389()) {
7508 | 0 |
         jj_scanpos = xsp;
7509 | 0 |
         if (jj_3R_390()) return true;
7510 | 0 |
         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 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7513 | 0 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7514 | 0 |
         return false;
7515 |  |
       }
7516 |  |
7517 | 16308 |
       final private boolean jj_3R_158() {
7518 | 9046 |
         if (jj_3R_70()) return true;
7519 | 6944 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7520 | 318 |
         Token xsp;
7521 | 318 |
         while (true) {
7522 | 710 |
           xsp = jj_scanpos;
7523 | 318 |
           if (jj_3R_171()) { jj_scanpos = xsp; break; }
7524 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7525 |  |
         }
7526 | 318 |
         return false;
7527 |  |
       }
7528 |  |
7529 | 16308 |
       final private boolean jj_3R_119() {
7530 | 9046 |
         if (jj_3R_158()) return true;
7531 | 6944 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7532 | 318 |
         return false;
7533 |  |
       }
7534 |  |
7535 | 63674 |
       final private boolean jj_3R_64() {
7536 | 47366 |
         if (jj_scan_token(LPAREN)) return true;
7537 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7538 | 16308 |
         Token xsp;
7539 | 16308 |
         xsp = jj_scanpos;
7540 | 9046 |
         if (jj_3R_119()) jj_scanpos = xsp;
7541 | 6944 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7542 | 0 |
         if (jj_scan_token(RPAREN)) return true;
7543 | 9034 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7544 | 330 |
         return false;
7545 |  |
       }
7546 |  |
7547 | 0 |
       final private boolean jj_3R_334() {
7548 | 0 |
         if (jj_3R_370()) return true;
7549 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7550 | 0 |
         return false;
7551 |  |
       }
7552 |  |
7553 | 16108 |
       final private boolean jj_3R_193() {
7554 | 16016 |
         if (jj_scan_token(NULL)) return true;
7555 | 16 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7556 | 76 |
         return false;
7557 |  |
       }
7558 |  |
7559 | 0 |
       final private boolean jj_3R_333() {
7560 | 0 |
         if (jj_scan_token(EXTENDS)) return true;
7561 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7562 | 0 |
         if (jj_3R_369()) return true;
7563 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7564 | 0 |
         return false;
7565 |  |
       }
7566 |  |
7567 | 10254 |
       final private boolean jj_3R_149() {
7568 | 10254 |
         if (jj_scan_token(STRICTFP)) return true;
7569 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7570 | 0 |
         return false;
7571 |  |
       }
7572 |  |
7573 | 16292 |
       final private boolean jj_3R_214() {
7574 | 16108 |
         if (jj_scan_token(FALSE)) return true;
7575 | 136 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7576 | 48 |
         return false;
7577 |  |
       }
7578 |  |
7579 | 16328 |
       final private boolean jj_3R_192() {
7580 | 16328 |
         Token xsp;
7581 | 16328 |
         xsp = jj_scanpos;
7582 | 16328 |
         if (jj_3R_213()) {
7583 | 16292 |
         jj_scanpos = xsp;
7584 | 16108 |
         if (jj_3R_214()) return true;
7585 | 136 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7586 | 36 |
         } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7587 | 48 |
         return false;
7588 |  |
       }
7589 |  |
7590 | 16328 |
       final private boolean jj_3R_213() {
7591 | 16292 |
         if (jj_scan_token(TRUE)) return true;
7592 | 36 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7593 | 0 |
         return false;
7594 |  |
       }
7595 |  |
7596 | 48 |
       final private boolean jj_3R_166() {
7597 | 36 |
         if (jj_3R_170()) return true;
7598 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7599 | 12 |
         return false;
7600 |  |
       }
7601 |  |
7602 | 16108 |
       final private boolean jj_3R_185() {
7603 | 16016 |
         if (jj_3R_193()) return true;
7604 | 16 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7605 | 76 |
         return false;
7606 |  |
       }
7607 |  |
7608 | 16328 |
       final private boolean jj_3R_184() {
7609 | 16108 |
         if (jj_3R_192()) return true;
7610 | 172 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7611 | 48 |
         return false;
7612 |  |
       }
7613 |  |
7614 | 17352 |
       final private boolean jj_3R_183() {
7615 | 16328 |
         if (jj_scan_token(STRING_LITERAL)) return true;
7616 | 998 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7617 | 26 |
         return false;
7618 |  |
       }
7619 |  |
7620 | 10254 |
       final private boolean jj_3R_148() {
7621 | 10254 |
         if (jj_scan_token(SYNCHRONIZED)) return true;
7622 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7623 | 0 |
         return false;
7624 |  |
       }
7625 |  |
7626 | 17536 |
       final private boolean jj_3R_182() {
7627 | 17352 |
         if (jj_scan_token(CHARACTER_LITERAL)) return true;
7628 | 184 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7629 | 0 |
         return false;
7630 |  |
       }
7631 |  |
7632 | 48 |
       final private boolean jj_3R_165() {
7633 | 48 |
         if (jj_scan_token(NEW)) return true;
7634 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7635 | 0 |
         return false;
7636 |  |
       }
7637 |  |
7638 | 17536 |
       final private boolean jj_3R_181() {
7639 | 17536 |
         if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
7640 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7641 | 0 |
         return false;
7642 |  |
       }
7643 |  |
7644 | 0 |
       final private boolean jj_3R_191() {
7645 | 0 |
         if (jj_scan_token(INTERFACE)) return true;
7646 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7647 | 0 |
         if (jj_scan_token(IDENTIFIER)) return true;
7648 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7649 | 0 |
         Token xsp;
7650 | 0 |
         xsp = jj_scanpos;
7651 | 0 |
         if (jj_3R_333()) jj_scanpos = xsp;
7652 | 0 |
         else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7653 | 0 |
         if (jj_scan_token(LBRACE)) return true;
7654 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7655 | 0 |
         while (true) {
7656 | 0 |
           xsp = jj_scanpos;
7657 | 0 |
           if (jj_3R_334()) { jj_scanpos = xsp; break; }
7658 | 0 |
           if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7659 |  |
         }
7660 | 0 |
         if (jj_scan_token(RBRACE)) return true;
7661 | 0 |
         if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
7662 | 0 |
         return false;
7663 |  |
       }
7664 |  |
7665 |  |
       public SimpleParserTokenManager token_source;
7666 |  |
       JavaCharStream jj_input_stream;
7667 |  |
       public Token token, jj_nt;
7668 |  |
       private Token jj_scanpos, jj_lastpos;
7669 |  |
       private int jj_la;
7670 |  |
       public boolean lookingAhead = false;
7671 |  |
       private boolean jj_semLA;
7672 |  |
       private int jj_gen;
7673 |  |
       final private int[] jj_la1 = new int[129];
7674 |  |
       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,};
7675 |  |
       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,};
7676 |  |
       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,};
7677 |  |
       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,};
7678 |  |
       final private JJCalls[] jj_2_rtns = new JJCalls[31];
7679 |  |
       private boolean jj_rescan = false;
7680 |  |
       private int jj_gc = 0;
7681 |  |
7682 | 672 |
       public SimpleParser(java.io.InputStream stream) {
7683 | 672 |
         jj_input_stream = new JavaCharStream(stream, 1, 1);
7684 | 672 |
         token_source = new SimpleParserTokenManager(jj_input_stream);
7685 | 672 |
         token = new Token();
7686 | 672 |
         token.next = jj_nt = token_source.getNextToken();
7687 | 672 |
         jj_gen = 0;
7688 | 86688 |
         for (int i = 0; i < 129; i++) jj_la1[i] = -1;
7689 | 20832 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7690 |  |
       }
7691 |  |
7692 | 0 |
       public void ReInit(java.io.InputStream stream) {
7693 | 0 |
         jj_input_stream.ReInit(stream, 1, 1);
7694 | 0 |
         token_source.ReInit(jj_input_stream);
7695 | 0 |
         token = new Token();
7696 | 0 |
         token.next = jj_nt = token_source.getNextToken();
7697 | 0 |
         jj_gen = 0;
7698 | 0 |
         for (int i = 0; i < 129; i++) jj_la1[i] = -1;
7699 | 0 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7700 |  |
       }
7701 |  |
7702 | 0 |
       public SimpleParser(java.io.Reader stream) {
7703 | 0 |
         jj_input_stream = new JavaCharStream(stream, 1, 1);
7704 | 0 |
         token_source = new SimpleParserTokenManager(jj_input_stream);
7705 | 0 |
         token = new Token();
7706 | 0 |
         token.next = jj_nt = token_source.getNextToken();
7707 | 0 |
         jj_gen = 0;
7708 | 0 |
         for (int i = 0; i < 129; i++) jj_la1[i] = -1;
7709 | 0 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7710 |  |
       }
7711 |  |
7712 | 672 |
       public void ReInit(java.io.Reader stream) {
7713 | 672 |
         jj_input_stream.ReInit(stream, 1, 1);
7714 | 672 |
         token_source.ReInit(jj_input_stream);
7715 | 672 |
         token = new Token();
7716 | 672 |
         token.next = jj_nt = token_source.getNextToken();
7717 | 672 |
         jj_gen = 0;
7718 | 86688 |
         for (int i = 0; i < 129; i++) jj_la1[i] = -1;
7719 | 20832 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7720 |  |
       }
7721 |  |
7722 | 0 |
       public SimpleParser(SimpleParserTokenManager tm) {
7723 | 0 |
         token_source = tm;
7724 | 0 |
         token = new Token();
7725 | 0 |
         token.next = jj_nt = token_source.getNextToken();
7726 | 0 |
         jj_gen = 0;
7727 | 0 |
         for (int i = 0; i < 129; i++) jj_la1[i] = -1;
7728 | 0 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7729 |  |
       }
7730 |  |
7731 | 0 |
       public void ReInit(SimpleParserTokenManager tm) {
7732 | 0 |
         token_source = tm;
7733 | 0 |
         token = new Token();
7734 | 0 |
         token.next = jj_nt = token_source.getNextToken();
7735 | 0 |
         jj_gen = 0;
7736 | 0 |
         for (int i = 0; i < 129; i++) jj_la1[i] = -1;
7737 | 0 |
         for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
7738 |  |
       }
7739 |  |
7740 | 302040 |
       final private Token jj_consume_token(int kind) throws ParseException {
7741 | 302040 |
         Token oldToken = token;
7742 | ? |
         if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
7743 | 179158 |
         else jj_nt = jj_nt.next = token_source.getNextToken();
7744 | 302040 |
         if (token.kind == kind) {
7745 | 302040 |
           jj_gen++;
7746 | 302040 |
           if (++jj_gc > 100) {
7747 | 2684 |
             jj_gc = 0;
7748 | 2684 |
             for (int i = 0; i < jj_2_rtns.length; i++) {
7749 | 83204 |
               JJCalls c = jj_2_rtns[i];
7750 | 83204 |
               while (c != null) {
7751 | 80100 |
                 if (c.gen < jj_gen) c.first = null;
7752 | 85414 |
                 c = c.next;
7753 |  |
               }
7754 |  |
             }
7755 |  |
           }
7756 | 302040 |
           return token;
7757 |  |
         }
7758 | 0 |
         jj_nt = token;
7759 | 0 |
         token = oldToken;
7760 | 0 |
         jj_kind = kind;
7761 | 0 |
         throw generateParseException();
7762 |  |
       }
7763 |  |
7764 | 2553932 |
       final private boolean jj_scan_token(int kind) {
7765 | 2553932 |
         if (jj_scanpos == jj_lastpos) {
7766 | 555134 |
           jj_la--;
7767 | 555134 |
           if (jj_scanpos.next == null) {
7768 | 122882 |
             jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
7769 |  |
           } else {
7770 | 432252 |
             jj_lastpos = jj_scanpos = jj_scanpos.next;
7771 |  |
           }
7772 |  |
         } else {
7773 | 1998798 |
           jj_scanpos = jj_scanpos.next;
7774 |  |
         }
7775 | 2553932 |
         if (jj_rescan) {
7776 | 0 |
           int i = 0; Token tok = token;
7777 | 0 |
           while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
7778 | 0 |
           if (tok != null) jj_add_error_token(kind, i);
7779 |  |
         }
7780 | 2553932 |
         return (jj_scanpos.kind != kind);
7781 |  |
       }
7782 |  |
7783 | 0 |
       final public Token getNextToken() {
7784 | 0 |
         if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
7785 | 0 |
         else jj_nt = jj_nt.next = token_source.getNextToken();
7786 | 0 |
         jj_gen++;
7787 | 0 |
         return token;
7788 |  |
       }
7789 |  |
7790 | 0 |
       final public Token getToken(int index) {
7791 | 0 |
         Token t = lookingAhead ? jj_scanpos : token;
7792 | 0 |
         for (int i = 0; i < index; i++) {
7793 | 0 |
           if (t.next != null) t = t.next;
7794 | 0 |
           else t = t.next = token_source.getNextToken();
7795 |  |
         }
7796 | 0 |
         return t;
7797 |  |
       }
7798 |  |
7799 |  |
       private java.util.Vector jj_expentries = new java.util.Vector();
7800 |  |
       private int[] jj_expentry;
7801 |  |
       private int jj_kind = -1;
7802 |  |
       private int[] jj_lasttokens = new int[100];
7803 |  |
       private int jj_endpos;
7804 |  |
7805 | 0 |
       private void jj_add_error_token(int kind, int pos) {
7806 | 0 |
         if (pos >= 100) return;
7807 | 0 |
         if (pos == jj_endpos + 1) {
7808 | 0 |
           jj_lasttokens[jj_endpos++] = kind;
7809 | 0 |
         } else if (jj_endpos != 0) {
7810 | 0 |
           jj_expentry = new int[jj_endpos];
7811 | 0 |
           for (int i = 0; i < jj_endpos; i++) {
7812 | 0 |
             jj_expentry[i] = jj_lasttokens[i];
7813 |  |
           }
7814 | 0 |
           boolean exists = false;
7815 | 0 |
           for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
7816 | 0 |
             int[] oldentry = (int[])(enum.nextElement());
7817 | 0 |
             if (oldentry.length == jj_expentry.length) {
7818 | 0 |
               exists = true;
7819 | 0 |
               for (int i = 0; i < jj_expentry.length; i++) {
7820 | 0 |
                 if (oldentry[i] != jj_expentry[i]) {
7821 | 0 |
                   exists = false;
7822 | 0 |
                   break;
7823 |  |
                 }
7824 |  |
               }
7825 | 0 |
               if (exists) break;
7826 |  |
             }
7827 |  |
           }
7828 | 0 |
           if (!exists) jj_expentries.addElement(jj_expentry);
7829 | 0 |
           if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
7830 |  |
         }
7831 |  |
       }
7832 |  |
7833 | 0 |
       final public ParseException generateParseException() {
7834 | 0 |
         jj_expentries.removeAllElements();
7835 | 0 |
         boolean[] la1tokens = new boolean[122];
7836 | 0 |
         for (int i = 0; i < 122; i++) {
7837 | 0 |
           la1tokens[i] = false;
7838 |  |
         }
7839 | 0 |
         if (jj_kind >= 0) {
7840 | 0 |
           la1tokens[jj_kind] = true;
7841 | 0 |
           jj_kind = -1;
7842 |  |
         }
7843 | 0 |
         for (int i = 0; i < 129; i++) {
7844 | 0 |
           if (jj_la1[i] == jj_gen) {
7845 | 0 |
             for (int j = 0; j < 32; j++) {
7846 | 0 |
               if ((jj_la1_0[i] & (1<<j)) != 0) {
7847 | 0 |
                 la1tokens[j] = true;
7848 |  |
               }
7849 | 0 |
               if ((jj_la1_1[i] & (1<<j)) != 0) {
7850 | 0 |
                 la1tokens[32+j] = true;
7851 |  |
               }
7852 | 0 |
               if ((jj_la1_2[i] & (1<<j)) != 0) {
7853 | 0 |
                 la1tokens[64+j] = true;
7854 |  |
               }
7855 | 0 |
               if ((jj_la1_3[i] & (1<<j)) != 0) {
7856 | 0 |
                 la1tokens[96+j] = true;
7857 |  |
               }
7858 |  |
             }
7859 |  |
           }
7860 |  |
         }
7861 | 0 |
         for (int i = 0; i < 122; i++) {
7862 | 0 |
           if (la1tokens[i]) {
7863 | 0 |
             jj_expentry = new int[1];
7864 | 0 |
             jj_expentry[0] = i;
7865 | 0 |
             jj_expentries.addElement(jj_expentry);
7866 |  |
           }
7867 |  |
         }
7868 | 0 |
         jj_endpos = 0;
7869 | 0 |
         jj_rescan_token();
7870 | 0 |
         jj_add_error_token(0, 0);
7871 | 0 |
         int[][] exptokseq = new int[jj_expentries.size()][];
7872 | 0 |
         for (int i = 0; i < jj_expentries.size(); i++) {
7873 | 0 |
           exptokseq[i] = (int[])jj_expentries.elementAt(i);
7874 |  |
         }
7875 | 0 |
         return new ParseException(token, exptokseq, tokenImage);
7876 |  |
       }
7877 |  |
7878 | 0 |
       final public void enable_tracing() {
7879 |  |
       }
7880 |  |
7881 | 0 |
       final public void disable_tracing() {
7882 |  |
       }
7883 |  |
7884 | 0 |
       final private void jj_rescan_token() {
7885 | 0 |
         jj_rescan = true;
7886 | 0 |
         for (int i = 0; i < 31; i++) {
7887 | 0 |
           JJCalls p = jj_2_rtns[i];
7888 | 0 |
           do {
7889 | 0 |
             if (p.gen > jj_gen) {
7890 | 0 |
               jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
7891 | 0 |
               switch (i) {
7892 | 0 |
                 case 0: jj_3_1(); break;
7893 | 0 |
                 case 1: jj_3_2(); break;
7894 | 0 |
                 case 2: jj_3_3(); break;
7895 | 0 |
                 case 3: jj_3_4(); break;
7896 | 0 |
                 case 4: jj_3_5(); break;
7897 | 0 |
                 case 5: jj_3_6(); break;
7898 | 0 |
                 case 6: jj_3_7(); break;
7899 | 0 |
                 case 7: jj_3_8(); break;
7900 | 0 |
                 case 8: jj_3_9(); break;
7901 | 0 |
                 case 9: jj_3_10(); break;
7902 | 0 |
                 case 10: jj_3_11(); break;
7903 | 0 |
                 case 11: jj_3_12(); break;
7904 | 0 |
                 case 12: jj_3_13(); break;
7905 | 0 |
                 case 13: jj_3_14(); break;
7906 | 0 |
                 case 14: jj_3_15(); break;
7907 | 0 |
                 case 15: jj_3_16(); break;
7908 | 0 |
                 case 16: jj_3_17(); break;
7909 | 0 |
                 case 17: jj_3_18(); break;
7910 | 0 |
                 case 18: jj_3_19(); break;
7911 | 0 |
                 case 19: jj_3_20(); break;
7912 | 0 |
                 case 20: jj_3_21(); break;
7913 | 0 |
                 case 21: jj_3_22(); break;
7914 | 0 |
                 case 22: jj_3_23(); break;
7915 | 0 |
                 case 23: jj_3_24(); break;
7916 | 0 |
                 case 24: jj_3_25(); break;
7917 | 0 |
                 case 25: jj_3_26(); break;
7918 | 0 |
                 case 26: jj_3_27(); break;
7919 | 0 |
                 case 27: jj_3_28(); break;
7920 | 0 |
                 case 28: jj_3_29(); break;
7921 | 0 |
                 case 29: jj_3_30(); break;
7922 | 0 |
                 case 30: jj_3_31(); break;
7923 |  |
               }
7924 |  |
             }
7925 | 0 |
             p = p.next;
7926 | 0 |
           } while (p != null);
7927 |  |
         }
7928 | 0 |
         jj_rescan = false;
7929 |  |
       }
7930 |  |
7931 | 360576 |
       final private void jj_save(int index, int xla) {
7932 | 360576 |
         JJCalls p = jj_2_rtns[index];
7933 | 360576 |
         while (p.gen > jj_gen) {
7934 | 196 |
           if (p.next == null) { p = p.next = new JJCalls(); break; }
7935 | 1942 |
           p = p.next;
7936 |  |
         }
7937 | 360576 |
         p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
7938 |  |
       }
7939 |  |
7940 |  |
       static final class JJCalls {
7941 |  |
         int gen;
7942 |  |
         Token first;
7943 |  |
         int arg;
7944 |  |
         JJCalls next;
7945 |  |
       }
7946 |  |
7947 |  |
     }
7948 |  |