← Back to branch summary

~brian-thomason/+junk/jasperreports3.7

« back to all changes in this revision

Viewing changes to src/net/sf/jasperreports/olap/mapping/MappingParser.java

  • Committer: Brian Thomason
  • Date: 2011-12-20 17:51:16 UTC
  • Revision ID: brian.thomason@canonical.com-20111220175116-apwo6unuaedvgzo3
Initial import

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/net/sf/jasperreports/olap/mapping/MappingParser.java
 
1
// $ANTLR 2.7.5 (20050128): "mapping.g" -> "MappingParser.java"$
 
2
 
 
3
/*
 
4
 * JasperReports - Free Java Reporting Library.
 
5
 * Copyright (C) 2001 - 2009 Jaspersoft Corporation. All rights reserved.
 
6
 * http://www.jaspersoft.com
 
7
 *
 
8
 * Unless you have purchased a commercial license agreement from Jaspersoft,
 
9
 * the following license terms apply:
 
10
 *
 
11
 * This program is part of JasperReports.
 
12
 *
 
13
 * JasperReports is free software: you can redistribute it and/or modify
 
14
 * it under the terms of the GNU Lesser General Public License as published by
 
15
 * the Free Software Foundation, either version 3 of the License, or
 
16
 * (at your option) any later version.
 
17
 *
 
18
 * JasperReports is distributed in the hope that it will be useful,
 
19
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
20
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
21
 * GNU Lesser General Public License for more details.
 
22
 * 
 
23
 * You should have received a copy of the GNU Lesser General Public License
 
24
 * along with JasperReports. If not, see <http://www.gnu.org/licenses/>.
 
25
 */
 
26
package net.sf.jasperreports.olap.mapping;
 
27
 
 
28
import java.util.ArrayList;
 
29
import java.util.List;
 
30
import java.util.regex.Matcher;
 
31
import java.util.regex.Pattern;
 
32
 
 
33
import antlr.NoViableAltException;
 
34
import antlr.ParserSharedInputState;
 
35
import antlr.RecognitionException;
 
36
import antlr.Token;
 
37
import antlr.TokenBuffer;
 
38
import antlr.TokenStream;
 
39
import antlr.TokenStreamException;
 
40
import antlr.collections.impl.BitSet;
 
41
 
 
42
/**
 
43
 * @author Lucian Chirita (lucianc@users.sourceforge.net)
 
44
 * @version $Id: MappingParser.java 3740 2010-04-16 15:03:17Z lucianc $
 
45
 */
 
46
public class MappingParser extends antlr.LLkParser implements MappingParserTokenTypes
 
47
 {
 
48
 
 
49
        private MappingMetadata mappingMeta;
 
50
        
 
51
        public void setMappingMetadata(MappingMetadata mappingMeta)
 
52
        {
 
53
                this.mappingMeta = mappingMeta;
 
54
        }
 
55
        
 
56
        private String getMondrName (String text)
 
57
        {
 
58
                return text.substring(1, text.length() - 1).trim();
 
59
        }
 
60
        
 
61
        private static final Pattern IDX_PATTERN = Pattern.compile("#(\\d+)");
 
62
        private static final int IDX_GROUP = 1;
 
63
        
 
64
        private int getDimensionIndex(Axis axis, String dimensionName)
 
65
        {
 
66
                int idx;
 
67
                Matcher matcher = IDX_PATTERN.matcher(dimensionName);
 
68
                if (matcher.matches())
 
69
                {
 
70
                        String idxStr = matcher.group(IDX_GROUP);
 
71
                        idx = Integer.parseInt(idxStr);
 
72
                }
 
73
                else
 
74
                {
 
75
                        idx = mappingMeta.getDimensionIndex(axis, dimensionName);
 
76
                }
 
77
                return idx;
 
78
        }
 
79
        
 
80
        private int getLevelDepth(TuplePosition pos, String levelName)
 
81
        {
 
82
                int depth;
 
83
                Matcher matcher = IDX_PATTERN.matcher(levelName);
 
84
                if (matcher.matches())
 
85
                {
 
86
                        String depthStr = matcher.group(IDX_GROUP);
 
87
                        depth = Integer.parseInt(depthStr);
 
88
                }
 
89
                else
 
90
                {
 
91
                        depth = mappingMeta.getLevelDepth(pos, levelName);
 
92
                }
 
93
                return depth;
 
94
        }
 
95
 
 
96
protected MappingParser(TokenBuffer tokenBuf, int k) {
 
97
  super(tokenBuf,k);
 
98
  tokenNames = _tokenNames;
 
99
}
 
100
 
 
101
public MappingParser(TokenBuffer tokenBuf) {
 
102
  this(tokenBuf,2);
 
103
}
 
104
 
 
105
protected MappingParser(TokenStream lexer, int k) {
 
106
  super(lexer,k);
 
107
  tokenNames = _tokenNames;
 
108
}
 
109
 
 
110
public MappingParser(TokenStream lexer) {
 
111
  this(lexer,2);
 
112
}
 
113
 
 
114
public MappingParser(ParserSharedInputState state) {
 
115
  super(state,2);
 
116
  tokenNames = _tokenNames;
 
117
}
 
118
 
 
119
        public final Mapping  mapping() throws RecognitionException, TokenStreamException {
 
120
                Mapping mapping = null;
 
121
                
 
122
                
 
123
                try {      // for error handling
 
124
                        {
 
125
                        switch ( LA(1)) {
 
126
                        case LITERAL_Axis:
 
127
                        case LITERAL_Columns:
 
128
                        case LITERAL_Rows:
 
129
                        case LITERAL_Pages:
 
130
                        case LITERAL_Chapters:
 
131
                        case LITERAL_Sections:
 
132
                        {
 
133
                                mapping=memberMapping();
 
134
                                break;
 
135
                        }
 
136
                        case LITERAL_Data:
 
137
                        case LITERAL_FormattedData:
 
138
                        {
 
139
                                mapping=dataMapping();
 
140
                                break;
 
141
                        }
 
142
                        default:
 
143
                        {
 
144
                                throw new NoViableAltException(LT(1), getFilename());
 
145
                        }
 
146
                        }
 
147
                        }
 
148
                        match(Token.EOF_TYPE);
 
149
                }
 
150
                catch (RecognitionException ex) {
 
151
                        reportError(ex);
 
152
                        recover(ex,_tokenSet_0);
 
153
                }
 
154
                return mapping;
 
155
        }
 
156
        
 
157
        public final MemberMapping  memberMapping() throws RecognitionException, TokenStreamException {
 
158
                MemberMapping mapping = null;
 
159
                
 
160
                Member member; MemberProperty prop = null;
 
161
                
 
162
                try {      // for error handling
 
163
                        member=member();
 
164
                        {
 
165
                        switch ( LA(1)) {
 
166
                        case LPAREN:
 
167
                        {
 
168
                                prop=property();
 
169
                                break;
 
170
                        }
 
171
                        case EOF:
 
172
                        {
 
173
                                break;
 
174
                        }
 
175
                        default:
 
176
                        {
 
177
                                throw new NoViableAltException(LT(1), getFilename());
 
178
                        }
 
179
                        }
 
180
                        }
 
181
                        mapping = new MemberMapping(member, prop);
 
182
                }
 
183
                catch (RecognitionException ex) {
 
184
                        reportError(ex);
 
185
                        recover(ex,_tokenSet_0);
 
186
                }
 
187
                return mapping;
 
188
        }
 
189
        
 
190
        public final DataMapping  dataMapping() throws RecognitionException, TokenStreamException {
 
191
                DataMapping mapping = null;
 
192
                
 
193
                boolean formatted = false; List filter = null; List positions = null;
 
194
                
 
195
                try {      // for error handling
 
196
                        {
 
197
                        {
 
198
                        switch ( LA(1)) {
 
199
                        case LITERAL_Data:
 
200
                        {
 
201
                                match(LITERAL_Data);
 
202
                                break;
 
203
                        }
 
204
                        case LITERAL_FormattedData:
 
205
                        {
 
206
                                match(LITERAL_FormattedData);
 
207
                                formatted = true;
 
208
                                break;
 
209
                        }
 
210
                        default:
 
211
                        {
 
212
                                throw new NoViableAltException(LT(1), getFilename());
 
213
                        }
 
214
                        }
 
215
                        }
 
216
                        {
 
217
                        if ((LA(1)==LPAREN) && (_tokenSet_1.member(LA(2)))) {
 
218
                                filter=memberFilter();
 
219
                        }
 
220
                        else if ((LA(1)==EOF||LA(1)==LPAREN) && (_tokenSet_2.member(LA(2)))) { //NOPMD
 
221
                        }
 
222
                        else {
 
223
                                throw new NoViableAltException(LT(1), getFilename());
 
224
                        }
 
225
                        
 
226
                        }
 
227
                        {
 
228
                        switch ( LA(1)) {
 
229
                        case LPAREN:
 
230
                        {
 
231
                                positions=axisPositions();
 
232
                                break;
 
233
                        }
 
234
                        case EOF:
 
235
                        {
 
236
                                break;
 
237
                        }
 
238
                        default:
 
239
                        {
 
240
                                throw new NoViableAltException(LT(1), getFilename());
 
241
                        }
 
242
                        }
 
243
                        }
 
244
                        }
 
245
                        mapping = new DataMapping(formatted, filter, positions);
 
246
                }
 
247
                catch (RecognitionException ex) {
 
248
                        reportError(ex);
 
249
                        recover(ex,_tokenSet_0);
 
250
                }
 
251
                return mapping;
 
252
        }
 
253
        
 
254
        public final Member  member() throws RecognitionException, TokenStreamException {
 
255
                Member member = null;
 
256
                
 
257
                Axis axis; TuplePosition pos; MemberDepth depth = null;
 
258
                
 
259
                try {      // for error handling
 
260
                        axis=axis();
 
261
                        pos=tuplePosition(axis);
 
262
                        {
 
263
                        switch ( LA(1)) {
 
264
                        case MONDRNAME:
 
265
                        {
 
266
                                depth=memberDepth(axis, pos);
 
267
                                break;
 
268
                        }
 
269
                        case EOF:
 
270
                        case LPAREN:
 
271
                        {
 
272
                                break;
 
273
                        }
 
274
                        default:
 
275
                        {
 
276
                                throw new NoViableAltException(LT(1), getFilename());
 
277
                        }
 
278
                        }
 
279
                        }
 
280
                        member = new Member(pos, depth);
 
281
                }
 
282
                catch (RecognitionException ex) {
 
283
                        reportError(ex);
 
284
                        recover(ex,_tokenSet_3);
 
285
                }
 
286
                return member;
 
287
        }
 
288
        
 
289
        public final MemberProperty  property() throws RecognitionException, TokenStreamException {
 
290
                MemberProperty prop = null;
 
291
                
 
292
                String name;
 
293
                
 
294
                try {      // for error handling
 
295
                        match(LPAREN);
 
296
                        name=name();
 
297
                        match(RPAREN);
 
298
                        prop = new MemberProperty(name);
 
299
                }
 
300
                catch (RecognitionException ex) {
 
301
                        reportError(ex);
 
302
                        recover(ex,_tokenSet_0);
 
303
                }
 
304
                return prop;
 
305
        }
 
306
        
 
307
        public final Axis  axis() throws RecognitionException, TokenStreamException {
 
308
                Axis axis = null;
 
309
                
 
310
                int idx;
 
311
                
 
312
                try {      // for error handling
 
313
                        {
 
314
                        switch ( LA(1)) {
 
315
                        case LITERAL_Axis:
 
316
                        {
 
317
                                {
 
318
                                match(LITERAL_Axis);
 
319
                                match(LPAREN);
 
320
                                idx=idx();
 
321
                                match(RPAREN);
 
322
                                }
 
323
                                break;
 
324
                        }
 
325
                        case LITERAL_Columns:
 
326
                        case LITERAL_Rows:
 
327
                        case LITERAL_Pages:
 
328
                        case LITERAL_Chapters:
 
329
                        case LITERAL_Sections:
 
330
                        {
 
331
                                {
 
332
                                idx=axisName();
 
333
                                }
 
334
                                break;
 
335
                        }
 
336
                        default:
 
337
                        {
 
338
                                throw new NoViableAltException(LT(1), getFilename());
 
339
                        }
 
340
                        }
 
341
                        }
 
342
                        axis = new Axis(idx);
 
343
                }
 
344
                catch (RecognitionException ex) {
 
345
                        reportError(ex);
 
346
                        recover(ex,_tokenSet_4);
 
347
                }
 
348
                return axis;
 
349
        }
 
350
        
 
351
        public final TuplePosition  tuplePosition(
 
352
                Axis axis
 
353
        ) throws RecognitionException, TokenStreamException {
 
354
                TuplePosition pos = null;
 
355
                
 
356
                int idx;
 
357
                
 
358
                try {      // for error handling
 
359
                        String dimensionName;
 
360
                        dimensionName=mondrName();
 
361
                        idx = getDimensionIndex(axis, dimensionName);
 
362
                        pos = new TuplePosition(axis, idx);
 
363
                }
 
364
                catch (RecognitionException ex) {
 
365
                        reportError(ex);
 
366
                        recover(ex,_tokenSet_5);
 
367
                }
 
368
                return pos;
 
369
        }
 
370
        
 
371
        public final MemberDepth  memberDepth(
 
372
                Axis axis, TuplePosition pos
 
373
        ) throws RecognitionException, TokenStreamException {
 
374
                MemberDepth memberDepth = null;
 
375
                
 
376
                
 
377
                try {      // for error handling
 
378
                        String levelName;
 
379
                        levelName=mondrName();
 
380
                        memberDepth = new MemberDepth(getLevelDepth(pos, levelName));
 
381
                }
 
382
                catch (RecognitionException ex) {
 
383
                        reportError(ex);
 
384
                        recover(ex,_tokenSet_6);
 
385
                }
 
386
                return memberDepth;
 
387
        }
 
388
        
 
389
        public final Member  memberLevel() throws RecognitionException, TokenStreamException {
 
390
                Member member = null;
 
391
                
 
392
                Axis axis; TuplePosition pos; MemberDepth depth;
 
393
                
 
394
                try {      // for error handling
 
395
                        axis=axis();
 
396
                        pos=tuplePosition(axis);
 
397
                        depth=memberDepth(axis, pos);
 
398
                        member = new Member(pos, depth);
 
399
                }
 
400
                catch (RecognitionException ex) {
 
401
                        reportError(ex);
 
402
                        recover(ex,_tokenSet_7);
 
403
                }
 
404
                return member;
 
405
        }
 
406
        
 
407
        public final int  idx() throws RecognitionException, TokenStreamException {
 
408
                int i = -1;
 
409
                
 
410
                Token  idx = null;
 
411
                
 
412
                try {      // for error handling
 
413
                        idx = LT(1);
 
414
                        match(INT);
 
415
                        i = Integer.parseInt(idx.getText());
 
416
                }
 
417
                catch (RecognitionException ex) {
 
418
                        reportError(ex);
 
419
                        recover(ex,_tokenSet_7);
 
420
                }
 
421
                return i;
 
422
        }
 
423
        
 
424
        public final int  axisName() throws RecognitionException, TokenStreamException {
 
425
                int idx = -1;
 
426
                
 
427
                
 
428
                try {      // for error handling
 
429
                        {
 
430
                        switch ( LA(1)) {
 
431
                        case LITERAL_Columns:
 
432
                        {
 
433
                                match(LITERAL_Columns);
 
434
                                idx = 0;
 
435
                                break;
 
436
                        }
 
437
                        case LITERAL_Rows:
 
438
                        {
 
439
                                match(LITERAL_Rows);
 
440
                                idx = 1;
 
441
                                break;
 
442
                        }
 
443
                        case LITERAL_Pages:
 
444
                        {
 
445
                                match(LITERAL_Pages);
 
446
                                idx = 2;
 
447
                                break;
 
448
                        }
 
449
                        case LITERAL_Chapters:
 
450
                        {
 
451
                                match(LITERAL_Chapters);
 
452
                                idx = 3;
 
453
                                break;
 
454
                        }
 
455
                        case LITERAL_Sections:
 
456
                        {
 
457
                                match(LITERAL_Sections);
 
458
                                idx = 4;
 
459
                                break;
 
460
                        }
 
461
                        default:
 
462
                        {
 
463
                                throw new NoViableAltException(LT(1), getFilename());
 
464
                        }
 
465
                        }
 
466
                        }
 
467
                }
 
468
                catch (RecognitionException ex) {
 
469
                        reportError(ex);
 
470
                        recover(ex,_tokenSet_4);
 
471
                }
 
472
                return idx;
 
473
        }
 
474
        
 
475
        public final String  mondrName() throws RecognitionException, TokenStreamException {
 
476
                String name = null;
 
477
                
 
478
                Token  n = null;
 
479
                
 
480
                try {      // for error handling
 
481
                        n = LT(1);
 
482
                        match(MONDRNAME);
 
483
                        name = getMondrName(n.getText());
 
484
                }
 
485
                catch (RecognitionException ex) {
 
486
                        reportError(ex);
 
487
                        recover(ex,_tokenSet_8);
 
488
                }
 
489
                return name;
 
490
        }
 
491
        
 
492
        public final String  name() throws RecognitionException, TokenStreamException {
 
493
                String name = null;
 
494
                
 
495
                Token  n = null;
 
496
                
 
497
                try {      // for error handling
 
498
                        n = LT(1);
 
499
                        match(NAME);
 
500
                        name = n.getText();
 
501
                }
 
502
                catch (RecognitionException ex) {
 
503
                        reportError(ex);
 
504
                        recover(ex,_tokenSet_9);
 
505
                }
 
506
                return name;
 
507
        }
 
508
        
 
509
        public final List  memberFilter() throws RecognitionException, TokenStreamException {
 
510
                List filter = new ArrayList();
 
511
                
 
512
                Member member;
 
513
                
 
514
                try {      // for error handling
 
515
                        match(LPAREN);
 
516
                        member=memberLevel();
 
517
                        filter.add(member);
 
518
                        {
 
519
                        _loop24:
 
520
                        do {
 
521
                                if ((LA(1)==COMMA)) {
 
522
                                        match(COMMA);
 
523
                                        member=memberLevel();
 
524
                                        filter.add(member);
 
525
                                }
 
526
                                else {
 
527
                                        break _loop24;
 
528
                                }
 
529
                                
 
530
                        } while (true);
 
531
                        }
 
532
                        match(RPAREN);
 
533
                }
 
534
                catch (RecognitionException ex) {
 
535
                        reportError(ex);
 
536
                        recover(ex,_tokenSet_3);
 
537
                }
 
538
                return filter;
 
539
        }
 
540
        
 
541
        public final List  axisPositions() throws RecognitionException, TokenStreamException {
 
542
                List positions = new ArrayList();
 
543
                
 
544
                AxisPosition pos; int axis = 0;
 
545
                
 
546
                try {      // for error handling
 
547
                        match(LPAREN);
 
548
                        pos=axisPosition(axis);
 
549
                        ++axis; positions.add(pos);
 
550
                        {
 
551
                        _loop27:
 
552
                        do {
 
553
                                if ((LA(1)==COMMA)) {
 
554
                                        match(COMMA);
 
555
                                        pos=axisPosition(axis);
 
556
                                        ++axis; positions.add(pos);
 
557
                                }
 
558
                                else {
 
559
                                        break _loop27;
 
560
                                }
 
561
                                
 
562
                        } while (true);
 
563
                        }
 
564
                        match(RPAREN);
 
565
                }
 
566
                catch (RecognitionException ex) {
 
567
                        reportError(ex);
 
568
                        recover(ex,_tokenSet_0);
 
569
                }
 
570
                return positions;
 
571
        }
 
572
        
 
573
        public final AxisPosition  axisPosition(
 
574
                int axis
 
575
        ) throws RecognitionException, TokenStreamException {
 
576
                AxisPosition pos = null;
 
577
                
 
578
                int idx;
 
579
                
 
580
                try {      // for error handling
 
581
                        {
 
582
                        switch ( LA(1)) {
 
583
                        case QMARK:
 
584
                        {
 
585
                                match(QMARK);
 
586
                                idx = AxisPosition.POSITION_UNSPECIFIED;
 
587
                                break;
 
588
                        }
 
589
                        case INT:
 
590
                        {
 
591
                                idx=idx();
 
592
                                break;
 
593
                        }
 
594
                        case LPAREN:
 
595
                        case MONDRNAME:
 
596
                        {
 
597
                                Tuple tuple;
 
598
                                tuple=tuple();
 
599
                                idx = mappingMeta.getTuplePosition(axis, tuple);
 
600
                                break;
 
601
                        }
 
602
                        default:
 
603
                        {
 
604
                                throw new NoViableAltException(LT(1), getFilename());
 
605
                        }
 
606
                        }
 
607
                        }
 
608
                        pos = new AxisPosition(idx);
 
609
                }
 
610
                catch (RecognitionException ex) {
 
611
                        reportError(ex);
 
612
                        recover(ex,_tokenSet_7);
 
613
                }
 
614
                return pos;
 
615
        }
 
616
        
 
617
        public final Tuple  tuple() throws RecognitionException, TokenStreamException {
 
618
                Tuple tuple = null;
 
619
                
 
620
                TupleMember member;
 
621
                
 
622
                try {      // for error handling
 
623
                        switch ( LA(1)) {
 
624
                        case LPAREN:
 
625
                        {
 
626
                                {
 
627
                                match(LPAREN);
 
628
                                tuple = new Tuple();
 
629
                                member=tupleMember();
 
630
                                tuple.addMember(member);
 
631
                                {
 
632
                                _loop33:
 
633
                                do {
 
634
                                        if ((LA(1)==COMMA)) {
 
635
                                                match(COMMA);
 
636
                                                member=tupleMember();
 
637
                                                tuple.addMember(member);
 
638
                                        }
 
639
                                        else {
 
640
                                                break _loop33;
 
641
                                        }
 
642
                                        
 
643
                                } while (true);
 
644
                                }
 
645
                                match(RPAREN);
 
646
                                }
 
647
                                break;
 
648
                        }
 
649
                        case MONDRNAME:
 
650
                        {
 
651
                                member=tupleMember();
 
652
                                tuple = new Tuple(member);
 
653
                                break;
 
654
                        }
 
655
                        default:
 
656
                        {
 
657
                                throw new NoViableAltException(LT(1), getFilename());
 
658
                        }
 
659
                        }
 
660
                }
 
661
                catch (RecognitionException ex) {
 
662
                        reportError(ex);
 
663
                        recover(ex,_tokenSet_7);
 
664
                }
 
665
                return tuple;
 
666
        }
 
667
        
 
668
        public final TupleMember  tupleMember() throws RecognitionException, TokenStreamException {
 
669
                TupleMember tuple = new TupleMember();
 
670
                
 
671
                String name;
 
672
                
 
673
                try {      // for error handling
 
674
                        name=mondrName();
 
675
                        tuple.addName(name);
 
676
                        {
 
677
                        _loop36:
 
678
                        do {
 
679
                                if ((LA(1)==POINT)) {
 
680
                                        match(POINT);
 
681
                                        name=mondrName();
 
682
                                        tuple.addName(name);
 
683
                                }
 
684
                                else {
 
685
                                        break _loop36;
 
686
                                }
 
687
                                
 
688
                        } while (true);
 
689
                        }
 
690
                }
 
691
                catch (RecognitionException ex) {
 
692
                        reportError(ex);
 
693
                        recover(ex,_tokenSet_7);
 
694
                }
 
695
                return tuple;
 
696
        }
 
697
        
 
698
        
 
699
        public static final String[] _tokenNames = {
 
700
                "<0>",
 
701
                "EOF",
 
702
                "<2>",
 
703
                "NULL_TREE_LOOKAHEAD",
 
704
                "\"Axis\"",
 
705
                "LPAREN",
 
706
                "RPAREN",
 
707
                "\"Columns\"",
 
708
                "\"Rows\"",
 
709
                "\"Pages\"",
 
710
                "\"Chapters\"",
 
711
                "\"Sections\"",
 
712
                "\"Data\"",
 
713
                "\"FormattedData\"",
 
714
                "COMMA",
 
715
                "QMARK",
 
716
                "POINT",
 
717
                "INT",
 
718
                "MONDRNAME",
 
719
                "NAME",
 
720
                "PLUS",
 
721
                "MINUS",
 
722
                "STAR",
 
723
                "WS",
 
724
                "DIGIT",
 
725
                "LETTER"
 
726
        };
 
727
        
 
728
        private static final long[] mk_tokenSet_0() {
 
729
                long[] data = { 2L, 0L};
 
730
                return data;
 
731
        }
 
732
        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
 
733
        private static final long[] mk_tokenSet_1() {
 
734
                long[] data = { 3984L, 0L};
 
735
                return data;
 
736
        }
 
737
        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
 
738
        private static final long[] mk_tokenSet_2() {
 
739
                long[] data = { 426018L, 0L};
 
740
                return data;
 
741
        }
 
742
        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
 
743
        private static final long[] mk_tokenSet_3() {
 
744
                long[] data = { 34L, 0L};
 
745
                return data;
 
746
        }
 
747
        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
 
748
        private static final long[] mk_tokenSet_4() {
 
749
                long[] data = { 262144L, 0L};
 
750
                return data;
 
751
        }
 
752
        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
 
753
        private static final long[] mk_tokenSet_5() {
 
754
                long[] data = { 262178L, 0L};
 
755
                return data;
 
756
        }
 
757
        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
 
758
        private static final long[] mk_tokenSet_6() {
 
759
                long[] data = { 16482L, 0L};
 
760
                return data;
 
761
        }
 
762
        public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
 
763
        private static final long[] mk_tokenSet_7() {
 
764
                long[] data = { 16448L, 0L};
 
765
                return data;
 
766
        }
 
767
        public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
 
768
        private static final long[] mk_tokenSet_8() {
 
769
                long[] data = { 344162L, 0L};
 
770
                return data;
 
771
        }
 
772
        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
 
773
        private static final long[] mk_tokenSet_9() {
 
774
                long[] data = { 64L, 0L};
 
775
                return data;
 
776
        }
 
777
        public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
 
778
        
 
779
        }