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