diff options
Diffstat (limited to 'language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemLexer.java')
-rw-r--r-- | language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemLexer.java | 1940 |
1 files changed, 0 insertions, 1940 deletions
diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemLexer.java b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemLexer.java deleted file mode 100644 index c6044e0c..00000000 --- a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemLexer.java +++ /dev/null | |||
@@ -1,1940 +0,0 @@ | |||
1 | package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal; | ||
2 | |||
3 | // Hack: Use our own Lexer superclass by means of import. | ||
4 | // Currently there is no other way to specify the superclass for the lexer. | ||
5 | import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; | ||
6 | |||
7 | |||
8 | import org.antlr.runtime.*; | ||
9 | import java.util.Stack; | ||
10 | import java.util.List; | ||
11 | import java.util.ArrayList; | ||
12 | |||
13 | @SuppressWarnings("all") | ||
14 | public class InternalProblemLexer extends Lexer { | ||
15 | public static final int T__19=19; | ||
16 | public static final int T__15=15; | ||
17 | public static final int T__16=16; | ||
18 | public static final int T__17=17; | ||
19 | public static final int T__18=18; | ||
20 | public static final int T__13=13; | ||
21 | public static final int T__14=14; | ||
22 | public static final int RULE_EXPONENTIAL=7; | ||
23 | public static final int RULE_ID=6; | ||
24 | public static final int RULE_QUOTED_ID=5; | ||
25 | public static final int T__26=26; | ||
26 | public static final int T__27=27; | ||
27 | public static final int T__28=28; | ||
28 | public static final int RULE_INT=4; | ||
29 | public static final int T__29=29; | ||
30 | public static final int T__22=22; | ||
31 | public static final int RULE_ML_COMMENT=10; | ||
32 | public static final int T__23=23; | ||
33 | public static final int T__24=24; | ||
34 | public static final int T__25=25; | ||
35 | public static final int T__20=20; | ||
36 | public static final int T__21=21; | ||
37 | public static final int RULE_STRING=8; | ||
38 | public static final int RULE_SL_COMMENT=9; | ||
39 | public static final int T__37=37; | ||
40 | public static final int T__38=38; | ||
41 | public static final int T__39=39; | ||
42 | public static final int T__33=33; | ||
43 | public static final int T__34=34; | ||
44 | public static final int T__35=35; | ||
45 | public static final int T__36=36; | ||
46 | public static final int EOF=-1; | ||
47 | public static final int T__30=30; | ||
48 | public static final int T__31=31; | ||
49 | public static final int T__32=32; | ||
50 | public static final int RULE_WS=11; | ||
51 | public static final int RULE_ANY_OTHER=12; | ||
52 | public static final int T__44=44; | ||
53 | public static final int T__45=45; | ||
54 | public static final int T__46=46; | ||
55 | public static final int T__40=40; | ||
56 | public static final int T__41=41; | ||
57 | public static final int T__42=42; | ||
58 | public static final int T__43=43; | ||
59 | |||
60 | // delegates | ||
61 | // delegators | ||
62 | |||
63 | public InternalProblemLexer() {;} | ||
64 | public InternalProblemLexer(CharStream input) { | ||
65 | this(input, new RecognizerSharedState()); | ||
66 | } | ||
67 | public InternalProblemLexer(CharStream input, RecognizerSharedState state) { | ||
68 | super(input,state); | ||
69 | |||
70 | } | ||
71 | public String getGrammarFileName() { return "InternalProblem.g"; } | ||
72 | |||
73 | // $ANTLR start "T__13" | ||
74 | public final void mT__13() throws RecognitionException { | ||
75 | try { | ||
76 | int _type = T__13; | ||
77 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
78 | // InternalProblem.g:11:7: ( '.' ) | ||
79 | // InternalProblem.g:11:9: '.' | ||
80 | { | ||
81 | match('.'); | ||
82 | |||
83 | } | ||
84 | |||
85 | state.type = _type; | ||
86 | state.channel = _channel; | ||
87 | } | ||
88 | finally { | ||
89 | } | ||
90 | } | ||
91 | // $ANTLR end "T__13" | ||
92 | |||
93 | // $ANTLR start "T__14" | ||
94 | public final void mT__14() throws RecognitionException { | ||
95 | try { | ||
96 | int _type = T__14; | ||
97 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
98 | // InternalProblem.g:12:7: ( ',' ) | ||
99 | // InternalProblem.g:12:9: ',' | ||
100 | { | ||
101 | match(','); | ||
102 | |||
103 | } | ||
104 | |||
105 | state.type = _type; | ||
106 | state.channel = _channel; | ||
107 | } | ||
108 | finally { | ||
109 | } | ||
110 | } | ||
111 | // $ANTLR end "T__14" | ||
112 | |||
113 | // $ANTLR start "T__15" | ||
114 | public final void mT__15() throws RecognitionException { | ||
115 | try { | ||
116 | int _type = T__15; | ||
117 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
118 | // InternalProblem.g:13:7: ( ';' ) | ||
119 | // InternalProblem.g:13:9: ';' | ||
120 | { | ||
121 | match(';'); | ||
122 | |||
123 | } | ||
124 | |||
125 | state.type = _type; | ||
126 | state.channel = _channel; | ||
127 | } | ||
128 | finally { | ||
129 | } | ||
130 | } | ||
131 | // $ANTLR end "T__15" | ||
132 | |||
133 | // $ANTLR start "T__16" | ||
134 | public final void mT__16() throws RecognitionException { | ||
135 | try { | ||
136 | int _type = T__16; | ||
137 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
138 | // InternalProblem.g:14:7: ( 'refers' ) | ||
139 | // InternalProblem.g:14:9: 'refers' | ||
140 | { | ||
141 | match("refers"); | ||
142 | |||
143 | |||
144 | } | ||
145 | |||
146 | state.type = _type; | ||
147 | state.channel = _channel; | ||
148 | } | ||
149 | finally { | ||
150 | } | ||
151 | } | ||
152 | // $ANTLR end "T__16" | ||
153 | |||
154 | // $ANTLR start "T__17" | ||
155 | public final void mT__17() throws RecognitionException { | ||
156 | try { | ||
157 | int _type = T__17; | ||
158 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
159 | // InternalProblem.g:15:7: ( 'pred' ) | ||
160 | // InternalProblem.g:15:9: 'pred' | ||
161 | { | ||
162 | match("pred"); | ||
163 | |||
164 | |||
165 | } | ||
166 | |||
167 | state.type = _type; | ||
168 | state.channel = _channel; | ||
169 | } | ||
170 | finally { | ||
171 | } | ||
172 | } | ||
173 | // $ANTLR end "T__17" | ||
174 | |||
175 | // $ANTLR start "T__18" | ||
176 | public final void mT__18() throws RecognitionException { | ||
177 | try { | ||
178 | int _type = T__18; | ||
179 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
180 | // InternalProblem.g:16:7: ( '=' ) | ||
181 | // InternalProblem.g:16:9: '=' | ||
182 | { | ||
183 | match('='); | ||
184 | |||
185 | } | ||
186 | |||
187 | state.type = _type; | ||
188 | state.channel = _channel; | ||
189 | } | ||
190 | finally { | ||
191 | } | ||
192 | } | ||
193 | // $ANTLR end "T__18" | ||
194 | |||
195 | // $ANTLR start "T__19" | ||
196 | public final void mT__19() throws RecognitionException { | ||
197 | try { | ||
198 | int _type = T__19; | ||
199 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
200 | // InternalProblem.g:17:7: ( '*' ) | ||
201 | // InternalProblem.g:17:9: '*' | ||
202 | { | ||
203 | match('*'); | ||
204 | |||
205 | } | ||
206 | |||
207 | state.type = _type; | ||
208 | state.channel = _channel; | ||
209 | } | ||
210 | finally { | ||
211 | } | ||
212 | } | ||
213 | // $ANTLR end "T__19" | ||
214 | |||
215 | // $ANTLR start "T__20" | ||
216 | public final void mT__20() throws RecognitionException { | ||
217 | try { | ||
218 | int _type = T__20; | ||
219 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
220 | // InternalProblem.g:18:7: ( 'true' ) | ||
221 | // InternalProblem.g:18:9: 'true' | ||
222 | { | ||
223 | match("true"); | ||
224 | |||
225 | |||
226 | } | ||
227 | |||
228 | state.type = _type; | ||
229 | state.channel = _channel; | ||
230 | } | ||
231 | finally { | ||
232 | } | ||
233 | } | ||
234 | // $ANTLR end "T__20" | ||
235 | |||
236 | // $ANTLR start "T__21" | ||
237 | public final void mT__21() throws RecognitionException { | ||
238 | try { | ||
239 | int _type = T__21; | ||
240 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
241 | // InternalProblem.g:19:7: ( 'false' ) | ||
242 | // InternalProblem.g:19:9: 'false' | ||
243 | { | ||
244 | match("false"); | ||
245 | |||
246 | |||
247 | } | ||
248 | |||
249 | state.type = _type; | ||
250 | state.channel = _channel; | ||
251 | } | ||
252 | finally { | ||
253 | } | ||
254 | } | ||
255 | // $ANTLR end "T__21" | ||
256 | |||
257 | // $ANTLR start "T__22" | ||
258 | public final void mT__22() throws RecognitionException { | ||
259 | try { | ||
260 | int _type = T__22; | ||
261 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
262 | // InternalProblem.g:20:7: ( 'unknown' ) | ||
263 | // InternalProblem.g:20:9: 'unknown' | ||
264 | { | ||
265 | match("unknown"); | ||
266 | |||
267 | |||
268 | } | ||
269 | |||
270 | state.type = _type; | ||
271 | state.channel = _channel; | ||
272 | } | ||
273 | finally { | ||
274 | } | ||
275 | } | ||
276 | // $ANTLR end "T__22" | ||
277 | |||
278 | // $ANTLR start "T__23" | ||
279 | public final void mT__23() throws RecognitionException { | ||
280 | try { | ||
281 | int _type = T__23; | ||
282 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
283 | // InternalProblem.g:21:7: ( '!' ) | ||
284 | // InternalProblem.g:21:9: '!' | ||
285 | { | ||
286 | match('!'); | ||
287 | |||
288 | } | ||
289 | |||
290 | state.type = _type; | ||
291 | state.channel = _channel; | ||
292 | } | ||
293 | finally { | ||
294 | } | ||
295 | } | ||
296 | // $ANTLR end "T__23" | ||
297 | |||
298 | // $ANTLR start "T__24" | ||
299 | public final void mT__24() throws RecognitionException { | ||
300 | try { | ||
301 | int _type = T__24; | ||
302 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
303 | // InternalProblem.g:22:7: ( '?' ) | ||
304 | // InternalProblem.g:22:9: '?' | ||
305 | { | ||
306 | match('?'); | ||
307 | |||
308 | } | ||
309 | |||
310 | state.type = _type; | ||
311 | state.channel = _channel; | ||
312 | } | ||
313 | finally { | ||
314 | } | ||
315 | } | ||
316 | // $ANTLR end "T__24" | ||
317 | |||
318 | // $ANTLR start "T__25" | ||
319 | public final void mT__25() throws RecognitionException { | ||
320 | try { | ||
321 | int _type = T__25; | ||
322 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
323 | // InternalProblem.g:23:7: ( 'problem' ) | ||
324 | // InternalProblem.g:23:9: 'problem' | ||
325 | { | ||
326 | match("problem"); | ||
327 | |||
328 | |||
329 | } | ||
330 | |||
331 | state.type = _type; | ||
332 | state.channel = _channel; | ||
333 | } | ||
334 | finally { | ||
335 | } | ||
336 | } | ||
337 | // $ANTLR end "T__25" | ||
338 | |||
339 | // $ANTLR start "T__26" | ||
340 | public final void mT__26() throws RecognitionException { | ||
341 | try { | ||
342 | int _type = T__26; | ||
343 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
344 | // InternalProblem.g:24:7: ( 'class' ) | ||
345 | // InternalProblem.g:24:9: 'class' | ||
346 | { | ||
347 | match("class"); | ||
348 | |||
349 | |||
350 | } | ||
351 | |||
352 | state.type = _type; | ||
353 | state.channel = _channel; | ||
354 | } | ||
355 | finally { | ||
356 | } | ||
357 | } | ||
358 | // $ANTLR end "T__26" | ||
359 | |||
360 | // $ANTLR start "T__27" | ||
361 | public final void mT__27() throws RecognitionException { | ||
362 | try { | ||
363 | int _type = T__27; | ||
364 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
365 | // InternalProblem.g:25:7: ( 'extends' ) | ||
366 | // InternalProblem.g:25:9: 'extends' | ||
367 | { | ||
368 | match("extends"); | ||
369 | |||
370 | |||
371 | } | ||
372 | |||
373 | state.type = _type; | ||
374 | state.channel = _channel; | ||
375 | } | ||
376 | finally { | ||
377 | } | ||
378 | } | ||
379 | // $ANTLR end "T__27" | ||
380 | |||
381 | // $ANTLR start "T__28" | ||
382 | public final void mT__28() throws RecognitionException { | ||
383 | try { | ||
384 | int _type = T__28; | ||
385 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
386 | // InternalProblem.g:26:7: ( '{' ) | ||
387 | // InternalProblem.g:26:9: '{' | ||
388 | { | ||
389 | match('{'); | ||
390 | |||
391 | } | ||
392 | |||
393 | state.type = _type; | ||
394 | state.channel = _channel; | ||
395 | } | ||
396 | finally { | ||
397 | } | ||
398 | } | ||
399 | // $ANTLR end "T__28" | ||
400 | |||
401 | // $ANTLR start "T__29" | ||
402 | public final void mT__29() throws RecognitionException { | ||
403 | try { | ||
404 | int _type = T__29; | ||
405 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
406 | // InternalProblem.g:27:7: ( '}' ) | ||
407 | // InternalProblem.g:27:9: '}' | ||
408 | { | ||
409 | match('}'); | ||
410 | |||
411 | } | ||
412 | |||
413 | state.type = _type; | ||
414 | state.channel = _channel; | ||
415 | } | ||
416 | finally { | ||
417 | } | ||
418 | } | ||
419 | // $ANTLR end "T__29" | ||
420 | |||
421 | // $ANTLR start "T__30" | ||
422 | public final void mT__30() throws RecognitionException { | ||
423 | try { | ||
424 | int _type = T__30; | ||
425 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
426 | // InternalProblem.g:28:7: ( 'enum' ) | ||
427 | // InternalProblem.g:28:9: 'enum' | ||
428 | { | ||
429 | match("enum"); | ||
430 | |||
431 | |||
432 | } | ||
433 | |||
434 | state.type = _type; | ||
435 | state.channel = _channel; | ||
436 | } | ||
437 | finally { | ||
438 | } | ||
439 | } | ||
440 | // $ANTLR end "T__30" | ||
441 | |||
442 | // $ANTLR start "T__31" | ||
443 | public final void mT__31() throws RecognitionException { | ||
444 | try { | ||
445 | int _type = T__31; | ||
446 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
447 | // InternalProblem.g:29:7: ( '[' ) | ||
448 | // InternalProblem.g:29:9: '[' | ||
449 | { | ||
450 | match('['); | ||
451 | |||
452 | } | ||
453 | |||
454 | state.type = _type; | ||
455 | state.channel = _channel; | ||
456 | } | ||
457 | finally { | ||
458 | } | ||
459 | } | ||
460 | // $ANTLR end "T__31" | ||
461 | |||
462 | // $ANTLR start "T__32" | ||
463 | public final void mT__32() throws RecognitionException { | ||
464 | try { | ||
465 | int _type = T__32; | ||
466 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
467 | // InternalProblem.g:30:7: ( ']' ) | ||
468 | // InternalProblem.g:30:9: ']' | ||
469 | { | ||
470 | match(']'); | ||
471 | |||
472 | } | ||
473 | |||
474 | state.type = _type; | ||
475 | state.channel = _channel; | ||
476 | } | ||
477 | finally { | ||
478 | } | ||
479 | } | ||
480 | // $ANTLR end "T__32" | ||
481 | |||
482 | // $ANTLR start "T__33" | ||
483 | public final void mT__33() throws RecognitionException { | ||
484 | try { | ||
485 | int _type = T__33; | ||
486 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
487 | // InternalProblem.g:31:7: ( 'opposite' ) | ||
488 | // InternalProblem.g:31:9: 'opposite' | ||
489 | { | ||
490 | match("opposite"); | ||
491 | |||
492 | |||
493 | } | ||
494 | |||
495 | state.type = _type; | ||
496 | state.channel = _channel; | ||
497 | } | ||
498 | finally { | ||
499 | } | ||
500 | } | ||
501 | // $ANTLR end "T__33" | ||
502 | |||
503 | // $ANTLR start "T__34" | ||
504 | public final void mT__34() throws RecognitionException { | ||
505 | try { | ||
506 | int _type = T__34; | ||
507 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
508 | // InternalProblem.g:32:7: ( '(' ) | ||
509 | // InternalProblem.g:32:9: '(' | ||
510 | { | ||
511 | match('('); | ||
512 | |||
513 | } | ||
514 | |||
515 | state.type = _type; | ||
516 | state.channel = _channel; | ||
517 | } | ||
518 | finally { | ||
519 | } | ||
520 | } | ||
521 | // $ANTLR end "T__34" | ||
522 | |||
523 | // $ANTLR start "T__35" | ||
524 | public final void mT__35() throws RecognitionException { | ||
525 | try { | ||
526 | int _type = T__35; | ||
527 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
528 | // InternalProblem.g:33:7: ( ')' ) | ||
529 | // InternalProblem.g:33:9: ')' | ||
530 | { | ||
531 | match(')'); | ||
532 | |||
533 | } | ||
534 | |||
535 | state.type = _type; | ||
536 | state.channel = _channel; | ||
537 | } | ||
538 | finally { | ||
539 | } | ||
540 | } | ||
541 | // $ANTLR end "T__35" | ||
542 | |||
543 | // $ANTLR start "T__36" | ||
544 | public final void mT__36() throws RecognitionException { | ||
545 | try { | ||
546 | int _type = T__36; | ||
547 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
548 | // InternalProblem.g:34:7: ( ':-' ) | ||
549 | // InternalProblem.g:34:9: ':-' | ||
550 | { | ||
551 | match(":-"); | ||
552 | |||
553 | |||
554 | } | ||
555 | |||
556 | state.type = _type; | ||
557 | state.channel = _channel; | ||
558 | } | ||
559 | finally { | ||
560 | } | ||
561 | } | ||
562 | // $ANTLR end "T__36" | ||
563 | |||
564 | // $ANTLR start "T__37" | ||
565 | public final void mT__37() throws RecognitionException { | ||
566 | try { | ||
567 | int _type = T__37; | ||
568 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
569 | // InternalProblem.g:35:7: ( ':' ) | ||
570 | // InternalProblem.g:35:9: ':' | ||
571 | { | ||
572 | match(':'); | ||
573 | |||
574 | } | ||
575 | |||
576 | state.type = _type; | ||
577 | state.channel = _channel; | ||
578 | } | ||
579 | finally { | ||
580 | } | ||
581 | } | ||
582 | // $ANTLR end "T__37" | ||
583 | |||
584 | // $ANTLR start "T__38" | ||
585 | public final void mT__38() throws RecognitionException { | ||
586 | try { | ||
587 | int _type = T__38; | ||
588 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
589 | // InternalProblem.g:36:7: ( 'scope' ) | ||
590 | // InternalProblem.g:36:9: 'scope' | ||
591 | { | ||
592 | match("scope"); | ||
593 | |||
594 | |||
595 | } | ||
596 | |||
597 | state.type = _type; | ||
598 | state.channel = _channel; | ||
599 | } | ||
600 | finally { | ||
601 | } | ||
602 | } | ||
603 | // $ANTLR end "T__38" | ||
604 | |||
605 | // $ANTLR start "T__39" | ||
606 | public final void mT__39() throws RecognitionException { | ||
607 | try { | ||
608 | int _type = T__39; | ||
609 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
610 | // InternalProblem.g:37:7: ( '..' ) | ||
611 | // InternalProblem.g:37:9: '..' | ||
612 | { | ||
613 | match(".."); | ||
614 | |||
615 | |||
616 | } | ||
617 | |||
618 | state.type = _type; | ||
619 | state.channel = _channel; | ||
620 | } | ||
621 | finally { | ||
622 | } | ||
623 | } | ||
624 | // $ANTLR end "T__39" | ||
625 | |||
626 | // $ANTLR start "T__40" | ||
627 | public final void mT__40() throws RecognitionException { | ||
628 | try { | ||
629 | int _type = T__40; | ||
630 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
631 | // InternalProblem.g:38:7: ( '::' ) | ||
632 | // InternalProblem.g:38:9: '::' | ||
633 | { | ||
634 | match("::"); | ||
635 | |||
636 | |||
637 | } | ||
638 | |||
639 | state.type = _type; | ||
640 | state.channel = _channel; | ||
641 | } | ||
642 | finally { | ||
643 | } | ||
644 | } | ||
645 | // $ANTLR end "T__40" | ||
646 | |||
647 | // $ANTLR start "T__41" | ||
648 | public final void mT__41() throws RecognitionException { | ||
649 | try { | ||
650 | int _type = T__41; | ||
651 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
652 | // InternalProblem.g:39:7: ( '-' ) | ||
653 | // InternalProblem.g:39:9: '-' | ||
654 | { | ||
655 | match('-'); | ||
656 | |||
657 | } | ||
658 | |||
659 | state.type = _type; | ||
660 | state.channel = _channel; | ||
661 | } | ||
662 | finally { | ||
663 | } | ||
664 | } | ||
665 | // $ANTLR end "T__41" | ||
666 | |||
667 | // $ANTLR start "T__42" | ||
668 | public final void mT__42() throws RecognitionException { | ||
669 | try { | ||
670 | int _type = T__42; | ||
671 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
672 | // InternalProblem.g:40:7: ( 'abstract' ) | ||
673 | // InternalProblem.g:40:9: 'abstract' | ||
674 | { | ||
675 | match("abstract"); | ||
676 | |||
677 | |||
678 | } | ||
679 | |||
680 | state.type = _type; | ||
681 | state.channel = _channel; | ||
682 | } | ||
683 | finally { | ||
684 | } | ||
685 | } | ||
686 | // $ANTLR end "T__42" | ||
687 | |||
688 | // $ANTLR start "T__43" | ||
689 | public final void mT__43() throws RecognitionException { | ||
690 | try { | ||
691 | int _type = T__43; | ||
692 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
693 | // InternalProblem.g:41:7: ( 'contains' ) | ||
694 | // InternalProblem.g:41:9: 'contains' | ||
695 | { | ||
696 | match("contains"); | ||
697 | |||
698 | |||
699 | } | ||
700 | |||
701 | state.type = _type; | ||
702 | state.channel = _channel; | ||
703 | } | ||
704 | finally { | ||
705 | } | ||
706 | } | ||
707 | // $ANTLR end "T__43" | ||
708 | |||
709 | // $ANTLR start "T__44" | ||
710 | public final void mT__44() throws RecognitionException { | ||
711 | try { | ||
712 | int _type = T__44; | ||
713 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
714 | // InternalProblem.g:42:7: ( 'error' ) | ||
715 | // InternalProblem.g:42:9: 'error' | ||
716 | { | ||
717 | match("error"); | ||
718 | |||
719 | |||
720 | } | ||
721 | |||
722 | state.type = _type; | ||
723 | state.channel = _channel; | ||
724 | } | ||
725 | finally { | ||
726 | } | ||
727 | } | ||
728 | // $ANTLR end "T__44" | ||
729 | |||
730 | // $ANTLR start "T__45" | ||
731 | public final void mT__45() throws RecognitionException { | ||
732 | try { | ||
733 | int _type = T__45; | ||
734 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
735 | // InternalProblem.g:43:7: ( '+' ) | ||
736 | // InternalProblem.g:43:9: '+' | ||
737 | { | ||
738 | match('+'); | ||
739 | |||
740 | } | ||
741 | |||
742 | state.type = _type; | ||
743 | state.channel = _channel; | ||
744 | } | ||
745 | finally { | ||
746 | } | ||
747 | } | ||
748 | // $ANTLR end "T__45" | ||
749 | |||
750 | // $ANTLR start "T__46" | ||
751 | public final void mT__46() throws RecognitionException { | ||
752 | try { | ||
753 | int _type = T__46; | ||
754 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
755 | // InternalProblem.g:44:7: ( '+=' ) | ||
756 | // InternalProblem.g:44:9: '+=' | ||
757 | { | ||
758 | match("+="); | ||
759 | |||
760 | |||
761 | } | ||
762 | |||
763 | state.type = _type; | ||
764 | state.channel = _channel; | ||
765 | } | ||
766 | finally { | ||
767 | } | ||
768 | } | ||
769 | // $ANTLR end "T__46" | ||
770 | |||
771 | // $ANTLR start "RULE_ID" | ||
772 | public final void mRULE_ID() throws RecognitionException { | ||
773 | try { | ||
774 | int _type = RULE_ID; | ||
775 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
776 | // InternalProblem.g:5739:9: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) | ||
777 | // InternalProblem.g:5739:11: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
778 | { | ||
779 | if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
780 | input.consume(); | ||
781 | |||
782 | } | ||
783 | else { | ||
784 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
785 | recover(mse); | ||
786 | throw mse;} | ||
787 | |||
788 | // InternalProblem.g:5739:35: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
789 | loop1: | ||
790 | do { | ||
791 | int alt1=2; | ||
792 | int LA1_0 = input.LA(1); | ||
793 | |||
794 | if ( ((LA1_0>='0' && LA1_0<='9')||(LA1_0>='A' && LA1_0<='Z')||LA1_0=='_'||(LA1_0>='a' && LA1_0<='z')) ) { | ||
795 | alt1=1; | ||
796 | } | ||
797 | |||
798 | |||
799 | switch (alt1) { | ||
800 | case 1 : | ||
801 | // InternalProblem.g: | ||
802 | { | ||
803 | if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
804 | input.consume(); | ||
805 | |||
806 | } | ||
807 | else { | ||
808 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
809 | recover(mse); | ||
810 | throw mse;} | ||
811 | |||
812 | |||
813 | } | ||
814 | break; | ||
815 | |||
816 | default : | ||
817 | break loop1; | ||
818 | } | ||
819 | } while (true); | ||
820 | |||
821 | |||
822 | } | ||
823 | |||
824 | state.type = _type; | ||
825 | state.channel = _channel; | ||
826 | } | ||
827 | finally { | ||
828 | } | ||
829 | } | ||
830 | // $ANTLR end "RULE_ID" | ||
831 | |||
832 | // $ANTLR start "RULE_EXPONENTIAL" | ||
833 | public final void mRULE_EXPONENTIAL() throws RecognitionException { | ||
834 | try { | ||
835 | int _type = RULE_EXPONENTIAL; | ||
836 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
837 | // InternalProblem.g:5741:18: ( RULE_INT ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT ) | ||
838 | // InternalProblem.g:5741:20: RULE_INT ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT | ||
839 | { | ||
840 | mRULE_INT(); | ||
841 | if ( input.LA(1)=='E'||input.LA(1)=='e' ) { | ||
842 | input.consume(); | ||
843 | |||
844 | } | ||
845 | else { | ||
846 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
847 | recover(mse); | ||
848 | throw mse;} | ||
849 | |||
850 | // InternalProblem.g:5741:39: ( '+' | '-' )? | ||
851 | int alt2=2; | ||
852 | int LA2_0 = input.LA(1); | ||
853 | |||
854 | if ( (LA2_0=='+'||LA2_0=='-') ) { | ||
855 | alt2=1; | ||
856 | } | ||
857 | switch (alt2) { | ||
858 | case 1 : | ||
859 | // InternalProblem.g: | ||
860 | { | ||
861 | if ( input.LA(1)=='+'||input.LA(1)=='-' ) { | ||
862 | input.consume(); | ||
863 | |||
864 | } | ||
865 | else { | ||
866 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
867 | recover(mse); | ||
868 | throw mse;} | ||
869 | |||
870 | |||
871 | } | ||
872 | break; | ||
873 | |||
874 | } | ||
875 | |||
876 | mRULE_INT(); | ||
877 | |||
878 | } | ||
879 | |||
880 | state.type = _type; | ||
881 | state.channel = _channel; | ||
882 | } | ||
883 | finally { | ||
884 | } | ||
885 | } | ||
886 | // $ANTLR end "RULE_EXPONENTIAL" | ||
887 | |||
888 | // $ANTLR start "RULE_STRING" | ||
889 | public final void mRULE_STRING() throws RecognitionException { | ||
890 | try { | ||
891 | int _type = RULE_STRING; | ||
892 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
893 | // InternalProblem.g:5743:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) | ||
894 | // InternalProblem.g:5743:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | ||
895 | { | ||
896 | match('\"'); | ||
897 | // InternalProblem.g:5743:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* | ||
898 | loop3: | ||
899 | do { | ||
900 | int alt3=3; | ||
901 | int LA3_0 = input.LA(1); | ||
902 | |||
903 | if ( (LA3_0=='\\') ) { | ||
904 | alt3=1; | ||
905 | } | ||
906 | else if ( ((LA3_0>='\u0000' && LA3_0<='!')||(LA3_0>='#' && LA3_0<='[')||(LA3_0>=']' && LA3_0<='\uFFFF')) ) { | ||
907 | alt3=2; | ||
908 | } | ||
909 | |||
910 | |||
911 | switch (alt3) { | ||
912 | case 1 : | ||
913 | // InternalProblem.g:5743:20: '\\\\' . | ||
914 | { | ||
915 | match('\\'); | ||
916 | matchAny(); | ||
917 | |||
918 | } | ||
919 | break; | ||
920 | case 2 : | ||
921 | // InternalProblem.g:5743:27: ~ ( ( '\\\\' | '\"' ) ) | ||
922 | { | ||
923 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
924 | input.consume(); | ||
925 | |||
926 | } | ||
927 | else { | ||
928 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
929 | recover(mse); | ||
930 | throw mse;} | ||
931 | |||
932 | |||
933 | } | ||
934 | break; | ||
935 | |||
936 | default : | ||
937 | break loop3; | ||
938 | } | ||
939 | } while (true); | ||
940 | |||
941 | match('\"'); | ||
942 | |||
943 | } | ||
944 | |||
945 | state.type = _type; | ||
946 | state.channel = _channel; | ||
947 | } | ||
948 | finally { | ||
949 | } | ||
950 | } | ||
951 | // $ANTLR end "RULE_STRING" | ||
952 | |||
953 | // $ANTLR start "RULE_QUOTED_ID" | ||
954 | public final void mRULE_QUOTED_ID() throws RecognitionException { | ||
955 | try { | ||
956 | int _type = RULE_QUOTED_ID; | ||
957 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
958 | // InternalProblem.g:5745:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) | ||
959 | // InternalProblem.g:5745:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' | ||
960 | { | ||
961 | match('\''); | ||
962 | // InternalProblem.g:5745:23: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* | ||
963 | loop4: | ||
964 | do { | ||
965 | int alt4=3; | ||
966 | int LA4_0 = input.LA(1); | ||
967 | |||
968 | if ( (LA4_0=='\\') ) { | ||
969 | alt4=1; | ||
970 | } | ||
971 | else if ( ((LA4_0>='\u0000' && LA4_0<='&')||(LA4_0>='(' && LA4_0<='[')||(LA4_0>=']' && LA4_0<='\uFFFF')) ) { | ||
972 | alt4=2; | ||
973 | } | ||
974 | |||
975 | |||
976 | switch (alt4) { | ||
977 | case 1 : | ||
978 | // InternalProblem.g:5745:24: '\\\\' . | ||
979 | { | ||
980 | match('\\'); | ||
981 | matchAny(); | ||
982 | |||
983 | } | ||
984 | break; | ||
985 | case 2 : | ||
986 | // InternalProblem.g:5745:31: ~ ( ( '\\\\' | '\\'' ) ) | ||
987 | { | ||
988 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
989 | input.consume(); | ||
990 | |||
991 | } | ||
992 | else { | ||
993 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
994 | recover(mse); | ||
995 | throw mse;} | ||
996 | |||
997 | |||
998 | } | ||
999 | break; | ||
1000 | |||
1001 | default : | ||
1002 | break loop4; | ||
1003 | } | ||
1004 | } while (true); | ||
1005 | |||
1006 | match('\''); | ||
1007 | |||
1008 | } | ||
1009 | |||
1010 | state.type = _type; | ||
1011 | state.channel = _channel; | ||
1012 | } | ||
1013 | finally { | ||
1014 | } | ||
1015 | } | ||
1016 | // $ANTLR end "RULE_QUOTED_ID" | ||
1017 | |||
1018 | // $ANTLR start "RULE_SL_COMMENT" | ||
1019 | public final void mRULE_SL_COMMENT() throws RecognitionException { | ||
1020 | try { | ||
1021 | int _type = RULE_SL_COMMENT; | ||
1022 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1023 | // InternalProblem.g:5747:17: ( ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) | ||
1024 | // InternalProblem.g:5747:19: ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? | ||
1025 | { | ||
1026 | // InternalProblem.g:5747:19: ( '%' | '//' ) | ||
1027 | int alt5=2; | ||
1028 | int LA5_0 = input.LA(1); | ||
1029 | |||
1030 | if ( (LA5_0=='%') ) { | ||
1031 | alt5=1; | ||
1032 | } | ||
1033 | else if ( (LA5_0=='/') ) { | ||
1034 | alt5=2; | ||
1035 | } | ||
1036 | else { | ||
1037 | NoViableAltException nvae = | ||
1038 | new NoViableAltException("", 5, 0, input); | ||
1039 | |||
1040 | throw nvae; | ||
1041 | } | ||
1042 | switch (alt5) { | ||
1043 | case 1 : | ||
1044 | // InternalProblem.g:5747:20: '%' | ||
1045 | { | ||
1046 | match('%'); | ||
1047 | |||
1048 | } | ||
1049 | break; | ||
1050 | case 2 : | ||
1051 | // InternalProblem.g:5747:24: '//' | ||
1052 | { | ||
1053 | match("//"); | ||
1054 | |||
1055 | |||
1056 | } | ||
1057 | break; | ||
1058 | |||
1059 | } | ||
1060 | |||
1061 | // InternalProblem.g:5747:30: (~ ( ( '\\n' | '\\r' ) ) )* | ||
1062 | loop6: | ||
1063 | do { | ||
1064 | int alt6=2; | ||
1065 | int LA6_0 = input.LA(1); | ||
1066 | |||
1067 | if ( ((LA6_0>='\u0000' && LA6_0<='\t')||(LA6_0>='\u000B' && LA6_0<='\f')||(LA6_0>='\u000E' && LA6_0<='\uFFFF')) ) { | ||
1068 | alt6=1; | ||
1069 | } | ||
1070 | |||
1071 | |||
1072 | switch (alt6) { | ||
1073 | case 1 : | ||
1074 | // InternalProblem.g:5747:30: ~ ( ( '\\n' | '\\r' ) ) | ||
1075 | { | ||
1076 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { | ||
1077 | input.consume(); | ||
1078 | |||
1079 | } | ||
1080 | else { | ||
1081 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1082 | recover(mse); | ||
1083 | throw mse;} | ||
1084 | |||
1085 | |||
1086 | } | ||
1087 | break; | ||
1088 | |||
1089 | default : | ||
1090 | break loop6; | ||
1091 | } | ||
1092 | } while (true); | ||
1093 | |||
1094 | // InternalProblem.g:5747:46: ( ( '\\r' )? '\\n' )? | ||
1095 | int alt8=2; | ||
1096 | int LA8_0 = input.LA(1); | ||
1097 | |||
1098 | if ( (LA8_0=='\n'||LA8_0=='\r') ) { | ||
1099 | alt8=1; | ||
1100 | } | ||
1101 | switch (alt8) { | ||
1102 | case 1 : | ||
1103 | // InternalProblem.g:5747:47: ( '\\r' )? '\\n' | ||
1104 | { | ||
1105 | // InternalProblem.g:5747:47: ( '\\r' )? | ||
1106 | int alt7=2; | ||
1107 | int LA7_0 = input.LA(1); | ||
1108 | |||
1109 | if ( (LA7_0=='\r') ) { | ||
1110 | alt7=1; | ||
1111 | } | ||
1112 | switch (alt7) { | ||
1113 | case 1 : | ||
1114 | // InternalProblem.g:5747:47: '\\r' | ||
1115 | { | ||
1116 | match('\r'); | ||
1117 | |||
1118 | } | ||
1119 | break; | ||
1120 | |||
1121 | } | ||
1122 | |||
1123 | match('\n'); | ||
1124 | |||
1125 | } | ||
1126 | break; | ||
1127 | |||
1128 | } | ||
1129 | |||
1130 | |||
1131 | } | ||
1132 | |||
1133 | state.type = _type; | ||
1134 | state.channel = _channel; | ||
1135 | } | ||
1136 | finally { | ||
1137 | } | ||
1138 | } | ||
1139 | // $ANTLR end "RULE_SL_COMMENT" | ||
1140 | |||
1141 | // $ANTLR start "RULE_INT" | ||
1142 | public final void mRULE_INT() throws RecognitionException { | ||
1143 | try { | ||
1144 | int _type = RULE_INT; | ||
1145 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1146 | // InternalProblem.g:5749:10: ( ( '0' .. '9' )+ ) | ||
1147 | // InternalProblem.g:5749:12: ( '0' .. '9' )+ | ||
1148 | { | ||
1149 | // InternalProblem.g:5749:12: ( '0' .. '9' )+ | ||
1150 | int cnt9=0; | ||
1151 | loop9: | ||
1152 | do { | ||
1153 | int alt9=2; | ||
1154 | int LA9_0 = input.LA(1); | ||
1155 | |||
1156 | if ( ((LA9_0>='0' && LA9_0<='9')) ) { | ||
1157 | alt9=1; | ||
1158 | } | ||
1159 | |||
1160 | |||
1161 | switch (alt9) { | ||
1162 | case 1 : | ||
1163 | // InternalProblem.g:5749:13: '0' .. '9' | ||
1164 | { | ||
1165 | matchRange('0','9'); | ||
1166 | |||
1167 | } | ||
1168 | break; | ||
1169 | |||
1170 | default : | ||
1171 | if ( cnt9 >= 1 ) break loop9; | ||
1172 | EarlyExitException eee = | ||
1173 | new EarlyExitException(9, input); | ||
1174 | throw eee; | ||
1175 | } | ||
1176 | cnt9++; | ||
1177 | } while (true); | ||
1178 | |||
1179 | |||
1180 | } | ||
1181 | |||
1182 | state.type = _type; | ||
1183 | state.channel = _channel; | ||
1184 | } | ||
1185 | finally { | ||
1186 | } | ||
1187 | } | ||
1188 | // $ANTLR end "RULE_INT" | ||
1189 | |||
1190 | // $ANTLR start "RULE_ML_COMMENT" | ||
1191 | public final void mRULE_ML_COMMENT() throws RecognitionException { | ||
1192 | try { | ||
1193 | int _type = RULE_ML_COMMENT; | ||
1194 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1195 | // InternalProblem.g:5751:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) | ||
1196 | // InternalProblem.g:5751:19: '/*' ( options {greedy=false; } : . )* '*/' | ||
1197 | { | ||
1198 | match("/*"); | ||
1199 | |||
1200 | // InternalProblem.g:5751:24: ( options {greedy=false; } : . )* | ||
1201 | loop10: | ||
1202 | do { | ||
1203 | int alt10=2; | ||
1204 | int LA10_0 = input.LA(1); | ||
1205 | |||
1206 | if ( (LA10_0=='*') ) { | ||
1207 | int LA10_1 = input.LA(2); | ||
1208 | |||
1209 | if ( (LA10_1=='/') ) { | ||
1210 | alt10=2; | ||
1211 | } | ||
1212 | else if ( ((LA10_1>='\u0000' && LA10_1<='.')||(LA10_1>='0' && LA10_1<='\uFFFF')) ) { | ||
1213 | alt10=1; | ||
1214 | } | ||
1215 | |||
1216 | |||
1217 | } | ||
1218 | else if ( ((LA10_0>='\u0000' && LA10_0<=')')||(LA10_0>='+' && LA10_0<='\uFFFF')) ) { | ||
1219 | alt10=1; | ||
1220 | } | ||
1221 | |||
1222 | |||
1223 | switch (alt10) { | ||
1224 | case 1 : | ||
1225 | // InternalProblem.g:5751:52: . | ||
1226 | { | ||
1227 | matchAny(); | ||
1228 | |||
1229 | } | ||
1230 | break; | ||
1231 | |||
1232 | default : | ||
1233 | break loop10; | ||
1234 | } | ||
1235 | } while (true); | ||
1236 | |||
1237 | match("*/"); | ||
1238 | |||
1239 | |||
1240 | } | ||
1241 | |||
1242 | state.type = _type; | ||
1243 | state.channel = _channel; | ||
1244 | } | ||
1245 | finally { | ||
1246 | } | ||
1247 | } | ||
1248 | // $ANTLR end "RULE_ML_COMMENT" | ||
1249 | |||
1250 | // $ANTLR start "RULE_WS" | ||
1251 | public final void mRULE_WS() throws RecognitionException { | ||
1252 | try { | ||
1253 | int _type = RULE_WS; | ||
1254 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1255 | // InternalProblem.g:5753:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) | ||
1256 | // InternalProblem.g:5753:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
1257 | { | ||
1258 | // InternalProblem.g:5753:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
1259 | int cnt11=0; | ||
1260 | loop11: | ||
1261 | do { | ||
1262 | int alt11=2; | ||
1263 | int LA11_0 = input.LA(1); | ||
1264 | |||
1265 | if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) { | ||
1266 | alt11=1; | ||
1267 | } | ||
1268 | |||
1269 | |||
1270 | switch (alt11) { | ||
1271 | case 1 : | ||
1272 | // InternalProblem.g: | ||
1273 | { | ||
1274 | if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { | ||
1275 | input.consume(); | ||
1276 | |||
1277 | } | ||
1278 | else { | ||
1279 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1280 | recover(mse); | ||
1281 | throw mse;} | ||
1282 | |||
1283 | |||
1284 | } | ||
1285 | break; | ||
1286 | |||
1287 | default : | ||
1288 | if ( cnt11 >= 1 ) break loop11; | ||
1289 | EarlyExitException eee = | ||
1290 | new EarlyExitException(11, input); | ||
1291 | throw eee; | ||
1292 | } | ||
1293 | cnt11++; | ||
1294 | } while (true); | ||
1295 | |||
1296 | |||
1297 | } | ||
1298 | |||
1299 | state.type = _type; | ||
1300 | state.channel = _channel; | ||
1301 | } | ||
1302 | finally { | ||
1303 | } | ||
1304 | } | ||
1305 | // $ANTLR end "RULE_WS" | ||
1306 | |||
1307 | // $ANTLR start "RULE_ANY_OTHER" | ||
1308 | public final void mRULE_ANY_OTHER() throws RecognitionException { | ||
1309 | try { | ||
1310 | int _type = RULE_ANY_OTHER; | ||
1311 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1312 | // InternalProblem.g:5755:16: ( . ) | ||
1313 | // InternalProblem.g:5755:18: . | ||
1314 | { | ||
1315 | matchAny(); | ||
1316 | |||
1317 | } | ||
1318 | |||
1319 | state.type = _type; | ||
1320 | state.channel = _channel; | ||
1321 | } | ||
1322 | finally { | ||
1323 | } | ||
1324 | } | ||
1325 | // $ANTLR end "RULE_ANY_OTHER" | ||
1326 | |||
1327 | public void mTokens() throws RecognitionException { | ||
1328 | // InternalProblem.g:1:8: ( T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | RULE_ID | RULE_EXPONENTIAL | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) | ||
1329 | int alt12=43; | ||
1330 | alt12 = dfa12.predict(input); | ||
1331 | switch (alt12) { | ||
1332 | case 1 : | ||
1333 | // InternalProblem.g:1:10: T__13 | ||
1334 | { | ||
1335 | mT__13(); | ||
1336 | |||
1337 | } | ||
1338 | break; | ||
1339 | case 2 : | ||
1340 | // InternalProblem.g:1:16: T__14 | ||
1341 | { | ||
1342 | mT__14(); | ||
1343 | |||
1344 | } | ||
1345 | break; | ||
1346 | case 3 : | ||
1347 | // InternalProblem.g:1:22: T__15 | ||
1348 | { | ||
1349 | mT__15(); | ||
1350 | |||
1351 | } | ||
1352 | break; | ||
1353 | case 4 : | ||
1354 | // InternalProblem.g:1:28: T__16 | ||
1355 | { | ||
1356 | mT__16(); | ||
1357 | |||
1358 | } | ||
1359 | break; | ||
1360 | case 5 : | ||
1361 | // InternalProblem.g:1:34: T__17 | ||
1362 | { | ||
1363 | mT__17(); | ||
1364 | |||
1365 | } | ||
1366 | break; | ||
1367 | case 6 : | ||
1368 | // InternalProblem.g:1:40: T__18 | ||
1369 | { | ||
1370 | mT__18(); | ||
1371 | |||
1372 | } | ||
1373 | break; | ||
1374 | case 7 : | ||
1375 | // InternalProblem.g:1:46: T__19 | ||
1376 | { | ||
1377 | mT__19(); | ||
1378 | |||
1379 | } | ||
1380 | break; | ||
1381 | case 8 : | ||
1382 | // InternalProblem.g:1:52: T__20 | ||
1383 | { | ||
1384 | mT__20(); | ||
1385 | |||
1386 | } | ||
1387 | break; | ||
1388 | case 9 : | ||
1389 | // InternalProblem.g:1:58: T__21 | ||
1390 | { | ||
1391 | mT__21(); | ||
1392 | |||
1393 | } | ||
1394 | break; | ||
1395 | case 10 : | ||
1396 | // InternalProblem.g:1:64: T__22 | ||
1397 | { | ||
1398 | mT__22(); | ||
1399 | |||
1400 | } | ||
1401 | break; | ||
1402 | case 11 : | ||
1403 | // InternalProblem.g:1:70: T__23 | ||
1404 | { | ||
1405 | mT__23(); | ||
1406 | |||
1407 | } | ||
1408 | break; | ||
1409 | case 12 : | ||
1410 | // InternalProblem.g:1:76: T__24 | ||
1411 | { | ||
1412 | mT__24(); | ||
1413 | |||
1414 | } | ||
1415 | break; | ||
1416 | case 13 : | ||
1417 | // InternalProblem.g:1:82: T__25 | ||
1418 | { | ||
1419 | mT__25(); | ||
1420 | |||
1421 | } | ||
1422 | break; | ||
1423 | case 14 : | ||
1424 | // InternalProblem.g:1:88: T__26 | ||
1425 | { | ||
1426 | mT__26(); | ||
1427 | |||
1428 | } | ||
1429 | break; | ||
1430 | case 15 : | ||
1431 | // InternalProblem.g:1:94: T__27 | ||
1432 | { | ||
1433 | mT__27(); | ||
1434 | |||
1435 | } | ||
1436 | break; | ||
1437 | case 16 : | ||
1438 | // InternalProblem.g:1:100: T__28 | ||
1439 | { | ||
1440 | mT__28(); | ||
1441 | |||
1442 | } | ||
1443 | break; | ||
1444 | case 17 : | ||
1445 | // InternalProblem.g:1:106: T__29 | ||
1446 | { | ||
1447 | mT__29(); | ||
1448 | |||
1449 | } | ||
1450 | break; | ||
1451 | case 18 : | ||
1452 | // InternalProblem.g:1:112: T__30 | ||
1453 | { | ||
1454 | mT__30(); | ||
1455 | |||
1456 | } | ||
1457 | break; | ||
1458 | case 19 : | ||
1459 | // InternalProblem.g:1:118: T__31 | ||
1460 | { | ||
1461 | mT__31(); | ||
1462 | |||
1463 | } | ||
1464 | break; | ||
1465 | case 20 : | ||
1466 | // InternalProblem.g:1:124: T__32 | ||
1467 | { | ||
1468 | mT__32(); | ||
1469 | |||
1470 | } | ||
1471 | break; | ||
1472 | case 21 : | ||
1473 | // InternalProblem.g:1:130: T__33 | ||
1474 | { | ||
1475 | mT__33(); | ||
1476 | |||
1477 | } | ||
1478 | break; | ||
1479 | case 22 : | ||
1480 | // InternalProblem.g:1:136: T__34 | ||
1481 | { | ||
1482 | mT__34(); | ||
1483 | |||
1484 | } | ||
1485 | break; | ||
1486 | case 23 : | ||
1487 | // InternalProblem.g:1:142: T__35 | ||
1488 | { | ||
1489 | mT__35(); | ||
1490 | |||
1491 | } | ||
1492 | break; | ||
1493 | case 24 : | ||
1494 | // InternalProblem.g:1:148: T__36 | ||
1495 | { | ||
1496 | mT__36(); | ||
1497 | |||
1498 | } | ||
1499 | break; | ||
1500 | case 25 : | ||
1501 | // InternalProblem.g:1:154: T__37 | ||
1502 | { | ||
1503 | mT__37(); | ||
1504 | |||
1505 | } | ||
1506 | break; | ||
1507 | case 26 : | ||
1508 | // InternalProblem.g:1:160: T__38 | ||
1509 | { | ||
1510 | mT__38(); | ||
1511 | |||
1512 | } | ||
1513 | break; | ||
1514 | case 27 : | ||
1515 | // InternalProblem.g:1:166: T__39 | ||
1516 | { | ||
1517 | mT__39(); | ||
1518 | |||
1519 | } | ||
1520 | break; | ||
1521 | case 28 : | ||
1522 | // InternalProblem.g:1:172: T__40 | ||
1523 | { | ||
1524 | mT__40(); | ||
1525 | |||
1526 | } | ||
1527 | break; | ||
1528 | case 29 : | ||
1529 | // InternalProblem.g:1:178: T__41 | ||
1530 | { | ||
1531 | mT__41(); | ||
1532 | |||
1533 | } | ||
1534 | break; | ||
1535 | case 30 : | ||
1536 | // InternalProblem.g:1:184: T__42 | ||
1537 | { | ||
1538 | mT__42(); | ||
1539 | |||
1540 | } | ||
1541 | break; | ||
1542 | case 31 : | ||
1543 | // InternalProblem.g:1:190: T__43 | ||
1544 | { | ||
1545 | mT__43(); | ||
1546 | |||
1547 | } | ||
1548 | break; | ||
1549 | case 32 : | ||
1550 | // InternalProblem.g:1:196: T__44 | ||
1551 | { | ||
1552 | mT__44(); | ||
1553 | |||
1554 | } | ||
1555 | break; | ||
1556 | case 33 : | ||
1557 | // InternalProblem.g:1:202: T__45 | ||
1558 | { | ||
1559 | mT__45(); | ||
1560 | |||
1561 | } | ||
1562 | break; | ||
1563 | case 34 : | ||
1564 | // InternalProblem.g:1:208: T__46 | ||
1565 | { | ||
1566 | mT__46(); | ||
1567 | |||
1568 | } | ||
1569 | break; | ||
1570 | case 35 : | ||
1571 | // InternalProblem.g:1:214: RULE_ID | ||
1572 | { | ||
1573 | mRULE_ID(); | ||
1574 | |||
1575 | } | ||
1576 | break; | ||
1577 | case 36 : | ||
1578 | // InternalProblem.g:1:222: RULE_EXPONENTIAL | ||
1579 | { | ||
1580 | mRULE_EXPONENTIAL(); | ||
1581 | |||
1582 | } | ||
1583 | break; | ||
1584 | case 37 : | ||
1585 | // InternalProblem.g:1:239: RULE_STRING | ||
1586 | { | ||
1587 | mRULE_STRING(); | ||
1588 | |||
1589 | } | ||
1590 | break; | ||
1591 | case 38 : | ||
1592 | // InternalProblem.g:1:251: RULE_QUOTED_ID | ||
1593 | { | ||
1594 | mRULE_QUOTED_ID(); | ||
1595 | |||
1596 | } | ||
1597 | break; | ||
1598 | case 39 : | ||
1599 | // InternalProblem.g:1:266: RULE_SL_COMMENT | ||
1600 | { | ||
1601 | mRULE_SL_COMMENT(); | ||
1602 | |||
1603 | } | ||
1604 | break; | ||
1605 | case 40 : | ||
1606 | // InternalProblem.g:1:282: RULE_INT | ||
1607 | { | ||
1608 | mRULE_INT(); | ||
1609 | |||
1610 | } | ||
1611 | break; | ||
1612 | case 41 : | ||
1613 | // InternalProblem.g:1:291: RULE_ML_COMMENT | ||
1614 | { | ||
1615 | mRULE_ML_COMMENT(); | ||
1616 | |||
1617 | } | ||
1618 | break; | ||
1619 | case 42 : | ||
1620 | // InternalProblem.g:1:307: RULE_WS | ||
1621 | { | ||
1622 | mRULE_WS(); | ||
1623 | |||
1624 | } | ||
1625 | break; | ||
1626 | case 43 : | ||
1627 | // InternalProblem.g:1:315: RULE_ANY_OTHER | ||
1628 | { | ||
1629 | mRULE_ANY_OTHER(); | ||
1630 | |||
1631 | } | ||
1632 | break; | ||
1633 | |||
1634 | } | ||
1635 | |||
1636 | } | ||
1637 | |||
1638 | |||
1639 | protected DFA12 dfa12 = new DFA12(this); | ||
1640 | static final String DFA12_eotS = | ||
1641 | "\1\uffff\1\44\2\uffff\2\50\2\uffff\3\50\2\uffff\2\50\4\uffff\1\50\2\uffff\1\77\1\50\1\uffff\1\50\1\104\1\uffff\1\105\2\42\1\uffff\1\42\6\uffff\1\50\1\uffff\1\50\2\uffff\3\50\2\uffff\5\50\4\uffff\1\50\5\uffff\1\50\1\uffff\1\50\3\uffff\1\105\6\uffff\17\50\1\152\1\50\1\154\5\50\1\162\5\50\1\uffff\1\50\1\uffff\1\171\1\50\1\173\2\50\1\uffff\1\176\1\50\1\u0080\1\50\1\u0082\1\50\1\uffff\1\50\1\uffff\2\50\1\uffff\1\50\1\uffff\1\50\1\uffff\1\u0089\1\u008a\1\50\1\u008c\2\50\2\uffff\1\u008f\1\uffff\1\u0090\1\u0091\3\uffff"; | ||
1642 | static final String DFA12_eofS = | ||
1643 | "\u0092\uffff"; | ||
1644 | static final String DFA12_minS = | ||
1645 | "\1\0\1\56\2\uffff\1\145\1\162\2\uffff\1\162\1\141\1\156\2\uffff\1\154\1\156\4\uffff\1\160\2\uffff\1\55\1\143\1\uffff\1\142\1\75\1\uffff\1\60\2\0\1\uffff\1\52\6\uffff\1\146\1\uffff\1\145\2\uffff\1\165\1\154\1\153\2\uffff\1\141\1\156\1\164\1\165\1\162\4\uffff\1\160\5\uffff\1\157\1\uffff\1\163\3\uffff\1\60\6\uffff\1\145\1\144\1\142\1\145\1\163\1\156\1\163\1\164\1\145\1\155\2\157\1\160\1\164\1\162\1\60\1\154\1\60\1\145\1\157\1\163\1\141\1\156\1\60\1\162\1\163\1\145\1\162\1\163\1\uffff\1\145\1\uffff\1\60\1\167\1\60\1\151\1\144\1\uffff\1\60\1\151\1\60\1\141\1\60\1\155\1\uffff\1\156\1\uffff\1\156\1\163\1\uffff\1\164\1\uffff\1\143\1\uffff\2\60\1\163\1\60\1\145\1\164\2\uffff\1\60\1\uffff\2\60\3\uffff"; | ||
1646 | static final String DFA12_maxS = | ||
1647 | "\1\uffff\1\56\2\uffff\1\145\1\162\2\uffff\1\162\1\141\1\156\2\uffff\1\157\1\170\4\uffff\1\160\2\uffff\1\72\1\143\1\uffff\1\142\1\75\1\uffff\1\145\2\uffff\1\uffff\1\57\6\uffff\1\146\1\uffff\1\157\2\uffff\1\165\1\154\1\153\2\uffff\1\141\1\156\1\164\1\165\1\162\4\uffff\1\160\5\uffff\1\157\1\uffff\1\163\3\uffff\1\145\6\uffff\1\145\1\144\1\142\1\145\1\163\1\156\1\163\1\164\1\145\1\155\2\157\1\160\1\164\1\162\1\172\1\154\1\172\1\145\1\157\1\163\1\141\1\156\1\172\1\162\1\163\1\145\1\162\1\163\1\uffff\1\145\1\uffff\1\172\1\167\1\172\1\151\1\144\1\uffff\1\172\1\151\1\172\1\141\1\172\1\155\1\uffff\1\156\1\uffff\1\156\1\163\1\uffff\1\164\1\uffff\1\143\1\uffff\2\172\1\163\1\172\1\145\1\164\2\uffff\1\172\1\uffff\2\172\3\uffff"; | ||
1648 | static final String DFA12_acceptS = | ||
1649 | "\2\uffff\1\2\1\3\2\uffff\1\6\1\7\3\uffff\1\13\1\14\2\uffff\1\20\1\21\1\23\1\24\1\uffff\1\26\1\27\2\uffff\1\35\2\uffff\1\43\3\uffff\1\47\1\uffff\1\52\1\53\1\33\1\1\1\2\1\3\1\uffff\1\43\1\uffff\1\6\1\7\3\uffff\1\13\1\14\5\uffff\1\20\1\21\1\23\1\24\1\uffff\1\26\1\27\1\30\1\34\1\31\1\uffff\1\35\1\uffff\1\42\1\41\1\50\1\uffff\1\44\1\45\1\46\1\47\1\51\1\52\35\uffff\1\5\1\uffff\1\10\5\uffff\1\22\6\uffff\1\11\1\uffff\1\16\2\uffff\1\40\1\uffff\1\32\1\uffff\1\4\6\uffff\1\15\1\12\1\uffff\1\17\2\uffff\1\37\1\25\1\36"; | ||
1650 | static final String DFA12_specialS = | ||
1651 | "\1\1\34\uffff\1\0\1\2\163\uffff}>"; | ||
1652 | static final String[] DFA12_transitionS = { | ||
1653 | "\11\42\2\41\2\42\1\41\22\42\1\41\1\13\1\35\2\42\1\37\1\42\1\36\1\24\1\25\1\7\1\32\1\2\1\30\1\1\1\40\12\34\1\26\1\3\1\42\1\6\1\42\1\14\1\42\32\33\1\21\1\42\1\22\1\42\1\33\1\42\1\31\1\33\1\15\1\33\1\16\1\11\10\33\1\23\1\5\1\33\1\4\1\27\1\10\1\12\5\33\1\17\1\42\1\20\uff82\42", | ||
1654 | "\1\43", | ||
1655 | "", | ||
1656 | "", | ||
1657 | "\1\47", | ||
1658 | "\1\51", | ||
1659 | "", | ||
1660 | "", | ||
1661 | "\1\54", | ||
1662 | "\1\55", | ||
1663 | "\1\56", | ||
1664 | "", | ||
1665 | "", | ||
1666 | "\1\61\2\uffff\1\62", | ||
1667 | "\1\64\3\uffff\1\65\5\uffff\1\63", | ||
1668 | "", | ||
1669 | "", | ||
1670 | "", | ||
1671 | "", | ||
1672 | "\1\72", | ||
1673 | "", | ||
1674 | "", | ||
1675 | "\1\75\14\uffff\1\76", | ||
1676 | "\1\100", | ||
1677 | "", | ||
1678 | "\1\102", | ||
1679 | "\1\103", | ||
1680 | "", | ||
1681 | "\12\106\13\uffff\1\107\37\uffff\1\107", | ||
1682 | "\0\110", | ||
1683 | "\0\111", | ||
1684 | "", | ||
1685 | "\1\113\4\uffff\1\112", | ||
1686 | "", | ||
1687 | "", | ||
1688 | "", | ||
1689 | "", | ||
1690 | "", | ||
1691 | "", | ||
1692 | "\1\115", | ||
1693 | "", | ||
1694 | "\1\116\11\uffff\1\117", | ||
1695 | "", | ||
1696 | "", | ||
1697 | "\1\120", | ||
1698 | "\1\121", | ||
1699 | "\1\122", | ||
1700 | "", | ||
1701 | "", | ||
1702 | "\1\123", | ||
1703 | "\1\124", | ||
1704 | "\1\125", | ||
1705 | "\1\126", | ||
1706 | "\1\127", | ||
1707 | "", | ||
1708 | "", | ||
1709 | "", | ||
1710 | "", | ||
1711 | "\1\130", | ||
1712 | "", | ||
1713 | "", | ||
1714 | "", | ||
1715 | "", | ||
1716 | "", | ||
1717 | "\1\131", | ||
1718 | "", | ||
1719 | "\1\132", | ||
1720 | "", | ||
1721 | "", | ||
1722 | "", | ||
1723 | "\12\106\13\uffff\1\107\37\uffff\1\107", | ||
1724 | "", | ||
1725 | "", | ||
1726 | "", | ||
1727 | "", | ||
1728 | "", | ||
1729 | "", | ||
1730 | "\1\133", | ||
1731 | "\1\134", | ||
1732 | "\1\135", | ||
1733 | "\1\136", | ||
1734 | "\1\137", | ||
1735 | "\1\140", | ||
1736 | "\1\141", | ||
1737 | "\1\142", | ||
1738 | "\1\143", | ||
1739 | "\1\144", | ||
1740 | "\1\145", | ||
1741 | "\1\146", | ||
1742 | "\1\147", | ||
1743 | "\1\150", | ||
1744 | "\1\151", | ||
1745 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1746 | "\1\153", | ||
1747 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1748 | "\1\155", | ||
1749 | "\1\156", | ||
1750 | "\1\157", | ||
1751 | "\1\160", | ||
1752 | "\1\161", | ||
1753 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1754 | "\1\163", | ||
1755 | "\1\164", | ||
1756 | "\1\165", | ||
1757 | "\1\166", | ||
1758 | "\1\167", | ||
1759 | "", | ||
1760 | "\1\170", | ||
1761 | "", | ||
1762 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1763 | "\1\172", | ||
1764 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1765 | "\1\174", | ||
1766 | "\1\175", | ||
1767 | "", | ||
1768 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1769 | "\1\177", | ||
1770 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1771 | "\1\u0081", | ||
1772 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1773 | "\1\u0083", | ||
1774 | "", | ||
1775 | "\1\u0084", | ||
1776 | "", | ||
1777 | "\1\u0085", | ||
1778 | "\1\u0086", | ||
1779 | "", | ||
1780 | "\1\u0087", | ||
1781 | "", | ||
1782 | "\1\u0088", | ||
1783 | "", | ||
1784 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1785 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1786 | "\1\u008b", | ||
1787 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1788 | "\1\u008d", | ||
1789 | "\1\u008e", | ||
1790 | "", | ||
1791 | "", | ||
1792 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1793 | "", | ||
1794 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1795 | "\12\50\7\uffff\32\50\4\uffff\1\50\1\uffff\32\50", | ||
1796 | "", | ||
1797 | "", | ||
1798 | "" | ||
1799 | }; | ||
1800 | |||
1801 | static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS); | ||
1802 | static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS); | ||
1803 | static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS); | ||
1804 | static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS); | ||
1805 | static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS); | ||
1806 | static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS); | ||
1807 | static final short[][] DFA12_transition; | ||
1808 | |||
1809 | static { | ||
1810 | int numStates = DFA12_transitionS.length; | ||
1811 | DFA12_transition = new short[numStates][]; | ||
1812 | for (int i=0; i<numStates; i++) { | ||
1813 | DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]); | ||
1814 | } | ||
1815 | } | ||
1816 | |||
1817 | class DFA12 extends DFA { | ||
1818 | |||
1819 | public DFA12(BaseRecognizer recognizer) { | ||
1820 | this.recognizer = recognizer; | ||
1821 | this.decisionNumber = 12; | ||
1822 | this.eot = DFA12_eot; | ||
1823 | this.eof = DFA12_eof; | ||
1824 | this.min = DFA12_min; | ||
1825 | this.max = DFA12_max; | ||
1826 | this.accept = DFA12_accept; | ||
1827 | this.special = DFA12_special; | ||
1828 | this.transition = DFA12_transition; | ||
1829 | } | ||
1830 | public String getDescription() { | ||
1831 | return "1:1: Tokens : ( T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | RULE_ID | RULE_EXPONENTIAL | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER );"; | ||
1832 | } | ||
1833 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { | ||
1834 | IntStream input = _input; | ||
1835 | int _s = s; | ||
1836 | switch ( s ) { | ||
1837 | case 0 : | ||
1838 | int LA12_29 = input.LA(1); | ||
1839 | |||
1840 | s = -1; | ||
1841 | if ( ((LA12_29>='\u0000' && LA12_29<='\uFFFF')) ) {s = 72;} | ||
1842 | |||
1843 | else s = 34; | ||
1844 | |||
1845 | if ( s>=0 ) return s; | ||
1846 | break; | ||
1847 | case 1 : | ||
1848 | int LA12_0 = input.LA(1); | ||
1849 | |||
1850 | s = -1; | ||
1851 | if ( (LA12_0=='.') ) {s = 1;} | ||
1852 | |||
1853 | else if ( (LA12_0==',') ) {s = 2;} | ||
1854 | |||
1855 | else if ( (LA12_0==';') ) {s = 3;} | ||
1856 | |||
1857 | else if ( (LA12_0=='r') ) {s = 4;} | ||
1858 | |||
1859 | else if ( (LA12_0=='p') ) {s = 5;} | ||
1860 | |||
1861 | else if ( (LA12_0=='=') ) {s = 6;} | ||
1862 | |||
1863 | else if ( (LA12_0=='*') ) {s = 7;} | ||
1864 | |||
1865 | else if ( (LA12_0=='t') ) {s = 8;} | ||
1866 | |||
1867 | else if ( (LA12_0=='f') ) {s = 9;} | ||
1868 | |||
1869 | else if ( (LA12_0=='u') ) {s = 10;} | ||
1870 | |||
1871 | else if ( (LA12_0=='!') ) {s = 11;} | ||
1872 | |||
1873 | else if ( (LA12_0=='?') ) {s = 12;} | ||
1874 | |||
1875 | else if ( (LA12_0=='c') ) {s = 13;} | ||
1876 | |||
1877 | else if ( (LA12_0=='e') ) {s = 14;} | ||
1878 | |||
1879 | else if ( (LA12_0=='{') ) {s = 15;} | ||
1880 | |||
1881 | else if ( (LA12_0=='}') ) {s = 16;} | ||
1882 | |||
1883 | else if ( (LA12_0=='[') ) {s = 17;} | ||
1884 | |||
1885 | else if ( (LA12_0==']') ) {s = 18;} | ||
1886 | |||
1887 | else if ( (LA12_0=='o') ) {s = 19;} | ||
1888 | |||
1889 | else if ( (LA12_0=='(') ) {s = 20;} | ||
1890 | |||
1891 | else if ( (LA12_0==')') ) {s = 21;} | ||
1892 | |||
1893 | else if ( (LA12_0==':') ) {s = 22;} | ||
1894 | |||
1895 | else if ( (LA12_0=='s') ) {s = 23;} | ||
1896 | |||
1897 | else if ( (LA12_0=='-') ) {s = 24;} | ||
1898 | |||
1899 | else if ( (LA12_0=='a') ) {s = 25;} | ||
1900 | |||
1901 | else if ( (LA12_0=='+') ) {s = 26;} | ||
1902 | |||
1903 | else if ( ((LA12_0>='A' && LA12_0<='Z')||LA12_0=='_'||LA12_0=='b'||LA12_0=='d'||(LA12_0>='g' && LA12_0<='n')||LA12_0=='q'||(LA12_0>='v' && LA12_0<='z')) ) {s = 27;} | ||
1904 | |||
1905 | else if ( ((LA12_0>='0' && LA12_0<='9')) ) {s = 28;} | ||
1906 | |||
1907 | else if ( (LA12_0=='\"') ) {s = 29;} | ||
1908 | |||
1909 | else if ( (LA12_0=='\'') ) {s = 30;} | ||
1910 | |||
1911 | else if ( (LA12_0=='%') ) {s = 31;} | ||
1912 | |||
1913 | else if ( (LA12_0=='/') ) {s = 32;} | ||
1914 | |||
1915 | else if ( ((LA12_0>='\t' && LA12_0<='\n')||LA12_0=='\r'||LA12_0==' ') ) {s = 33;} | ||
1916 | |||
1917 | else if ( ((LA12_0>='\u0000' && LA12_0<='\b')||(LA12_0>='\u000B' && LA12_0<='\f')||(LA12_0>='\u000E' && LA12_0<='\u001F')||(LA12_0>='#' && LA12_0<='$')||LA12_0=='&'||LA12_0=='<'||LA12_0=='>'||LA12_0=='@'||LA12_0=='\\'||LA12_0=='^'||LA12_0=='`'||LA12_0=='|'||(LA12_0>='~' && LA12_0<='\uFFFF')) ) {s = 34;} | ||
1918 | |||
1919 | if ( s>=0 ) return s; | ||
1920 | break; | ||
1921 | case 2 : | ||
1922 | int LA12_30 = input.LA(1); | ||
1923 | |||
1924 | s = -1; | ||
1925 | if ( ((LA12_30>='\u0000' && LA12_30<='\uFFFF')) ) {s = 73;} | ||
1926 | |||
1927 | else s = 34; | ||
1928 | |||
1929 | if ( s>=0 ) return s; | ||
1930 | break; | ||
1931 | } | ||
1932 | NoViableAltException nvae = | ||
1933 | new NoViableAltException(getDescription(), 12, _s, input); | ||
1934 | error(nvae); | ||
1935 | throw nvae; | ||
1936 | } | ||
1937 | } | ||
1938 | |||
1939 | |||
1940 | } \ No newline at end of file | ||