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