|
1
2
3 package org.sablecc.sablecc.syntax3.analysis;
4
5 import java.util.*;
6 import org.sablecc.sablecc.syntax3.node.*;
7
8 public class ReversedDepthFirstAdapter extends AnalysisAdapter
9 {
10 public void inStart(Start node)
11 {
12 defaultIn(node);
13 }
14
15 public void outStart(Start node)
16 {
17 defaultOut(node);
18 }
19
20 public void defaultIn(@SuppressWarnings  ("unused") Node node)
21 {
22 }
24
25 public void defaultOut(@SuppressWarnings ("unused") Node node)
26 {
27 }
29
30 @Override
31 public void caseStart(Start node)
32 {
33 inStart(node);
34 node.getEOF().apply(this);
35 node.getPSpecification().apply(this);
36 outStart(node);
37 }
38
39 public void inASpecification(ASpecification node)
40 {
41 defaultIn(node);
42 }
43
44 public void outASpecification(ASpecification node)
45 {
46 defaultOut(node);
47 }
48
49 @Override
50 public void caseASpecification(ASpecification node)
51 {
52 inASpecification(node);
53 if(node.getLexer() != null)
54 {
55 node.getLexer().apply(this);
56 }
57 if(node.getHeader() != null)
58 {
59 node.getHeader().apply(this);
60 }
61 outASpecification(node);
62 }
63
64 public void inAHeader(AHeader node)
65 {
66 defaultIn(node);
67 }
68
69 public void outAHeader(AHeader node)
70 {
71 defaultOut(node);
72 }
73
74 @Override
75 public void caseAHeader(AHeader node)
76 {
77 inAHeader(node);
78 if(node.getSyntax() != null)
79 {
80 node.getSyntax().apply(this);
81 }
82 if(node.getLanguage() != null)
83 {
84 node.getLanguage().apply(this);
85 }
86 outAHeader(node);
87 }
88
89 public void inALanguage(ALanguage node)
90 {
91 defaultIn(node);
92 }
93
94 public void outALanguage(ALanguage node)
95 {
96 defaultOut(node);
97 }
98
99 @Override
100 public void caseALanguage(ALanguage node)
101 {
102 inALanguage(node);
103 if(node.getName() != null)
104 {
105 node.getName().apply(this);
106 }
107 outALanguage(node);
108 }
109
110 public void inASyntax(ASyntax node)
111 {
112 defaultIn(node);
113 }
114
115 public void outASyntax(ASyntax node)
116 {
117 defaultOut(node);
118 }
119
120 @Override
121 public void caseASyntax(ASyntax node)
122 {
123 inASyntax(node);
124 if(node.getVersion() != null)
125 {
126 node.getVersion().apply(this);
127 }
128 outASyntax(node);
129 }
130
131 public void inANoStatesLexer(ANoStatesLexer node)
132 {
133 defaultIn(node);
134 }
135
136 public void outANoStatesLexer(ANoStatesLexer node)
137 {
138 defaultOut(node);
139 }
140
141 @Override
142 public void caseANoStatesLexer(ANoStatesLexer node)
143 {
144 inANoStatesLexer(node);
145 if(node.getLookahead() != null)
146 {
147 node.getLookahead().apply(this);
148 }
149 if(node.getIgnored() != null)
150 {
151 node.getIgnored().apply(this);
152 }
153 if(node.getPriorities() != null)
154 {
155 node.getPriorities().apply(this);
156 }
157 if(node.getInvestigators() != null)
158 {
159 node.getInvestigators().apply(this);
160 }
161 if(node.getTokens() != null)
162 {
163 node.getTokens().apply(this);
164 }
165 if(node.getHelpers() != null)
166 {
167 node.getHelpers().apply(this);
168 }
169 outANoStatesLexer(node);
170 }
171
172 public void inAStatesLexer(AStatesLexer node)
173 {
174 defaultIn(node);
175 }
176
177 public void outAStatesLexer(AStatesLexer node)
178 {
179 defaultOut(node);
180 }
181
182 @Override
183 public void caseAStatesLexer(AStatesLexer node)
184 {
185 inAStatesLexer(node);
186 if(node.getStates() != null)
187 {
188 node.getStates().apply(this);
189 }
190 if(node.getInvestigators() != null)
191 {
192 node.getInvestigators().apply(this);
193 }
194 if(node.getTokens() != null)
195 {
196 node.getTokens().apply(this);
197 }
198 if(node.getHelpers() != null)
199 {
200 node.getHelpers().apply(this);
201 }
202 outAStatesLexer(node);
203 }
204
205 public void inAHelpers(AHelpers node)
206 {
207 defaultIn(node);
208 }
209
210 public void outAHelpers(AHelpers node)
211 {
212 defaultOut(node);
213 }
214
215 @Override
216 public void caseAHelpers(AHelpers node)
217 {
218 inAHelpers(node);
219 {
220 List<PHelper> copy = new ArrayList<PHelper>(node.getHelpers());
221 Collections.reverse(copy);
222 for(PHelper e : copy)
223 {
224 e.apply(this);
225 }
226 }
227 outAHelpers(node);
228 }
229
230 public void inAHelper(AHelper node)
231 {
232 defaultIn(node);
233 }
234
235 public void outAHelper(AHelper node)
236 {
237 defaultOut(node);
238 }
239
240 @Override
241 public void caseAHelper(AHelper node)
242 {
243 inAHelper(node);
244 if(node.getRegularExpression() != null)
245 {
246 node.getRegularExpression().apply(this);
247 }
248 if(node.getName() != null)
249 {
250 node.getName().apply(this);
251 }
252 outAHelper(node);
253 }
254
255 public void inASimpleTokens(ASimpleTokens node)
256 {
257 defaultIn(node);
258 }
259
260 public void outASimpleTokens(ASimpleTokens node)
261 {
262 defaultOut(node);
263 }
264
265 @Override
266 public void caseASimpleTokens(ASimpleTokens node)
267 {
268 inASimpleTokens(node);
269 {
270 List<PToken> copy = new ArrayList<PToken>(node.getTokens());
271 Collections.reverse(copy);
272 for(PToken e : copy)
273 {
274 e.apply(this);
275 }
276 }
277 outASimpleTokens(node);
278 }
279
280 public void inAGroupsTokens(AGroupsTokens node)
281 {
282 defaultIn(node);
283 }
284
285 public void outAGroupsTokens(AGroupsTokens node)
286 {
287 defaultOut(node);
288 }
289
290 @Override
291 public void caseAGroupsTokens(AGroupsTokens node)
292 {
293 inAGroupsTokens(node);
294 {
295 List<PGroup> copy = new ArrayList<PGroup>(node.getGroups());
296 Collections.reverse(copy);
297 for(PGroup e : copy)
298 {
299 e.apply(this);
300 }
301 }
302 outAGroupsTokens(node);
303 }
304
305 public void inAGroup(AGroup node)
306 {
307 defaultIn(node);
308 }
309
310 public void outAGroup(AGroup node)
311 {
312 defaultOut(node);
313 }
314
315 @Override
316 public void caseAGroup(AGroup node)
317 {
318 inAGroup(node);
319 {
320 List<PToken> copy = new ArrayList<PToken>(node.getTokens());
321 Collections.reverse(copy);
322 for(PToken e : copy)
323 {
324 e.apply(this);
325 }
326 }
327 if(node.getName() != null)
328 {
329 node.getName().apply(this);
330 }
331 outAGroup(node);
332 }
333
334 public void inASimpleToken(ASimpleToken node)
335 {
336 defaultIn(node);
337 }
338
339 public void outASimpleToken(ASimpleToken node)
340 {
341 defaultOut(node);
342 }
343
344 @Override
345 public void caseASimpleToken(ASimpleToken node)
346 {
347 inASimpleToken(node);
348 if(node.getThreeDots() != null)
349 {
350 node.getThreeDots().apply(this);
351 }
352 if(node.getRegularExpression() != null)
353 {
354 node.getRegularExpression().apply(this);
355 }
356 if(node.getName() != null)
357 {
358 node.getName().apply(this);
359 }
360 outASimpleToken(node);
361 }
362
363 public void inASelectionToken(ASelectionToken node)
364 {
365 defaultIn(node);
366 }
367
368 public void outASelectionToken(ASelectionToken node)
369 {
370 defaultOut(node);
371 }
372
373 @Override
374 public void caseASelectionToken(ASelectionToken node)
375 {
376 inASelectionToken(node);
377 if(node.getThreeDots() != null)
378 {
379 node.getThreeDots().apply(this);
380 }
381 if(node.getRegularExpression() != null)
382 {
383 node.getRegularExpression().apply(this);
384 }
385 if(node.getSelector() != null)
386 {
387 node.getSelector().apply(this);
388 }
389 if(node.getSelection() != null)
390 {
391 node.getSelection().apply(this);
392 }
393 outASelectionToken(node);
394 }
395
396 public void inASelection(ASelection node)
397 {
398 defaultIn(node);
399 }
400
401 public void outASelection(ASelection node)
402 {
403 defaultOut(node);
404 }
405
406 @Override
407 public void caseASelection(ASelection node)
408 {
409 inASelection(node);
410 {
411 List<TIdentifier> copy = new ArrayList<TIdentifier>(node.getNames());
412 Collections.reverse(copy);
413 for(TIdentifier e : copy)
414 {
415 e.apply(this);
416 }
417 }
418 outASelection(node);
419 }
420
421 public void inASelector(ASelector node)
422 {
423 defaultIn(node);
424 }
425
426 public void outASelector(ASelector node)
427 {
428 defaultOut(node);
429 }
430
431 @Override
432 public void caseASelector(ASelector node)
433 {
434 inASelector(node);
435 if(node.getName() != null)
436 {
437 node.getName().apply(this);
438 }
439 outASelector(node);
440 }
441
442 public void inAPriorities(APriorities node)
443 {
444 defaultIn(node);
445 }
446
447 public void outAPriorities(APriorities node)
448 {
449 defaultOut(node);
450 }
451
452 @Override
453 public void caseAPriorities(APriorities node)
454 {
455 inAPriorities(node);
456 {
457 List<PPriority> copy = new ArrayList<PPriority>(node.getPriorities());
458 Collections.reverse(copy);
459 for(PPriority e : copy)
460 {
461 e.apply(this);
462 }
463 }
464 outAPriorities(node);
465 }
466
467 public void inAPriority(APriority node)
468 {
469 defaultIn(node);
470 }
471
472 public void outAPriority(APriority node)
473 {
474 defaultOut(node);
475 }
476
477 @Override
478 public void caseAPriority(APriority node)
479 {
480 inAPriority(node);
481 if(node.getLowPriorityTokens() != null)
482 {
483 node.getLowPriorityTokens().apply(this);
484 }
485 if(node.getHighPriorityTokens() != null)
486 {
487 node.getHighPriorityTokens().apply(this);
488 }
489 outAPriority(node);
490 }
491
492 public void inAInvestigators(AInvestigators node)
493 {
494 defaultIn(node);
495 }
496
497 public void outAInvestigators(AInvestigators node)
498 {
499 defaultOut(node);
500 }
501
502 @Override
503 public void caseAInvestigators(AInvestigators node)
504 {
505 inAInvestigators(node);
506 {
507 List<PInvestigator> copy = new ArrayList<PInvestigator>(node.getInvestigators());
508 Collections.reverse(copy);
509 for(PInvestigator e : copy)
510 {
511 e.apply(this);
512 }
513 }
514 outAInvestigators(node);
515 }
516
517 public void inAInvestigator(AInvestigator node)
518 {
519 defaultIn(node);
520 }
521
522 public void outAInvestigator(AInvestigator node)
523 {
524 defaultOut(node);
525 }
526
527 @Override
528 public void caseAInvestigator(AInvestigator node)
529 {
530 inAInvestigator(node);
531 if(node.getName() != null)
532 {
533 node.getName().apply(this);
534 }
535 if(node.getTokenCollection() != null)
536 {
537 node.getTokenCollection().apply(this);
538 }
539 outAInvestigator(node);
540 }
541
542 public void inAStates(AStates node)
543 {
544 defaultIn(node);
545 }
546
547 public void outAStates(AStates node)
548 {
549 defaultOut(node);
550 }
551
552 @Override
553 public void caseAStates(AStates node)
554 {
555 inAStates(node);
556 if(node.getInternalStates() != null)
557 {
558 node.getInternalStates().apply(this);
559 }
560 {
561 List<PNormalState> copy = new ArrayList<PNormalState>(node.getNormalStates());
562 Collections.reverse(copy);
563 for(PNormalState e : copy)
564 {
565 e.apply(this);
566 }
567 }
568 outAStates(node);
569 }
570
571 public void inANormalState(ANormalState node)
572 {
573 defaultIn(node);
574 }
575
576 public void outANormalState(ANormalState node)
577 {
578 defaultOut(node);
579 }
580
581 @Override
582 public void caseANormalState(ANormalState node)
583 {
584 inANormalState(node);
585 if(node.getLookahead() != null)
586 {
587 node.getLookahead().apply(this);
588 }
589 if(node.getIgnored() != null)
590 {
591 node.getIgnored().apply(this);
592 }
593 if(node.getPriorities() != null)
594 {
595 node.getPriorities().apply(this);
596 }
597 if(node.getTokenCollection() != null)
598 {
599 node.getTokenCollection().apply(this);
600 }
601 if(node.getName() != null)
602 {
603 node.getName().apply(this);
604 }
605 outANormalState(node);
606 }
607
608 public void inANoneLookahead(ANoneLookahead node)
609 {
610 defaultIn(node);
611 }
612
613 public void outANoneLookahead(ANoneLookahead node)
614 {
615 defaultOut(node);
616 }
617
618 @Override
619 public void caseANoneLookahead(ANoneLookahead node)
620 {
621 inANoneLookahead(node);
622 outANoneLookahead(node);
623 }
624
625 public void inAInfiniteLookahead(AInfiniteLookahead node)
626 {
627 defaultIn(node);
628 }
629
630 public void outAInfiniteLookahead(AInfiniteLookahead node)
631 {
632 defaultOut(node);
633 }
634
635 @Override
636 public void caseAInfiniteLookahead(AInfiniteLookahead node)
637 {
638 inAInfiniteLookahead(node);
639 outAInfiniteLookahead(node);
640 }
641
642 public void inAIgnored(AIgnored node)
643 {
644 defaultIn(node);
645 }
646
647 public void outAIgnored(AIgnored node)
648 {
649 defaultOut(node);
650 }
651
652 @Override
653 public void caseAIgnored(AIgnored node)
654 {
655 inAIgnored(node);
656 if(node.getTokenCollection() != null)
657 {
658 node.getTokenCollection().apply(this);
659 }
660 outAIgnored(node);
661 }
662
663 public void inAInternalStates(AInternalStates node)
664 {
665 defaultIn(node);
666 }
667
668 public void outAInternalStates(AInternalStates node)
669 {
670 defaultOut(node);
671 }
672
673 @Override
674 public void caseAInternalStates(AInternalStates node)
675 {
676 inAInternalStates(node);
677 if(node.getTransitions() != null)
678 {
679 node.getTransitions().apply(this);
680 }
681 {
682 List<PInternalState> copy = new ArrayList<PInternalState>(node.getInternalStates());
683 Collections.reverse(copy);
684 for(PInternalState e : copy)
685 {
686 e.apply(this);
687 }
688 }
689 outAInternalStates(node);
690 }
691
692 public void inAInternalState(AInternalState node)
693 {
694 defaultIn(node);
695 }
696
697 public void outAInternalState(AInternalState node)
698 {
699 defaultOut(node);
700 }
701
702 @Override
703 public void caseAInternalState(AInternalState node)
704 {
705 inAInternalState(node);
706 if(node.getLookahead() != null)
707 {
708 node.getLookahead().apply(this);
709 }
710 if(node.getPriorities() != null)
711 {
712 node.getPriorities().apply(this);
713 }
714 if(node.getTokenCollection() != null)
715 {
716 node.getTokenCollection().apply(this);
717 }
718 if(node.getName() != null)
719 {
720 node.getName().apply(this);
721 }
722 outAInternalState(node);
723 }
724
725 public void inATransitions(ATransitions node)
726 {
727 defaultIn(node);
728 }
729
730 public void outATransitions(ATransitions node)
731 {
732 defaultOut(node);
733 }
734
735 @Override
736 public void caseATransitions(ATransitions node)
737 {
738 inATransitions(node);
739 {
740 List<PTransition> copy = new ArrayList<PTransition>(node.getTransitions());
741 Collections.reverse(copy);
742 for(PTransition e : copy)
743 {
744 e.apply(this);
745 }
746 }
747 outATransitions(node);
748 }
749
750 public void inANormalTransition(ANormalTransition node)
751 {
752 defaultIn(node);
753 }
754
755 public void outANormalTransition(ANormalTransition node)
756 {
757 defaultOut(node);
758 }
759
760 @Override
761 public void caseANormalTransition(ANormalTransition node)
762 {
763 inANormalTransition(node);
764 if(node.getDestination() != null)
765 {
766 node.getDestination().apply(this);
767 }
768 if(node.getTokenCollection() != null)
769 {
770 node.getTokenCollection().apply(this);
771 }
772 if(node.getSource() != null)
773 {
774 node.getSource().apply(this);
775 }
776 outANormalTransition(node);
777 }
778
779 public void inABackTransition(ABackTransition node)
780 {
781 defaultIn(node);
782 }
783
784 public void outABackTransition(ABackTransition node)
785 {
786 defaultOut(node);
787 }
788
789 @Override
790 public void caseABackTransition(ABackTransition node)
791 {
792 inABackTransition(node);
793 if(node.getTokenCollection() != null)
794 {
795 node.getTokenCollection().apply(this);
796 }
797 if(node.getSource() != null)
798 {
799 node.getSource().apply(this);
800 }
801 outABackTransition(node);
802 }
803
804 public void inAUnionRegularExpression(AUnionRegularExpression node)
805 {
806 defaultIn(node);
807 }
808
809 public void outAUnionRegularExpression(AUnionRegularExpression node)
810 {
811 defaultOut(node);
812 }
813
814 @Override
815 public void caseAUnionRegularExpression(AUnionRegularExpression node)
816 {
817 inAUnionRegularExpression(node);
818 if(node.getRightRegularExpression() != null)
819 {
820 node.getRightRegularExpression().apply(this);
821 }
822 if(node.getLeftRegularExpression() != null)
823 {
824 node.getLeftRegularExpression().apply(this);
825 }
826 outAUnionRegularExpression(node);
827 }
828
829 public void inASubtractionRegularExpression(ASubtractionRegularExpression node)
830 {
831 defaultIn(node);
832 }
833
834 public void outASubtractionRegularExpression(ASubtractionRegularExpression node)
835 {
836 defaultOut(node);
837 }
838
839 @Override
840 public void caseASubtractionRegularExpression(ASubtractionRegularExpression node)
841 {
842 inASubtractionRegularExpression(node);
843 if(node.getRightRegularExpression() != null)
844 {
845 node.getRightRegularExpression().apply(this);
846 }
847 if(node.getLeftRegularExpression() != null)
848 {
849 node.getLeftRegularExpression().apply(this);
850 }
851 outASubtractionRegularExpression(node);
852 }
853
854 public void inAConcatenationRegularExpression(AConcatenationRegularExpression node)
855 {
856 defaultIn(node);
857 }
858
859 public void outAConcatenationRegularExpression(AConcatenationRegularExpression node)
860 {
861 defaultOut(node);
862 }
863
864 @Override
865 public void caseAConcatenationRegularExpression(AConcatenationRegularExpression node)
866 {
867 inAConcatenationRegularExpression(node);
868 if(node.getRightRegularExpression() != null)
869 {
870 node.getRightRegularExpression().apply(this);
871 }
872 if(node.getLeftRegularExpression() != null)
873 {
874 node.getLeftRegularExpression().apply(this);
875 }
876 outAConcatenationRegularExpression(node);
877 }
878
879 public void inAZeroOrOneRegularExpression(AZeroOrOneRegularExpression node)
880 {
881 defaultIn(node);
882 }
883
884 public void outAZeroOrOneRegularExpression(AZeroOrOneRegularExpression node)
885 {
886 defaultOut(node);
887 }
888
889 @Override
890 public void caseAZeroOrOneRegularExpression(AZeroOrOneRegularExpression node)
891 {
892 inAZeroOrOneRegularExpression(node);
893 if(node.getRegularExpression() != null)
894 {
895 node.getRegularExpression().apply(this);
896 }
897 outAZeroOrOneRegularExpression(node);
898 }
899
900 public void inAZeroOrMoreRegularExpression(AZeroOrMoreRegularExpression node)
901 {
902 defaultIn(node);
903 }
904
905 public void outAZeroOrMoreRegularExpression(AZeroOrMoreRegularExpression node)
906 {
907 defaultOut(node);
908 }
909
910 @Override
911 public void caseAZeroOrMoreRegularExpression(AZeroOrMoreRegularExpression node)
912 {
913 inAZeroOrMoreRegularExpression(node);
914 if(node.getRegularExpression() != null)
915 {
916 node.getRegularExpression().apply(this);
917 }
918 outAZeroOrMoreRegularExpression(node);
919 }
920
921 public void inAOneOrMoreRegularExpression(AOneOrMoreRegularExpression node)
922 {
923 defaultIn(node);
924 }
925
926 public void outAOneOrMoreRegularExpression(AOneOrMoreRegularExpression node)
927 {
928 defaultOut(node);
929 }
930
931 @Override
932 public void caseAOneOrMoreRegularExpression(AOneOrMoreRegularExpression node)
933 {
934 inAOneOrMoreRegularExpression(node);
935 if(node.getRegularExpression() != null)
936 {
937 node.getRegularExpression().apply(this);
938 }
939 outAOneOrMoreRegularExpression(node);
940 }
941
942 public void inAExponentRegularExpression(AExponentRegularExpression node)
943 {
944 defaultIn(node);
945 }
946
947 public void outAExponentRegularExpression(AExponentRegularExpression node)
948 {
949 defaultOut(node);
950 }
951
952 @Override
953 public void caseAExponentRegularExpression(AExponentRegularExpression node)
954 {
955 inAExponentRegularExpression(node);
956 if(node.getTimes() != null)
957 {
958 node.getTimes().apply(this);
959 }
960 if(node.getRegularExpression() != null)
961 {
962 node.getRegularExpression().apply(this);
963 }
964 outAExponentRegularExpression(node);
965 }
966
967 public void inARangeRegularExpression(ARangeRegularExpression node)
968 {
969 defaultIn(node);
970 }
971
972 public void outARangeRegularExpression(ARangeRegularExpression node)
973 {
974 defaultOut(node);
975 }
976
977 @Override
978 public void caseARangeRegularExpression(ARangeRegularExpression node)
979 {
980 inARangeRegularExpression(node);
981 if(node.getTo() != null)
982 {
983 node.getTo().apply(this);
984 }
985 if(node.getFrom() != null)
986 {
987 node.getFrom().apply(this);
988 }
989 if(node.getRegularExpression() != null)
990 {
991 node.getRegularExpression().apply(this);
992 }
993 outARangeRegularExpression(node);
994 }
995
996 public void inAAtLeastRegularExpression(AAtLeastRegularExpression node)
997 {
998 defaultIn(node);
999 }
1000
1001 public void outAAtLeastRegularExpression(AAtLeastRegularExpression node)
1002 {
1003 defaultOut(node);
1004 }
1005
1006 @Override
1007 public void caseAAtLeastRegularExpression(AAtLeastRegularExpression node)
1008 {
1009 inAAtLeastRegularExpression(node);
1010 if(node.getTimes() != null)
1011 {
1012 node.getTimes().apply(this);
1013 }
1014 if(node.getRegularExpression() != null)
1015 {
1016 node.getRegularExpression().apply(this);
1017 }
1018 outAAtLeastRegularExpression(node);
1019 }
1020
1021 public void inAIntersectionRegularExpression(AIntersectionRegularExpression node)
1022 {
1023 defaultIn(node);
1024 }
1025
1026 public void outAIntersectionRegularExpression(AIntersectionRegularExpression node)
1027 {
1028 defaultOut(node);
1029 }
1030
1031 @Override
1032 public void caseAIntersectionRegularExpression(AIntersectionRegularExpression node)
1033 {
1034 inAIntersectionRegularExpression(node);
1035 if(node.getRightRegularExpression() != null)
1036 {
1037 node.getRightRegularExpression().apply(this);
1038 }
1039 if(node.getLeftRegularExpression() != null)
1040 {
1041 node.getLeftRegularExpression().apply(this);
1042 }
1043 outAIntersectionRegularExpression(node);
1044 }
1045
1046 public void inAShortestRegularExpression(AShortestRegularExpression node)
1047 {
1048 defaultIn(node);
1049 }
1050
1051 public void outAShortestRegularExpression(AShortestRegularExpression node)
1052 {
1053 defaultOut(node);
1054 }
1055
1056 @Override
1057 public void caseAShortestRegularExpression(AShortestRegularExpression node)
1058 {
1059 inAShortestRegularExpression(node);
1060 if(node.getRegularExpression() != null)
1061 {
1062 node.getRegularExpression().apply(this);
1063 }
1064 outAShortestRegularExpression(node);
1065 }
1066
1067 public void inAIntervalRegularExpression(AIntervalRegularExpression node)
1068 {
1069 defaultIn(node);
1070 }
1071
1072 public void outAIntervalRegularExpression(AIntervalRegularExpression node)
1073 {
1074 defaultOut(node);
1075 }
1076
1077 @Override
1078 public void caseAIntervalRegularExpression(AIntervalRegularExpression node)
1079 {
1080 inAIntervalRegularExpression(node);
1081 if(node.getUpperBound() != null)
1082 {
1083 node.getUpperBound().apply(this);
1084 }
1085 if(node.getLowerBound() != null)
1086 {
1087 node.getLowerBound().apply(this);
1088 }
1089 outAIntervalRegularExpression(node);
1090 }
1091
1092 public void inAStringRegularExpression(AStringRegularExpression node)
1093 {
1094 defaultIn(node);
1095 }
1096
1097 public void outAStringRegularExpression(AStringRegularExpression node)
1098 {
1099 defaultOut(node);
1100 }
1101
1102 @Override
1103 public void caseAStringRegularExpression(AStringRegularExpression node)
1104 {
1105 inAStringRegularExpression(node);
1106 if(node.getString() != null)
1107 {
1108 node.getString().apply(this);
1109 }
1110 outAStringRegularExpression(node);
1111 }
1112
1113 public void inACharacterRegularExpression(ACharacterRegularExpression node)
1114 {
1115 defaultIn(node);
1116 }
1117
1118 public void outACharacterRegularExpression(ACharacterRegularExpression node)
1119 {
1120 defaultOut(node);
1121 }
1122
1123 @Override
1124 public void caseACharacterRegularExpression(ACharacterRegularExpression node)
1125 {
1126 inACharacterRegularExpression(node);
1127 if(node.getCharacter() != null)
1128 {
1129 node.getCharacter().apply(this);
1130 }
1131 outACharacterRegularExpression(node);
1132 }
1133
1134 public void inAAnyRegularExpression(AAnyRegularExpression node)
1135 {
1136 defaultIn(node);
1137 }
1138
1139 public void outAAnyRegularExpression(AAnyRegularExpression node)
1140 {
1141 defaultOut(node);
1142 }
1143
1144 @Override
1145 public void caseAAnyRegularExpression(AAnyRegularExpression node)
1146 {
1147 inAAnyRegularExpression(node);
1148 outAAnyRegularExpression(node);
1149 }
1150
1151 public void inAEmptyStringRegularExpression(AEmptyStringRegularExpression node)
1152 {
1153 defaultIn(node);
1154 }
1155
1156 public void outAEmptyStringRegularExpression(AEmptyStringRegularExpression node)
1157 {
1158 defaultOut(node);
1159 }
1160
1161 @Override
1162 public void caseAEmptyStringRegularExpression(AEmptyStringRegularExpression node)
1163 {
1164 inAEmptyStringRegularExpression(node);
1165 outAEmptyStringRegularExpression(node);
1166 }
1167
1168 public void inAHelperRegularExpression(AHelperRegularExpression node)
1169 {
1170 defaultIn(node);
1171 }
1172
1173 public void outAHelperRegularExpression(AHelperRegularExpression node)
1174 {
1175 defaultOut(node);
1176 }
1177
1178 @Override
1179 public void caseAHelperRegularExpression(AHelperRegularExpression node)
1180 {
1181 inAHelperRegularExpression(node);
1182 if(node.getIdentifier() != null)
1183 {
1184 node.getIdentifier().apply(this);
1185 }
1186 outAHelperRegularExpression(node);
1187 }
1188
1189 public void inACharacterCharacter(ACharacterCharacter node)
1190 {
1191 defaultIn(node);
1192 }
1193
1194 public void outACharacterCharacter(ACharacterCharacter node)
1195 {
1196 defaultOut(node);
1197 }
1198
1199 @Override
1200 public void caseACharacterCharacter(ACharacterCharacter node)
1201 {
1202 inACharacterCharacter(node);
1203 if(node.getCharacterToken() != null)
1204 {
1205 node.getCharacterToken().apply(this);
1206 }
1207 outACharacterCharacter(node);
1208 }
1209
1210 public void inADecimalCharacter(ADecimalCharacter node)
1211 {
1212 defaultIn(node);
1213 }
1214
1215 public void outADecimalCharacter(ADecimalCharacter node)
1216 {
1217 defaultOut(node);
1218 }
1219
1220 @Override
1221 public void caseADecimalCharacter(ADecimalCharacter node)
1222 {
1223 inADecimalCharacter(node);
1224 if(node.getDecimalCharacter() != null)
1225 {
1226 node.getDecimalCharacter().apply(this);
1227 }
1228 outADecimalCharacter(node);
1229 }
1230
1231 public void inAHexadecimalCharacter(AHexadecimalCharacter node)
1232 {
1233 defaultIn(node);
1234 }
1235
1236 public void outAHexadecimalCharacter(AHexadecimalCharacter node)
1237 {
1238 defaultOut(node);
1239 }
1240
1241 @Override
1242 public void caseAHexadecimalCharacter(AHexadecimalCharacter node)
1243 {
1244 inAHexadecimalCharacter(node);
1245 if(node.getHexadecimalCharacter() != null)
1246 {
1247 node.getHexadecimalCharacter().apply(this);
1248 }
1249 outAHexadecimalCharacter(node);
1250 }
1251
1252 public void inACompleteTokenCollection(ACompleteTokenCollection node)
1253 {
1254 defaultIn(node);
1255 }
1256
1257 public void outACompleteTokenCollection(ACompleteTokenCollection node)
1258 {
1259 defaultOut(node);
1260 }
1261
1262 @Override
1263 public void caseACompleteTokenCollection(ACompleteTokenCollection node)
1264 {
1265 inACompleteTokenCollection(node);
1266 outACompleteTokenCollection(node);
1267 }
1268
1269 public void inAInclusiveTokenCollection(AInclusiveTokenCollection node)
1270 {
1271 defaultIn(node);
1272 }
1273
1274 public void outAInclusiveTokenCollection(AInclusiveTokenCollection node)
1275 {
1276 defaultOut(node);
1277 }
1278
1279 @Override
1280 public void caseAInclusiveTokenCollection(AInclusiveTokenCollection node)
1281 {
1282 inAInclusiveTokenCollection(node);
1283 {
1284 List<TIdentifier> copy = new ArrayList<TIdentifier>(node.getIdentifiers());
1285 Collections.reverse(copy);
1286 for(TIdentifier e : copy)
1287 {
1288 e.apply(this);
1289 }
1290 }
1291 outAInclusiveTokenCollection(node);
1292 }
1293
1294 public void inAExclusiveTokenCollection(AExclusiveTokenCollection node)
1295 {
1296 defaultIn(node);
1297 }
1298
1299 public void outAExclusiveTokenCollection(AExclusiveTokenCollection node)
1300 {
1301 defaultOut(node);
1302 }
1303
1304 @Override
1305 public void caseAExclusiveTokenCollection(AExclusiveTokenCollection node)
1306 {
1307 inAExclusiveTokenCollection(node);
1308 {
1309 List<TIdentifier> copy = new ArrayList<TIdentifier>(node.getIdentifiers());
1310 Collections.reverse(copy);
1311 for(TIdentifier e : copy)
1312 {
1313 e.apply(this);
1314 }
1315 }
1316 outAExclusiveTokenCollection(node);
1317 }
1318
1319 public void inASubsetTokenCollection(ASubsetTokenCollection node)
1320 {
1321 defaultIn(node);
1322 }
1323
1324 public void outASubsetTokenCollection(ASubsetTokenCollection node)
1325 {
1326 defaultOut(node);
1327 }
1328
1329 @Override
1330 public void caseASubsetTokenCollection(ASubsetTokenCollection node)
1331 {
1332 inASubsetTokenCollection(node);
1333 {
1334 List<TIdentifier> copy = new ArrayList<TIdentifier>(node.getExcludedIdentifiers());
1335 Collections.reverse(copy);
1336 for(TIdentifier e : copy)
1337 {
1338 e.apply(this);
1339 }
1340 }
1341 {
1342 List<TIdentifier> copy = new ArrayList<TIdentifier>(node.getIdentifiers());
1343 Collections.reverse(copy);
1344 for(TIdentifier e : copy)
1345 {
1346 e.apply(this);
1347 }
1348 }
1349 outASubsetTokenCollection(node);
1350 }
1351}
1352 |
Popular Tags |
Java API By Example, From Geeks To Geeks.