Java > Open Source Codes > polyglot > ext > jl > ast > AbstractExtFactory_c


1 package polyglot.ext.jl.ast;
2
3 import polyglot.ast.Ext;
4 import polyglot.ast.ExtFactory;
5
6 /**
7  * This abstract implementation of <code>ExtFactory</code> provides
8  * a way of chaining together ExtFactories, and default implementations
9  * of factory methods for each node.
10  *
11  * <p>
12  * For a given type of AST node <code>N</code>, there are three methods:
13  * <code>extN()</code>, <code>extNImpl()</code> and <code>postExtN(Ext)</code>.
14  * The method <code>extN()</code> calls <code>extNImpl()</code> to create
15  * an appropriate extension object, and if other <code>ExtFactory</code>s are
16  * chained onto this one, it will also call <code>extN()</code> on the next
17  * <code>ExtFactory</code>. The method <code>extN()</code> will then
18  * call <code>postExtN</code>, passing in the newly created extension object.
19  *
20  * <p>
21  * The default implementation of <code>extNImpl()</code> is to simply call
22  * <code>extMImpl()</code>, where <code>M</code> is the immediate
23  * superclass of <code>N</code>. Similarly, the default implementation of
24  * <code>postExtN(Ext)</code> is to call <code>postExtM(Ext)</code>.
25  *
26  * @see polyglot.ext.jl.ast.AbstractDelFactory_c has a very similar structure.
27  */
28 public abstract class AbstractExtFactory_c implements ExtFactory
29 {
30     protected AbstractExtFactory_c() {
31         this(null);
32     }
33     
34     protected AbstractExtFactory_c(ExtFactory nextExtFactory) {
35         this.nextExtFactory = nextExtFactory;
36     }
37     
38     /**
39      * The next extFactory in the chain. Whenever an extension is instantiated,
40      * the next extFactory should be called to see if it also has an extension,
41      * and if so, the extensions should be joined together using the method
42      * <code>composeExts</code>
43      */
44     private ExtFactory nextExtFactory;
45
46     public ExtFactory nextExtFactory() {
47         return nextExtFactory;
48     }
49     /**
50      * Compose two extensions together. Order is important: e1 gets added
51      * at the end of e2's chain of extensions.
52      * @param e1 the <code>Ext</code> object to add to the end of e2's
53      * chain of extensions.
54      * @param e2 the second <code>Ext</code> object that will have e1 added to
55      * its chain of extensions.
56      * @return the result of adding e1 to the end of e2's chain of extensions.
57      */
58     protected Ext composeExts(Ext e1, Ext e2) {
59         if (e1 == null) return e2;
60         if (e2 == null) return e1;
61         // add e1 as e2's last extension, by recursing...
62 return e2.ext(composeExts(e1, e2.ext()));
63     }
64     
65     // ******************************************
66 // Final methods that call the Impl methods to construct
67 // extensions, and then check with nextExtFactory to see if it
68 // also has an extension. Finally, call an appropriate post method,
69 // to allow subclasses to perform operations on the construction Exts
70 // ******************************************
71 public final Ext extAmbAssign() {
72         Ext e = extAmbAssignImpl();
73
74         if (nextExtFactory != null) {
75             Ext e2 = nextExtFactory.extAmbAssign();
76             e = composeExts(e, e2);
77         }
78         return postExtAmbAssign(e);
79     }
80
81     public final Ext extAmbExpr() {
82         Ext e = extAmbExprImpl();
83
84         if (nextExtFactory != null) {
85             Ext e2 = nextExtFactory.extAmbExpr();
86             e = composeExts(e, e2);
87         }
88         return postExtAmbExpr(e);
89     }
90
91     public final Ext extAmbPrefix() {
92         Ext e = extAmbPrefixImpl();
93
94         if (nextExtFactory != null) {
95             Ext e2 = nextExtFactory.extAmbPrefix();
96             e = composeExts(e, e2);
97         }
98         return postExtAmbPrefix(e);
99     }
100
101     public final Ext extAmbQualifierNode() {
102         Ext e = extAmbQualifierNodeImpl();
103
104         if (nextExtFactory != null) {
105             Ext e2 = nextExtFactory.extAmbQualifierNode();
106             e = composeExts(e, e2);
107         }
108         return postExtAmbQualifierNode(e);
109     }
110
111     public final Ext extAmbReceiver() {
112         Ext e = extAmbReceiverImpl();
113
114         if (nextExtFactory != null) {
115             Ext e2 = nextExtFactory.extAmbReceiver();
116             e = composeExts(e, e2);
117         }
118         return postExtAmbReceiver(e);
119     }
120
121     public final Ext extAmbTypeNode() {
122         Ext e = extAmbTypeNodeImpl();
123
124         if (nextExtFactory != null) {
125             Ext e2 = nextExtFactory.extAmbTypeNode();
126             e = composeExts(e, e2);
127         }
128         return postExtAmbTypeNode(e);
129     }
130
131     public final Ext extArrayAccess() {
132         Ext e = extArrayAccessImpl();
133
134         if (nextExtFactory != null) {
135             Ext e2 = nextExtFactory.extArrayAccess();
136             e = composeExts(e, e2);
137         }
138         return postExtArrayAccess(e);
139     }
140
141     public final Ext extArrayInit() {
142         Ext e = extArrayInitImpl();
143
144         if (nextExtFactory != null) {
145             Ext e2 = nextExtFactory.extArrayInit();
146             e = composeExts(e, e2);
147         }
148         return postExtArrayInit(e);
149     }
150
151     public final Ext extArrayTypeNode() {
152         Ext e = extArrayTypeNodeImpl();
153
154         if (nextExtFactory != null) {
155             Ext e2 = nextExtFactory.extArrayTypeNode();
156             e = composeExts(e, e2);
157         }
158         return postExtArrayTypeNode(e);
159     }
160
161     public final Ext extAssert() {
162         Ext e = extAssertImpl();
163
164         if (nextExtFactory != null) {
165             Ext e2 = nextExtFactory.extAssert();
166             e = composeExts(e, e2);
167         }
168         return postExtAssert(e);
169     }
170
171     public final Ext extAssign() {
172         Ext e = extAssignImpl();
173
174         if (nextExtFactory != null) {
175             Ext e2 = nextExtFactory.extAssign();
176             e = composeExts(e, e2);
177         }
178         return postExtAssign(e);
179     }
180
181     public final Ext extLocalAssign() {
182         Ext e = extLocalAssignImpl();
183
184         if (nextExtFactory != null) {
185             Ext e2 = nextExtFactory.extLocalAssign();
186             e = composeExts(e, e2);
187         }
188         return postExtLocalAssign(e);
189     }
190
191     public final Ext extFieldAssign() {
192         Ext e = extFieldAssignImpl();
193
194         if (nextExtFactory != null) {
195             Ext e2 = nextExtFactory.extFieldAssign();
196             e = composeExts(e, e2);
197         }
198         return postExtFieldAssign(e);
199     }
200
201     public final Ext extArrayAccessAssign() {
202         Ext e = extArrayAccessAssignImpl();
203
204         if (nextExtFactory != null) {
205             Ext e2 = nextExtFactory.extArrayAccessAssign();
206             e = composeExts(e, e2);
207         }
208         return postExtArrayAccessAssign(e);
209     }
210
211     public final Ext extBinary() {
212         Ext e = extBinaryImpl();
213
214         if (nextExtFactory != null) {
215             Ext e2 = nextExtFactory.extBinary();
216             e = composeExts(e, e2);
217         }
218         return postExtBinary(e);
219     }
220
221     public final Ext extBlock() {
222         Ext e = extBlockImpl();
223
224         if (nextExtFactory != null) {
225             Ext e2 = nextExtFactory.extBlock();
226             e = composeExts(e, e2);
227         }
228         return postExtBlock(e);
229     }
230
231     public final Ext extBooleanLit() {
232         Ext e = extBooleanLitImpl();
233
234         if (nextExtFactory != null) {
235             Ext e2 = nextExtFactory.extBooleanLit();
236             e = composeExts(e, e2);
237         }
238         return postExtBooleanLit(e);
239     }
240
241     public final Ext extBranch() {
242         Ext e = extBranchImpl();
243
244         if (nextExtFactory != null) {
245             Ext e2 = nextExtFactory.extBranch();
246             e = composeExts(e, e2);
247         }
248         return postExtBranch(e);
249     }
250
251     public final Ext extCall() {
252         Ext e = extCallImpl();
253
254         if (nextExtFactory != null) {
255             Ext e2 = nextExtFactory.extCall();
256             e = composeExts(e, e2);
257         }
258         return postExtCall(e);
259     }
260
261     public final Ext extCanonicalTypeNode() {
262         Ext e = extCanonicalTypeNodeImpl();
263
264         if (nextExtFactory != null) {
265             Ext e2 = nextExtFactory.extCanonicalTypeNode();
266             e = composeExts(e, e2);
267         }
268         return postExtCanonicalTypeNode(e);
269     }
270
271     public final Ext extCase() {
272         Ext e = extCaseImpl();
273
274         if (nextExtFactory != null) {
275             Ext e2 = nextExtFactory.extCase();
276             e = composeExts(e, e2);
277         }
278         return postExtCase(e);
279     }
280
281     public final Ext extCast() {
282         Ext e = extCastImpl();
283
284         if (nextExtFactory != null) {
285             Ext e2 = nextExtFactory.extCast();
286             e = composeExts(e, e2);
287         }
288         return postExtCast(e);
289     }
290
291     public final Ext extCatch() {
292         Ext e = extCatchImpl();
293
294         if (nextExtFactory != null) {
295             Ext e2 = nextExtFactory.extCatch();
296             e = composeExts(e, e2);
297         }
298         return postExtCatch(e);
299     }
300
301     public final Ext extCharLit() {
302         Ext e = extCharLitImpl();
303
304         if (nextExtFactory != null) {
305             Ext e2 = nextExtFactory.extCharLit();
306             e = composeExts(e, e2);
307         }
308         return postExtCharLit(e);
309     }
310
311     public final Ext extClassBody() {
312         Ext e = extClassBodyImpl();
313
314         if (nextExtFactory != null) {
315             Ext e2 = nextExtFactory.extClassBody();
316             e = composeExts(e, e2);
317         }
318         return postExtClassBody(e);
319     }
320
321     public final Ext extClassDecl() {
322         Ext e = extClassDeclImpl();
323
324         if (nextExtFactory != null) {
325             Ext e2 = nextExtFactory.extClassDecl();
326             e = composeExts(e, e2);
327         }
328         return postExtClassDecl(e);
329     }
330
331     public final Ext extClassLit() {
332         Ext e = extClassLitImpl();
333
334         if (nextExtFactory != null) {
335             Ext e2 = nextExtFactory.extClassLit();
336             e = composeExts(e, e2);
337         }
338         return postExtClassLit(e);
339     }
340
341     public final Ext extClassMember() {
342         Ext e = extClassMemberImpl();
343
344         if (nextExtFactory != null) {
345             Ext e2 = nextExtFactory.extClassMember();
346             e = composeExts(e, e2);
347         }
348         return postExtClassMember(e);
349     }
350
351     public final Ext extCodeDecl() {
352         Ext e = extCodeDeclImpl();
353
354         if (nextExtFactory != null) {
355             Ext e2 = nextExtFactory.extCodeDecl();
356             e = composeExts(e, e2);
357         }
358         return postExtCodeDecl(e);
359     }
360
361     public final Ext extConditional() {
362         Ext e = extConditionalImpl();
363
364         if (nextExtFactory != null) {
365             Ext e2 = nextExtFactory.extConditional();
366             e = composeExts(e, e2);
367         }
368         return postExtConditional(e);
369     }
370
371     public final Ext extConstructorCall() {
372         Ext e = extConstructorCallImpl();
373
374         if (nextExtFactory != null) {
375             Ext e2 = nextExtFactory.extConstructorCall();
376             e = composeExts(e, e2);
377         }
378         return postExtConstructorCall(e);
379     }
380
381     public final Ext extConstructorDecl() {
382         Ext e = extConstructorDeclImpl();
383
384         if (nextExtFactory != null) {
385             Ext e2 = nextExtFactory.extConstructorDecl();
386             e = composeExts(e, e2);
387         }
388         return postExtConstructorDecl(e);
389     }
390
391     public final Ext extDo() {
392         Ext e = extDoImpl();
393
394         if (nextExtFactory != null) {
395             Ext e2 = nextExtFactory.extDo();
396             e = composeExts(e, e2);
397         }
398         return postExtDo(e);
399     }
400
401     public final Ext extEmpty() {
402         Ext e = extEmptyImpl();
403
404         if (nextExtFactory != null) {
405             Ext e2 = nextExtFactory.extEmpty();
406             e = composeExts(e, e2);
407         }
408         return postExtEmpty(e);
409     }
410
411     public final Ext extEval() {
412         Ext e = extEvalImpl();
413
414         if (nextExtFactory != null) {
415             Ext e2 = nextExtFactory.extEval();
416             e = composeExts(e, e2);
417         }
418         return postExtEval(e);
419     }
420
421     public final Ext extExpr() {
422         Ext e = extExprImpl();
423
424         if (nextExtFactory != null) {
425             Ext e2 = nextExtFactory.extExpr();
426             e = composeExts(e, e2);
427         }
428         return postExtExpr(e);
429     }
430
431     public final Ext extField() {
432         Ext e = extFieldImpl();
433
434         if (nextExtFactory != null) {
435             Ext e2 = nextExtFactory.extField();
436             e = composeExts(e, e2);
437         }
438         return postExtField(e);
439     }
440
441     public final Ext extFieldDecl() {
442         Ext e = extFieldDeclImpl();
443
444         if (nextExtFactory != null) {
445             Ext e2 = nextExtFactory.extFieldDecl();
446             e = composeExts(e, e2);
447         }
448         return postExtFieldDecl(e);
449     }
450
451     public final Ext extFloatLit() {
452         Ext e = extFloatLitImpl();
453
454         if (nextExtFactory != null) {
455             Ext e2 = nextExtFactory.extFloatLit();
456             e = composeExts(e, e2);
457         }
458         return postExtFloatLit(e);
459     }
460
461     public final Ext extFor() {
462         Ext e = extForImpl();
463
464         if (nextExtFactory != null) {
465             Ext e2 = nextExtFactory.extFor();
466             e = composeExts(e, e2);
467         }
468         return postExtFor(e);
469     }
470
471     public final Ext extFormal() {
472         Ext e = extFormalImpl();
473
474         if (nextExtFactory != null) {
475             Ext e2 = nextExtFactory.extFormal();
476             e = composeExts(e, e2);
477         }
478         return postExtFormal(e);
479     }
480
481     public final Ext extIf() {
482         Ext e = extIfImpl();
483
484         if (nextExtFactory != null) {
485             Ext e2 = nextExtFactory.extIf();
486             e = composeExts(e, e2);
487         }
488         return postExtIf(e);
489     }
490
491     public final Ext extImport() {
492         Ext e = extImportImpl();
493
494         if (nextExtFactory != null) {
495             Ext e2 = nextExtFactory.extImport();
496             e = composeExts(e, e2);
497         }
498         return postExtImport(e);
499     }
500
501     public final Ext extInitializer() {
502         Ext e = extInitializerImpl();
503
504         if (nextExtFactory != null) {
505             Ext e2 = nextExtFactory.extInitializer();
506             e = composeExts(e, e2);
507         }
508         return postExtInitializer(e);
509     }
510
511     public final Ext extInstanceof() {
512         Ext e = extInstanceofImpl();
513
514         if (nextExtFactory != null) {
515             Ext e2 = nextExtFactory.extInstanceof();
516             e = composeExts(e, e2);
517         }
518         return postExtInstanceof(e);
519     }
520
521     public final Ext extIntLit() {
522         Ext e = extIntLitImpl();
523
524         if (nextExtFactory != null) {
525             Ext e2 = nextExtFactory.extIntLit();
526             e = composeExts(e, e2);
527         }
528         return postExtIntLit(e);
529     }
530
531     public final Ext extLabeled() {
532         Ext e = extLabeledImpl();
533
534         if (nextExtFactory != null) {
535             Ext e2 = nextExtFactory.extLabeled();
536             e = composeExts(e, e2);
537         }
538         return postExtLabeled(e);
539     }
540
541     public final Ext extLit() {
542         Ext e = extLitImpl();
543
544         if (nextExtFactory != null) {
545             Ext e2 = nextExtFactory.extLit();
546             e = composeExts(e, e2);
547         }
548         return postExtLit(e);
549     }
550
551     public final Ext extLocal() {
552         Ext e = extLocalImpl();
553
554         if (nextExtFactory != null) {
555             Ext e2 = nextExtFactory.extLocal();
556             e = composeExts(e, e2);
557         }
558         return postExtLocal(e);
559     }
560
561     public final Ext extLocalClassDecl() {
562         Ext e = extLocalClassDeclImpl();
563
564         if (nextExtFactory != null) {
565             Ext e2 = nextExtFactory.extLocalClassDecl();
566             e = composeExts(e, e2);
567         }
568         return postExtLocalClassDecl(e);
569     }
570
571     public final Ext extLocalDecl() {
572         Ext e = extLocalDeclImpl();
573
574         if (nextExtFactory != null) {
575             Ext e2 = nextExtFactory.extLocalDecl();
576             e = composeExts(e, e2);
577         }
578         return postExtLocalDecl(e);
579     }
580
581     public final Ext extLoop() {
582         Ext e = extLoopImpl();
583
584         if (nextExtFactory != null) {
585             Ext e2 = nextExtFactory.extLoop();
586             e = composeExts(e, e2);
587         }
588         return postExtLoop(e);
589     }
590
591     public final Ext extMethodDecl() {
592         Ext e = extMethodDeclImpl();
593
594         if (nextExtFactory != null) {
595             Ext e2 = nextExtFactory.extMethodDecl();
596             e = composeExts(e, e2);
597         }
598         return postExtMethodDecl(e);
599     }
600
601     public final Ext extNewArray() {
602         Ext e = extNewArrayImpl();
603
604         if (nextExtFactory != null) {
605             Ext e2 = nextExtFactory.extNewArray();
606             e = composeExts(e, e2);
607         }
608         return postExtNewArray(e);
609     }
610
611     public final Ext extNode() {
612         Ext e = extNodeImpl();
613
614         if (nextExtFactory != null) {
615             Ext e2 = nextExtFactory.extNode();
616             e = composeExts(e, e2);
617         }
618         return postExtNode(e);
619     }
620
621     public final Ext extNew() {
622         Ext e = extNewImpl();
623
624         if (nextExtFactory != null) {
625             Ext e2 = nextExtFactory.extNew();
626             e = composeExts(e, e2);
627         }
628         return postExtNew(e);
629     }
630
631     public final Ext extNullLit() {
632         Ext e = extNullLitImpl();
633
634         if (nextExtFactory != null) {
635             Ext e2 = nextExtFactory.extNullLit();
636             e = composeExts(e, e2);
637         }
638         return postExtNullLit(e);
639     }
640
641     public final Ext extNumLit() {
642         Ext e = extNumLitImpl();
643
644         if (nextExtFactory != null) {
645             Ext e2 = nextExtFactory.extNumLit();
646             e = composeExts(e, e2);
647         }
648         return postExtNumLit(e);
649     }
650
651     public final Ext extPackageNode() {
652         Ext e = extPackageNodeImpl();
653
654         if (nextExtFactory != null) {
655             Ext e2 = nextExtFactory.extPackageNode();
656             e = composeExts(e, e2);
657         }
658         return postExtPackageNode(e);
659     }
660
661     public final Ext extProcedureDecl() {
662         Ext e = extProcedureDeclImpl();
663
664         if (nextExtFactory != null) {
665             Ext e2 = nextExtFactory.extProcedureDecl();
666             e = composeExts(e, e2);
667         }
668         return postExtProcedureDecl(e);
669     }
670
671     public final Ext extReturn() {
672         Ext e = extReturnImpl();
673
674         if (nextExtFactory != null) {
675             Ext e2 = nextExtFactory.extReturn();
676             e = composeExts(e, e2);
677         }
678         return postExtReturn(e);
679     }
680
681     public final Ext extSourceCollection() {
682         Ext e = extSourceCollectionImpl();
683
684         if (nextExtFactory != null) {
685             Ext e2 = nextExtFactory.extSourceCollection();
686             e = composeExts(e, e2);
687         }
688         return postExtSourceCollection(e);
689     }
690
691     public final Ext extSourceFile() {
692         Ext e = extSourceFileImpl();
693
694         if (nextExtFactory != null) {
695             Ext e2 = nextExtFactory.extSourceFile();
696             e = composeExts(e, e2);
697         }
698         return postExtSourceFile(e);
699     }
700
701     public final Ext extSpecial() {
702         Ext e = extSpecialImpl();
703
704         if (nextExtFactory != null) {
705             Ext e2 = nextExtFactory.extSpecial();
706             e = composeExts(e, e2);
707         }
708         return postExtSpecial(e);
709     }
710
711     public final Ext extStmt() {
712         Ext e = extStmtImpl();
713
714         if (nextExtFactory != null) {
715             Ext e2 = nextExtFactory.extStmt();
716             e = composeExts(e, e2);
717         }
718         return postExtStmt(e);
719     }
720
721     public final Ext extStringLit() {
722         Ext e = extStringLitImpl();
723
724         if (nextExtFactory != null) {
725             Ext e2 = nextExtFactory.extStringLit();
726             e = composeExts(e, e2);
727         }
728         return postExtStringLit(e);
729     }
730
731     public final Ext extSwitchBlock() {
732         Ext e = extSwitchBlockImpl();
733
734         if (nextExtFactory != null) {
735             Ext e2 = nextExtFactory.extSwitchBlock();
736             e = composeExts(e, e2);
737         }
738         return postExtSwitchBlock(e);
739     }
740
741     public final Ext extSwitchElement() {
742         Ext e = extSwitchElementImpl();
743
744         if (nextExtFactory != null) {
745             Ext e2 = nextExtFactory.extSwitchElement();
746             e = composeExts(e, e2);
747         }
748         return postExtSwitchElement(e);
749     }
750
751     public final Ext extSwitch() {
752         Ext e = extSwitchImpl();
753
754         if (nextExtFactory != null) {
755             Ext e2 = nextExtFactory.extSwitch();
756             e = composeExts(e, e2);
757         }
758         return postExtSwitch(e);
759     }
760
761     public final Ext extSynchronized() {
762         Ext e = extSynchronizedImpl();
763
764         if (nextExtFactory != null) {
765             Ext e2 = nextExtFactory.extSynchronized();
766             e = composeExts(e, e2);
767         }
768         return postExtSynchronized(e);
769     }
770
771     public final Ext extTerm() {
772         Ext e = extTermImpl();
773
774         if (nextExtFactory != null) {
775             Ext e2 = nextExtFactory.extTerm();
776             e = composeExts(e, e2);
777         }
778         return postExtTerm(e);
779     }
780
781     public final Ext extThrow() {
782         Ext e = extThrowImpl();
783
784         if (nextExtFactory != null) {
785             Ext e2 = nextExtFactory.extThrow();
786             e = composeExts(e, e2);
787         }
788         return postExtThrow(e);
789     }
790
791     public final Ext extTry() {
792         Ext e = extTryImpl();
793
794         if (nextExtFactory != null) {
795             Ext e2 = nextExtFactory.extTry();
796             e = composeExts(e, e2);
797         }
798         return postExtTry(e);
799     }
800
801     public final Ext extTypeNode() {
802         Ext e = extTypeNodeImpl();
803
804         if (nextExtFactory != null) {
805             Ext e2 = nextExtFactory.extTypeNode();
806             e = composeExts(e, e2);
807         }
808         return postExtTypeNode(e);
809     }
810
811     public final Ext extUnary() {
812         Ext e = extUnaryImpl();
813
814         if (nextExtFactory != null) {
815             Ext e2 = nextExtFactory.extUnary();
816             e = composeExts(e, e2);
817         }
818         return postExtUnary(e);
819     }
820
821     public final Ext extWhile() {
822         Ext e = extWhileImpl();
823
824         if (nextExtFactory != null) {
825             Ext e2 = nextExtFactory.extWhile();
826             e = composeExts(e, e2);
827         }
828         return postExtWhile(e);
829     }
830
831     // ********************************************
832 // Impl methods
833 // ********************************************
834
835     /**
836      * Create the <code>Ext</code> object for a <code>AmbAssign</code> AST node.
837      * @return the <code>Ext</code> object for a <code>AmbAssign</code> AST node.
838      */
839     protected Ext extAmbAssignImpl() {
840         return extAssignImpl();
841     }
842
843     /**
844      * Create the <code>Ext</code> object for a <code>AmbExpr</code> AST node.
845      * @return the <code>Ext</code> object for a <code>AmbExpr</code> AST node.
846      */
847     protected Ext extAmbExprImpl() {
848         return extExprImpl();
849     }
850
851     /**
852      * Create the <code>Ext</code> object for a <code>AmbPrefix</code> AST node.
853      * @return the <code>Ext</code> object for a <code>AmbPrefix</code> AST node.
854      */
855     protected Ext extAmbPrefixImpl() {
856         return extNodeImpl();
857     }
858
859     /**
860      * Create the <code>Ext</code> object for a <code>AmbQualifierNode</code> AST node.
861      * @return the <code>Ext</code> object for a <code>AmbQualifierNode</code> AST node.
862      */
863     protected Ext extAmbQualifierNodeImpl() {
864         return extNodeImpl();
865     }
866
867     /**
868      * Create the <code>Ext</code> object for a <code>AmbReceiver</code> AST node.
869      * @return the <code>Ext</code> object for a <code>AmbReceiver</code> AST node.
870      */
871     protected Ext extAmbReceiverImpl() {
872         return extNodeImpl();
873     }
874
875     /**
876      * Create the <code>Ext</code> object for a <code>AmbTypeNode</code> AST node.
877      * @return the <code>Ext</code> object for a <code>AmbTypeNode</code> AST node.
878      */
879     protected Ext extAmbTypeNodeImpl() {
880         return extTypeNodeImpl();
881     }
882
883     /**
884      * Create the <code>Ext</code> object for a <code>ArrayAccess</code> AST node.
885      * @return the <code>Ext</code> object for a <code>ArrayAccess</code> AST node.
886      */
887     protected Ext extArrayAccessImpl() {
888         return extExprImpl();
889     }
890
891     /**
892      * Create the <code>Ext</code> object for a <code>ArrayInit</code> AST node.
893      * @return the <code>Ext</code> object for a <code>ArrayInit</code> AST node.
894      */
895     protected Ext extArrayInitImpl() {
896         return extExprImpl();
897     }
898
899     /**
900      * Create the <code>Ext</code> object for a <code>ArrayTypeNode</code> AST node.
901      * @return the <code>Ext</code> object for a <code>ArrayTypeNode</code> AST node.
902      */
903     protected Ext extArrayTypeNodeImpl() {
904         return extTypeNodeImpl();
905     }
906
907     /**
908      * Create the <code>Ext</code> object for a <code>Assert</code> AST node.
909      * @return the <code>Ext</code> object for a <code>Assert</code> AST node.
910      */
911     protected Ext extAssertImpl() {
912         return extStmtImpl();
913     }
914
915     /**
916      * Create the <code>Ext</code> object for a <code>Assign</code> AST node.
917      * @return the <code>Ext</code> object for a <code>Assign</code> AST node.
918      */
919     protected Ext extAssignImpl() {
920         return extExprImpl();
921     }
922
923     /**
924      * Create the <code>Ext</code> object for a <code>LocalAssign</code> AST node.
925      * @return the <code>Ext</code> object for a <code>LocalAssign</code> AST node.
926      */
927     protected Ext extLocalAssignImpl() {
928         return extAssignImpl();
929     }
930
931     /**
932      * Create the <code>Ext</code> object for a <code>FieldAssign</code> AST node.
933      * @return the <code>Ext</code> object for a <code>FieldAssign</code> AST node.
934      */
935     protected Ext extFieldAssignImpl() {
936         return extAssignImpl();
937     }
938
939     /**
940      * Create the <code>Ext</code> object for a <code>ArrayAccessAssign</code> AST node.
941      * @return the <code>Ext</code> object for a <code>ArrayAccessAssign</code> AST node.
942      */
943     protected Ext extArrayAccessAssignImpl() {
944         return extAssignImpl();
945     }
946
947     /**
948      * Create the <code>Ext</code> object for a <code>Binary</code> AST node.
949      * @return the <code>Ext</code> object for a <code>Binary</code> AST node.
950      */
951     protected Ext extBinaryImpl() {
952         return extExprImpl();
953     }
954
955     /**
956      * Create the <code>Ext</code> object for a <code>Block</code> AST node.
957      * @return the <code>Ext</code> object for a <code>Block</code> AST node.
958      */
959     protected Ext extBlockImpl() {
960         return extStmtImpl();
961     }
962
963     /**
964      * Create the <code>Ext</code> object for a <code>BooleanLit</code> AST node.
965      * @return the <code>Ext</code> object for a <code>BooleanLit</code> AST node.
966      */
967     protected Ext extBooleanLitImpl() {
968         return extLitImpl();
969     }
970
971     /**
972      * Create the <code>Ext</code> object for a <code>Branch</code> AST node.
973      * @return the <code>Ext</code> object for a <code>Branch</code> AST node.
974      */
975     protected Ext extBranchImpl() {
976         return extStmtImpl();
977     }
978
979     /**
980      * Create the <code>Ext</code> object for a <code>Call</code> AST node.
981      * @return the <code>Ext</code> object for a <code>Call</code> AST node.
982      */
983     protected Ext extCallImpl() {
984         return extExprImpl();
985     }
986
987     /**
988      * Create the <code>Ext</code> object for a <code>CanonicalTypeNode</code> AST node.
989      * @return the <code>Ext</code> object for a <code>CanonicalTypeNode</code> AST node.
990      */
991     protected Ext extCanonicalTypeNodeImpl() {
992         return extTypeNodeImpl();
993     }
994
995     /**
996      * Create the <code>Ext</code> object for a <code>Case</code> AST node.
997      * @return the <code>Ext</code> object for a <code>Case</code> AST node.
998      */
999     protected Ext extCaseImpl() {
1000        return extSwitchElementImpl();
1001    }
1002
1003    /**
1004     * Create the <code>Ext</code> object for a <code>Cast</code> AST node.
1005     * @return the <code>Ext</code> object for a <code>Cast</code> AST node.
1006     */
1007    protected Ext extCastImpl() {
1008        return extExprImpl();
1009    }
1010
1011    /**
1012     * Create the <code>Ext</code> object for a <code>Catch</code> AST node.
1013     * @return the <code>Ext</code> object for a <code>Catch</code> AST node.
1014     */
1015    protected Ext extCatchImpl() {
1016        return extStmtImpl();
1017    }
1018
1019    /**
1020     * Create the <code>Ext</code> object for a <code>CharLit</code> AST node.
1021     * @return the <code>Ext</code> object for a <code>CharLit</code> AST node.
1022     */
1023    protected Ext extCharLitImpl() {
1024        return extNumLitImpl();
1025    }
1026
1027    /**
1028     * Create the <code>Ext</code> object for a <code>ClassBody</code> AST node.
1029     * @return the <code>Ext</code> object for a <code>ClassBody</code> AST node.
1030     */
1031    protected Ext extClassBodyImpl() {
1032        return extTermImpl();
1033    }
1034
1035    /**
1036     * Create the <code>Ext</code> object for a <code>ClassDecl</code> AST node.
1037     * @return the <code>Ext</code> object for a <code>ClassDecl</code> AST node.
1038     */
1039    protected Ext extClassDeclImpl() {
1040        return extTermImpl();
1041    }
1042
1043    /**
1044     * Create the <code>Ext</code> object for a <code>ClassLit</code> AST node.
1045     * @return the <code>Ext</code> object for a <code>ClassLit</code> AST node.
1046     */
1047    protected Ext extClassLitImpl() {
1048        return extLitImpl();
1049    }
1050
1051    /**
1052     * Create the <code>Ext</code> object for a <code>ClassMember</code> AST node.
1053     * @return the <code>Ext</code> object for a <code>ClassMember</code> AST node.
1054     */
1055    protected Ext extClassMemberImpl() {
1056        return extNodeImpl();
1057    }
1058
1059    /**
1060     * Create the <code>Ext</code> object for a <code>CodeDecl</code> AST node.
1061     * @return the <code>Ext</code> object for a <code>CodeDecl</code> AST node.
1062     */
1063    protected Ext extCodeDeclImpl() {
1064        return extClassMemberImpl();
1065    }
1066
1067    /**
1068     * Create the <code>Ext</code> object for a <code>Conditional</code> AST node.
1069     * @return the <code>Ext</code> object for a <code>Conditional</code> AST node.
1070     */
1071    protected Ext extConditionalImpl() {
1072        return extExprImpl();
1073    }
1074
1075    /**
1076     * Create the <code>Ext</code> object for a <code>ConstructorCall</code> AST node.
1077     * @return the <code>Ext</code> object for a <code>ConstructorCall</code> AST node.
1078     */
1079    protected Ext extConstructorCallImpl() {
1080        return extStmtImpl();
1081    }
1082
1083    /**
1084     * Create the <code>Ext</code> object for a <code>ConstructorDecl</code> AST node.
1085     * @return the <code>Ext</code> object for a <code>ConstructorDecl</code> AST node.
1086     */
1087    protected Ext extConstructorDeclImpl() {
1088        return extProcedureDeclImpl();
1089    }
1090
1091    /**
1092     * Create the <code>Ext</code> object for a <code>Do</code> AST node.
1093     * @return the <code>Ext</code> object for a <code>Do</code> AST node.
1094     */
1095    protected Ext extDoImpl() {
1096        return extLoopImpl();
1097    }
1098
1099    /**
1100     * Create the <code>Ext</code> object for a <code>Empty</code> AST node.
1101     * @return the <code>Ext</code> object for a <code>Empty</code> AST node.
1102     */
1103    protected Ext extEmptyImpl() {
1104        return extStmtImpl();
1105    }
1106
1107    /**
1108     * Create the <code>Ext</code> object for a <code>Eval</code> AST node.
1109     * @return the <code>Ext</code> object for a <code>Eval</code> AST node.
1110     */
1111    protected Ext extEvalImpl() {
1112        return extStmtImpl();
1113    }
1114
1115    /**
1116     * Create the <code>Ext</code> object for a <code>Expr</code> AST node.
1117     * @return the <code>Ext</code> object for a <code>Expr</code> AST node.
1118     */
1119    protected Ext extExprImpl() {
1120        return extTermImpl();
1121    }
1122
1123    /**
1124     * Create the <code>Ext</code> object for a <code>Field</code> AST node.
1125     * @return the <code>Ext</code> object for a <code>Field</code> AST node.
1126     */
1127    protected Ext extFieldImpl() {
1128        return extExprImpl();
1129    }
1130
1131    /**
1132     * Create the <code>Ext</code> object for a <code>FieldDecl</code> AST node.
1133     * @return the <code>Ext</code> object for a <code>FieldDecl</code> AST node.
1134     */
1135    protected Ext extFieldDeclImpl() {
1136        return extClassMemberImpl();
1137    }
1138
1139    /**
1140     * Create the <code>Ext</code> object for a <code>FloatLit</code> AST node.
1141     * @return the <code>Ext</code> object for a <code>FloatLit</code> AST node.
1142     */
1143    protected Ext extFloatLitImpl() {
1144        return extLitImpl();
1145    }
1146
1147    /**
1148     * Create the <code>Ext</code> object for a <code>For</code> AST node.
1149     * @return the <code>Ext</code> object for a <code>For</code> AST node.
1150     */
1151    protected Ext extForImpl() {
1152        return extLoopImpl();
1153    }
1154
1155    /**
1156     * Create the <code>Ext</code> object for a <code>Formal</code> AST node.
1157     * @return the <code>Ext</code> object for a <code>Formal</code> AST node.
1158     */
1159    protected Ext extFormalImpl() {
1160        return extNodeImpl();
1161    }
1162
1163    /**
1164     * Create the <code>Ext</code> object for a <code>If</code> AST node.
1165     * @return the <code>Ext</code> object for a <code>If</code> AST node.
1166     */
1167    protected Ext extIfImpl() {
1168        return extStmtImpl();
1169    }
1170
1171    /**
1172     * Create the <code>Ext</code> object for a <code>Import</code> AST node.
1173     * @return the <code>Ext</code> object for a <code>Import</code> AST node.
1174     */
1175    protected Ext extImportImpl() {
1176        return extNodeImpl();
1177    }
1178
1179    /**
1180     * Create the <code>Ext</code> object for a <code>Initializer</code> AST node.
1181     * @return the <code>Ext</code> object for a <code>Initializer</code> AST node.
1182     */
1183    protected Ext extInitializerImpl() {
1184        return extCodeDeclImpl();
1185    }
1186
1187    /**
1188     * Create the <code>Ext</code> object for a <code>Instanceof</code> AST node.
1189     * @return the <code>Ext</code> object for a <code>Instanceof</code> AST node.
1190     */
1191    protected Ext extInstanceofImpl() {
1192        return extExprImpl();
1193    }
1194
1195    /**
1196     * Create the <code>Ext</code> object for a <code>IntLit</code> AST node.
1197     * @return the <code>Ext</code> object for a <code>IntLit</code> AST node.
1198     */
1199    protected Ext extIntLitImpl() {
1200        return extNumLitImpl();
1201    }
1202
1203    /**
1204     * Create the <code>Ext</code> object for a <code>Labeled</code> AST node.
1205     * @return the <code>Ext</code> object for a <code>Labeled</code> AST node.
1206     */
1207    protected Ext extLabeledImpl() {
1208        return extStmtImpl();
1209    }
1210
1211    /**
1212     * Create the <code>Ext</code> object for a <code>Lit</code> AST node.
1213     * @return the <code>Ext</code> object for a <code>Lit</code> AST node.
1214     */
1215    protected Ext extLitImpl() {
1216        return extExprImpl();
1217    }
1218
1219    /**
1220     * Create the <code>Ext</code> object for a <code>Local</code> AST node.
1221     * @return the <code>Ext</code> object for a <code>Local</code> AST node.
1222     */
1223    protected Ext extLocalImpl() {
1224        return extExprImpl();
1225    }
1226
1227    /**
1228     * Create the <code>Ext</code> object for a <code>LocalClassDecl</code> AST node.
1229     * @return the <code>Ext</code> object for a <code>LocalClassDecl</code> AST node.
1230     */
1231    protected Ext extLocalClassDeclImpl() {
1232        return extStmtImpl();
1233    }
1234
1235    /**
1236     * Create the <code>Ext</code> object for a <code>LocalDecl</code> AST node.
1237     * @return the <code>Ext</code> object for a <code>LocalDecl</code> AST node.
1238     */
1239    protected Ext extLocalDeclImpl() {
1240        return extStmtImpl();
1241    }
1242
1243    /**
1244     * Create the <code>Ext</code> object for a <code>Loop</code> AST node.
1245     * @return the <code>Ext</code> object for a <code>Loop</code> AST node.
1246     */
1247    protected Ext extLoopImpl() {
1248        return extStmtImpl();
1249    }
1250
1251    /**
1252     * Create the <code>Ext</code> object for a <code>MethodDecl</code> AST node.
1253     * @return the <code>Ext</code> object for a <code>MethodDecl</code> AST node.
1254     */
1255    protected Ext extMethodDeclImpl() {
1256        return extProcedureDeclImpl();
1257    }
1258
1259    /**
1260     * Create the <code>Ext</code> object for a <code>NewArray</code> AST node.
1261     * @return the <code>Ext</code> object for a <code>NewArray</code> AST node.
1262     */
1263    protected Ext extNewArrayImpl() {
1264        return extExprImpl();
1265    }
1266
1267    /**
1268     * Create the <code>Ext</code> object for a <code>Node</code> AST node.
1269     * @return the <code>Ext</code> object for a <code>Node</code> AST node.
1270     */
1271    protected Ext extNodeImpl() {
1272        return null;
1273    }
1274
1275    /**
1276     * Create the <code>Ext</code> object for a <code>New</code> AST node.
1277     * @return the <code>Ext</code> object for a <code>New</code> AST node.
1278     */
1279    protected Ext extNewImpl() {
1280        return extExprImpl();
1281    }
1282
1283    /**
1284     * Create the <code>Ext</code> object for a <code>NullLit</code> AST node.
1285     * @return the <code>Ext</code> object for a <code>NullLit</code> AST node.
1286     */
1287    protected Ext extNullLitImpl() {
1288        return extLitImpl();
1289    }
1290
1291    /**
1292     * Create the <code>Ext</code> object for a <code>NumLit</code> AST node.
1293     * @return the <code>Ext</code> object for a <code>NumLit</code> AST node.
1294     */
1295    protected Ext extNumLitImpl() {
1296        return extLitImpl();
1297    }
1298
1299    /**
1300     * Create the <code>Ext</code> object for a <code>PackageNode</code> AST node.
1301     * @return the <code>Ext</code> object for a <code>PackageNode</code> AST node.
1302     */
1303    protected Ext extPackageNodeImpl() {
1304        return extNodeImpl();
1305    }
1306
1307    /**
1308     * Create the <code>Ext</code> object for a <code>ProcedureDecl</code> AST node.
1309     * @return the <code>Ext</code> object for a <code>ProcedureDecl</code> AST node.
1310     */
1311    protected Ext extProcedureDeclImpl() {
1312        return extCodeDeclImpl();
1313    }
1314
1315    /**
1316     * Create the <code>Ext</code> object for a <code>Return</code> AST node.
1317     * @return the <code>Ext</code> object for a <code>Return</code> AST node.
1318     */
1319    protected Ext extReturnImpl() {
1320        return extStmtImpl();
1321    }
1322
1323    /**
1324     * Create the <code>Ext</code> object for a <code>SourceCollection</code> AST node.
1325     * @return the <code>Ext</code> object for a <code>SourceCollection</code> AST node.
1326     */
1327    protected Ext extSourceCollectionImpl() {
1328        return extNodeImpl();
1329    }
1330
1331    /**
1332     * Create the <code>Ext</code> object for a <code>SourceFile</code> AST node.
1333     * @return the <code>Ext</code> object for a <code>SourceFile</code> AST node.
1334     */
1335    protected Ext extSourceFileImpl() {
1336        return extNodeImpl();
1337    }
1338
1339    /**
1340     * Create the <code>Ext</code> object for a <code>Special</code> AST node.
1341     * @return the <code>Ext</code> object for a <code>Special</code> AST node.
1342     */
1343    protected Ext extSpecialImpl() {
1344        return extExprImpl();
1345    }
1346
1347    /**
1348     * Create the <code>Ext</code> object for a <code>Stmt</code> AST node.
1349     * @return the <code>Ext</code> object for a <code>Stmt</code> AST node.
1350     */
1351    protected Ext extStmtImpl() {
1352        return extTermImpl();
1353    }
1354
1355    /**
1356     * Create the <code>Ext</code> object for a <code>StringLit</code> AST node.
1357     * @return the <code>Ext</code> object for a <code>StringLit</code> AST node.
1358     */
1359    protected Ext extStringLitImpl() {
1360        return extLitImpl();
1361    }
1362
1363    /**
1364     * Create the <code>Ext</code> object for a <code>SwitchBlock</code> AST node.
1365     * @return the <code>Ext</code> object for a <code>SwitchBlock</code> AST node.
1366     */
1367    protected Ext extSwitchBlockImpl() {
1368        return extSwitchElementImpl();
1369    }
1370
1371    /**
1372     * Create the <code>Ext</code> object for a <code>SwitchElement</code> AST node.
1373     * @return the <code>Ext</code> object for a <code>SwitchElement</code> AST node.
1374     */
1375    protected Ext extSwitchElementImpl() {
1376        return extStmtImpl();
1377    }
1378
1379    /**
1380     * Create the <code>Ext</code> object for a <code>Switch</code> AST node.
1381     * @return the <code>Ext</code> object for a <code>Switch</code> AST node.
1382     */
1383    protected Ext extSwitchImpl() {
1384        return extStmtImpl();
1385    }
1386
1387    /**
1388     * Create the <code>Ext</code> object for a <code>Synchronized</code> AST node.
1389     * @return the <code>Ext</code> object for a <code>Synchronized</code> AST node.
1390     */
1391    protected Ext extSynchronizedImpl() {
1392        return extStmtImpl();
1393    }
1394
1395    /**
1396     * Create the <code>Ext</code> object for a <code>Term</code> AST node.
1397     * @return the <code>Ext</code> object for a <code>Term</code> AST node.
1398     */
1399    protected Ext extTermImpl() {
1400        return extNodeImpl();
1401    }
1402
1403    /**
1404     * Create the <code>Ext</code> object for a <code>Throw</code> AST node.
1405     * @return the <code>Ext</code> object for a <code>Throw</code> AST node.
1406     */
1407    protected Ext extThrowImpl() {
1408        return extStmtImpl();
1409    }
1410
1411    /**
1412     * Create the <code>Ext</code> object for a <code>Try</code> AST node.
1413     * @return the <code>Ext</code> object for a <code>Try</code> AST node.
1414     */
1415    protected Ext extTryImpl() {
1416        return extStmtImpl();
1417    }
1418
1419    /**
1420     * Create the <code>Ext</code> object for a <code>TypeNode</code> AST node.
1421     * @return the <code>Ext</code> object for a <code>TypeNode</code> AST node.
1422     */
1423    protected Ext extTypeNodeImpl() {
1424        return extNodeImpl();
1425    }
1426
1427    /**
1428     * Create the <code>Ext</code> object for a <code>Unary</code> AST node.
1429     * @return the <code>Ext</code> object for a <code>Unary</code> AST node.
1430     */
1431    protected Ext extUnaryImpl() {
1432        return extExprImpl();
1433    }
1434
1435    /**
1436     * Create the <code>Ext</code> object for a <code>While</code> AST node.
1437     * @return the <code>Ext</code> object for a <code>While</code> AST node.
1438     */
1439    protected Ext extWhileImpl() {
1440        return extLoopImpl();
1441    }
1442
1443
1444
1445    // ********************************************
1446 // Post methods
1447 // ********************************************
1448
1449    protected Ext postExtAmbAssign(Ext ext) {
1450        return postExtAssign(ext);
1451    }
1452
1453    protected Ext postExtAmbExpr(Ext ext) {
1454        return postExtExpr(ext);
1455    }
1456
1457    protected Ext postExtAmbPrefix(Ext ext) {
1458        return postExtNode(ext);
1459    }
1460
1461    protected Ext postExtAmbQualifierNode(Ext ext) {
1462        return postExtNode(ext);
1463    }
1464
1465    protected Ext postExtAmbReceiver(Ext ext) {
1466        return postExtNode(ext);
1467    }
1468
1469    protected Ext postExtAmbTypeNode(Ext ext) {
1470        return postExtTypeNode(ext);
1471    }
1472
1473    protected Ext postExtArrayAccess(Ext ext) {
1474        return postExtExpr(ext);
1475    }
1476
1477    protected Ext postExtArrayInit(Ext ext) {
1478        return postExtExpr(ext);
1479    }
1480
1481    protected Ext postExtArrayTypeNode(Ext ext) {
1482        return postExtTypeNode(ext);
1483    }
1484
1485    protected Ext postExtAssert(Ext ext) {
1486        return postExtStmt(ext);
1487    }
1488
1489    protected Ext postExtAssign(Ext ext) {
1490        return postExtExpr(ext);
1491    }
1492
1493    protected Ext postExtLocalAssign(Ext ext) {
1494        return postExtAssign(ext);
1495    }
1496
1497    protected Ext postExtFieldAssign(Ext ext) {
1498        return postExtAssign(ext);
1499    }
1500
1501    protected Ext postExtArrayAccessAssign(Ext ext) {
1502        return postExtAssign(ext);
1503    }
1504
1505    protected Ext postExtBinary(Ext ext) {
1506        return postExtExpr(ext);
1507    }
1508
1509    protected Ext postExtBlock(Ext ext) {
1510        return postExtStmt(ext);
1511    }
1512
1513    protected Ext postExtBooleanLit(Ext ext) {
1514        return postExtLit(ext);
1515    }
1516
1517    protected Ext postExtBranch(Ext ext) {
1518        return postExtStmt(ext);
1519    }
1520
1521    protected Ext postExtCall(Ext ext) {
1522        return postExtExpr(ext);
1523    }
1524
1525    protected Ext postExtCanonicalTypeNode(Ext ext) {
1526        return postExtTypeNode(ext);
1527    }
1528
1529    protected Ext postExtCase(Ext ext) {
1530        return postExtSwitchElement(ext);
1531    }
1532
1533    protected Ext postExtCast(Ext ext) {
1534        return postExtExpr(ext);
1535    }
1536
1537    protected Ext postExtCatch(Ext ext) {
1538        return postExtStmt(ext);
1539    }
1540
1541    protected Ext postExtCharLit(Ext ext) {
1542        return postExtNumLit(ext);
1543    }
1544
1545    protected Ext postExtClassBody(Ext ext) {
1546        return postExtTerm(ext);
1547    }
1548
1549    protected Ext postExtClassDecl(Ext ext) {
1550        return postExtTerm(ext);
1551    }
1552
1553    protected Ext postExtClassLit(Ext ext) {
1554        return postExtLit(ext);
1555    }
1556
1557    protected Ext postExtClassMember(Ext ext) {
1558        return postExtNode(ext);
1559    }
1560
1561    protected Ext postExtCodeDecl(Ext ext) {
1562        return postExtClassMember(ext);
1563    }
1564
1565    protected Ext postExtConditional(Ext ext) {
1566        return postExtExpr(ext);
1567    }
1568
1569    protected Ext postExtConstructorCall(Ext ext) {
1570        return postExtStmt(ext);
1571    }
1572
1573    protected Ext postExtConstructorDecl(Ext ext) {
1574        return postExtProcedureDecl(ext);
1575    }
1576
1577    protected Ext postExtDo(Ext ext) {
1578        return postExtLoop(ext);
1579    }
1580
1581    protected Ext postExtEmpty(Ext ext) {
1582        return postExtStmt(ext);
1583    }
1584
1585    protected Ext postExtEval(Ext ext) {
1586        return postExtStmt(ext);
1587    }
1588
1589    protected Ext postExtExpr(Ext ext) {
1590        return postExtTerm(ext);
1591    }
1592
1593    protected Ext postExtField(Ext ext) {
1594        return postExtExpr(ext);
1595    }
1596
1597    protected Ext postExtFieldDecl(Ext ext) {
1598        return postExtClassMember(ext);
1599    }
1600
1601    protected Ext postExtFloatLit(Ext ext) {
1602        return postExtLit(ext);
1603    }
1604
1605    protected Ext postExtFor(Ext ext) {
1606        return postExtLoop(ext);
1607    }
1608
1609    protected Ext postExtFormal(Ext ext) {
1610        return postExtNode(ext);
1611    }
1612
1613    protected Ext postExtIf(Ext ext) {
1614        return postExtStmt(ext);
1615    }
1616
1617    protected Ext postExtImport(Ext ext) {
1618        return postExtNode(ext);
1619    }
1620
1621    protected Ext postExtInitializer(Ext ext) {
1622        return postExtCodeDecl(ext);
1623    }
1624
1625    protected Ext postExtInstanceof(Ext ext) {
1626        return postExtExpr(ext);
1627    }
1628
1629    protected Ext postExtIntLit(Ext ext) {
1630        return postExtNumLit(ext);
1631    }
1632
1633    protected Ext postExtLabeled(Ext ext) {
1634        return postExtStmt(ext);
1635    }
1636
1637    protected Ext postExtLit(Ext ext) {
1638        return postExtExpr(ext);
1639    }
1640
1641    protected Ext postExtLocal(Ext ext) {
1642        return postExtExpr(ext);
1643    }
1644
1645    protected Ext postExtLocalClassDecl(Ext ext) {
1646        return postExtStmt(ext);
1647    }
1648
1649    protected Ext postExtLocalDecl(Ext ext) {
1650        return postExtNode(ext);
1651    }
1652
1653    protected Ext postExtLoop(Ext ext) {
1654        return postExtStmt(ext);
1655    }
1656
1657    protected Ext postExtMethodDecl(Ext ext) {
1658        return postExtProcedureDecl(ext);
1659    }
1660
1661    protected Ext postExtNewArray(Ext ext) {
1662        return postExtExpr(ext);
1663    }
1664
1665    protected Ext postExtNode(Ext ext) {
1666        return ext;
1667    }
1668
1669    protected Ext postExtNew(Ext ext) {
1670        return postExtExpr(ext);
1671    }
1672
1673    protected Ext postExtNullLit(Ext ext) {
1674        return postExtLit(ext);
1675    }
1676
1677    protected Ext postExtNumLit(Ext ext) {
1678        return postExtLit(ext);
1679    }
1680
1681    protected Ext postExtPackageNode(Ext ext) {
1682        return postExtNode(ext);
1683    }
1684
1685    protected Ext postExtProcedureDecl(Ext ext) {
1686        return postExtCodeDecl(ext);
1687    }
1688
1689    protected Ext postExtReturn(Ext ext) {
1690        return postExtStmt(ext);
1691    }
1692
1693    protected Ext postExtSourceCollection(Ext ext) {
1694        return postExtNode(ext);
1695    }
1696
1697    protected Ext postExtSourceFile(Ext ext) {
1698        return postExtNode(ext);
1699    }
1700
1701    protected Ext postExtSpecial(Ext ext) {
1702        return postExtExpr(ext);
1703    }
1704
1705    protected Ext postExtStmt(Ext ext) {
1706        return postExtTerm(ext);
1707    }
1708
1709    protected Ext postExtStringLit(Ext ext) {
1710        return postExtLit(ext);
1711    }
1712
1713    protected Ext postExtSwitchBlock(Ext ext) {
1714        return postExtSwitchElement(ext);
1715    }
1716
1717    protected Ext postExtSwitchElement(Ext ext) {
1718        return postExtStmt(ext);
1719    }
1720
1721    protected Ext postExtSwitch(Ext ext) {
1722        return postExtStmt(ext);
1723    }
1724
1725    protected Ext postExtSynchronized(Ext ext) {
1726        return postExtStmt(ext);
1727    }
1728
1729    protected Ext postExtTerm(Ext ext) {
1730        return postExtNode(ext);
1731    }
1732
1733    protected Ext postExtThrow(Ext ext) {
1734        return postExtStmt(ext);
1735    }
1736
1737    protected Ext postExtTry(Ext ext) {
1738        return postExtStmt(ext);
1739    }
1740
1741    protected Ext postExtTypeNode(Ext ext) {
1742        return postExtNode(ext);
1743    }
1744
1745    protected Ext postExtUnary(Ext ext) {
1746        return postExtExpr(ext);
1747    }
1748
1749    protected Ext postExtWhile(Ext ext) {
1750        return postExtLoop(ext);
1751    }
1752
1753}
1754

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags