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