|
1
2
3 package soot.jimple.parser.analysis;
4
5 import soot.jimple.parser.node.*;
6
7 public class ReversedDepthFirstAdapter extends AnalysisAdapter
8 {
9 public void inStart(Start node)
10 {
11 defaultIn(node);
12 }
13
14 public void outStart(Start node)
15 {
16 defaultOut(node);
17 }
18
19 public void defaultIn(Node node)
20 {
21 }
22
23 public void defaultOut(Node node)
24 {
25 }
26
27 public void caseStart(Start node)
28 {
29 inStart(node);
30 node.getEOF().apply(this);
31 node.getPFile().apply(this);
32 outStart(node);
33 }
34
35 public void inAFile(AFile node)
36 {
37 defaultIn(node);
38 }
39
40 public void outAFile(AFile node)
41 {
42 defaultOut(node);
43 }
44
45 public void caseAFile(AFile node)
46 {
47 inAFile(node);
48 if(node.getFileBody() != null)
49 {
50 node.getFileBody().apply(this);
51 }
52 if(node.getImplementsClause() != null)
53 {
54 node.getImplementsClause().apply(this);
55 }
56 if(node.getExtendsClause() != null)
57 {
58 node.getExtendsClause().apply(this);
59 }
60 if(node.getClassName() != null)
61 {
62 node.getClassName().apply(this);
63 }
64 if(node.getFileType() != null)
65 {
66 node.getFileType().apply(this);
67 }
68 {
69 Object  temp[] = node.getModifier().toArray();
70 for(int i = temp.length - 1; i >= 0; i--)
71 {
72 ((PModifier) temp[i]).apply(this);
73 }
74 }
75 outAFile(node);
76 }
77
78 public void inAAbstractModifier(AAbstractModifier node)
79 {
80 defaultIn(node);
81 }
82
83 public void outAAbstractModifier(AAbstractModifier node)
84 {
85 defaultOut(node);
86 }
87
88 public void caseAAbstractModifier(AAbstractModifier node)
89 {
90 inAAbstractModifier(node);
91 if(node.getAbstract() != null)
92 {
93 node.getAbstract().apply(this);
94 }
95 outAAbstractModifier(node);
96 }
97
98 public void inAFinalModifier(AFinalModifier node)
99 {
100 defaultIn(node);
101 }
102
103 public void outAFinalModifier(AFinalModifier node)
104 {
105 defaultOut(node);
106 }
107
108 public void caseAFinalModifier(AFinalModifier node)
109 {
110 inAFinalModifier(node);
111 if(node.getFinal() != null)
112 {
113 node.getFinal().apply(this);
114 }
115 outAFinalModifier(node);
116 }
117
118 public void inANativeModifier(ANativeModifier node)
119 {
120 defaultIn(node);
121 }
122
123 public void outANativeModifier(ANativeModifier node)
124 {
125 defaultOut(node);
126 }
127
128 public void caseANativeModifier(ANativeModifier node)
129 {
130 inANativeModifier(node);
131 if(node.getNative() != null)
132 {
133 node.getNative().apply(this);
134 }
135 outANativeModifier(node);
136 }
137
138 public void inAPublicModifier(APublicModifier node)
139 {
140 defaultIn(node);
141 }
142
143 public void outAPublicModifier(APublicModifier node)
144 {
145 defaultOut(node);
146 }
147
148 public void caseAPublicModifier(APublicModifier node)
149 {
150 inAPublicModifier(node);
151 if(node.getPublic() != null)
152 {
153 node.getPublic().apply(this);
154 }
155 outAPublicModifier(node);
156 }
157
158 public void inAProtectedModifier(AProtectedModifier node)
159 {
160 defaultIn(node);
161 }
162
163 public void outAProtectedModifier(AProtectedModifier node)
164 {
165 defaultOut(node);
166 }
167
168 public void caseAProtectedModifier(AProtectedModifier node)
169 {
170 inAProtectedModifier(node);
171 if(node.getProtected() != null)
172 {
173 node.getProtected().apply(this);
174 }
175 outAProtectedModifier(node);
176 }
177
178 public void inAPrivateModifier(APrivateModifier node)
179 {
180 defaultIn(node);
181 }
182
183 public void outAPrivateModifier(APrivateModifier node)
184 {
185 defaultOut(node);
186 }
187
188 public void caseAPrivateModifier(APrivateModifier node)
189 {
190 inAPrivateModifier(node);
191 if(node.getPrivate() != null)
192 {
193 node.getPrivate().apply(this);
194 }
195 outAPrivateModifier(node);
196 }
197
198 public void inAStaticModifier(AStaticModifier node)
199 {
200 defaultIn(node);
201 }
202
203 public void outAStaticModifier(AStaticModifier node)
204 {
205 defaultOut(node);
206 }
207
208 public void caseAStaticModifier(AStaticModifier node)
209 {
210 inAStaticModifier(node);
211 if(node.getStatic() != null)
212 {
213 node.getStatic().apply(this);
214 }
215 outAStaticModifier(node);
216 }
217
218 public void inASynchronizedModifier(ASynchronizedModifier node)
219 {
220 defaultIn(node);
221 }
222
223 public void outASynchronizedModifier(ASynchronizedModifier node)
224 {
225 defaultOut(node);
226 }
227
228 public void caseASynchronizedModifier(ASynchronizedModifier node)
229 {
230 inASynchronizedModifier(node);
231 if(node.getSynchronized() != null)
232 {
233 node.getSynchronized().apply(this);
234 }
235 outASynchronizedModifier(node);
236 }
237
238 public void inATransientModifier(ATransientModifier node)
239 {
240 defaultIn(node);
241 }
242
243 public void outATransientModifier(ATransientModifier node)
244 {
245 defaultOut(node);
246 }
247
248 public void caseATransientModifier(ATransientModifier node)
249 {
250 inATransientModifier(node);
251 if(node.getTransient() != null)
252 {
253 node.getTransient().apply(this);
254 }
255 outATransientModifier(node);
256 }
257
258 public void inAVolatileModifier(AVolatileModifier node)
259 {
260 defaultIn(node);
261 }
262
263 public void outAVolatileModifier(AVolatileModifier node)
264 {
265 defaultOut(node);
266 }
267
268 public void caseAVolatileModifier(AVolatileModifier node)
269 {
270 inAVolatileModifier(node);
271 if(node.getVolatile() != null)
272 {
273 node.getVolatile().apply(this);
274 }
275 outAVolatileModifier(node);
276 }
277
278 public void inAStrictfpModifier(AStrictfpModifier node)
279 {
280 defaultIn(node);
281 }
282
283 public void outAStrictfpModifier(AStrictfpModifier node)
284 {
285 defaultOut(node);
286 }
287
288 public void caseAStrictfpModifier(AStrictfpModifier node)
289 {
290 inAStrictfpModifier(node);
291 if(node.getStrictfp() != null)
292 {
293 node.getStrictfp().apply(this);
294 }
295 outAStrictfpModifier(node);
296 }
297
298 public void inAEnumModifier(AEnumModifier node)
299 {
300 defaultIn(node);
301 }
302
303 public void outAEnumModifier(AEnumModifier node)
304 {
305 defaultOut(node);
306 }
307
308 public void caseAEnumModifier(AEnumModifier node)
309 {
310 inAEnumModifier(node);
311 if(node.getEnum() != null)
312 {
313 node.getEnum().apply(this);
314 }
315 outAEnumModifier(node);
316 }
317
318 public void inAAnnotationModifier(AAnnotationModifier node)
319 {
320 defaultIn(node);
321 }
322
323 public void outAAnnotationModifier(AAnnotationModifier node)
324 {
325 defaultOut(node);
326 }
327
328 public void caseAAnnotationModifier(AAnnotationModifier node)
329 {
330 inAAnnotationModifier(node);
331 if(node.getAnnotation() != null)
332 {
333 node.getAnnotation().apply(this);
334 }
335 outAAnnotationModifier(node);
336 }
337
338 public void inAClassFileType(AClassFileType node)
339 {
340 defaultIn(node);
341 }
342
343 public void outAClassFileType(AClassFileType node)
344 {
345 defaultOut(node);
346 }
347
348 public void caseAClassFileType(AClassFileType node)
349 {
350 inAClassFileType(node);
351 if(node.getTheclass() != null)
352 {
353 node.getTheclass().apply(this);
354 }
355 outAClassFileType(node);
356 }
357
358 public void inAInterfaceFileType(AInterfaceFileType node)
359 {
360 defaultIn(node);
361 }
362
363 public void outAInterfaceFileType(AInterfaceFileType node)
364 {
365 defaultOut(node);
366 }
367
368 public void caseAInterfaceFileType(AInterfaceFileType node)
369 {
370 inAInterfaceFileType(node);
371 if(node.getInterface() != null)
372 {
373 node.getInterface().apply(this);
374 }
375 outAInterfaceFileType(node);
376 }
377
378 public void inAExtendsClause(AExtendsClause node)
379 {
380 defaultIn(node);
381 }
382
383 public void outAExtendsClause(AExtendsClause node)
384 {
385 defaultOut(node);
386 }
387
388 public void caseAExtendsClause(AExtendsClause node)
389 {
390 inAExtendsClause(node);
391 if(node.getClassName() != null)
392 {
393 node.getClassName().apply(this);
394 }
395 if(node.getExtends() != null)
396 {
397 node.getExtends().apply(this);
398 }
399 outAExtendsClause(node);
400 }
401
402 public void inAImplementsClause(AImplementsClause node)
403 {
404 defaultIn(node);
405 }
406
407 public void outAImplementsClause(AImplementsClause node)
408 {
409 defaultOut(node);
410 }
411
412 public void caseAImplementsClause(AImplementsClause node)
413 {
414 inAImplementsClause(node);
415 if(node.getClassNameList() != null)
416 {
417 node.getClassNameList().apply(this);
418 }
419 if(node.getImplements() != null)
420 {
421 node.getImplements().apply(this);
422 }
423 outAImplementsClause(node);
424 }
425
426 public void inAFileBody(AFileBody node)
427 {
428 defaultIn(node);
429 }
430
431 public void outAFileBody(AFileBody node)
432 {
433 defaultOut(node);
434 }
435
436 public void caseAFileBody(AFileBody node)
437 {
438 inAFileBody(node);
439 if(node.getRBrace() != null)
440 {
441 node.getRBrace().apply(this);
442 }
443 {
444 Object temp[] = node.getMember().toArray();
445 for(int i = temp.length - 1; i >= 0; i--)
446 {
447 ((PMember) temp[i]).apply(this);
448 }
449 }
450 if(node.getLBrace() != null)
451 {
452 node.getLBrace().apply(this);
453 }
454 outAFileBody(node);
455 }
456
457 public void inASingleNameList(ASingleNameList node)
458 {
459 defaultIn(node);
460 }
461
462 public void outASingleNameList(ASingleNameList node)
463 {
464 defaultOut(node);
465 }
466
467 public void caseASingleNameList(ASingleNameList node)
468 {
469 inASingleNameList(node);
470 if(node.getName() != null)
471 {
472 node.getName().apply(this);
473 }
474 outASingleNameList(node);
475 }
476
477 public void inAMultiNameList(AMultiNameList node)
478 {
479 defaultIn(node);
480 }
481
482 public void outAMultiNameList(AMultiNameList node)
483 {
484 defaultOut(node);
485 }
486
487 public void caseAMultiNameList(AMultiNameList node)
488 {
489 inAMultiNameList(node);
490 if(node.getNameList() != null)
491 {
492 node.getNameList().apply(this);
493 }
494 if(node.getComma() != null)
495 {
496 node.getComma().apply(this);
497 }
498 if(node.getName() != null)
499 {
500 node.getName().apply(this);
501 }
502 outAMultiNameList(node);
503 }
504
505 public void inAClassNameSingleClassNameList(AClassNameSingleClassNameList node)
506 {
507 defaultIn(node);
508 }
509
510 public void outAClassNameSingleClassNameList(AClassNameSingleClassNameList node)
511 {
512 defaultOut(node);
513 }
514
515 public void caseAClassNameSingleClassNameList(AClassNameSingleClassNameList node)
516 {
517 inAClassNameSingleClassNameList(node);
518 if(node.getClassName() != null)
519 {
520 node.getClassName().apply(this);
521 }
522 outAClassNameSingleClassNameList(node);
523 }
524
525 public void inAClassNameMultiClassNameList(AClassNameMultiClassNameList node)
526 {
527 defaultIn(node);
528 }
529
530 public void outAClassNameMultiClassNameList(AClassNameMultiClassNameList node)
531 {
532 defaultOut(node);
533 }
534
535 public void caseAClassNameMultiClassNameList(AClassNameMultiClassNameList node)
536 {
537 inAClassNameMultiClassNameList(node);
538 if(node.getClassNameList() != null)
539 {
540 node.getClassNameList().apply(this);
541 }
542 if(node.getComma() != null)
543 {
544 node.getComma().apply(this);
545 }
546 if(node.getClassName() != null)
547 {
548 node.getClassName().apply(this);
549 }
550 outAClassNameMultiClassNameList(node);
551 }
552
553 public void inAFieldMember(AFieldMember node)
554 {
555 defaultIn(node);
556 }
557
558 public void outAFieldMember(AFieldMember node)
559 {
560 defaultOut(node);
561 }
562
563 public void caseAFieldMember(AFieldMember node)
564 {
565 inAFieldMember(node);
566 if(node.getSemicolon() != null)
567 {
568 node.getSemicolon().apply(this);
569 }
570 if(node.getName() != null)
571 {
572 node.getName().apply(this);
573 }
574 if(node.getType() != null)
575 {
576 node.getType().apply(this);
577 }
578 {
579 Object temp[] = node.getModifier().toArray();
580 for(int i = temp.length - 1; i >= 0; i--)
581 {
582 ((PModifier) temp[i]).apply(this);
583 }
584 }
585 outAFieldMember(node);
586 }
587
588 public void inAMethodMember(AMethodMember node)
589 {
590 defaultIn(node);
591 }
592
593 public void outAMethodMember(AMethodMember node)
594 {
595 defaultOut(node);
596 }
597
598 public void caseAMethodMember(AMethodMember node)
599 {
600 inAMethodMember(node);
601 if(node.getMethodBody() != null)
602 {
603 node.getMethodBody().apply(this);
604 }
605 if(node.getThrowsClause() != null)
606 {
607 node.getThrowsClause().apply(this);
608 }
609 if(node.getRParen() != null)
610 {
611 node.getRParen().apply(this);
612 }
613 if(node.getParameterList() != null)
614 {
615 node.getParameterList().apply(this);
616 }
617 if(node.getLParen() != null)
618 {
619 node.getLParen().apply(this);
620 }
621 if(node.getName() != null)
622 {
623 node.getName().apply(this);
624 }
625 if(node.getType() != null)
626 {
627 node.getType().apply(this);
628 }
629 {
630 Object temp[] = node.getModifier().toArray();
631 for(int i = temp.length - 1; i >= 0; i--)
632 {
633 ((PModifier) temp[i]).apply(this);
634 }
635 }
636 outAMethodMember(node);
637 }
638
639 public void inAVoidType(AVoidType node)
640 {
641 defaultIn(node);
642 }
643
644 public void outAVoidType(AVoidType node)
645 {
646 defaultOut(node);
647 }
648
649 public void caseAVoidType(AVoidType node)
650 {
651 inAVoidType(node);
652 if(node.getVoid() != null)
653 {
654 node.getVoid().apply(this);
655 }
656 outAVoidType(node);
657 }
658
659 public void inANovoidType(ANovoidType node)
660 {
661 defaultIn(node);
662 }
663
664 public void outANovoidType(ANovoidType node)
665 {
666 defaultOut(node);
667 }
668
669 public void caseANovoidType(ANovoidType node)
670 {
671 inANovoidType(node);
672 if(node.getNonvoidType() != null)
673 {
674 node.getNonvoidType().apply(this);
675 }
676 outANovoidType(node);
677 }
678
679 public void inASingleParameterList(ASingleParameterList node)
680 {
681 defaultIn(node);
682 }
683
684 public void outASingleParameterList(ASingleParameterList node)
685 {
686 defaultOut(node);
687 }
688
689 public void caseASingleParameterList(ASingleParameterList node)
690 {
691 inASingleParameterList(node);
692 if(node.getParameter() != null)
693 {
694 node.getParameter().apply(this);
695 }
696 outASingleParameterList(node);
697 }
698
699 public void inAMultiParameterList(AMultiParameterList node)
700 {
701 defaultIn(node);
702 }
703
704 public void outAMultiParameterList(AMultiParameterList node)
705 {
706 defaultOut(node);
707 }
708
709 public void caseAMultiParameterList(AMultiParameterList node)
710 {
711 inAMultiParameterList(node);
712 if(node.getParameterList() != null)
713 {
714 node.getParameterList().apply(this);
715 }
716 if(node.getComma() != null)
717 {
718 node.getComma().apply(this);
719 }
720 if(node.getParameter() != null)
721 {
722 node.getParameter().apply(this);
723 }
724 outAMultiParameterList(node);
725 }
726
727 public void inAParameter(AParameter node)
728 {
729 defaultIn(node);
730 }
731
732 public void outAParameter(AParameter node)
733 {
734 defaultOut(node);
735 }
736
737 public void caseAParameter(AParameter node)
738 {
739 inAParameter(node);
740 if(node.getNonvoidType() != null)
741 {
742 node.getNonvoidType().apply(this);
743 }
744 outAParameter(node);
745 }
746
747 public void inAThrowsClause(AThrowsClause node)
748 {
749 defaultIn(node);
750 }
751
752 public void outAThrowsClause(AThrowsClause node)
753 {
754 defaultOut(node);
755 }
756
757 public void caseAThrowsClause(AThrowsClause node)
758 {
759 inAThrowsClause(node);
760 if(node.getClassNameList() != null)
761 {
762 node.getClassNameList().apply(this);
763 }
764 if(node.getThrows() != null)
765 {
766 node.getThrows().apply(this);
767 }
768 outAThrowsClause(node);
769 }
770
771 public void inABooleanBaseTypeNoName(ABooleanBaseTypeNoName node)
772 {
773 defaultIn(node);
774 }
775
776 public void outABooleanBaseTypeNoName(ABooleanBaseTypeNoName node)
777 {
778 defaultOut(node);
779 }
780
781 public void caseABooleanBaseTypeNoName(ABooleanBaseTypeNoName node)
782 {
783 inABooleanBaseTypeNoName(node);
784 if(node.getBoolean() != null)
785 {
786 node.getBoolean().apply(this);
787 }
788 outABooleanBaseTypeNoName(node);
789 }
790
791 public void inAByteBaseTypeNoName(AByteBaseTypeNoName node)
792 {
793 defaultIn(node);
794 }
795
796 public void outAByteBaseTypeNoName(AByteBaseTypeNoName node)
797 {
798 defaultOut(node);
799 }
800
801 public void caseAByteBaseTypeNoName(AByteBaseTypeNoName node)
802 {
803 inAByteBaseTypeNoName(node);
804 if(node.getByte() != null)
805 {
806 node.getByte().apply(this);
807 }
808 outAByteBaseTypeNoName(node);
809 }
810
811 public void inACharBaseTypeNoName(ACharBaseTypeNoName node)
812 {
813 defaultIn(node);
814 }
815
816 public void outACharBaseTypeNoName(ACharBaseTypeNoName node)
817 {
818 defaultOut(node);
819 }
820
821 public void caseACharBaseTypeNoName(ACharBaseTypeNoName node)
822 {
823 inACharBaseTypeNoName(node);
824 if(node.getChar() != null)
825 {
826 node.getChar().apply(this);
827 }
828 outACharBaseTypeNoName(node);
829 }
830
831 public void inAShortBaseTypeNoName(AShortBaseTypeNoName node)
832 {
833 defaultIn(node);
834 }
835
836 public void outAShortBaseTypeNoName(AShortBaseTypeNoName node)
837 {
838 defaultOut(node);
839 }
840
841 public void caseAShortBaseTypeNoName(AShortBaseTypeNoName node)
842 {
843 inAShortBaseTypeNoName(node);
844 if(node.getShort() != null)
845 {
846 node.getShort().apply(this);
847 }
848 outAShortBaseTypeNoName(node);
849 }
850
851 public void inAIntBaseTypeNoName(AIntBaseTypeNoName node)
852 {
853 defaultIn(node);
854 }
855
856 public void outAIntBaseTypeNoName(AIntBaseTypeNoName node)
857 {
858 defaultOut(node);
859 }
860
861 public void caseAIntBaseTypeNoName(AIntBaseTypeNoName node)
862 {
863 inAIntBaseTypeNoName(node);
864 if(node.getInt() != null)
865 {
866 node.getInt().apply(this);
867 }
868 outAIntBaseTypeNoName(node);
869 }
870
871 public void inALongBaseTypeNoName(ALongBaseTypeNoName node)
872 {
873 defaultIn(node);
874 }
875
876 public void outALongBaseTypeNoName(ALongBaseTypeNoName node)
877 {
878 defaultOut(node);
879 }
880
881 public void caseALongBaseTypeNoName(ALongBaseTypeNoName node)
882 {
883 inALongBaseTypeNoName(node);
884 if(node.getLong() != null)
885 {
886 node.getLong().apply(this);
887 }
888 outALongBaseTypeNoName(node);
889 }
890
891 public void inAFloatBaseTypeNoName(AFloatBaseTypeNoName node)
892 {
893 defaultIn(node);
894 }
895
896 public void outAFloatBaseTypeNoName(AFloatBaseTypeNoName node)
897 {
898 defaultOut(node);
899 }
900
901 public void caseAFloatBaseTypeNoName(AFloatBaseTypeNoName node)
902 {
903 inAFloatBaseTypeNoName(node);
904 if(node.getFloat() != null)
905 {
906 node.getFloat().apply(this);
907 }
908 outAFloatBaseTypeNoName(node);
909 }
910
911 public void inADoubleBaseTypeNoName(ADoubleBaseTypeNoName node)
912 {
913 defaultIn(node);
914 }
915
916 public void outADoubleBaseTypeNoName(ADoubleBaseTypeNoName node)
917 {
918 defaultOut(node);
919 }
920
921 public void caseADoubleBaseTypeNoName(ADoubleBaseTypeNoName node)
922 {
923 inADoubleBaseTypeNoName(node);
924 if(node.getDouble() != null)
925 {
926 node.getDouble().apply(this);
927 }
928 outADoubleBaseTypeNoName(node);
929 }
930
931 public void inANullBaseTypeNoName(ANullBaseTypeNoName node)
932 {
933 defaultIn(node);
934 }
935
936 public void outANullBaseTypeNoName(ANullBaseTypeNoName node)
937 {
938 defaultOut(node);
939 }
940
941 public void caseANullBaseTypeNoName(ANullBaseTypeNoName node)
942 {
943 inANullBaseTypeNoName(node);
944 if(node.getNullType() != null)
945 {
946 node.getNullType().apply(this);
947 }
948 outANullBaseTypeNoName(node);
949 }
950
951 public void inABooleanBaseType(ABooleanBaseType node)
952 {
953 defaultIn(node);
954 }
955
956 public void outABooleanBaseType(ABooleanBaseType node)
957 {
958 defaultOut(node);
959 }
960
961 public void caseABooleanBaseType(ABooleanBaseType node)
962 {
963 inABooleanBaseType(node);
964 if(node.getBoolean() != null)
965 {
966 node.getBoolean().apply(this);
967 }
968 outABooleanBaseType(node);
969 }
970
971 public void inAByteBaseType(AByteBaseType node)
972 {
973 defaultIn(node);
974 }
975
976 public void outAByteBaseType(AByteBaseType node)
977 {
978 defaultOut(node);
979 }
980
981 public void caseAByteBaseType(AByteBaseType node)
982 {
983 inAByteBaseType(node);
984 if(node.getByte() != null)
985 {
986 node.getByte().apply(this);
987 }
988 outAByteBaseType(node);
989 }
990
991 public void inACharBaseType(ACharBaseType node)
992 {
993 defaultIn(node);
994 }
995
996 public void outACharBaseType(ACharBaseType node)
997 {
998 defaultOut(node);
999 }
1000
1001 public void caseACharBaseType(ACharBaseType node)
1002 {
1003 inACharBaseType(node);
1004 if(node.getChar() != null)
1005 {
1006 node.getChar().apply(this);
1007 }
1008 outACharBaseType(node);
1009 }
1010
1011 public void inAShortBaseType(AShortBaseType node)
1012 {
1013 defaultIn(node);
1014 }
1015
1016 public void outAShortBaseType(AShortBaseType node)
1017 {
1018 defaultOut(node);
1019 }
1020
1021 public void caseAShortBaseType(AShortBaseType node)
1022 {
1023 inAShortBaseType(node);
1024 if(node.getShort() != null)
1025 {
1026 node.getShort().apply(this);
1027 }
1028 outAShortBaseType(node);
1029 }
1030
1031 public void inAIntBaseType(AIntBaseType node)
1032 {
1033 defaultIn(node);
1034 }
1035
1036 public void outAIntBaseType(AIntBaseType node)
1037 {
1038 defaultOut(node);
1039 }
1040
1041 public void caseAIntBaseType(AIntBaseType node)
1042 {
1043 inAIntBaseType(node);
1044 if(node.getInt() != null)
1045 {
1046 node.getInt().apply(this);
1047 }
1048 outAIntBaseType(node);
1049 }
1050
1051 public void inALongBaseType(ALongBaseType node)
1052 {
1053 defaultIn(node);
1054 }
1055
1056 public void outALongBaseType(ALongBaseType node)
1057 {
1058 defaultOut(node);
1059 }
1060
1061 public void caseALongBaseType(ALongBaseType node)
1062 {
1063 inALongBaseType(node);
1064 if(node.getLong() != null)
1065 {
1066 node.getLong().apply(this);
1067 }
1068 outALongBaseType(node);
1069 }
1070
1071 public void inAFloatBaseType(AFloatBaseType node)
1072 {
1073 defaultIn(node);
1074 }
1075
1076 public void outAFloatBaseType(AFloatBaseType node)
1077 {
1078 defaultOut(node);
1079 }
1080
1081 public void caseAFloatBaseType(AFloatBaseType node)
1082 {
1083 inAFloatBaseType(node);
1084 if(node.getFloat() != null)
1085 {
1086 node.getFloat().apply(this);
1087 }
1088 outAFloatBaseType(node);
1089 }
1090
1091 public void inADoubleBaseType(ADoubleBaseType node)
1092 {
1093 defaultIn(node);
1094 }
1095
1096 public void outADoubleBaseType(ADoubleBaseType node)
1097 {
1098 defaultOut(node);
1099 }
1100
1101 public void caseADoubleBaseType(ADoubleBaseType node)
1102 {
1103 inADoubleBaseType(node);
1104 if(node.getDouble() != null)
1105 {
1106 node.getDouble().apply(this);
1107 }
1108 outADoubleBaseType(node);
1109 }
1110
1111 public void inANullBaseType(ANullBaseType node)
1112 {
1113 defaultIn(node);
1114 }
1115
1116 public void outANullBaseType(ANullBaseType node)
1117 {
1118 defaultOut(node);
1119 }
1120
1121 public void caseANullBaseType(ANullBaseType node)
1122 {
1123 inANullBaseType(node);
1124 if(node.getNullType() != null)
1125 {
1126 node.getNullType().apply(this);
1127 }
1128 outANullBaseType(node);
1129 }
1130
1131 public void inAClassNameBaseType(AClassNameBaseType node)
1132 {
1133 defaultIn(node);
1134 }
1135
1136 public void outAClassNameBaseType(AClassNameBaseType node)
1137 {
1138 defaultOut(node);
1139 }
1140
1141 public void caseAClassNameBaseType(AClassNameBaseType node)
1142 {
1143 inAClassNameBaseType(node);
1144 if(node.getClassName() != null)
1145 {
1146 node.getClassName().apply(this);
1147 }
1148 outAClassNameBaseType(node);
1149 }
1150
1151 public void inABaseNonvoidType(ABaseNonvoidType node)
1152 {
1153 defaultIn(node);
1154 }
1155
1156 public void outABaseNonvoidType(ABaseNonvoidType node)
1157 {
1158 defaultOut(node);
1159 }
1160
1161 public void caseABaseNonvoidType(ABaseNonvoidType node)
1162 {
1163 inABaseNonvoidType(node);
1164 {
1165 Object temp[] = node.getArrayBrackets().toArray();
1166 for(int i = temp.length - 1; i >= 0; i--)
1167 {
1168 ((PArrayBrackets) temp[i]).apply(this);
1169 }
1170 }
1171 if(node.getBaseTypeNoName() != null)
1172 {
1173 node.getBaseTypeNoName().apply(this);
1174 }
1175 outABaseNonvoidType(node);
1176 }
1177
1178 public void inAQuotedNonvoidType(AQuotedNonvoidType node)
1179 {
1180 defaultIn(node);
1181 }
1182
1183 public void outAQuotedNonvoidType(AQuotedNonvoidType node)
1184 {
1185 defaultOut(node);
1186 }
1187
1188 public void caseAQuotedNonvoidType(AQuotedNonvoidType node)
1189 {
1190 inAQuotedNonvoidType(node);
1191 {
1192 Object temp[] = node.getArrayBrackets().toArray();
1193 for(int i = temp.length - 1; i >= 0; i--)
1194 {
1195 ((PArrayBrackets) temp[i]).apply(this);
1196 }
1197 }
1198 if(node.getQuotedName() != null)
1199 {
1200 node.getQuotedName().apply(this);
1201 }
1202 outAQuotedNonvoidType(node);
1203 }
1204
1205 public void inAIdentNonvoidType(AIdentNonvoidType node)
1206 {
1207 defaultIn(node);
1208 }
1209
1210 public void outAIdentNonvoidType(AIdentNonvoidType node)
1211 {
1212 defaultOut(node);
1213 }
1214
1215 public void caseAIdentNonvoidType(AIdentNonvoidType node)
1216 {
1217 inAIdentNonvoidType(node);
1218 {
1219 Object temp[] = node.getArrayBrackets().toArray();
1220 for(int i = temp.length - 1; i >= 0; i--)
1221 {
1222 ((PArrayBrackets) temp[i]).apply(this);
1223 }
1224 }
1225 if(node.getIdentifier() != null)
1226 {
1227 node.getIdentifier().apply(this);
1228 }
1229 outAIdentNonvoidType(node);
1230 }
1231
1232 public void inAFullIdentNonvoidType(AFullIdentNonvoidType node)
1233 {
1234 defaultIn(node);
1235 }
1236
1237 public void outAFullIdentNonvoidType(AFullIdentNonvoidType node)
1238 {
1239 defaultOut(node);
1240 }
1241
1242 public void caseAFullIdentNonvoidType(AFullIdentNonvoidType node)
1243 {
1244 inAFullIdentNonvoidType(node);
1245 {
1246 Object temp[] = node.getArrayBrackets().toArray();
1247 for(int i = temp.length - 1; i >= 0; i--)
1248 {
1249 ((PArrayBrackets) temp[i]).apply(this);
1250 }
1251 }
1252 if(node.getFullIdentifier() != null)
1253 {
1254 node.getFullIdentifier().apply(this);
1255 }
1256 outAFullIdentNonvoidType(node);
1257 }
1258
1259 public void inAArrayBrackets(AArrayBrackets node)
1260 {
1261 defaultIn(node);
1262 }
1263
1264 public void outAArrayBrackets(AArrayBrackets node)
1265 {
1266 defaultOut(node);
1267 }
1268
1269 public void caseAArrayBrackets(AArrayBrackets node)
1270 {
1271 inAArrayBrackets(node);
1272 if(node.getRBracket() != null)
1273 {
1274 node.getRBracket().apply(this);
1275 }
1276 if(node.getLBracket() != null)
1277 {
1278 node.getLBracket().apply(this);
1279 }
1280 outAArrayBrackets(node);
1281 }
1282
1283 public void inAEmptyMethodBody(AEmptyMethodBody node)
1284 {
1285 defaultIn(node);
1286 }
1287
1288 public void outAEmptyMethodBody(AEmptyMethodBody node)
1289 {
1290 defaultOut(node);
1291 }
1292
1293 public void caseAEmptyMethodBody(AEmptyMethodBody node)
1294 {
1295 inAEmptyMethodBody(node);
1296 if(node.getSemicolon() != null)
1297 {
1298 node.getSemicolon().apply(this);
1299 }
1300 outAEmptyMethodBody(node);
1301 }
1302
1303 public void inAFullMethodBody(AFullMethodBody node)
1304 {
1305 defaultIn(node);
1306 }
1307
1308 public void outAFullMethodBody(AFullMethodBody node)
1309 {
1310 defaultOut(node);
1311 }
1312
1313 public void caseAFullMethodBody(AFullMethodBody node)
1314 {
1315 inAFullMethodBody(node);
1316 if(node.getRBrace() != null)
1317 {
1318 node.getRBrace().apply(this);
1319 }
1320 {
1321 Object temp[] = node.getCatchClause().toArray();
1322 for(int i = temp.length - 1; i >= 0; i--)
1323 {
1324 ((PCatchClause) temp[i]).apply(this);
1325 }
1326 }
1327 {
1328 Object temp[] = node.getStatement().toArray();
1329 for(int i = temp.length - 1; i >= 0; i--)
1330 {
1331 ((PStatement) temp[i]).apply(this);
1332 }
1333 }
1334 {
1335 Object temp[] = node.getDeclaration().toArray();
1336 for(int i = temp.length - 1; i >= 0; i--)
1337 {
1338 ((PDeclaration) temp[i]).apply(this);
1339 }
1340 }
1341 if(node.getLBrace() != null)
1342 {
1343 node.getLBrace().apply(this);
1344 }
1345 outAFullMethodBody(node);
1346 }
1347
1348 public void inADeclaration(ADeclaration node)
1349 {
1350 defaultIn(node);
1351 }
1352
1353 public void outADeclaration(ADeclaration node)
1354 {
1355 defaultOut(node);
1356 }
1357
1358 public void caseADeclaration(ADeclaration node)
1359 {
1360 inADeclaration(node);
1361 if(node.getSemicolon() != null)
1362 {
1363 node.getSemicolon().apply(this);
1364 }
1365 if(node.getLocalNameList() != null)
1366 {
1367 node.getLocalNameList().apply(this);
1368 }
1369 if(node.getJimpleType() != null)
1370 {
1371 node.getJimpleType().apply(this);
1372 }
1373 outADeclaration(node);
1374 }
1375
1376 public void inAUnknownJimpleType(AUnknownJimpleType node)
1377 {
1378 defaultIn(node);
1379 }
1380
1381 public void outAUnknownJimpleType(AUnknownJimpleType node)
1382 {
1383 defaultOut(node);
1384 }
1385
1386 public void caseAUnknownJimpleType(AUnknownJimpleType node)
1387 {
1388 inAUnknownJimpleType(node);
1389 if(node.getUnknown() != null)
1390 {
1391 node.getUnknown().apply(this);
1392 }
1393 outAUnknownJimpleType(node);
1394 }
1395
1396 public void inANonvoidJimpleType(ANonvoidJimpleType node)
1397 {
1398 defaultIn(node);
1399 }
1400
1401 public void outANonvoidJimpleType(ANonvoidJimpleType node)
1402 {
1403 defaultOut(node);
1404 }
1405
1406 public void caseANonvoidJimpleType(ANonvoidJimpleType node)
1407 {
1408 inANonvoidJimpleType(node);
1409 if(node.getNonvoidType() != null)
1410 {
1411 node.getNonvoidType().apply(this);
1412 }
1413 outANonvoidJimpleType(node);
1414 }
1415
1416 public void inALocalName(ALocalName node)
1417 {
1418 defaultIn(node);
1419 }
1420
1421 public void outALocalName(ALocalName node)
1422 {
1423 defaultOut(node);
1424 }
1425
1426 public void caseALocalName(ALocalName node)
1427 {
1428 inALocalName(node);
1429 if(node.getName() != null)
1430 {
1431 node.getName().apply(this);
1432 }
1433 outALocalName(node);
1434 }
1435
1436 public void inASingleLocalNameList(ASingleLocalNameList node)
1437 {
1438 defaultIn(node);
1439 }
1440
1441 public void outASingleLocalNameList(ASingleLocalNameList node)
1442 {
1443 defaultOut(node);
1444 }
1445
1446 public void caseASingleLocalNameList(ASingleLocalNameList node)
1447 {
1448 inASingleLocalNameList(node);
1449 if(node.getLocalName() != null)
1450 {
1451 node.getLocalName().apply(this);
1452 }
1453 outASingleLocalNameList(node);
1454 }
1455
1456 public void inAMultiLocalNameList(AMultiLocalNameList node)
1457 {
1458 defaultIn(node);
1459 }
1460
1461 public void outAMultiLocalNameList(AMultiLocalNameList node)
1462 {
1463 defaultOut(node);
1464 }
1465
1466 public void caseAMultiLocalNameList(AMultiLocalNameList node)
1467 {
1468 inAMultiLocalNameList(node);
1469 if(node.getLocalNameList() != null)
1470 {
1471 node.getLocalNameList().apply(this);
1472 }
1473 if(node.getComma() != null)
1474 {
1475 node.getComma().apply(this);
1476 }
1477 if(node.getLocalName() != null)
1478 {
1479 node.getLocalName().apply(this);
1480 }
1481 outAMultiLocalNameList(node);
1482 }
1483
1484 public void inALabelStatement(ALabelStatement node)
1485 {
1486 defaultIn(node);
1487 }
1488
1489 public void outALabelStatement(ALabelStatement node)
1490 {
1491 defaultOut(node);
1492 }
1493
1494 public void caseALabelStatement(ALabelStatement node)
1495 {
1496 inALabelStatement(node);
1497 if(node.getColon() != null)
1498 {
1499 node.getColon().apply(this);
1500 }
1501 if(node.getLabelName() != null)
1502 {
1503 node.getLabelName().apply(this);
1504 }
1505 outALabelStatement(node);
1506 }
1507
1508 public void inABreakpointStatement(ABreakpointStatement node)
1509 {
1510 defaultIn(node);
1511 }
1512
1513 public void outABreakpointStatement(ABreakpointStatement node)
1514 {
1515 defaultOut(node);
1516 }
1517
1518 public void caseABreakpointStatement(ABreakpointStatement node)
1519 {
1520 inABreakpointStatement(node);
1521 if(node.getSemicolon() != null)
1522 {
1523 node.getSemicolon().apply(this);
1524 }
1525 if(node.getBreakpoint() != null)
1526 {
1527 node.getBreakpoint().apply(this);
1528 }
1529 outABreakpointStatement(node);
1530 }
1531
1532 public void inAEntermonitorStatement(AEntermonitorStatement node)
1533 {
1534 defaultIn(node);
1535 }
1536
1537 public void outAEntermonitorStatement(AEntermonitorStatement node)
1538 {
1539 defaultOut(node);
1540 }
1541
1542 public void caseAEntermonitorStatement(AEntermonitorStatement node)
1543 {
1544 inAEntermonitorStatement(node);
1545 if(node.getSemicolon() != null)
1546 {
1547 node.getSemicolon().apply(this);
1548 }
1549 if(node.getImmediate() != null)
1550 {
1551 node.getImmediate().apply(this);
1552 }
1553 if(node.getEntermonitor() != null)
1554 {
1555 node.getEntermonitor().apply(this);
1556 }
1557 outAEntermonitorStatement(node);
1558 }
1559
1560 public void inAExitmonitorStatement(AExitmonitorStatement node)
1561 {
1562 defaultIn(node);
1563 }
1564
1565 public void outAExitmonitorStatement(AExitmonitorStatement node)
1566 {
1567 defaultOut(node);
1568 }
1569
1570 public void caseAExitmonitorStatement(AExitmonitorStatement node)
1571 {
1572 inAExitmonitorStatement(node);
1573 if(node.getSemicolon() != null)
1574 {
1575 node.getSemicolon().apply(this);
1576 }
1577 if(node.getImmediate() != null)
1578 {
1579 node.getImmediate().apply(this);
1580 }
1581 if(node.getExitmonitor() != null)
1582 {
1583 node.getExitmonitor().apply(this);
1584 }
1585 outAExitmonitorStatement(node);
1586 }
1587
1588 public void inATableswitchStatement(ATableswitchStatement node)
1589 {
1590 defaultIn(node);
1591 }
1592
1593 public void outATableswitchStatement(ATableswitchStatement node)
1594 {
1595 defaultOut(node);
1596 }
1597
1598 public void caseATableswitchStatement(ATableswitchStatement node)
1599 {
1600 inATableswitchStatement(node);
1601 if(node.getSemicolon() != null)
1602 {
1603 node.getSemicolon().apply(this);
1604 }
1605 if(node.getRBrace() != null)
1606 {
1607 node.getRBrace().apply(this);
1608 }
1609 {
1610 Object temp[] = node.getCaseStmt().toArray();
1611 for(int i = temp.length - 1; i >= 0; i--)
1612 {
1613 ((PCaseStmt) temp[i]).apply(this);
1614 }
1615 }
1616 if(node.getLBrace() != null)
1617 {
1618 node.getLBrace().apply(this);
1619 }
1620 if(node.getRParen() != null)
1621 {
1622 node.getRParen().apply(this);
1623 }
1624 if(node.getImmediate() != null)
1625 {
1626 node.getImmediate().apply(this);
1627 }
1628 if(node.getLParen() != null)
1629 {
1630 node.getLParen().apply(this);
1631 }
1632 if(node.getTableswitch() != null)
1633 {
1634 node.getTableswitch().apply(this);
1635 }
1636 outATableswitchStatement(node);
1637 }
1638
1639 public void inALookupswitchStatement(ALookupswitchStatement node)
1640 {
1641 defaultIn(node);
1642 }
1643
1644 public void outALookupswitchStatement(ALookupswitchStatement node)
1645 {
1646 defaultOut(node);
1647 }
1648
1649 public void caseALookupswitchStatement(ALookupswitchStatement node)
1650 {
1651 inALookupswitchStatement(node);
1652 if(node.getSemicolon() != null)
1653 {
1654 node.getSemicolon().apply(this);
1655 }
1656 if(node.getRBrace() != null)
1657 {
1658 node.getRBrace().apply(this);
1659 }
1660 {
1661 Object temp[] = node.getCaseStmt().toArray();
1662 for(int i = temp.length - 1; i >= 0; i--)
1663 {
1664 ((PCaseStmt) temp[i]).apply(this);
1665 }
1666 }
1667 if(node.getLBrace() != null)
1668 {
1669 node.getLBrace().apply(this);
1670 }
1671 if(node.getRParen() != null)
1672 {
1673 node.getRParen().apply(this);
1674 }
1675 if(node.getImmediate() != null)
1676 {
1677 node.getImmediate().apply(this);
1678 }
1679 if(node.getLParen() != null)
1680 {
1681 node.getLParen().apply(this);
1682 }
1683 if(node.getLookupswitch() != null)
1684 {
1685 node.getLookupswitch().apply(this);
1686 }
1687 outALookupswitchStatement(node);
1688 }
1689
1690 public void inAIdentityStatement(AIdentityStatement node)
1691 {
1692 defaultIn(node);
1693 }
1694
1695 public void outAIdentityStatement(AIdentityStatement node)
1696 {
1697 defaultOut(node);
1698 }
1699
1700 public void caseAIdentityStatement(AIdentityStatement node)
1701 {
1702 inAIdentityStatement(node);
1703 if(node.getSemicolon() != null)
1704 {
1705 node.getSemicolon().apply(this);
1706 }
1707 if(node.getType() != null)
1708 {
1709 node.getType().apply(this);
1710 }
1711 if(node.getAtIdentifier() != null)
1712 {
1713 node.getAtIdentifier().apply(this);
1714 }
1715 if(node.getColonEquals() != null)
1716 {
1717 node.getColonEquals().apply(this);
1718 }
1719 if(node.getLocalName() != null)
1720 {
1721 node.getLocalName().apply(this);
1722 }
1723 outAIdentityStatement(node);
1724 }
1725
1726 public void inAIdentityNoTypeStatement(AIdentityNoTypeStatement node)
1727 {
1728 defaultIn(node);
1729 }
1730
1731 public void outAIdentityNoTypeStatement(AIdentityNoTypeStatement node)
1732 {
1733 defaultOut(node);
1734 }
1735
1736 public void caseAIdentityNoTypeStatement(AIdentityNoTypeStatement node)
1737 {
1738 inAIdentityNoTypeStatement(node);
1739 if(node.getSemicolon() != null)
1740 {
1741 node.getSemicolon().apply(this);
1742 }
1743 if(node.getAtIdentifier() != null)
1744 {
1745 node.getAtIdentifier().apply(this);
1746 }
1747 if(node.getColonEquals() != null)
1748 {
1749 node.getColonEquals().apply(this);
1750 }
1751 if(node.getLocalName() != null)
1752 {
1753 node.getLocalName().apply(this);
1754 }
1755 outAIdentityNoTypeStatement(node);
1756 }
1757
1758 public void inAAssignStatement(AAssignStatement node)
1759 {
1760 defaultIn(node);
1761 }
1762
1763 public void outAAssignStatement(AAssignStatement node)
1764 {
1765 defaultOut(node);
1766 }
1767
1768 public void caseAAssignStatement(AAssignStatement node)
1769 {
1770 inAAssignStatement(node);
1771 if(node.getSemicolon() != null)
1772 {
1773 node.getSemicolon().apply(this);
1774 }
1775 if(node.getExpression() != null)
1776 {
1777 node.getExpression().apply(this);
1778 }
1779 if(node.getEquals() != null)
1780 {
1781 node.getEquals().apply(this);
1782 }
1783 if(node.getVariable() != null)
1784 {
1785 node.getVariable().apply(this);
1786 }
1787 outAAssignStatement(node);
1788 }
1789
1790 public void inAIfStatement(AIfStatement node)
1791 {
1792 defaultIn(node);
1793 }
1794
1795 public void outAIfStatement(AIfStatement node)
1796 {
1797 defaultOut(node);
1798 }
1799
1800 public void caseAIfStatement(AIfStatement node)
1801 {
1802 inAIfStatement(node);
1803 if(node.getGotoStmt() != null)
1804 {
1805 node.getGotoStmt().apply(this);
1806 }
1807 if(node.getBoolExpr() != null)
1808 {
1809 node.getBoolExpr().apply(this);
1810 }
1811 if(node.getIf() != null)
1812 {
1813 node.getIf().apply(this);
1814 }
1815 outAIfStatement(node);
1816 }
1817
1818 public void inAGotoStatement(AGotoStatement node)
1819 {
1820 defaultIn(node);
1821 }
1822
1823 public void outAGotoStatement(AGotoStatement node)
1824 {
1825 defaultOut(node);
1826 }
1827
1828 public void caseAGotoStatement(AGotoStatement node)
1829 {
1830 inAGotoStatement(node);
1831 if(node.getGotoStmt() != null)
1832 {
1833 node.getGotoStmt().apply(this);
1834 }
1835 outAGotoStatement(node);
1836 }
1837
1838 public void inANopStatement(ANopStatement node)
1839 {
1840 defaultIn(node);
1841 }
1842
1843 public void outANopStatement(ANopStatement node)
1844 {
1845 defaultOut(node);
1846 }
1847
1848 public void caseANopStatement(ANopStatement node)
1849 {
1850 inANopStatement(node);
1851 if(node.getSemicolon() != null)
1852 {
1853 node.getSemicolon().apply(this);
1854 }
1855 if(node.getNop() != null)
1856 {
1857 node.getNop().apply(this);
1858 }
1859 outANopStatement(node);
1860 }
1861
1862 public void inARetStatement(ARetStatement node)
1863 {
1864 defaultIn(node);
1865 }
1866
1867 public void outARetStatement(ARetStatement node)
1868 {
1869 defaultOut(node);
1870 }
1871
1872 public void caseARetStatement(ARetStatement node)
1873 {
1874 inARetStatement(node);
1875 if(node.getSemicolon() != null)
1876 {
1877 node.getSemicolon().apply(this);
1878 }
1879 if(node.getImmediate() != null)
1880 {
1881 node.getImmediate().apply(this);
1882 }
1883 if(node.getRet() != null)
1884 {
1885 node.getRet().apply(this);
1886 }
1887 outARetStatement(node);
1888 }
1889
1890 public void inAReturnStatement(AReturnStatement node)
1891 {
1892 defaultIn(node);
1893 }
1894
1895 public void outAReturnStatement(AReturnStatement node)
1896 {
1897 defaultOut(node);
1898 }
1899
1900 public void caseAReturnStatement(AReturnStatement node)
1901 {
1902 inAReturnStatement(node);
1903 if(node.getSemicolon() != null)
1904 {
1905 node.getSemicolon().apply(this);
1906 }
1907 if(node.getImmediate() != null)
1908 {
1909 node.getImmediate().apply(this);
1910 }
1911 if(node.getReturn() != null)
1912 {
1913 node.getReturn().apply(this);
1914 }
1915 outAReturnStatement(node);
1916 }
1917
1918 public void inAThrowStatement(AThrowStatement node)
1919 {
1920 defaultIn(node);
1921 }
1922
1923 public void outAThrowStatement(AThrowStatement node)
1924 {
1925 defaultOut(node);
1926 }
1927
1928 public void caseAThrowStatement(AThrowStatement node)
1929 {
1930 inAThrowStatement(node);
1931 if(node.getSemicolon() != null)
1932 {
1933 node.getSemicolon().apply(this);
1934 }
1935 if(node.getImmediate() != null)
1936 {
1937 node.getImmediate().apply(this);
1938 }
1939 if(node.getThrow() != null)
1940 {
1941 node.getThrow().apply(this);
1942 }
1943 outAThrowStatement(node);
1944 }
1945
1946 public void inAInvokeStatement(AInvokeStatement node)
1947 {
1948 defaultIn(node);
1949 }
1950
1951 public void outAInvokeStatement(AInvokeStatement node)
1952 {
1953 defaultOut(node);
1954 }
1955
1956 public void caseAInvokeStatement(AInvokeStatement node)
1957 {
1958 inAInvokeStatement(node);
1959 if(node.getSemicolon() != null)
1960 {
1961 node.getSemicolon().apply(this);
1962 }
1963 if(node.getInvokeExpr() != null)
1964 {
1965 node.getInvokeExpr().apply(this);
1966 }
1967 outAInvokeStatement(node);
1968 }
1969
1970 public void inALabelName(ALabelName node)
1971 {
1972 defaultIn(node);
1973 }
1974
1975 public void outALabelName(ALabelName node)
1976 {
1977 defaultOut(node);
1978 }
1979
1980 public void caseALabelName(ALabelName node)
1981 {
1982 inALabelName(node);
1983 if(node.getIdentifier() != null)
1984 {
1985 node.getIdentifier().apply(this);
1986 }
1987 outALabelName(node);
1988 }
1989
1990 public void inACaseStmt(ACaseStmt node)
1991 {
1992 defaultIn(node);
1993 }
1994
1995 public void outACaseStmt(ACaseStmt node)
1996 {
1997 defaultOut(node);
1998 }
1999
2000 public void caseACaseStmt(ACaseStmt node)
2001 {
2002 inACaseStmt(node);
2003 if(node.getGotoStmt() != null)
2004 {
2005 node.getGotoStmt().apply(this);
2006 }
2007 if(node.getColon() != null)
2008 {
2009 node.getColon().apply(this);
2010 }
2011 if(node.getCaseLabel() != null)
2012 {
2013 node.getCaseLabel().apply(this);
2014 }
2015 outACaseStmt(node);
2016 }
2017
2018 public void inAConstantCaseLabel(AConstantCaseLabel node)
2019 {
2020 defaultIn(node);
2021 }
2022
2023 public void outAConstantCaseLabel(AConstantCaseLabel node)
2024 {
2025 defaultOut(node);
2026 }
2027
2028 public void caseAConstantCaseLabel(AConstantCaseLabel node)
2029 {
2030 inAConstantCaseLabel(node);
2031 if(node.getIntegerConstant() != null)
2032 {
2033 node.getIntegerConstant().apply(this);
2034 }
2035 if(node.getMinus() != null)
2036 {
2037 node.getMinus().apply(this);
2038 }
2039 if(node.getCase() != null)
2040 {
2041 node.getCase().apply(this);
2042 }
2043 outAConstantCaseLabel(node);
2044 }
2045
2046 public void inADefaultCaseLabel(ADefaultCaseLabel node)
2047 {
2048 defaultIn(node);
2049 }
2050
2051 public void outADefaultCaseLabel(ADefaultCaseLabel node)
2052 {
2053 defaultOut(node);
2054 }
2055
2056 public void caseADefaultCaseLabel(ADefaultCaseLabel node)
2057 {
2058 inADefaultCaseLabel(node);
2059 if(node.getDefault() != null)
2060 {
2061 node.getDefault().apply(this);
2062 }
2063 outADefaultCaseLabel(node);
2064 }
2065
2066 public void inAGotoStmt(AGotoStmt node)
2067 {
2068 defaultIn(node);
2069 }
2070
2071 public void outAGotoStmt(AGotoStmt node)
2072 {
2073 defaultOut(node);
2074 }
2075
2076 public void caseAGotoStmt(AGotoStmt node)
2077 {
2078 inAGotoStmt(node);
2079 if(node.getSemicolon() != null)
2080 {
2081 node.getSemicolon().apply(this);
2082 }
2083 if(node.getLabelName() != null)
2084 {
2085 node.getLabelName().apply(this);
2086 }
2087 if(node.getGoto() != null)
2088 {
2089 node.getGoto().apply(this);
2090 }
2091 outAGotoStmt(node);
2092 }
2093
2094 public void inACatchClause(ACatchClause node)
2095 {
2096 defaultIn(node);
2097 }
2098
2099 public void outACatchClause(ACatchClause node)
2100 {
2101 defaultOut(node);
2102 }
2103
2104 public void caseACatchClause(ACatchClause node)
2105 {
2106 inACatchClause(node);
2107 if(node.getSemicolon() != null)
2108 {
2109 node.getSemicolon().apply(this);
2110 }
2111 if(node.getWithLabel() != null)
2112 {
2113 node.getWithLabel().apply(this);
2114 }
2115 if(node.getWith() != null)
2116 {
2117 node.getWith().apply(this);
2118 }
2119 if(node.getToLabel() != null)
2120 {
2121 node.getToLabel().apply(this);
2122 }
2123 if(node.getTo() != null)
2124 {
2125 node.getTo().apply(this);
2126 }
2127 if(node.getFromLabel() != null)
2128 {
2129 node.getFromLabel().apply(this);
2130 }
2131 if(node.getFrom() != null)
2132 {
2133 node.getFrom().apply(this);
2134 }
2135 if(node.getName() != null)
2136 {
2137 node.getName().apply(this);
2138 }
2139 if(node.getCatch() != null)
2140 {
2141 node.getCatch().apply(this);
2142 }
2143 outACatchClause(node);
2144 }
2145
2146 public void inANewExpression(ANewExpression node)
2147 {
2148 defaultIn(node);
2149 }
2150
2151 public void outANewExpression(ANewExpression node)
2152 {
2153 defaultOut(node);
2154 }
2155
2156 public void caseANewExpression(ANewExpression node)
2157 {
2158 inANewExpression(node);
2159 if(node.getNewExpr() != null)
2160 {
2161 node.getNewExpr().apply(this);
2162 }
2163 outANewExpression(node);
2164 }
2165
2166 public void inACastExpression(ACastExpression node)
2167 {
2168 defaultIn(node);
2169 }
2170
2171 public void outACastExpression(ACastExpression node)
2172 {
2173 defaultOut(node);
2174 }
2175
2176 public void caseACastExpression(ACastExpression node)
2177 {
2178 inACastExpression(node);
2179 if(node.getImmediate() != null)
2180 {
2181 node.getImmediate().apply(this);
2182 }
2183 if(node.getRParen() != null)
2184 {
2185 node.getRParen().apply(this);
2186 }
2187 if(node.getNonvoidType() != null)
2188 {
2189 node.getNonvoidType().apply(this);
2190 }
2191 if(node.getLParen() != null)
2192 {
2193 node.getLParen().apply(this);
2194 }
2195 outACastExpression(node);
2196 }
2197
2198 public void inAInstanceofExpression(AInstanceofExpression node)
2199 {
2200 defaultIn(node);
2201 }
2202
2203 public void outAInstanceofExpression(AInstanceofExpression node)
2204 {
2205 defaultOut(node);
2206 }
2207
2208 public void caseAInstanceofExpression(AInstanceofExpression node)
2209 {
2210 inAInstanceofExpression(node);
2211 if(node.getNonvoidType() != null)
2212 {
2213 node.getNonvoidType().apply(this);
2214 }
2215 if(node.getInstanceof() != null)
2216 {
2217 node.getInstanceof().apply(this);
2218 }
2219 if(node.getImmediate() != null)
2220 {
2221 node.getImmediate().apply(this);
2222 }
2223 outAInstanceofExpression(node);
2224 }
2225
2226 public void inAInvokeExpression(AInvokeExpression node)
2227 {
2228 defaultIn(node);
2229 }
2230
2231 public void outAInvokeExpression(AInvokeExpression node)
2232 {
2233 defaultOut(node);
2234 }
2235
2236 public void caseAInvokeExpression(AInvokeExpression node)
2237 {
2238 inAInvokeExpression(node);
2239 if(node.getInvokeExpr() != null)
2240 {
2241 node.getInvokeExpr().apply(this);
2242 }
2243 outAInvokeExpression(node);
2244 }
2245
2246 public void inAReferenceExpression(AReferenceExpression node)
2247 {
2248 defaultIn(node);
2249 }
2250
2251 public void outAReferenceExpression(AReferenceExpression node)
2252 {
2253 defaultOut(node);
2254 }
2255
2256 public void caseAReferenceExpression(AReferenceExpression node)
2257 {
2258 inAReferenceExpression(node);
2259 if(node.getReference() != null)
2260 {
2261 node.getReference().apply(this);
2262 }
2263 outAReferenceExpression(node);
2264 }
2265
2266 public void inABinopExpression(ABinopExpression node)
2267 {
2268 defaultIn(node);
2269 }
2270
2271 public void outABinopExpression(ABinopExpression node)
2272 {
2273 defaultOut(node);
2274 }
2275
2276 public void caseABinopExpression(ABinopExpression node)
2277 {
2278 inABinopExpression(node);
2279 if(node.getBinopExpr() != null)
2280 {
2281 node.getBinopExpr().apply(this);
2282 }
2283 outABinopExpression(node);
2284 }
2285
2286 public void inAUnopExpression(AUnopExpression node)
2287 {
2288 defaultIn(node);
2289 }
2290
2291 public void outAUnopExpression(AUnopExpression node)
2292 {
2293 defaultOut(node);
2294 }
2295
2296 public void caseAUnopExpression(AUnopExpression node)
2297 {
2298 inAUnopExpression(node);
2299 if(node.getUnopExpr() != null)
2300 {
2301 node.getUnopExpr().apply(this);
2302 }
2303 outAUnopExpression(node);
2304 }
2305
2306 public void inAImmediateExpression(AImmediateExpression node)
2307 {
2308 defaultIn(node);
2309 }
2310
2311 public void outAImmediateExpression(AImmediateExpression node)
2312 {
2313 defaultOut(node);
2314 }
2315
2316 public void caseAImmediateExpression(AImmediateExpression node)
2317 {
2318 inAImmediateExpression(node);
2319 if(node.getImmediate() != null)
2320 {
2321 node.getImmediate().apply(this);
2322 }
2323 outAImmediateExpression(node);
2324 }
2325
2326 public void inASimpleNewExpr(ASimpleNewExpr node)
2327 {
2328 defaultIn(node);
2329 }
2330
2331 public void outASimpleNewExpr(ASimpleNewExpr node)
2332 {
2333 defaultOut(node);
2334 }
2335
2336 public void caseASimpleNewExpr(ASimpleNewExpr node)
2337 {
2338 inASimpleNewExpr(node);
2339 if(node.getBaseType() != null)
2340 {
2341 node.getBaseType().apply(this);
2342 }
2343 if(node.getNew() != null)
2344 {
2345 node.getNew().apply(this);
2346 }
2347 outASimpleNewExpr(node);
2348 }
2349
2350 public void inAArrayNewExpr(AArrayNewExpr node)
2351 {
2352 defaultIn(node);
2353 }
2354
2355 public void outAArrayNewExpr(AArrayNewExpr node)
2356 {
2357 defaultOut(node);
2358 }
2359
2360 public void caseAArrayNewExpr(AArrayNewExpr node)
2361 {
2362 inAArrayNewExpr(node);
2363 if(node.getFixedArrayDescriptor() != null)
2364 {
2365 node.getFixedArrayDescriptor().apply(this);
2366 }
2367 if(node.getRParen() != null)
2368 {
2369 node.getRParen().apply(this);
2370 }
2371 if(node.getNonvoidType() != null)
2372 {
2373 node.getNonvoidType().apply(this);
2374 }
2375 if(node.getLParen() != null)
2376 {
2377 node.getLParen().apply(this);
2378 }
2379 if(node.getNewarray() != null)
2380 {
2381 node.getNewarray().apply(this);
2382 }
2383 outAArrayNewExpr(node);
2384 }
2385
2386 public void inAMultiNewExpr(AMultiNewExpr node)
2387 {
2388 defaultIn(node);
2389 }
2390
2391 public void outAMultiNewExpr(AMultiNewExpr node)
2392 {
2393 defaultOut(node);
2394 }
2395
2396 public void caseAMultiNewExpr(AMultiNewExpr node)
2397 {
2398 inAMultiNewExpr(node);
2399 {
2400 Object temp[] = node.getArrayDescriptor().toArray();
2401 for(int i = temp.length - 1; i >= 0; i--)
2402 {
2403 ((PArrayDescriptor) temp[i]).apply(this);
2404 }
2405 }
2406 if(node.getRParen() != null)
2407 {
2408 node.getRParen().apply(this);
2409 }
2410 if(node.getBaseType() != null)
2411 {
2412 node.getBaseType().apply(this);
2413 }
2414 if(node.getLParen() != null)
2415 {
2416 node.getLParen().apply(this);
2417 }
2418 if(node.getNewmultiarray() != null)
2419 {
2420 node.getNewmultiarray().apply(this);
2421 }
2422 outAMultiNewExpr(node);
2423 }
2424
2425 public void inAArrayDescriptor(AArrayDescriptor node)
2426 {
2427 defaultIn(node);
2428 }
2429
2430 public void outAArrayDescriptor(AArrayDescriptor node)
2431 {
2432 defaultOut(node);
2433 }
2434
2435 public void caseAArrayDescriptor(AArrayDescriptor node)
2436 {
2437 inAArrayDescriptor(node);
2438 if(node.getRBracket() != null)
2439 {
2440 node.getRBracket().apply(this);
2441 }
2442 if(node.getImmediate() != null)
2443 {
2444 node.getImmediate().apply(this);
2445 }
2446 if(node.getLBracket() != null)
2447 {
2448 node.getLBracket().apply(this);
2449 }
2450 outAArrayDescriptor(node);
2451 }
2452
2453 public void inAReferenceVariable(AReferenceVariable node)
2454 {
2455 defaultIn(node);
2456 }
2457
2458 public void outAReferenceVariable(AReferenceVariable node)
2459 {
2460 defaultOut(node);
2461 }
2462
2463 public void caseAReferenceVariable(AReferenceVariable node)
2464 {
2465 inAReferenceVariable(node);
2466 if(node.getReference() != null)
2467 {
2468 node.getReference().apply(this);
2469 }
2470 outAReferenceVariable(node);
2471 }
2472
2473 public void inALocalVariable(ALocalVariable node)
2474 {
2475 defaultIn(node);
2476 }
2477
2478 public void outALocalVariable(ALocalVariable node)
2479 {
2480 defaultOut(node);
2481 }
2482
2483 public void caseALocalVariable(ALocalVariable node)
2484 {
2485 inALocalVariable(node);
2486 if(node.getLocalName() != null)
2487 {
2488 node.getLocalName().apply(this);
2489 }
2490 outALocalVariable(node);
2491 }
2492
2493 public void inABinopBoolExpr(ABinopBoolExpr node)
2494 {
2495 defaultIn(node);
2496 }
2497
2498 public void outABinopBoolExpr(ABinopBoolExpr node)
2499 {
2500 defaultOut(node);
2501 }
2502
2503 public void caseABinopBoolExpr(ABinopBoolExpr node)
2504 {
2505 inABinopBoolExpr(node);
2506 if(node.getBinopExpr() != null)
2507 {
2508 node.getBinopExpr().apply(this);
2509 }
2510 outABinopBoolExpr(node);
2511 }
2512
2513 public void inAUnopBoolExpr(AUnopBoolExpr node)
2514 {
2515 defaultIn(node);
2516 }
2517
2518 public void outAUnopBoolExpr(AUnopBoolExpr node)
2519 {
2520 defaultOut(node);
2521 }
2522
2523 public void caseAUnopBoolExpr(AUnopBoolExpr node)
2524 {
2525 inAUnopBoolExpr(node);
2526 if(node.getUnopExpr() != null)
2527 {
2528 node.getUnopExpr().apply(this);
2529 }
2530 outAUnopBoolExpr(node);
2531 }
2532
2533 public void inANonstaticInvokeExpr(ANonstaticInvokeExpr node)
2534 {
2535 defaultIn(node);
2536 }
2537
2538 public void outANonstaticInvokeExpr(ANonstaticInvokeExpr node)
2539 {
2540 defaultOut(node);
2541 }
2542
2543 public void caseANonstaticInvokeExpr(ANonstaticInvokeExpr node)
2544 {
2545 inANonstaticInvokeExpr(node);
2546 if(node.getRParen() != null)
2547 {
2548 node.getRParen().apply(this);
2549 }
2550 if(node.getArgList() != null)
2551 {
2552 node.getArgList().apply(this);
2553 }
2554 if(node.getLParen() != null)
2555 {
2556 node.getLParen().apply(this);
2557 }
2558 if(node.getMethodSignature() != null)
2559 {
2560 node.getMethodSignature().apply(this);
2561 }
2562 if(node.getDot() != null)
2563 {
2564 node.getDot().apply(this);
2565 }
2566 if(node.getLocalName() != null)
2567 {
2568 node.getLocalName().apply(this);
2569 }
2570 if(node.getNonstaticInvoke() != null)
2571 {
2572 node.getNonstaticInvoke().apply(this);
2573 }
2574 outANonstaticInvokeExpr(node);
2575 }
2576
2577 public void inAStaticInvokeExpr(AStaticInvokeExpr node)
2578 {
2579 defaultIn(node);
2580 }
2581
2582 public void outAStaticInvokeExpr(AStaticInvokeExpr node)
2583 {
2584 defaultOut(node);
2585 }
2586
2587 public void caseAStaticInvokeExpr(AStaticInvokeExpr node)
2588 {
2589 inAStaticInvokeExpr(node);
2590 if(node.getRParen() != null)
2591 {
2592 node.getRParen().apply(this);
2593 }
2594 if(node.getArgList() != null)
2595 {
2596 node.getArgList().apply(this);
2597 }
2598 if(node.getLParen() != null)
2599 {
2600 node.getLParen().apply(this);
2601 }
2602 if(node.getMethodSignature() != null)
2603 {
2604 node.getMethodSignature().apply(this);
2605 }
2606 if(node.getStaticinvoke() != null)
2607 {
2608 node.getStaticinvoke().apply(this);
2609 }
2610 outAStaticInvokeExpr(node);
2611 }
2612
2613 public void inABinopExpr(ABinopExpr node)
2614 {
2615 defaultIn(node);
2616 }
2617
2618 public void outABinopExpr(ABinopExpr node)
2619 {
2620 defaultOut(node);
2621 }
2622
2623 public void caseABinopExpr(ABinopExpr node)
2624 {
2625 inABinopExpr(node);
2626 if(node.getRight() != null)
2627 {
2628 node.getRight().apply(this);
2629 }
2630 if(node.getBinop() != null)
2631 {
2632 node.getBinop().apply(this);
2633 }
2634 if(node.getLeft() != null)
2635 {
2636 node.getLeft().apply(this);
2637 }
2638 outABinopExpr(node);
2639 }
2640
2641 public void inAUnopExpr(AUnopExpr node)
2642 {
2643 defaultIn(node);
2644 }
2645
2646 public void outAUnopExpr(AUnopExpr node)
2647 {
2648 defaultOut(node);
2649 }
2650
2651 public void caseAUnopExpr(AUnopExpr node)
2652 {
2653 inAUnopExpr(node);
2654 if(node.getImmediate() != null)
2655 {
2656 node.getImmediate().apply(this);
2657 }
2658 if(node.getUnop() != null)
2659 {
2660 node.getUnop().apply(this);
2661 }
2662 outAUnopExpr(node);
2663 }
2664
2665 public void inASpecialNonstaticInvoke(ASpecialNonstaticInvoke node)
2666 {
2667 defaultIn(node);
2668 }
2669
2670 public void outASpecialNonstaticInvoke(ASpecialNonstaticInvoke node)
2671 {
2672 defaultOut(node);
2673 }
2674
2675 public void caseASpecialNonstaticInvoke(ASpecialNonstaticInvoke node)
2676 {
2677 inASpecialNonstaticInvoke(node);
2678 if(node.getSpecialinvoke() != null)
2679 {
2680 node.getSpecialinvoke().apply(this);
2681 }
2682 outASpecialNonstaticInvoke(node);
2683 }
2684
2685 public void inAVirtualNonstaticInvoke(AVirtualNonstaticInvoke node)
2686 {
2687 defaultIn(node);
2688 }
2689
2690 public void outAVirtualNonstaticInvoke(AVirtualNonstaticInvoke node)
2691 {
2692 defaultOut(node);
2693 }
2694
2695 public void caseAVirtualNonstaticInvoke(AVirtualNonstaticInvoke node)
2696 {
2697 inAVirtualNonstaticInvoke(node);
2698 if(node.getVirtualinvoke() != null)
2699 {
2700 node.getVirtualinvoke().apply(this);
2701 }
2702 outAVirtualNonstaticInvoke(node);
2703 }
2704
2705 public void inAInterfaceNonstaticInvoke(AInterfaceNonstaticInvoke node)
2706 {
2707 defaultIn(node);
2708 }
2709
2710 public void outAInterfaceNonstaticInvoke(AInterfaceNonstaticInvoke node)
2711 {
2712 defaultOut(node);
2713 }
2714
2715 public void caseAInterfaceNonstaticInvoke(AInterfaceNonstaticInvoke node)
2716 {
2717 inAInterfaceNonstaticInvoke(node);
2718 if(node.getInterfaceinvoke() != null)
2719 {
2720 node.getInterfaceinvoke().apply(this);
2721 }
2722 outAInterfaceNonstaticInvoke(node);
2723 }
2724
2725 public void inAMethodSignature(AMethodSignature node)
2726 {
2727 defaultIn(node);
2728 }
2729
2730 public void outAMethodSignature(AMethodSignature node)
2731 {
2732 defaultOut(node);
2733 }
2734
2735 public void caseAMethodSignature(AMethodSignature node)
2736 {
2737 inAMethodSignature(node);
2738 if(node.getCmpgt() != null)
2739 {
2740 node.getCmpgt().apply(this);
2741 }
2742 if(node.getRParen() != null)
2743 {
2744 node.getRParen().apply(this);
2745 }
2746 if(node.getParameterList() != null)
2747 {
2748 node.getParameterList().apply(this);
2749 }
2750 if(node.getLParen() != null)
2751 {
2752 node.getLParen().apply(this);
2753 }
2754 if(node.getMethodName() != null)
2755 {
2756 node.getMethodName().apply(this);
2757 }
2758 if(node.getType() != null)
2759 {
2760 node.getType().apply(this);
2761 }
2762 if(node.getFirst() != null)
2763 {
2764 node.getFirst().apply(this);
2765 }
2766 if(node.getClassName() != null)
2767 {
2768 node.getClassName().apply(this);
2769 }
2770 if(node.getCmplt() != null)
2771 {
2772 node.getCmplt().apply(this);
2773 }
2774 outAMethodSignature(node);
2775 }
2776
2777 public void inAArrayReference(AArrayReference node)
2778 {
2779 defaultIn(node);
2780 }
2781
2782 public void outAArrayReference(AArrayReference node)
2783 {
2784 defaultOut(node);
2785 }
2786
2787 public void caseAArrayReference(AArrayReference node)
2788 {
2789 inAArrayReference(node);
2790 if(node.getArrayRef() != null)
2791 {
2792 node.getArrayRef().apply(this);
2793 }
2794 outAArrayReference(node);
2795 }
2796
2797 public void inAFieldReference(AFieldReference node)
2798 {
2799 defaultIn(node);
2800 }
2801
2802 public void outAFieldReference(AFieldReference node)
2803 {
2804 defaultOut(node);
2805 }
2806
2807 public void caseAFieldReference(AFieldReference node)
2808 {
2809 inAFieldReference(node);
2810 if(node.getFieldRef() != null)
2811 {
2812 node.getFieldRef().apply(this);
2813 }
2814 outAFieldReference(node);
2815 }
2816
2817 public void inAArrayRef(AArrayRef node)
2818 {
2819 defaultIn(node);
2820 }
2821
2822 public void outAArrayRef(AArrayRef node)
2823 {
2824 defaultOut(node);
2825 }
2826
2827 public void caseAArrayRef(AArrayRef node)
2828 {
2829 inAArrayRef(node);
2830 if(node.getFixedArrayDescriptor() != null)
2831 {
2832 node.getFixedArrayDescriptor().apply(this);
2833 }
2834 if(node.getIdentifier() != null)
2835 {
2836 node.getIdentifier().apply(this);
2837 }
2838 outAArrayRef(node);
2839 }
2840
2841 public void inALocalFieldRef(ALocalFieldRef node)
2842 {
2843 defaultIn(node);
2844 }
2845
2846 public void outALocalFieldRef(ALocalFieldRef node)
2847 {
2848 defaultOut(node);
2849 }
2850
2851 public void caseALocalFieldRef(ALocalFieldRef node)
2852 {
2853 inALocalFieldRef(node);
2854 if(node.getFieldSignature() != null)
2855 {
2856 node.getFieldSignature().apply(this);
2857 }
2858 if(node.getDot() != null)
2859 {
2860 node.getDot().apply(this);
2861 }
2862 if(node.getLocalName() != null)
2863 {
2864 node.getLocalName().apply(this);
2865 }
2866 outALocalFieldRef(node);
2867 }
2868
2869 public void inASigFieldRef(ASigFieldRef node)
2870 {
2871 defaultIn(node);
2872 }
2873
2874 public void outASigFieldRef(ASigFieldRef node)
2875 {
2876 defaultOut(node);
2877 }
2878
2879 public void caseASigFieldRef(ASigFieldRef node)
2880 {
2881 inASigFieldRef(node);
2882 if(node.getFieldSignature() != null)
2883 {
2884 node.getFieldSignature().apply(this);
2885 }
2886 outASigFieldRef(node);
2887 }
2888
2889 public void inAFieldSignature(AFieldSignature node)
2890 {
2891 defaultIn(node);
2892 }
2893
2894 public void outAFieldSignature(AFieldSignature node)
2895 {
2896 defaultOut(node);
2897 }
2898
2899 public void caseAFieldSignature(AFieldSignature node)
2900 {
2901 inAFieldSignature(node);
2902 if(node.getCmpgt() != null)
2903 {
2904 node.getCmpgt().apply(this);
2905 }
2906 if(node.getFieldName() != null)
2907 {
2908 node.getFieldName().apply(this);
2909 }
2910 if(node.getType() != null)
2911 {
2912 node.getType().apply(this);
2913 }
2914 if(node.getFirst() != null)
2915 {
2916 node.getFirst().apply(this);
2917 }
2918 if(node.getClassName() != null)
2919 {
2920 node.getClassName().apply(this);
2921 }
2922 if(node.getCmplt() != null)
2923 {
2924 node.getCmplt().apply(this);
2925 }
2926 outAFieldSignature(node);
2927 }
2928
2929 public void inAFixedArrayDescriptor(AFixedArrayDescriptor node)
2930 {
2931 defaultIn(node);
2932 }
2933
2934 public void outAFixedArrayDescriptor(AFixedArrayDescriptor node)
2935 {
2936 defaultOut(node);
2937 }
2938
2939 public void caseAFixedArrayDescriptor(AFixedArrayDescriptor node)
2940 {
2941 inAFixedArrayDescriptor(node);
2942 if(node.getRBracket() != null)
2943 {
2944 node.getRBracket().apply(this);
2945 }
2946 if(node.getImmediate() != null)
2947 {
2948 node.getImmediate().apply(this);
2949 }
2950 if(node.getLBracket() != null)
2951 {
2952 node.getLBracket().apply(this);
2953 }
2954 outAFixedArrayDescriptor(node);
2955 }
2956
2957 public void inASingleArgList(ASingleArgList node)
2958 {
2959 defaultIn(node);
2960 }
2961
2962 public void outASingleArgList(ASingleArgList node)
2963 {
2964 defaultOut(node);
2965 }
2966
2967 public void caseASingleArgList(ASingleArgList node)
2968 {
2969 inASingleArgList(node);
2970 if(node.getImmediate() != null)
2971 {
2972 node.getImmediate().apply(this);
2973 }
2974 outASingleArgList(node);
2975 }
2976
2977 public void inAMultiArgList(AMultiArgList node)
2978 {
2979 defaultIn(node);
2980 }
2981
2982 public void outAMultiArgList(AMultiArgList node)
2983 {
2984 defaultOut(node);
2985 }
2986
2987 public void caseAMultiArgList(AMultiArgList node)
2988 {
2989 inAMultiArgList(node);
2990 if(node.getArgList() != null)
2991 {
2992 node.getArgList().apply(this);
2993 }
2994 if(node.getComma() != null)
2995 {
2996 node.getComma().apply(this);
2997 }
2998 if(node.getImmediate() != null)
2999 {
3000 node.getImmediate().apply(this);
3001 }
3002 outAMultiArgList(node);
3003 }
3004
3005 public void inALocalImmediate(ALocalImmediate node)
3006 {
3007 defaultIn(node);
3008 }
3009
3010 public void outALocalImmediate(ALocalImmediate node)
3011 {
3012 defaultOut(node);
3013 }
3014
3015 public void caseALocalImmediate(ALocalImmediate node)
3016 {
3017 inALocalImmediate(node);
3018 if(node.getLocalName() != null)
3019 {
3020 node.getLocalName().apply(this);
3021 }
3022 outALocalImmediate(node);
3023 }
3024
3025 public void inAConstantImmediate(AConstantImmediate node)
3026 {
3027 defaultIn(node);
3028 }
3029
3030 public void outAConstantImmediate(AConstantImmediate node)
3031 {
3032 defaultOut(node);
3033 }
3034
3035 public void caseAConstantImmediate(AConstantImmediate node)
3036 {
3037 inAConstantImmediate(node);
3038 if(node.getConstant() != null)
3039 {
3040 node.getConstant().apply(this);
3041 }
3042 outAConstantImmediate(node);
3043 }
3044
3045 public void inAIntegerConstant(AIntegerConstant node)
3046 {
3047 defaultIn(node);
3048 }
3049
3050 public void outAIntegerConstant(AIntegerConstant node)
3051 {
3052 defaultOut(node);
3053 }
3054
3055 public void caseAIntegerConstant(AIntegerConstant node)
3056 {
3057 inAIntegerConstant(node);
3058 if(node.getIntegerConstant() != null)
3059 {
3060 node.getIntegerConstant().apply(this);
3061 }
3062 if(node.getMinus() != null)
3063 {
3064 node.getMinus().apply(this);
3065 }
3066 outAIntegerConstant(node);
3067 }
3068
3069 public void inAFloatConstant(AFloatConstant node)
3070 {
3071 defaultIn(node);
3072 }
3073
3074 public void outAFloatConstant(AFloatConstant node)
3075 {
3076 defaultOut(node);
3077 }
3078
3079 public void caseAFloatConstant(AFloatConstant node)
3080 {
3081 inAFloatConstant(node);
3082 if(node.getFloatConstant() != null)
3083 {
3084 node.getFloatConstant().apply(this);
3085 }
3086 if(node.getMinus() != null)
3087 {
3088 node.getMinus().apply(this);
3089 }
3090 outAFloatConstant(node);
3091 }
3092
3093 public void inAStringConstant(AStringConstant node)
3094 {
3095 defaultIn(node);
3096 }
3097
3098 public void outAStringConstant(AStringConstant node)
3099 {
3100 defaultOut(node);
3101 }
3102
3103 public void caseAStringConstant(AStringConstant node)
3104 {
3105 inAStringConstant(node);
3106 if(node.getStringConstant() != null)
3107 {
3108 node.getStringConstant().apply(this);
3109 }
3110 outAStringConstant(node);
3111 }
3112
3113 public void inAClzzConstant(AClzzConstant node)
3114 {
3115 defaultIn(node);
3116 }
3117
3118 public void outAClzzConstant(AClzzConstant node)
3119 {
3120 defaultOut(node);
3121 }
3122
3123 public void caseAClzzConstant(AClzzConstant node)
3124 {
3125 inAClzzConstant(node);
3126 if(node.getStringConstant() != null)
3127 {
3128 node.getStringConstant().apply(this);
3129 }
3130 if(node.getId() != null)
3131 {
3132 node.getId().apply(this);
3133 }
3134 outAClzzConstant(node);
3135 }
3136
3137 public void inANullConstant(ANullConstant node)
3138 {
3139 defaultIn(node);
3140 }
3141
3142 public void outANullConstant(ANullConstant node)
3143 {
3144 defaultOut(node);
3145 }
3146
3147 public void caseANullConstant(ANullConstant node)
3148 {
3149 inANullConstant(node);
3150 if(node.getNull() != null)
3151 {
3152 node.getNull().apply(this);
3153 }
3154 outANullConstant(node);
3155 }
3156
3157 public void inAAndBinop(AAndBinop node)
3158 {
3159 defaultIn(node);
3160 }
3161
3162 public void outAAndBinop(AAndBinop node)
3163 {
3164 defaultOut(node);
3165 }
3166
3167 public void caseAAndBinop(AAndBinop node)
3168 {
3169 inAAndBinop(node);
3170 if(node.getAnd() != null)
3171 {
3172 node.getAnd().apply(this);
3173 }
3174 outAAndBinop(node);
3175 }
3176
3177 public void inAOrBinop(AOrBinop node)
3178 {
3179 defaultIn(node);
3180 }
3181
3182 public void outAOrBinop(AOrBinop node)
3183 {
3184 defaultOut(node);
3185 }
3186
3187 public void caseAOrBinop(AOrBinop node)
3188 {
3189 inAOrBinop(node);
3190 if(node.getOr() != null)
3191 {
3192 node.getOr().apply(this);
3193 }
3194 outAOrBinop(node);
3195 }
3196
3197 public void inAXorBinop(AXorBinop node)
3198 {
3199 defaultIn(node);
3200 }
3201
3202 public void outAXorBinop(AXorBinop node)
3203 {
3204 defaultOut(node);
3205 }
3206
3207 public void caseAXorBinop(AXorBinop node)
3208 {
3209 inAXorBinop(node);
3210 if(node.getXor() != null)
3211 {
3212 node.getXor().apply(this);
3213 }
3214 outAXorBinop(node);
3215 }
3216
3217 public void inAModBinop(AModBinop node)
3218 {
3219 defaultIn(node);
3220 }
3221
3222 public void outAModBinop(AModBinop node)
3223 {
3224 defaultOut(node);
3225 }
3226
3227 public void caseAModBinop(AModBinop node)
3228 {
3229 inAModBinop(node);
3230 if(node.getMod() != null)
3231 {
3232 node.getMod().apply(this);
3233 }
3234 outAModBinop(node);
3235 }
3236
3237 public void inACmpBinop(ACmpBinop node)
3238 {
3239 defaultIn(node);
3240 }
3241
3242 public void outACmpBinop(ACmpBinop node)
3243 {
3244 defaultOut(node);
3245 }
3246
3247 public void caseACmpBinop(ACmpBinop node)
3248 {
3249 inACmpBinop(node);
3250 if(node.getCmp() != null)
3251 {
3252 node.getCmp().apply(this);
3253 }
3254 outACmpBinop(node);
3255 }
3256
3257 public void inACmpgBinop(ACmpgBinop node)
3258 {
3259 defaultIn(node);
3260 }
3261
3262 public void outACmpgBinop(ACmpgBinop node)
3263 {
3264 defaultOut(node);
3265 }
3266
3267 public void caseACmpgBinop(ACmpgBinop node)
3268 {
3269 inACmpgBinop(node);
3270 if(node.getCmpg() != null)
3271 {
3272 node.getCmpg().apply(this);
3273 }
3274 outACmpgBinop(node);
3275 }
3276
3277 public void inACmplBinop(ACmplBinop node)
3278 {
3279 defaultIn(node);
3280 }
3281
3282 public void outACmplBinop(ACmplBinop node)
3283 {
3284 defaultOut(node);
3285 }
3286
3287 public void caseACmplBinop(ACmplBinop node)
3288 {
3289 inACmplBinop(node);
3290 if(node.getCmpl() != null)
3291 {
3292 node.getCmpl().apply(this);
3293 }
3294 outACmplBinop(node);
3295 }
3296
3297 public void inACmpeqBinop(ACmpeqBinop node)
3298 {
3299 defaultIn(node);
3300 }
3301
3302 public void outACmpeqBinop(ACmpeqBinop node)
3303 {
3304 defaultOut(node);
3305 }
3306
3307 public void caseACmpeqBinop(ACmpeqBinop node)
3308 {
3309 inACmpeqBinop(node);
3310 if(node.getCmpeq() != null)
3311 {
3312 node.getCmpeq().apply(this);
3313 }
3314 outACmpeqBinop(node);
3315 }
3316
3317 public void inACmpneBinop(ACmpneBinop node)
3318 {
3319 defaultIn(node);
3320 }
3321
3322 public void outACmpneBinop(ACmpneBinop node)
3323 {
3324 defaultOut(node);
3325 }
3326
3327 public void caseACmpneBinop(ACmpneBinop node)
3328 {
3329 inACmpneBinop(node);
3330 if(node.getCmpne() != null)
3331 {
3332 node.getCmpne().apply(this);
3333 }
3334 outACmpneBinop(node);
3335 }
3336
3337 public void inACmpgtBinop(ACmpgtBinop node)
3338 {
3339 defaultIn(node);
3340 }
3341
3342 public void outACmpgtBinop(ACmpgtBinop node)
3343 {
3344 defaultOut(node);
3345 }
3346
3347 public void caseACmpgtBinop(ACmpgtBinop node)
3348 {
3349 inACmpgtBinop(node);
3350 if(node.getCmpgt() != null)
3351 {
3352 node.getCmpgt().apply(this);
3353 }
3354 outACmpgtBinop(node);
3355 }
3356
3357 public void inACmpgeBinop(ACmpgeBinop node)
3358 {
3359 defaultIn(node);
3360 }
3361
3362 public void outACmpgeBinop(ACmpgeBinop node)
3363 {
3364 defaultOut(node);
3365 }
3366
3367 public void caseACmpgeBinop(ACmpgeBinop node)
3368 {
3369 inACmpgeBinop(node);
3370 if(node.getCmpge() != null)
3371 {
3372 node.getCmpge().apply(this);
3373 }
3374 outACmpgeBinop(node);
3375 }
3376
3377 public void inACmpltBinop(ACmpltBinop node)
3378 {
3379 defaultIn(node);
3380 }
3381
3382 public void outACmpltBinop(ACmpltBinop node)
3383 {
3384 defaultOut(node);
3385 }
3386
3387 public void caseACmpltBinop(ACmpltBinop node)
3388 {
3389 inACmpltBinop(node);
3390 if(node.getCmplt() != null)
3391 {
3392 node.getCmplt().apply(this);
3393 }
3394 outACmpltBinop(node);
3395 }
3396
3397 public void inACmpleBinop(ACmpleBinop node)
3398 {
3399 defaultIn(node);
3400 }
3401
3402 public void outACmpleBinop(ACmpleBinop node)
3403 {
3404 defaultOut(node);
3405 }
3406
3407 public void caseACmpleBinop(ACmpleBinop node)
3408 {
3409 inACmpleBinop(node);
3410 if(node.getCmple() != null)
3411 {
3412 node.getCmple().apply(this);
3413 }
3414 outACmpleBinop(node);
3415 }
3416
3417 public void inAShlBinop(AShlBinop node)
3418 {
3419 defaultIn(node);
3420 }
3421
3422 public void outAShlBinop(AShlBinop node)
3423 {
3424 defaultOut(node);
3425 }
3426
3427 public void caseAShlBinop(AShlBinop node)
3428 {
3429 inAShlBinop(node);
3430 if(node.getShl() != null)
3431 {
3432 node.getShl().apply(this);
3433 }
3434 outAShlBinop(node);
3435 }
3436
3437 public void inAShrBinop(AShrBinop node)
3438 {
3439 defaultIn(node);
3440 }
3441
3442 public void outAShrBinop(AShrBinop node)
3443 {
3444 defaultOut(node);
3445 }
3446
3447 public void caseAShrBinop(AShrBinop node)
3448 {
3449 inAShrBinop(node);
3450 if(node.getShr() != null)
3451 {
3452 node.getShr().apply(this);
3453 }
3454 outAShrBinop(node);
3455 }
3456
3457 public void inAUshrBinop(AUshrBinop node)
3458 {
3459 defaultIn(node);
3460 }
3461
3462 public void outAUshrBinop(AUshrBinop node)
3463 {
3464 defaultOut(node);
3465 }
3466
3467 public void caseAUshrBinop(AUshrBinop node)
3468 {
3469 inAUshrBinop(node);
3470 if(node.getUshr() != null)
3471 {
3472 node.getUshr().apply(this);
3473 }
3474 outAUshrBinop(node);
3475 }
3476
3477 public void inAPlusBinop(APlusBinop node)
3478 {
3479 defaultIn(node);
3480 }
3481
3482 public void outAPlusBinop(APlusBinop node)
3483 {
3484 defaultOut(node);
3485 }
3486
3487 public void caseAPlusBinop(APlusBinop node)
3488 {
3489 inAPlusBinop(node);
3490 if(node.getPlus() != null)
3491 {
3492 node.getPlus().apply(this);
3493 }
3494 outAPlusBinop(node);
3495 }
3496
3497 public void inAMinusBinop(AMinusBinop node)
3498 {
3499 defaultIn(node);
3500 }
3501
3502 public void outAMinusBinop(AMinusBinop node)
3503 {
3504 defaultOut(node);
3505 }
3506
3507 public void caseAMinusBinop(AMinusBinop node)
3508 {
3509 inAMinusBinop(node);
3510 if(node.getMinus() != null)
3511 {
3512 node.getMinus().apply(this);
3513 }
3514 outAMinusBinop(node);
3515 }
3516
3517 public void inAMultBinop(AMultBinop node)
3518 {
3519 defaultIn(node);
3520 }
3521
3522 public void outAMultBinop(AMultBinop node)
3523 {
3524 defaultOut(node);
3525 }
3526
3527 public void caseAMultBinop(AMultBinop node)
3528 {
3529 inAMultBinop(node);
3530 if(node.getMult() != null)
3531 {
3532 node.getMult().apply(this);
3533 }
3534 outAMultBinop(node);
3535 }
3536
3537 public void inADivBinop(ADivBinop node)
3538 {
3539 defaultIn(node);
3540 }
3541
3542 public void outADivBinop(ADivBinop node)
3543 {
3544 defaultOut(node);
3545 }
3546
3547 public void caseADivBinop(ADivBinop node)
3548 {
3549 inADivBinop(node);
3550 if(node.getDiv() != null)
3551 {
3552 node.getDiv().apply(this);
3553 }
3554 outADivBinop(node);
3555 }
3556
3557 public void inALengthofUnop(ALengthofUnop node)
3558 {
3559 defaultIn(node);
3560 }
3561
3562 public void outALengthofUnop(ALengthofUnop node)
3563 {
3564 defaultOut(node);
3565 }
3566
3567 public void caseALengthofUnop(ALengthofUnop node)
3568 {
3569 inALengthofUnop(node);
3570 if(node.getLengthof() != null)
3571 {
3572 node.getLengthof().apply(this);
3573 }
3574 outALengthofUnop(node);
3575 }
3576
3577 public void inANegUnop(ANegUnop node)
3578 {
3579 defaultIn(node);
3580 }
3581
3582 public void outANegUnop(ANegUnop node)
3583 {
3584 defaultOut(node);
3585 }
3586
3587 public void caseANegUnop(ANegUnop node)
3588 {
3589 inANegUnop(node);
3590 if(node.getNeg() != null)
3591 {
3592 node.getNeg().apply(this);
3593 }
3594 outANegUnop(node);
3595 }
3596
3597 public void inAQuotedClassName(AQuotedClassName node)
3598 {
3599 defaultIn(node);
3600 }
3601
3602 public void outAQuotedClassName(AQuotedClassName node)
3603 {
3604 defaultOut(node);
3605 }
3606
3607 public void caseAQuotedClassName(AQuotedClassName node)
3608 {
3609 inAQuotedClassName(node);
3610 if(node.getQuotedName() != null)
3611 {
3612 node.getQuotedName().apply(this);
3613 }
3614 outAQuotedClassName(node);
3615 }
3616
3617 public void inAIdentClassName(AIdentClassName node)
3618 {
3619 defaultIn(node);
3620 }
3621
3622 public void outAIdentClassName(AIdentClassName node)
3623 {
3624 defaultOut(node);
3625 }
3626
3627 public void caseAIdentClassName(AIdentClassName node)
3628 {
3629 inAIdentClassName(node);
3630 if(node.getIdentifier() != null)
3631 {
3632 node.getIdentifier().apply(this);
3633 }
3634 outAIdentClassName(node);
3635 }
3636
3637 public void inAFullIdentClassName(AFullIdentClassName node)
3638 {
3639 defaultIn(node);
3640 }
3641
3642 public void outAFullIdentClassName(AFullIdentClassName node)
3643 {
3644 defaultOut(node);
3645 }
3646
3647 public void caseAFullIdentClassName(AFullIdentClassName node)
3648 {
3649 inAFullIdentClassName(node);
3650 if(node.getFullIdentifier() != null)
3651 {
3652 node.getFullIdentifier().apply(this);
3653 }
3654 outAFullIdentClassName(node);
3655 }
3656
3657 public void inAQuotedName(AQuotedName node)
3658 {
3659 defaultIn(node);
3660 }
3661
3662 public void outAQuotedName(AQuotedName node)
3663 {
3664 defaultOut(node);
3665 }
3666
3667 public void caseAQuotedName(AQuotedName node)
3668 {
3669 inAQuotedName(node);
3670 if(node.getQuotedName() != null)
3671 {
3672 node.getQuotedName().apply(this);
3673 }
3674 outAQuotedName(node);
3675 }
3676
3677 public void inAIdentName(AIdentName node)
3678 {
3679 defaultIn(node);
3680 }
3681
3682 public void outAIdentName(AIdentName node)
3683 {
3684 defaultOut(node);
3685 }
3686
3687 public void caseAIdentName(AIdentName node)
3688 {
3689 inAIdentName(node);
3690 if(node.getIdentifier() != null)
3691 {
3692 node.getIdentifier().apply(this);
3693 }
3694 outAIdentName(node);
3695 }
3696}
3697 |
Popular Tags |
Java API By Example, From Geeks To Geeks.