1 /* $ANTLR 2.7.7 (2006-11-01): "format.g" -> "FMTParser.cpp"$ */
2
3 #include "includefirst.hpp"
4
5 #include "FMTParser.hpp"
6 #include <antlr/NoViableAltException.hpp>
7 #include <antlr/SemanticException.hpp>
8 #include <antlr/ASTFactory.hpp>
FMTParser(antlr::TokenBuffer & tokenBuf,int k)9 FMTParser::FMTParser(antlr::TokenBuffer& tokenBuf, int k)
10 : antlr::LLkParser(tokenBuf,k)
11 {
12 }
13
FMTParser(antlr::TokenBuffer & tokenBuf)14 FMTParser::FMTParser(antlr::TokenBuffer& tokenBuf)
15 : antlr::LLkParser(tokenBuf,1)
16 {
17 }
18
FMTParser(antlr::TokenStream & lexer,int k)19 FMTParser::FMTParser(antlr::TokenStream& lexer, int k)
20 : antlr::LLkParser(lexer,k)
21 {
22 }
23
FMTParser(antlr::TokenStream & lexer)24 FMTParser::FMTParser(antlr::TokenStream& lexer)
25 : antlr::LLkParser(lexer,1)
26 {
27 }
28
FMTParser(const antlr::ParserSharedInputState & state)29 FMTParser::FMTParser(const antlr::ParserSharedInputState& state)
30 : antlr::LLkParser(state,1)
31 {
32 }
33
format(int repeat)34 void FMTParser::format(
35 int repeat
36 ) {
37 returnAST = RefFMTNode(antlr::nullAST);
38 antlr::ASTPair currentAST;
39 RefFMTNode format_AST = RefFMTNode(antlr::nullAST);
40
41 match(LBRACE);
42 qfq();
43 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
44 { // ( ... )*
45 for (;;) {
46 if ((LA(1) == COMMA)) {
47 match(COMMA);
48 qfq();
49 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
50 }
51 else {
52 goto _loop3;
53 }
54
55 }
56 _loop3:;
57 } // ( ... )*
58 match(RBRACE);
59 format_AST = RefFMTNode(currentAST.root);
60
61 format_AST = RefFMTNode(astFactory->make((new antlr::ASTArray(2))->add(antlr::RefAST(astFactory->create(FORMAT,"FORMAT")))->add(antlr::RefAST(format_AST))));
62 format_AST->setRep( repeat);
63
64 currentAST.root = format_AST;
65 if ( format_AST!=RefFMTNode(antlr::nullAST) &&
66 format_AST->getFirstChild() != RefFMTNode(antlr::nullAST) )
67 currentAST.child = format_AST->getFirstChild();
68 else
69 currentAST.child = format_AST;
70 currentAST.advanceChildToEnd();
71 format_AST = RefFMTNode(currentAST.root);
72 returnAST = format_AST;
73 }
74
qfq()75 void FMTParser::qfq() {
76 returnAST = RefFMTNode(antlr::nullAST);
77 antlr::ASTPair currentAST;
78 RefFMTNode qfq_AST = RefFMTNode(antlr::nullAST);
79
80 q();
81 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
82 {
83 switch ( LA(1)) {
84 case CSTR:
85 case CD:
86 case CSE:
87 case CE:
88 case CI:
89 case CF:
90 case CSG:
91 case CG:
92 case CO:
93 case CB:
94 case CS:
95 case CX:
96 case CZ:
97 case PM:
98 case MP:
99 case PLUS:
100 case MOINS:
101 case CNUMBER:
102 case LBRACE:
103 case STRING:
104 case TL:
105 case TR:
106 case TERM:
107 case NONL:
108 case Q:
109 case T:
110 case X:
111 case A:
112 case F:
113 case D:
114 case E:
115 case SE:
116 case G:
117 case SG:
118 case I:
119 case O:
120 case B:
121 case Z:
122 case ZZ:
123 case C:
124 case NUMBER:
125 {
126 f();
127 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
128 q();
129 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
130 break;
131 }
132 case COMMA:
133 case RBRACE:
134 {
135 break;
136 }
137 default:
138 {
139 throw antlr::NoViableAltException(LT(1), getFilename());
140 }
141 }
142 }
143 qfq_AST = RefFMTNode(currentAST.root);
144 returnAST = qfq_AST;
145 }
146
q()147 void FMTParser::q() {
148 returnAST = RefFMTNode(antlr::nullAST);
149 antlr::ASTPair currentAST;
150 RefFMTNode q_AST = RefFMTNode(antlr::nullAST);
151
152 int n1 = 0;
153
154
155 { // ( ... )*
156 for (;;) {
157 if ((LA(1) == SLASH)) {
158 RefFMTNode tmp4_AST = RefFMTNode(antlr::nullAST);
159 tmp4_AST = astFactory->create(LT(1));
160 match(SLASH);
161 n1++;
162 }
163 else {
164 goto _loop8;
165 }
166
167 }
168 _loop8:;
169 } // ( ... )*
170 q_AST = RefFMTNode(currentAST.root);
171
172 if( n1 > 0)
173 {
174 q_AST = RefFMTNode(astFactory->make((new antlr::ASTArray(1))->add(antlr::RefAST(astFactory->create(SLASH,"/")))));
175 q_AST->setRep( n1);
176 }
177
178 currentAST.root = q_AST;
179 if ( q_AST!=RefFMTNode(antlr::nullAST) &&
180 q_AST->getFirstChild() != RefFMTNode(antlr::nullAST) )
181 currentAST.child = q_AST->getFirstChild();
182 else
183 currentAST.child = q_AST;
184 currentAST.advanceChildToEnd();
185 returnAST = q_AST;
186 }
187
f()188 void FMTParser::f() {
189 returnAST = RefFMTNode(antlr::nullAST);
190 antlr::ASTPair currentAST;
191 RefFMTNode f_AST = RefFMTNode(antlr::nullAST);
192 antlr::RefToken t = antlr::nullToken;
193 RefFMTNode t_AST = RefFMTNode(antlr::nullAST);
194 antlr::RefToken x = antlr::nullToken;
195 RefFMTNode x_AST = RefFMTNode(antlr::nullAST);
196 antlr::RefToken xx = antlr::nullToken;
197 RefFMTNode xx_AST = RefFMTNode(antlr::nullAST);
198
199 int n1;
200
201
202 switch ( LA(1)) {
203 case TERM:
204 {
205 RefFMTNode tmp5_AST = RefFMTNode(antlr::nullAST);
206 tmp5_AST = astFactory->create(LT(1));
207 astFactory->addASTChild(currentAST, antlr::RefAST(tmp5_AST));
208 match(TERM);
209 f_AST = RefFMTNode(currentAST.root);
210 break;
211 }
212 case NONL:
213 {
214 RefFMTNode tmp6_AST = RefFMTNode(antlr::nullAST);
215 tmp6_AST = astFactory->create(LT(1));
216 astFactory->addASTChild(currentAST, antlr::RefAST(tmp6_AST));
217 match(NONL);
218 f_AST = RefFMTNode(currentAST.root);
219 break;
220 }
221 case Q:
222 {
223 RefFMTNode tmp7_AST = RefFMTNode(antlr::nullAST);
224 tmp7_AST = astFactory->create(LT(1));
225 astFactory->addASTChild(currentAST, antlr::RefAST(tmp7_AST));
226 match(Q);
227 f_AST = RefFMTNode(currentAST.root);
228 break;
229 }
230 case T:
231 {
232 t = LT(1);
233 t_AST = astFactory->create(t);
234 astFactory->addASTChild(currentAST, antlr::RefAST(t_AST));
235 match(T);
236 n1=nn();
237 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
238 t_AST->setW( n1);
239 f_AST = RefFMTNode(currentAST.root);
240 break;
241 }
242 case CSTR:
243 case CD:
244 case CSE:
245 case CE:
246 case CI:
247 case CF:
248 case CSG:
249 case CG:
250 case CO:
251 case CB:
252 case CS:
253 case CX:
254 case CZ:
255 case PM:
256 case MP:
257 case PLUS:
258 case MOINS:
259 case CNUMBER:
260 case STRING:
261 case TL:
262 case TR:
263 {
264 f_csubcode();
265 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
266 f_AST = RefFMTNode(currentAST.root);
267 break;
268 }
269 case LBRACE:
270 case A:
271 case F:
272 case D:
273 case E:
274 case SE:
275 case G:
276 case SG:
277 case I:
278 case O:
279 case B:
280 case Z:
281 case ZZ:
282 case C:
283 {
284 rep_fmt( 1);
285 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
286 f_AST = RefFMTNode(currentAST.root);
287 break;
288 }
289 case NUMBER:
290 {
291 n1=nn();
292 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
293 {
294 switch ( LA(1)) {
295 case LBRACE:
296 case A:
297 case F:
298 case D:
299 case E:
300 case SE:
301 case G:
302 case SG:
303 case I:
304 case O:
305 case B:
306 case Z:
307 case ZZ:
308 case C:
309 {
310 rep_fmt( n1);
311 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
312 break;
313 }
314 case X:
315 {
316 x = LT(1);
317 x_AST = astFactory->create(x);
318 astFactory->addASTChild(currentAST, antlr::RefAST(x_AST));
319 match(X);
320 x_AST->setW( n1);
321 break;
322 }
323 default:
324 {
325 throw antlr::NoViableAltException(LT(1), getFilename());
326 }
327 }
328 }
329 f_AST = RefFMTNode(currentAST.root);
330 break;
331 }
332 case X:
333 {
334 xx = LT(1);
335 xx_AST = astFactory->create(xx);
336 astFactory->addASTChild(currentAST, antlr::RefAST(xx_AST));
337 match(X);
338 xx_AST->setW( 1);
339 f_AST = RefFMTNode(currentAST.root);
340 break;
341 }
342 default:
343 {
344 throw antlr::NoViableAltException(LT(1), getFilename());
345 }
346 }
347 returnAST = f_AST;
348 }
349
f_csubcode()350 void FMTParser::f_csubcode() {
351 returnAST = RefFMTNode(antlr::nullAST);
352 antlr::ASTPair currentAST;
353 RefFMTNode f_csubcode_AST = RefFMTNode(antlr::nullAST);
354 antlr::RefToken tl = antlr::nullToken;
355 RefFMTNode tl_AST = RefFMTNode(antlr::nullAST);
356 antlr::RefToken tr = antlr::nullToken;
357 RefFMTNode tr_AST = RefFMTNode(antlr::nullAST);
358
359 int n1;
360
361
362 switch ( LA(1)) {
363 case STRING:
364 {
365 RefFMTNode tmp8_AST = RefFMTNode(antlr::nullAST);
366 tmp8_AST = astFactory->create(LT(1));
367 astFactory->addASTChild(currentAST, antlr::RefAST(tmp8_AST));
368 match(STRING);
369 f_csubcode_AST = RefFMTNode(currentAST.root);
370 break;
371 }
372 case CSTR:
373 case CD:
374 case CSE:
375 case CE:
376 case CI:
377 case CF:
378 case CSG:
379 case CG:
380 case CO:
381 case CB:
382 case CS:
383 case CX:
384 case CZ:
385 case PM:
386 case MP:
387 case PLUS:
388 case MOINS:
389 case CNUMBER:
390 {
391 cstring();
392 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
393 f_csubcode_AST = RefFMTNode(currentAST.root);
394 break;
395 }
396 case TL:
397 {
398 tl = LT(1);
399 tl_AST = astFactory->create(tl);
400 astFactory->addASTChild(currentAST, antlr::RefAST(tl_AST));
401 match(TL);
402 n1=nn();
403 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
404 tl_AST->setW( n1);
405 f_csubcode_AST = RefFMTNode(currentAST.root);
406 break;
407 }
408 case TR:
409 {
410 tr = LT(1);
411 tr_AST = astFactory->create(tr);
412 astFactory->addASTChild(currentAST, antlr::RefAST(tr_AST));
413 match(TR);
414 n1=nn();
415 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
416 tr_AST->setW( n1);
417 f_csubcode_AST = RefFMTNode(currentAST.root);
418 break;
419 }
420 default:
421 {
422 throw antlr::NoViableAltException(LT(1), getFilename());
423 }
424 }
425 returnAST = f_csubcode_AST;
426 }
427
cstring()428 void FMTParser::cstring() {
429 returnAST = RefFMTNode(antlr::nullAST);
430 antlr::ASTPair currentAST;
431 RefFMTNode cstring_AST = RefFMTNode(antlr::nullAST);
432 antlr::RefToken s = antlr::nullToken;
433 RefFMTNode s_AST = RefFMTNode(antlr::nullAST);
434
435 { // ( ... )+
436 int _cnt12=0;
437 for (;;) {
438 switch ( LA(1)) {
439 case CSTR:
440 {
441 s = LT(1);
442 s_AST = astFactory->create(s);
443 astFactory->addASTChild(currentAST, antlr::RefAST(s_AST));
444 match(CSTR);
445 s_AST->setType( STRING);
446 break;
447 }
448 case CD:
449 case CSE:
450 case CE:
451 case CI:
452 case CF:
453 case CSG:
454 case CG:
455 case CO:
456 case CB:
457 case CS:
458 case CX:
459 case CZ:
460 case PM:
461 case MP:
462 case PLUS:
463 case MOINS:
464 case CNUMBER:
465 {
466 cformat();
467 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
468 break;
469 }
470 default:
471 {
472 if ( _cnt12>=1 ) { goto _loop12; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
473 }
474 }
475 _cnt12++;
476 }
477 _loop12:;
478 } // ( ... )+
479 cstring_AST = RefFMTNode(currentAST.root);
480 returnAST = cstring_AST;
481 }
482
nn()483 int FMTParser::nn() {
484 int n;
485 returnAST = RefFMTNode(antlr::nullAST);
486 antlr::ASTPair currentAST;
487 RefFMTNode nn_AST = RefFMTNode(antlr::nullAST);
488 antlr::RefToken num = antlr::nullToken;
489 RefFMTNode num_AST = RefFMTNode(antlr::nullAST);
490
491 int sgn=1;
492
493
494 num = LT(1);
495 num_AST = astFactory->create(num);
496 match(NUMBER);
497
498 std::istringstream s(num_AST->getText());
499 s >> n;
500
501 returnAST = nn_AST;
502 return n;
503 }
504
cformat()505 void FMTParser::cformat() {
506 returnAST = RefFMTNode(antlr::nullAST);
507 antlr::ASTPair currentAST;
508 RefFMTNode cformat_AST = RefFMTNode(antlr::nullAST);
509 antlr::RefToken c = antlr::nullToken;
510 RefFMTNode c_AST = RefFMTNode(antlr::nullAST);
511 antlr::RefToken se = antlr::nullToken;
512 RefFMTNode se_AST = RefFMTNode(antlr::nullAST);
513 antlr::RefToken e = antlr::nullToken;
514 RefFMTNode e_AST = RefFMTNode(antlr::nullAST);
515 antlr::RefToken i = antlr::nullToken;
516 RefFMTNode i_AST = RefFMTNode(antlr::nullAST);
517 antlr::RefToken ff = antlr::nullToken;
518 RefFMTNode ff_AST = RefFMTNode(antlr::nullAST);
519 antlr::RefToken sg = antlr::nullToken;
520 RefFMTNode sg_AST = RefFMTNode(antlr::nullAST);
521 antlr::RefToken g = antlr::nullToken;
522 RefFMTNode g_AST = RefFMTNode(antlr::nullAST);
523 antlr::RefToken o = antlr::nullToken;
524 RefFMTNode o_AST = RefFMTNode(antlr::nullAST);
525 antlr::RefToken b = antlr::nullToken;
526 RefFMTNode b_AST = RefFMTNode(antlr::nullAST);
527 antlr::RefToken x = antlr::nullToken;
528 RefFMTNode x_AST = RefFMTNode(antlr::nullAST);
529 antlr::RefToken z = antlr::nullToken;
530 RefFMTNode z_AST = RefFMTNode(antlr::nullAST);
531 antlr::RefToken s = antlr::nullToken;
532 RefFMTNode s_AST = RefFMTNode(antlr::nullAST);
533
534 int w = 0;
535 int infos[4]={0,0,0,0};
536 int d = -1;
537
538
539 {
540 switch ( LA(1)) {
541 case PM:
542 case MP:
543 {
544 {
545 switch ( LA(1)) {
546 case PM:
547 {
548 match(PM);
549 break;
550 }
551 case MP:
552 {
553 match(MP);
554 break;
555 }
556 default:
557 {
558 throw antlr::NoViableAltException(LT(1), getFilename());
559 }
560 }
561 }
562 infos[1]=1;infos[2]=1;
563 break;
564 }
565 case PLUS:
566 {
567 {
568 match(PLUS);
569 infos[1]=1;
570 }
571 break;
572 }
573 case MOINS:
574 {
575 {
576 match(MOINS);
577 infos[2]=1;
578 }
579 break;
580 }
581 case CD:
582 case CSE:
583 case CE:
584 case CI:
585 case CF:
586 case CSG:
587 case CG:
588 case CO:
589 case CB:
590 case CS:
591 case CX:
592 case CZ:
593 case CNUMBER:
594 {
595 break;
596 }
597 default:
598 {
599 throw antlr::NoViableAltException(LT(1), getFilename());
600 }
601 }
602 }
603 {
604 switch ( LA(1)) {
605 case CNUMBER:
606 {
607 cnnf(infos);
608 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
609 w=infos[0];
610 {
611 switch ( LA(1)) {
612 case CDOT:
613 {
614 match(CDOT);
615 d=cnn();
616 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
617 break;
618 }
619 case CD:
620 case CSE:
621 case CE:
622 case CI:
623 case CF:
624 case CSG:
625 case CG:
626 case CO:
627 case CB:
628 case CS:
629 case CX:
630 case CZ:
631 {
632 break;
633 }
634 default:
635 {
636 throw antlr::NoViableAltException(LT(1), getFilename());
637 }
638 }
639 }
640 break;
641 }
642 case CD:
643 case CSE:
644 case CE:
645 case CI:
646 case CF:
647 case CSG:
648 case CG:
649 case CO:
650 case CB:
651 case CS:
652 case CX:
653 case CZ:
654 {
655 break;
656 }
657 default:
658 {
659 throw antlr::NoViableAltException(LT(1), getFilename());
660 }
661 }
662 }
663 {
664 switch ( LA(1)) {
665 case CD:
666 {
667 c = LT(1);
668 c_AST = astFactory->create(c);
669 astFactory->addASTChild(currentAST, antlr::RefAST(c_AST));
670 match(CD);
671 if (infos[1])c_AST->setShowSign(); if (infos[2])c_AST->setALignLeft(); if (infos[3])c_AST->setPadding(); c_AST->setW( w); c_AST->setD( d); c_AST->setType( I);
672 break;
673 }
674 case CSE:
675 {
676 se = LT(1);
677 se_AST = astFactory->create(se);
678 astFactory->addASTChild(currentAST, antlr::RefAST(se_AST));
679 match(CSE);
680 if (infos[1])se_AST->setShowSign(); if (infos[2])se_AST->setALignLeft(); if (infos[3])se_AST->setPadding(); se_AST->setW( w); se_AST->setD( d); se_AST->setType( SE);
681 break;
682 }
683 case CE:
684 {
685 e = LT(1);
686 e_AST = astFactory->create(e);
687 astFactory->addASTChild(currentAST, antlr::RefAST(e_AST));
688 match(CE);
689 if (infos[1])e_AST->setShowSign(); if (infos[2])e_AST->setALignLeft(); if (infos[3])e_AST->setPadding(); e_AST->setW( w); e_AST->setD( d); e_AST->setType( E);
690 break;
691 }
692 case CI:
693 {
694 i = LT(1);
695 i_AST = astFactory->create(i);
696 astFactory->addASTChild(currentAST, antlr::RefAST(i_AST));
697 match(CI);
698 if (infos[1])i_AST->setShowSign(); if (infos[2])i_AST->setALignLeft(); if (infos[3])i_AST->setPadding(); i_AST->setW( w); i_AST->setD( d); i_AST->setType( I);
699 break;
700 }
701 case CF:
702 {
703 ff = LT(1);
704 ff_AST = astFactory->create(ff);
705 astFactory->addASTChild(currentAST, antlr::RefAST(ff_AST));
706 match(CF);
707 if (infos[1])ff_AST->setShowSign(); if (infos[2])ff_AST->setALignLeft(); if (infos[3])ff_AST->setPadding(); ff_AST->setW( w); ff_AST->setD( d); ff_AST->setType( F);
708 break;
709 }
710 case CSG:
711 {
712 sg = LT(1);
713 sg_AST = astFactory->create(sg);
714 astFactory->addASTChild(currentAST, antlr::RefAST(sg_AST));
715 match(CSG);
716 if (infos[1])sg_AST->setShowSign(); if (infos[2])sg_AST->setALignLeft(); if (infos[3])sg_AST->setPadding(); sg_AST->setW( w); sg_AST->setD( d); sg_AST->setType( SG);
717 break;
718 }
719 case CG:
720 {
721 g = LT(1);
722 g_AST = astFactory->create(g);
723 astFactory->addASTChild(currentAST, antlr::RefAST(g_AST));
724 match(CG);
725 if (infos[1])g_AST->setShowSign(); if (infos[2])g_AST->setALignLeft(); if (infos[3])g_AST->setPadding(); g_AST->setW( w); g_AST->setD( d); g_AST->setType( G);
726 break;
727 }
728 case CO:
729 {
730 o = LT(1);
731 o_AST = astFactory->create(o);
732 astFactory->addASTChild(currentAST, antlr::RefAST(o_AST));
733 match(CO);
734 if (infos[1])o_AST->setShowSign(); if (infos[2])o_AST->setALignLeft(); if (infos[3])o_AST->setPadding(); o_AST->setW( w); o_AST->setD( d); o_AST->setType( O);
735 break;
736 }
737 case CB:
738 {
739 b = LT(1);
740 b_AST = astFactory->create(b);
741 astFactory->addASTChild(currentAST, antlr::RefAST(b_AST));
742 match(CB);
743 if (infos[1])b_AST->setShowSign(); if (infos[2])b_AST->setALignLeft(); if (infos[3])b_AST->setPadding(); b_AST->setW( w); b_AST->setD( d); b_AST->setType( B);
744 break;
745 }
746 case CX:
747 {
748 x = LT(1);
749 x_AST = astFactory->create(x);
750 astFactory->addASTChild(currentAST, antlr::RefAST(x_AST));
751 match(CX);
752 if (infos[1])x_AST->setShowSign(); if (infos[2])x_AST->setALignLeft(); if (infos[3])x_AST->setPadding(); x_AST->setW( w); x_AST->setD( d); x_AST->setType( Z);
753 break;
754 }
755 case CZ:
756 {
757 z = LT(1);
758 z_AST = astFactory->create(z);
759 astFactory->addASTChild(currentAST, antlr::RefAST(z_AST));
760 match(CZ);
761 if (infos[1])z_AST->setShowSign(); if (infos[2])z_AST->setALignLeft(); if (infos[3])z_AST->setPadding(); z_AST->setW( w); z_AST->setD( d); z_AST->setType( Z);
762 break;
763 }
764 case CS:
765 {
766 s = LT(1);
767 s_AST = astFactory->create(s);
768 astFactory->addASTChild(currentAST, antlr::RefAST(s_AST));
769 match(CS);
770 if (infos[1])s_AST->setShowSign(); if (infos[2])s_AST->setALignLeft(); if (infos[3])s_AST->setPadding(); s_AST->setW( w); s_AST->setType( A);
771 break;
772 }
773 default:
774 {
775 throw antlr::NoViableAltException(LT(1), getFilename());
776 }
777 }
778 }
779 cformat_AST = RefFMTNode(currentAST.root);
780 returnAST = cformat_AST;
781 }
782
cnnf(int * infos)783 void FMTParser::cnnf(
784 int *infos
785 ) {
786 returnAST = RefFMTNode(antlr::nullAST);
787 antlr::ASTPair currentAST;
788 RefFMTNode cnnf_AST = RefFMTNode(antlr::nullAST);
789 antlr::RefToken num = antlr::nullToken;
790 RefFMTNode num_AST = RefFMTNode(antlr::nullAST);
791
792 num = LT(1);
793 num_AST = astFactory->create(num);
794 match(CNUMBER);
795
796 char c;
797 std::istringstream s(num_AST->getText());
798 c=s.get();
799 s.putback(c);
800 s >> infos[0];
801 if (c == '0') infos[3]=-1;;
802
803 returnAST = cnnf_AST;
804 }
805
cnn()806 int FMTParser::cnn() {
807 int n;
808 returnAST = RefFMTNode(antlr::nullAST);
809 antlr::ASTPair currentAST;
810 RefFMTNode cnn_AST = RefFMTNode(antlr::nullAST);
811 antlr::RefToken num = antlr::nullToken;
812 RefFMTNode num_AST = RefFMTNode(antlr::nullAST);
813
814 num = LT(1);
815 num_AST = astFactory->create(num);
816 match(CNUMBER);
817
818 std::istringstream s(num_AST->getText());
819 s >> n;
820
821 returnAST = cnn_AST;
822 return n;
823 }
824
rep_fmt(int repeat)825 void FMTParser::rep_fmt(
826 int repeat
827 ) {
828 returnAST = RefFMTNode(antlr::nullAST);
829 antlr::ASTPair currentAST;
830 RefFMTNode rep_fmt_AST = RefFMTNode(antlr::nullAST);
831 antlr::RefToken a = antlr::nullToken;
832 RefFMTNode a_AST = RefFMTNode(antlr::nullAST);
833 antlr::RefToken ff = antlr::nullToken;
834 RefFMTNode ff_AST = RefFMTNode(antlr::nullAST);
835 antlr::RefToken d = antlr::nullToken;
836 RefFMTNode d_AST = RefFMTNode(antlr::nullAST);
837 antlr::RefToken e = antlr::nullToken;
838 RefFMTNode e_AST = RefFMTNode(antlr::nullAST);
839 antlr::RefToken se = antlr::nullToken;
840 RefFMTNode se_AST = RefFMTNode(antlr::nullAST);
841 antlr::RefToken g = antlr::nullToken;
842 RefFMTNode g_AST = RefFMTNode(antlr::nullAST);
843 antlr::RefToken sg = antlr::nullToken;
844 RefFMTNode sg_AST = RefFMTNode(antlr::nullAST);
845 antlr::RefToken i = antlr::nullToken;
846 RefFMTNode i_AST = RefFMTNode(antlr::nullAST);
847 antlr::RefToken o = antlr::nullToken;
848 RefFMTNode o_AST = RefFMTNode(antlr::nullAST);
849 antlr::RefToken b = antlr::nullToken;
850 RefFMTNode b_AST = RefFMTNode(antlr::nullAST);
851 antlr::RefToken z = antlr::nullToken;
852 RefFMTNode z_AST = RefFMTNode(antlr::nullAST);
853 antlr::RefToken zz = antlr::nullToken;
854 RefFMTNode zz_AST = RefFMTNode(antlr::nullAST);
855 antlr::RefToken c = antlr::nullToken;
856 RefFMTNode c_AST = RefFMTNode(antlr::nullAST);
857
858 int n1;
859
860
861 switch ( LA(1)) {
862 case LBRACE:
863 {
864 format( repeat);
865 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
866 rep_fmt_AST = RefFMTNode(currentAST.root);
867 break;
868 }
869 case A:
870 {
871 a = LT(1);
872 a_AST = astFactory->create(a);
873 astFactory->addASTChild(currentAST, antlr::RefAST(a_AST));
874 match(A);
875 {
876 if ((_tokenSet_0.member(LA(1)))) {
877 n1=nnf(a_AST);
878 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
879 a_AST->setW( n1);
880 }
881 else if (((LA(1) >= COMMA && LA(1) <= SLASH))) {
882 }
883 else {
884 throw antlr::NoViableAltException(LT(1), getFilename());
885 }
886
887 }
888 a_AST->setRep( repeat);
889 rep_fmt_AST = RefFMTNode(currentAST.root);
890 break;
891 }
892 case F:
893 {
894 ff = LT(1);
895 ff_AST = astFactory->create(ff);
896 astFactory->addASTChild(currentAST, antlr::RefAST(ff_AST));
897 match(F);
898 w_d( ff_AST);
899 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
900 ff_AST->setRep( repeat);
901 rep_fmt_AST = RefFMTNode(currentAST.root);
902 break;
903 }
904 case D:
905 {
906 d = LT(1);
907 d_AST = astFactory->create(d);
908 astFactory->addASTChild(currentAST, antlr::RefAST(d_AST));
909 match(D);
910 w_d( d_AST);
911 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
912 d_AST->setRep( repeat); d_AST->setText("f"); d_AST->setType(F);
913 rep_fmt_AST = RefFMTNode(currentAST.root);
914 break;
915 }
916 case E:
917 {
918 e = LT(1);
919 e_AST = astFactory->create(e);
920 astFactory->addASTChild(currentAST, antlr::RefAST(e_AST));
921 match(E);
922 w_d_e( e_AST);
923 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
924 e_AST->setRep( repeat);
925 rep_fmt_AST = RefFMTNode(currentAST.root);
926 break;
927 }
928 case SE:
929 {
930 se = LT(1);
931 se_AST = astFactory->create(se);
932 astFactory->addASTChild(currentAST, antlr::RefAST(se_AST));
933 match(SE);
934 w_d_e( se_AST);
935 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
936 se_AST->setRep( repeat);
937 rep_fmt_AST = RefFMTNode(currentAST.root);
938 break;
939 }
940 case G:
941 {
942 g = LT(1);
943 g_AST = astFactory->create(g);
944 astFactory->addASTChild(currentAST, antlr::RefAST(g_AST));
945 match(G);
946 w_d_e( g_AST);
947 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
948 g_AST->setRep( repeat);
949 rep_fmt_AST = RefFMTNode(currentAST.root);
950 break;
951 }
952 case SG:
953 {
954 sg = LT(1);
955 sg_AST = astFactory->create(sg);
956 astFactory->addASTChild(currentAST, antlr::RefAST(sg_AST));
957 match(SG);
958 w_d_e( sg_AST);
959 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
960 sg_AST->setRep( repeat);
961 rep_fmt_AST = RefFMTNode(currentAST.root);
962 break;
963 }
964 case I:
965 {
966 i = LT(1);
967 i_AST = astFactory->create(i);
968 astFactory->addASTChild(currentAST, antlr::RefAST(i_AST));
969 match(I);
970 w_d( i_AST);
971 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
972 i_AST->setRep( repeat);
973 rep_fmt_AST = RefFMTNode(currentAST.root);
974 break;
975 }
976 case O:
977 {
978 o = LT(1);
979 o_AST = astFactory->create(o);
980 astFactory->addASTChild(currentAST, antlr::RefAST(o_AST));
981 match(O);
982 w_d( o_AST);
983 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
984 o_AST->setRep( repeat);
985 rep_fmt_AST = RefFMTNode(currentAST.root);
986 break;
987 }
988 case B:
989 {
990 b = LT(1);
991 b_AST = astFactory->create(b);
992 astFactory->addASTChild(currentAST, antlr::RefAST(b_AST));
993 match(B);
994 w_d( b_AST);
995 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
996 b_AST->setRep( repeat);
997 rep_fmt_AST = RefFMTNode(currentAST.root);
998 break;
999 }
1000 case Z:
1001 {
1002 z = LT(1);
1003 z_AST = astFactory->create(z);
1004 astFactory->addASTChild(currentAST, antlr::RefAST(z_AST));
1005 match(Z);
1006 w_d( z_AST);
1007 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1008 z_AST->setRep( repeat);
1009 rep_fmt_AST = RefFMTNode(currentAST.root);
1010 break;
1011 }
1012 case ZZ:
1013 {
1014 zz = LT(1);
1015 zz_AST = astFactory->create(zz);
1016 astFactory->addASTChild(currentAST, antlr::RefAST(zz_AST));
1017 match(ZZ);
1018 w_d( zz_AST);
1019 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1020 zz_AST->setRep( repeat);
1021 rep_fmt_AST = RefFMTNode(currentAST.root);
1022 break;
1023 }
1024 case C:
1025 {
1026 c = LT(1);
1027 c_AST = astFactory->create(c);
1028 astFactory->makeASTRoot(currentAST, antlr::RefAST(c_AST));
1029 match(C);
1030 match(LBRACE);
1031 calendar_string();
1032 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1033 match(RBRACE);
1034 c_AST->setRep( repeat);
1035 rep_fmt_AST = RefFMTNode(currentAST.root);
1036 break;
1037 }
1038 default:
1039 {
1040 throw antlr::NoViableAltException(LT(1), getFilename());
1041 }
1042 }
1043 returnAST = rep_fmt_AST;
1044 }
1045
nnf(RefFMTNode fNode)1046 int FMTParser::nnf(
1047 RefFMTNode fNode
1048 ) {
1049 int n=-1;
1050 returnAST = RefFMTNode(antlr::nullAST);
1051 antlr::ASTPair currentAST;
1052 RefFMTNode nnf_AST = RefFMTNode(antlr::nullAST);
1053 antlr::RefToken num = antlr::nullToken;
1054 RefFMTNode num_AST = RefFMTNode(antlr::nullAST);
1055
1056 {
1057 switch ( LA(1)) {
1058 case PM:
1059 case MP:
1060 case PLUS:
1061 case MOINS:
1062 {
1063 {
1064 switch ( LA(1)) {
1065 case PM:
1066 case MP:
1067 {
1068 {
1069 switch ( LA(1)) {
1070 case PM:
1071 {
1072 RefFMTNode tmp16_AST = RefFMTNode(antlr::nullAST);
1073 tmp16_AST = astFactory->create(LT(1));
1074 match(PM);
1075 break;
1076 }
1077 case MP:
1078 {
1079 RefFMTNode tmp17_AST = RefFMTNode(antlr::nullAST);
1080 tmp17_AST = astFactory->create(LT(1));
1081 match(MP);
1082 break;
1083 }
1084 default:
1085 {
1086 throw antlr::NoViableAltException(LT(1), getFilename());
1087 }
1088 }
1089 }
1090
1091 fNode->setShowSign();
1092 fNode->setALignLeft();
1093
1094 break;
1095 }
1096 case PLUS:
1097 {
1098 RefFMTNode tmp18_AST = RefFMTNode(antlr::nullAST);
1099 tmp18_AST = astFactory->create(LT(1));
1100 match(PLUS);
1101 fNode->setShowSign();
1102 break;
1103 }
1104 case MOINS:
1105 {
1106 RefFMTNode tmp19_AST = RefFMTNode(antlr::nullAST);
1107 tmp19_AST = astFactory->create(LT(1));
1108 match(MOINS);
1109 fNode->setALignLeft();
1110 break;
1111 }
1112 default:
1113 {
1114 throw antlr::NoViableAltException(LT(1), getFilename());
1115 }
1116 }
1117 }
1118 break;
1119 }
1120 case COMMA:
1121 case RBRACE:
1122 case SLASH:
1123 case E:
1124 case SE:
1125 case NUMBER:
1126 case DOT:
1127 {
1128 break;
1129 }
1130 default:
1131 {
1132 throw antlr::NoViableAltException(LT(1), getFilename());
1133 }
1134 }
1135 }
1136 {
1137 switch ( LA(1)) {
1138 case NUMBER:
1139 {
1140 num = LT(1);
1141 num_AST = astFactory->create(num);
1142 match(NUMBER);
1143
1144 std::istringstream s(num_AST->getText());
1145 char c = s.get();
1146 char next = s.peek();
1147 s.putback(c);
1148 s >> n;
1149 if (c == '0') fNode->setPadding();
1150
1151 break;
1152 }
1153 case COMMA:
1154 case RBRACE:
1155 case SLASH:
1156 case E:
1157 case SE:
1158 case DOT:
1159 {
1160 break;
1161 }
1162 default:
1163 {
1164 throw antlr::NoViableAltException(LT(1), getFilename());
1165 }
1166 }
1167 }
1168 returnAST = nnf_AST;
1169 return n;
1170 }
1171
w_d(RefFMTNode fNode)1172 void FMTParser::w_d(
1173 RefFMTNode fNode
1174 ) {
1175 returnAST = RefFMTNode(antlr::nullAST);
1176 antlr::ASTPair currentAST;
1177 RefFMTNode w_d_AST = RefFMTNode(antlr::nullAST);
1178
1179 int n1=-1, n2=-1;
1180 fNode->setW( -1);
1181 fNode->setD( -1);
1182
1183
1184 {
1185 if ((_tokenSet_1.member(LA(1)))) {
1186 n1=nnf( fNode);
1187 fNode->setW( n1);
1188 {
1189 switch ( LA(1)) {
1190 case DOT:
1191 {
1192 RefFMTNode tmp20_AST = RefFMTNode(antlr::nullAST);
1193 tmp20_AST = astFactory->create(LT(1));
1194 match(DOT);
1195 n2=nn();
1196 fNode->setD( n2);
1197 break;
1198 }
1199 case COMMA:
1200 case RBRACE:
1201 case SLASH:
1202 case E:
1203 case SE:
1204 {
1205 break;
1206 }
1207 default:
1208 {
1209 throw antlr::NoViableAltException(LT(1), getFilename());
1210 }
1211 }
1212 }
1213 }
1214 else if ((_tokenSet_2.member(LA(1)))) {
1215 }
1216 else {
1217 throw antlr::NoViableAltException(LT(1), getFilename());
1218 }
1219
1220 }
1221 returnAST = w_d_AST;
1222 }
1223
w_d_e(RefFMTNode fNode)1224 void FMTParser::w_d_e(
1225 RefFMTNode fNode
1226 ) {
1227 returnAST = RefFMTNode(antlr::nullAST);
1228 antlr::ASTPair currentAST;
1229 RefFMTNode w_d_e_AST = RefFMTNode(antlr::nullAST);
1230 antlr::RefToken ignored = antlr::nullToken;
1231 RefFMTNode ignored_AST = RefFMTNode(antlr::nullAST);
1232
1233 {
1234 if ((_tokenSet_1.member(LA(1)))) {
1235 w_d( fNode);
1236 {
1237 switch ( LA(1)) {
1238 case E:
1239 case SE:
1240 {
1241 {
1242 switch ( LA(1)) {
1243 case E:
1244 {
1245 RefFMTNode tmp21_AST = RefFMTNode(antlr::nullAST);
1246 tmp21_AST = astFactory->create(LT(1));
1247 match(E);
1248 break;
1249 }
1250 case SE:
1251 {
1252 RefFMTNode tmp22_AST = RefFMTNode(antlr::nullAST);
1253 tmp22_AST = astFactory->create(LT(1));
1254 match(SE);
1255 break;
1256 }
1257 default:
1258 {
1259 throw antlr::NoViableAltException(LT(1), getFilename());
1260 }
1261 }
1262 }
1263 ignored = LT(1);
1264 ignored_AST = astFactory->create(ignored);
1265 match(NUMBER);
1266
1267 int n=0;
1268 std::istringstream s(ignored_AST->getText());
1269 s >> n;
1270 //does not work (loops probably at format_reversion) if (n < 0 || n > 255) throw GDLException("Value is out of allowed range (0 - 255).");
1271
1272 break;
1273 }
1274 case COMMA:
1275 case RBRACE:
1276 case SLASH:
1277 {
1278 break;
1279 }
1280 default:
1281 {
1282 throw antlr::NoViableAltException(LT(1), getFilename());
1283 }
1284 }
1285 }
1286 }
1287 else if (((LA(1) >= COMMA && LA(1) <= SLASH))) {
1288 }
1289 else {
1290 throw antlr::NoViableAltException(LT(1), getFilename());
1291 }
1292
1293 }
1294 returnAST = w_d_e_AST;
1295 }
1296
calendar_string()1297 void FMTParser::calendar_string() {
1298 returnAST = RefFMTNode(antlr::nullAST);
1299 antlr::ASTPair currentAST;
1300 RefFMTNode calendar_string_AST = RefFMTNode(antlr::nullAST);
1301
1302 {
1303 switch ( LA(1)) {
1304 case CSTR:
1305 case CD:
1306 case CSE:
1307 case CE:
1308 case CI:
1309 case CF:
1310 case CSG:
1311 case CG:
1312 case CO:
1313 case CB:
1314 case CS:
1315 case CX:
1316 case CZ:
1317 case PM:
1318 case MP:
1319 case PLUS:
1320 case MOINS:
1321 case CNUMBER:
1322 case STRING:
1323 case TL:
1324 case TR:
1325 case X:
1326 case CMOA:
1327 case CMoA:
1328 case CmoA:
1329 case CHI:
1330 case ChI:
1331 case CDWA:
1332 case CDwA:
1333 case CdwA:
1334 case CAPA:
1335 case CApA:
1336 case CapA:
1337 case CMOI:
1338 case CDI:
1339 case CYI:
1340 case CMI:
1341 case CSI:
1342 case CSF:
1343 case NUMBER:
1344 {
1345 {
1346 calendar_code();
1347 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1348 { // ( ... )*
1349 for (;;) {
1350 if ((LA(1) == COMMA)) {
1351 match(COMMA);
1352 calendar_code();
1353 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1354 }
1355 else {
1356 goto _loop31;
1357 }
1358
1359 }
1360 _loop31:;
1361 } // ( ... )*
1362 }
1363 break;
1364 }
1365 case RBRACE:
1366 {
1367 break;
1368 }
1369 default:
1370 {
1371 throw antlr::NoViableAltException(LT(1), getFilename());
1372 }
1373 }
1374 }
1375 calendar_string_AST = RefFMTNode(currentAST.root);
1376 returnAST = calendar_string_AST;
1377 }
1378
calendar_code()1379 void FMTParser::calendar_code() {
1380 returnAST = RefFMTNode(antlr::nullAST);
1381 antlr::ASTPair currentAST;
1382 RefFMTNode calendar_code_AST = RefFMTNode(antlr::nullAST);
1383 antlr::RefToken c1 = antlr::nullToken;
1384 RefFMTNode c1_AST = RefFMTNode(antlr::nullAST);
1385 antlr::RefToken c2 = antlr::nullToken;
1386 RefFMTNode c2_AST = RefFMTNode(antlr::nullAST);
1387 antlr::RefToken c3 = antlr::nullToken;
1388 RefFMTNode c3_AST = RefFMTNode(antlr::nullAST);
1389 antlr::RefToken c4 = antlr::nullToken;
1390 RefFMTNode c4_AST = RefFMTNode(antlr::nullAST);
1391 antlr::RefToken c5 = antlr::nullToken;
1392 RefFMTNode c5_AST = RefFMTNode(antlr::nullAST);
1393 antlr::RefToken c6 = antlr::nullToken;
1394 RefFMTNode c6_AST = RefFMTNode(antlr::nullAST);
1395 antlr::RefToken c7 = antlr::nullToken;
1396 RefFMTNode c7_AST = RefFMTNode(antlr::nullAST);
1397 antlr::RefToken c8 = antlr::nullToken;
1398 RefFMTNode c8_AST = RefFMTNode(antlr::nullAST);
1399 antlr::RefToken c9 = antlr::nullToken;
1400 RefFMTNode c9_AST = RefFMTNode(antlr::nullAST);
1401 antlr::RefToken c10 = antlr::nullToken;
1402 RefFMTNode c10_AST = RefFMTNode(antlr::nullAST);
1403 antlr::RefToken c11 = antlr::nullToken;
1404 RefFMTNode c11_AST = RefFMTNode(antlr::nullAST);
1405 antlr::RefToken c12 = antlr::nullToken;
1406 RefFMTNode c12_AST = RefFMTNode(antlr::nullAST);
1407 antlr::RefToken c13 = antlr::nullToken;
1408 RefFMTNode c13_AST = RefFMTNode(antlr::nullAST);
1409 antlr::RefToken c14 = antlr::nullToken;
1410 RefFMTNode c14_AST = RefFMTNode(antlr::nullAST);
1411 antlr::RefToken c15 = antlr::nullToken;
1412 RefFMTNode c15_AST = RefFMTNode(antlr::nullAST);
1413 antlr::RefToken c16 = antlr::nullToken;
1414 RefFMTNode c16_AST = RefFMTNode(antlr::nullAST);
1415 antlr::RefToken c17 = antlr::nullToken;
1416 RefFMTNode c17_AST = RefFMTNode(antlr::nullAST);
1417 antlr::RefToken x = antlr::nullToken;
1418 RefFMTNode x_AST = RefFMTNode(antlr::nullAST);
1419
1420 int n1;
1421
1422
1423 switch ( LA(1)) {
1424 case CMOA:
1425 {
1426 c1 = LT(1);
1427 c1_AST = astFactory->create(c1);
1428 astFactory->addASTChild(currentAST, antlr::RefAST(c1_AST));
1429 match(CMOA);
1430 {
1431 switch ( LA(1)) {
1432 case NUMBER:
1433 {
1434 n1=nn();
1435 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1436 c1_AST->setW( n1);
1437 break;
1438 }
1439 case COMMA:
1440 case RBRACE:
1441 {
1442 break;
1443 }
1444 default:
1445 {
1446 throw antlr::NoViableAltException(LT(1), getFilename());
1447 }
1448 }
1449 }
1450 calendar_code_AST = RefFMTNode(currentAST.root);
1451 break;
1452 }
1453 case CMoA:
1454 {
1455 c2 = LT(1);
1456 c2_AST = astFactory->create(c2);
1457 astFactory->addASTChild(currentAST, antlr::RefAST(c2_AST));
1458 match(CMoA);
1459 {
1460 switch ( LA(1)) {
1461 case NUMBER:
1462 {
1463 n1=nn();
1464 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1465 c2_AST->setW( n1);
1466 break;
1467 }
1468 case COMMA:
1469 case RBRACE:
1470 {
1471 break;
1472 }
1473 default:
1474 {
1475 throw antlr::NoViableAltException(LT(1), getFilename());
1476 }
1477 }
1478 }
1479 calendar_code_AST = RefFMTNode(currentAST.root);
1480 break;
1481 }
1482 case CmoA:
1483 {
1484 c3 = LT(1);
1485 c3_AST = astFactory->create(c3);
1486 astFactory->addASTChild(currentAST, antlr::RefAST(c3_AST));
1487 match(CmoA);
1488 {
1489 switch ( LA(1)) {
1490 case NUMBER:
1491 {
1492 n1=nn();
1493 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1494 c3_AST->setW( n1);
1495 break;
1496 }
1497 case COMMA:
1498 case RBRACE:
1499 {
1500 break;
1501 }
1502 default:
1503 {
1504 throw antlr::NoViableAltException(LT(1), getFilename());
1505 }
1506 }
1507 }
1508 calendar_code_AST = RefFMTNode(currentAST.root);
1509 break;
1510 }
1511 case CHI:
1512 {
1513 c4 = LT(1);
1514 c4_AST = astFactory->create(c4);
1515 astFactory->addASTChild(currentAST, antlr::RefAST(c4_AST));
1516 match(CHI);
1517 w_d( c4_AST);
1518 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1519 calendar_code_AST = RefFMTNode(currentAST.root);
1520 break;
1521 }
1522 case ChI:
1523 {
1524 c5 = LT(1);
1525 c5_AST = astFactory->create(c5);
1526 astFactory->addASTChild(currentAST, antlr::RefAST(c5_AST));
1527 match(ChI);
1528 w_d( c5_AST);
1529 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1530 calendar_code_AST = RefFMTNode(currentAST.root);
1531 break;
1532 }
1533 case CDWA:
1534 {
1535 c6 = LT(1);
1536 c6_AST = astFactory->create(c6);
1537 astFactory->addASTChild(currentAST, antlr::RefAST(c6_AST));
1538 match(CDWA);
1539 {
1540 switch ( LA(1)) {
1541 case NUMBER:
1542 {
1543 n1=nn();
1544 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1545 c6_AST->setW( n1);
1546 break;
1547 }
1548 case COMMA:
1549 case RBRACE:
1550 {
1551 break;
1552 }
1553 default:
1554 {
1555 throw antlr::NoViableAltException(LT(1), getFilename());
1556 }
1557 }
1558 }
1559 calendar_code_AST = RefFMTNode(currentAST.root);
1560 break;
1561 }
1562 case CDwA:
1563 {
1564 c7 = LT(1);
1565 c7_AST = astFactory->create(c7);
1566 astFactory->addASTChild(currentAST, antlr::RefAST(c7_AST));
1567 match(CDwA);
1568 {
1569 switch ( LA(1)) {
1570 case NUMBER:
1571 {
1572 n1=nn();
1573 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1574 c7_AST->setW( n1);
1575 break;
1576 }
1577 case COMMA:
1578 case RBRACE:
1579 {
1580 break;
1581 }
1582 default:
1583 {
1584 throw antlr::NoViableAltException(LT(1), getFilename());
1585 }
1586 }
1587 }
1588 calendar_code_AST = RefFMTNode(currentAST.root);
1589 break;
1590 }
1591 case CdwA:
1592 {
1593 c8 = LT(1);
1594 c8_AST = astFactory->create(c8);
1595 astFactory->addASTChild(currentAST, antlr::RefAST(c8_AST));
1596 match(CdwA);
1597 {
1598 switch ( LA(1)) {
1599 case NUMBER:
1600 {
1601 n1=nn();
1602 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1603 c8_AST->setW( n1);
1604 break;
1605 }
1606 case COMMA:
1607 case RBRACE:
1608 {
1609 break;
1610 }
1611 default:
1612 {
1613 throw antlr::NoViableAltException(LT(1), getFilename());
1614 }
1615 }
1616 }
1617 calendar_code_AST = RefFMTNode(currentAST.root);
1618 break;
1619 }
1620 case CAPA:
1621 {
1622 c9 = LT(1);
1623 c9_AST = astFactory->create(c9);
1624 astFactory->addASTChild(currentAST, antlr::RefAST(c9_AST));
1625 match(CAPA);
1626 {
1627 switch ( LA(1)) {
1628 case NUMBER:
1629 {
1630 n1=nn();
1631 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1632 c9_AST->setW( n1);
1633 break;
1634 }
1635 case COMMA:
1636 case RBRACE:
1637 {
1638 break;
1639 }
1640 default:
1641 {
1642 throw antlr::NoViableAltException(LT(1), getFilename());
1643 }
1644 }
1645 }
1646 calendar_code_AST = RefFMTNode(currentAST.root);
1647 break;
1648 }
1649 case CApA:
1650 {
1651 c10 = LT(1);
1652 c10_AST = astFactory->create(c10);
1653 astFactory->addASTChild(currentAST, antlr::RefAST(c10_AST));
1654 match(CApA);
1655 {
1656 switch ( LA(1)) {
1657 case NUMBER:
1658 {
1659 n1=nn();
1660 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1661 c10_AST->setW( n1);
1662 break;
1663 }
1664 case COMMA:
1665 case RBRACE:
1666 {
1667 break;
1668 }
1669 default:
1670 {
1671 throw antlr::NoViableAltException(LT(1), getFilename());
1672 }
1673 }
1674 }
1675 calendar_code_AST = RefFMTNode(currentAST.root);
1676 break;
1677 }
1678 case CapA:
1679 {
1680 c11 = LT(1);
1681 c11_AST = astFactory->create(c11);
1682 astFactory->addASTChild(currentAST, antlr::RefAST(c11_AST));
1683 match(CapA);
1684 {
1685 switch ( LA(1)) {
1686 case NUMBER:
1687 {
1688 n1=nn();
1689 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1690 c11_AST->setW( n1);
1691 break;
1692 }
1693 case COMMA:
1694 case RBRACE:
1695 {
1696 break;
1697 }
1698 default:
1699 {
1700 throw antlr::NoViableAltException(LT(1), getFilename());
1701 }
1702 }
1703 }
1704 calendar_code_AST = RefFMTNode(currentAST.root);
1705 break;
1706 }
1707 case CMOI:
1708 {
1709 c12 = LT(1);
1710 c12_AST = astFactory->create(c12);
1711 astFactory->addASTChild(currentAST, antlr::RefAST(c12_AST));
1712 match(CMOI);
1713 w_d( c12_AST);
1714 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1715 calendar_code_AST = RefFMTNode(currentAST.root);
1716 break;
1717 }
1718 case CDI:
1719 {
1720 c13 = LT(1);
1721 c13_AST = astFactory->create(c13);
1722 astFactory->addASTChild(currentAST, antlr::RefAST(c13_AST));
1723 match(CDI);
1724 w_d( c13_AST);
1725 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1726 calendar_code_AST = RefFMTNode(currentAST.root);
1727 break;
1728 }
1729 case CYI:
1730 {
1731 c14 = LT(1);
1732 c14_AST = astFactory->create(c14);
1733 astFactory->addASTChild(currentAST, antlr::RefAST(c14_AST));
1734 match(CYI);
1735 w_d( c14_AST);
1736 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1737 calendar_code_AST = RefFMTNode(currentAST.root);
1738 break;
1739 }
1740 case CMI:
1741 {
1742 c15 = LT(1);
1743 c15_AST = astFactory->create(c15);
1744 astFactory->addASTChild(currentAST, antlr::RefAST(c15_AST));
1745 match(CMI);
1746 w_d( c15_AST);
1747 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1748 calendar_code_AST = RefFMTNode(currentAST.root);
1749 break;
1750 }
1751 case CSI:
1752 {
1753 c16 = LT(1);
1754 c16_AST = astFactory->create(c16);
1755 astFactory->addASTChild(currentAST, antlr::RefAST(c16_AST));
1756 match(CSI);
1757 w_d( c16_AST);
1758 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1759 calendar_code_AST = RefFMTNode(currentAST.root);
1760 break;
1761 }
1762 case CSF:
1763 {
1764 c17 = LT(1);
1765 c17_AST = astFactory->create(c17);
1766 astFactory->addASTChild(currentAST, antlr::RefAST(c17_AST));
1767 match(CSF);
1768 w_d( c17_AST);
1769 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1770 calendar_code_AST = RefFMTNode(currentAST.root);
1771 break;
1772 }
1773 case X:
1774 case NUMBER:
1775 {
1776 {
1777 switch ( LA(1)) {
1778 case NUMBER:
1779 {
1780 n1=nn();
1781 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1782 break;
1783 }
1784 case X:
1785 {
1786 break;
1787 }
1788 default:
1789 {
1790 throw antlr::NoViableAltException(LT(1), getFilename());
1791 }
1792 }
1793 }
1794 x = LT(1);
1795 x_AST = astFactory->create(x);
1796 astFactory->addASTChild(currentAST, antlr::RefAST(x_AST));
1797 match(X);
1798 x_AST->setW( n1);
1799 calendar_code_AST = RefFMTNode(currentAST.root);
1800 break;
1801 }
1802 case CSTR:
1803 case CD:
1804 case CSE:
1805 case CE:
1806 case CI:
1807 case CF:
1808 case CSG:
1809 case CG:
1810 case CO:
1811 case CB:
1812 case CS:
1813 case CX:
1814 case CZ:
1815 case PM:
1816 case MP:
1817 case PLUS:
1818 case MOINS:
1819 case CNUMBER:
1820 case STRING:
1821 case TL:
1822 case TR:
1823 {
1824 f_csubcode();
1825 astFactory->addASTChild(currentAST, antlr::RefAST(returnAST));
1826 calendar_code_AST = RefFMTNode(currentAST.root);
1827 break;
1828 }
1829 default:
1830 {
1831 throw antlr::NoViableAltException(LT(1), getFilename());
1832 }
1833 }
1834 returnAST = calendar_code_AST;
1835 }
1836
initializeASTFactory(antlr::ASTFactory & factory)1837 void FMTParser::initializeASTFactory( antlr::ASTFactory& factory )
1838 {
1839 factory.setMaxNodeType(85);
1840 }
1841 const char* FMTParser::tokenNames[] = {
1842 "<0>",
1843 "EOF",
1844 "<2>",
1845 "NULL_TREE_LOOKAHEAD",
1846 "CSTYLE",
1847 "CSTR",
1848 "CSTR1",
1849 "CSTR2",
1850 "ESC",
1851 "OCTESC",
1852 "ODIGIT",
1853 "HEXESC",
1854 "HDIGIT",
1855 "CD",
1856 "CSE",
1857 "CE",
1858 "CI",
1859 "CF",
1860 "CSG",
1861 "CG",
1862 "CO",
1863 "CB",
1864 "CS",
1865 "CX",
1866 "CZ",
1867 "CDOT",
1868 "PM",
1869 "MP",
1870 "PLUS",
1871 "MOINS",
1872 "DIGITS",
1873 "CNUMBER",
1874 "CWS",
1875 "FORMAT",
1876 "LBRACE",
1877 "COMMA",
1878 "RBRACE",
1879 "SLASH",
1880 "STRING",
1881 "\"tl\"",
1882 "\"tr\"",
1883 "TERM",
1884 "NONL",
1885 "Q",
1886 "T",
1887 "X",
1888 "A",
1889 "F",
1890 "D",
1891 "E",
1892 "SE",
1893 "G",
1894 "SG",
1895 "I",
1896 "O",
1897 "B",
1898 "Z",
1899 "ZZ",
1900 "C",
1901 "CMOA",
1902 "CMoA",
1903 "CmoA",
1904 "CHI",
1905 "ChI",
1906 "CDWA",
1907 "CDwA",
1908 "CdwA",
1909 "CAPA",
1910 "CApA",
1911 "CapA",
1912 "CMOI",
1913 "CDI",
1914 "CYI",
1915 "CMI",
1916 "CSI",
1917 "CSF",
1918 "NUMBER",
1919 "DOT",
1920 "CSTRING",
1921 "H",
1922 "L",
1923 "R",
1924 "PERCENT",
1925 "W",
1926 "WHITESPACE",
1927 "CHAR",
1928 0
1929 };
1930
1931 const unsigned long FMTParser::_tokenSet_0_data_[] = { 1006632960UL, 56UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1932 // PM MP PLUS MOINS COMMA RBRACE SLASH NUMBER
1933 const antlr::BitSet FMTParser::_tokenSet_0(_tokenSet_0_data_,8);
1934 const unsigned long FMTParser::_tokenSet_1_data_[] = { 1006632960UL, 393272UL, 12288UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1935 // PM MP PLUS MOINS COMMA RBRACE SLASH E SE NUMBER DOT
1936 const antlr::BitSet FMTParser::_tokenSet_1(_tokenSet_1_data_,8);
1937 const unsigned long FMTParser::_tokenSet_2_data_[] = { 0UL, 393272UL, 0UL, 0UL };
1938 // COMMA RBRACE SLASH E SE
1939 const antlr::BitSet FMTParser::_tokenSet_2(_tokenSet_2_data_,4);
1940
1941
1942