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