KickJava   Java API By Example, From Geeks To Geeks.

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


1 package polyglot.ext.jl.ast;
2
3 import polyglot.ast.DelFactory;
4 import polyglot.ast.JL;
5 import polyglot.util.InternalCompilerError;
6
7 /**
8  * This abstract implementation of <code>DelFactory</code> provides
9  * a way of chaining together DelFactories, and default implementations
10  * of factory methods for each node.
11  *
12  * <p>
13  * For a given type of AST node <code>N</code>, there are three methods:
14  * <code>delN()</code>, <code>delNImpl()</code> and <code>postDelN(JL)</code>.
15  * The method <code>delN()</code> calls <code>delNImpl()</code> to create
16  * an appropriate delegate object, and if other <code>DelFactory</code>s are
17  * chained onto this one, it will also call <code>delN()</code> on the next
18  * <code>DelFactory</code>. The method <code>delN()</code> will then
19  * call <code>postDelN</code>, passing in the newly created extension object.
20  *
21  * <p>
22  * The default implementation of <code>delNImpl()</code> is to simply call
23  * <code>delMImpl()</code>, where <code>M</code> is the immediate
24  * superclass of <code>N</code>. Similarly, the default implementation of
25  * <code>postDelN(JL)</code> is to call <code>postDelM(JL)</code>.
26  *
27  * @see polyglot.ext.jl.ast.AbstractExtFactory_c has a very similar structure.
28  */

29 public abstract class AbstractDelFactory_c implements DelFactory
30 {
31     protected AbstractDelFactory_c() {
32         this(null);
33     }
34     
35     protected AbstractDelFactory_c(DelFactory nextDelFactory) {
36         this.nextDelFactory = nextDelFactory;
37     }
38     
39     /**
40      * The next delFactory in the chain. Whenever an extension is instantiated,
41      * the next delFactory should be called to see if it also has an extension,
42      * and if so, the extensions should be joined together using the method
43      * <code>composeDels</code>
44      */

45     private DelFactory nextDelFactory;
46
47     public DelFactory nextDelFactory() {
48         return nextDelFactory;
49     }
50     /**
51      * Compose two delegates together. Order is important: e1 gets added
52      * at the end of e2's chain.
53      * @param e1 the <code>JL</code> object to add to the end of e2's
54      * chain of delegates.
55      * @param e2 the second <code>JL</code> object that will have e1 added to
56      * its chain of delegates.
57      * @return the result of adding e1 to the end of e2's chain of delegates.
58      */

59     protected JL composeDels(JL e1, JL e2) {
60         if (e1 == null) return e2;
61         if (e2 == null) return e1;
62         throw new InternalCompilerError("Composition of delegates unimplemented.");
63         // add e1 as e2's last extension, by recursing...
64
//return e2.ext(composeDels(e1, e2.ext()));
65
}
66     
67     // ******************************************
68
// Final methods that call the Impl methods to construct
69
// extensions, and then check with nextDelFactory to see if it
70
// also has an extension. Finally, call an appropriate post method,
71
// to allow subclasses to perform operations on the construction Exts
72
// ******************************************
73
public final JL delAmbAssign() {
74         JL e = delAmbAssignImpl();
75
76         if (nextDelFactory != null) {
77             JL e2 = nextDelFactory.delAmbAssign();
78             e = composeDels(e, e2);
79         }
80         return postDelAmbAssign(e);
81     }
82
83     public final JL delAmbExpr() {
84         JL e = delAmbExprImpl();
85
86         if (nextDelFactory != null) {
87             JL e2 = nextDelFactory.delAmbExpr();
88             e = composeDels(e, e2);
89         }
90         return postDelAmbExpr(e);
91     }
92
93     public final JL delAmbPrefix() {
94         JL e = delAmbPrefixImpl();
95
96         if (nextDelFactory != null) {
97             JL e2 = nextDelFactory.delAmbPrefix();
98             e = composeDels(e, e2);
99         }
100         return postDelAmbPrefix(e);
101     }
102
103     public final JL delAmbQualifierNode() {
104         JL e = delAmbQualifierNodeImpl();
105
106         if (nextDelFactory != null) {
107             JL e2 = nextDelFactory.delAmbQualifierNode();
108             e = composeDels(e, e2);
109         }
110         return postDelAmbQualifierNode(e);
111     }
112
113     public final JL delAmbReceiver() {
114         JL e = delAmbReceiverImpl();
115
116         if (nextDelFactory != null) {
117             JL e2 = nextDelFactory.delAmbReceiver();
118             e = composeDels(e, e2);
119         }
120         return postDelAmbReceiver(e);
121     }
122
123     public final JL delAmbTypeNode() {
124         JL e = delAmbTypeNodeImpl();
125
126         if (nextDelFactory != null) {
127             JL e2 = nextDelFactory.delAmbTypeNode();
128             e = composeDels(e, e2);
129         }
130         return postDelAmbTypeNode(e);
131     }
132
133     public final JL delArrayAccess() {
134         JL e = delArrayAccessImpl();
135
136         if (nextDelFactory != null) {
137             JL e2 = nextDelFactory.delArrayAccess();
138             e = composeDels(e, e2);
139         }
140         return postDelArrayAccess(e);
141     }
142
143     public final JL delArrayInit() {
144         JL e = delArrayInitImpl();
145
146         if (nextDelFactory != null) {
147             JL e2 = nextDelFactory.delArrayInit();
148             e = composeDels(e, e2);
149         }
150         return postDelArrayInit(e);
151     }
152
153     public final JL delArrayTypeNode() {
154         JL e = delArrayTypeNodeImpl();
155
156         if (nextDelFactory != null) {
157             JL e2 = nextDelFactory.delArrayTypeNode();
158             e = composeDels(e, e2);
159         }
160         return postDelArrayTypeNode(e);
161     }
162
163     public final JL delAssert() {
164         JL e = delAssertImpl();
165
166         if (nextDelFactory != null) {
167             JL e2 = nextDelFactory.delAssert();
168             e = composeDels(e, e2);
169         }
170         return postDelAssert(e);
171     }
172
173     public final JL delAssign() {
174         JL e = delAssignImpl();
175
176         if (nextDelFactory != null) {
177             JL e2 = nextDelFactory.delAssign();
178             e = composeDels(e, e2);
179         }
180         return postDelAssign(e);
181     }
182
183     public final JL delLocalAssign() {
184         JL e = delLocalAssignImpl();
185
186         if (nextDelFactory != null) {
187             JL e2 = nextDelFactory.delLocalAssign();
188             e = composeDels(e, e2);
189         }
190         return postDelLocalAssign(e);
191     }
192
193     public final JL delFieldAssign() {
194         JL e = delFieldAssignImpl();
195
196         if (nextDelFactory != null) {
197             JL e2 = nextDelFactory.delFieldAssign();
198             e = composeDels(e, e2);
199         }
200         return postDelFieldAssign(e);
201     }
202
203     public final JL delArrayAccessAssign() {
204         JL e = delArrayAccessAssignImpl();
205
206         if (nextDelFactory != null) {
207             JL e2 = nextDelFactory.delArrayAccessAssign();
208             e = composeDels(e, e2);
209         }
210         return postDelArrayAccessAssign(e);
211     }
212
213     public final JL delBinary() {
214         JL e = delBinaryImpl();
215
216         if (nextDelFactory != null) {
217             JL e2 = nextDelFactory.delBinary();
218             e = composeDels(e, e2);
219         }
220         return postDelBinary(e);
221     }
222
223     public final JL delBlock() {
224         JL e = delBlockImpl();
225
226         if (nextDelFactory != null) {
227             JL e2 = nextDelFactory.delBlock();
228             e = composeDels(e, e2);
229         }
230         return postDelBlock(e);
231     }
232
233     public final JL delBooleanLit() {
234         JL e = delBooleanLitImpl();
235
236         if (nextDelFactory != null) {
237             JL e2 = nextDelFactory.delBooleanLit();
238             e = composeDels(e, e2);
239         }
240         return postDelBooleanLit(e);
241     }
242
243     public final JL delBranch() {
244         JL e = delBranchImpl();
245
246         if (nextDelFactory != null) {
247             JL e2 = nextDelFactory.delBranch();
248             e = composeDels(e, e2);
249         }
250         return postDelBranch(e);
251     }
252
253     public final JL delCall() {
254         JL e = delCallImpl();
255
256         if (nextDelFactory != null) {
257             JL e2 = nextDelFactory.delCall();
258             e = composeDels(e, e2);
259         }
260         return postDelCall(e);
261     }
262
263     public final JL delCanonicalTypeNode() {
264         JL e = delCanonicalTypeNodeImpl();
265
266         if (nextDelFactory != null) {
267             JL e2 = nextDelFactory.delCanonicalTypeNode();
268             e = composeDels(e, e2);
269         }
270         return postDelCanonicalTypeNode(e);
271     }
272
273     public final JL delCase() {
274         JL e = delCaseImpl();
275
276         if (nextDelFactory != null) {
277             JL e2 = nextDelFactory.delCase();
278             e = composeDels(e, e2);
279         }
280         return postDelCase(e);
281     }
282
283     public final JL delCast() {
284         JL e = delCastImpl();
285
286         if (nextDelFactory != null) {
287             JL e2 = nextDelFactory.delCast();
288             e = composeDels(e, e2);
289         }
290         return postDelCast(e);
291     }
292
293     public final JL delCatch() {
294         JL e = delCatchImpl();
295
296         if (nextDelFactory != null) {
297             JL e2 = nextDelFactory.delCatch();
298             e = composeDels(e, e2);
299         }
300         return postDelCatch(e);
301     }
302
303     public final JL delCharLit() {
304         JL e = delCharLitImpl();
305
306         if (nextDelFactory != null) {
307             JL e2 = nextDelFactory.delCharLit();
308             e = composeDels(e, e2);
309         }
310         return postDelCharLit(e);
311     }
312
313     public final JL delClassBody() {
314         JL e = delClassBodyImpl();
315
316         if (nextDelFactory != null) {
317             JL e2 = nextDelFactory.delClassBody();
318             e = composeDels(e, e2);
319         }
320         return postDelClassBody(e);
321     }
322
323     public final JL delClassDecl() {
324         JL e = delClassDeclImpl();
325
326         if (nextDelFactory != null) {
327             JL e2 = nextDelFactory.delClassDecl();
328             e = composeDels(e, e2);
329         }
330         return postDelClassDecl(e);
331     }
332
333     public final JL delClassLit() {
334         JL e = delClassLitImpl();
335
336         if (nextDelFactory != null) {
337             JL e2 = nextDelFactory.delClassLit();
338             e = composeDels(e, e2);
339         }
340         return postDelClassLit(e);
341     }
342
343     public final JL delClassMember() {
344         JL e = delClassMemberImpl();
345
346         if (nextDelFactory != null) {
347             JL e2 = nextDelFactory.delClassMember();
348             e = composeDels(e, e2);
349         }
350         return postDelClassMember(e);
351     }
352
353     public final JL delCodeDecl() {
354         JL e = delCodeDeclImpl();
355
356         if (nextDelFactory != null) {
357             JL e2 = nextDelFactory.delCodeDecl();
358             e = composeDels(e, e2);
359         }
360         return postDelCodeDecl(e);
361     }
362
363     public final JL delConditional() {
364         JL e = delConditionalImpl();
365
366         if (nextDelFactory != null) {
367             JL e2 = nextDelFactory.delConditional();
368             e = composeDels(e, e2);
369         }
370         return postDelConditional(e);
371     }
372
373     public final JL delConstructorCall() {
374         JL e = delConstructorCallImpl();
375
376         if (nextDelFactory != null) {
377             JL e2 = nextDelFactory.delConstructorCall();
378             e = composeDels(e, e2);
379         }
380         return postDelConstructorCall(e);
381     }
382
383     public final JL delConstructorDecl() {
384         JL e = delConstructorDeclImpl();
385
386         if (nextDelFactory != null) {
387             JL e2 = nextDelFactory.delConstructorDecl();
388             e = composeDels(e, e2);
389         }
390         return postDelConstructorDecl(e);
391     }
392
393     public final JL delDo() {
394         JL e = delDoImpl();
395
396         if (nextDelFactory != null) {
397             JL e2 = nextDelFactory.delDo();
398             e = composeDels(e, e2);
399         }
400         return postDelDo(e);
401     }
402
403     public final JL delEmpty() {
404         JL e = delEmptyImpl();
405
406         if (nextDelFactory != null) {
407             JL e2 = nextDelFactory.delEmpty();
408             e = composeDels(e, e2);
409         }
410         return postDelEmpty(e);
411     }
412
413     public final JL delEval() {
414         JL e = delEvalImpl();
415
416         if (nextDelFactory != null) {
417             JL e2 = nextDelFactory.delEval();
418             e = composeDels(e, e2);
419         }
420         return postDelEval(e);
421     }
422
423     public final JL delExpr() {
424         JL e = delExprImpl();
425
426         if (nextDelFactory != null) {
427             JL e2 = nextDelFactory.delExpr();
428             e = composeDels(e, e2);
429         }
430         return postDelExpr(e);
431     }
432
433     public final JL delField() {
434         JL e = delFieldImpl();
435
436         if (nextDelFactory != null) {
437             JL e2 = nextDelFactory.delField();
438             e = composeDels(e, e2);
439         }
440         return postDelField(e);
441     }
442
443     public final JL delFieldDecl() {
444         JL e = delFieldDeclImpl();
445
446         if (nextDelFactory != null) {
447             JL e2 = nextDelFactory.delFieldDecl();
448             e = composeDels(e, e2);
449         }
450         return postDelFieldDecl(e);
451     }
452
453     public final JL delFloatLit() {
454         JL e = delFloatLitImpl();
455
456         if (nextDelFactory != null) {
457             JL e2 = nextDelFactory.delFloatLit();
458             e = composeDels(e, e2);
459         }
460         return postDelFloatLit(e);
461     }
462
463     public final JL delFor() {
464         JL e = delForImpl();
465
466         if (nextDelFactory != null) {
467             JL e2 = nextDelFactory.delFor();
468             e = composeDels(e, e2);
469         }
470         return postDelFor(e);
471     }
472
473     public final JL delFormal() {
474         JL e = delFormalImpl();
475
476         if (nextDelFactory != null) {
477             JL e2 = nextDelFactory.delFormal();
478             e = composeDels(e, e2);
479         }
480         return postDelFormal(e);
481     }
482
483     public final JL delIf() {
484         JL e = delIfImpl();
485
486         if (nextDelFactory != null) {
487             JL e2 = nextDelFactory.delIf();
488             e = composeDels(e, e2);
489         }
490         return postDelIf(e);
491     }
492
493     public final JL delImport() {
494         JL e = delImportImpl();
495
496         if (nextDelFactory != null) {
497             JL e2 = nextDelFactory.delImport();
498             e = composeDels(e, e2);
499         }
500         return postDelImport(e);
501     }
502
503     public final JL delInitializer() {
504         JL e = delInitializerImpl();
505
506         if (nextDelFactory != null) {
507             JL e2 = nextDelFactory.delInitializer();
508             e = composeDels(e, e2);
509         }
510         return postDelInitializer(e);
511     }
512
513     public final JL delInstanceof() {
514         JL e = delInstanceofImpl();
515
516         if (nextDelFactory != null) {
517             JL e2 = nextDelFactory.delInstanceof();
518             e = composeDels(e, e2);
519         }
520         return postDelInstanceof(e);
521     }
522
523     public final JL delIntLit() {
524         JL e = delIntLitImpl();
525
526         if (nextDelFactory != null) {
527             JL e2 = nextDelFactory.delIntLit();
528             e = composeDels(e, e2);
529         }
530         return postDelIntLit(e);
531     }
532
533     public final JL delLabeled() {
534         JL e = delLabeledImpl();
535
536         if (nextDelFactory != null) {
537             JL e2 = nextDelFactory.delLabeled();
538             e = composeDels(e, e2);
539         }
540         return postDelLabeled(e);
541     }
542
543     public final JL delLit() {
544         JL e = delLitImpl();
545
546         if (nextDelFactory != null) {
547             JL e2 = nextDelFactory.delLit();
548             e = composeDels(e, e2);
549         }
550         return postDelLit(e);
551     }
552
553     public final JL delLocal() {
554         JL e = delLocalImpl();
555
556         if (nextDelFactory != null) {
557             JL e2 = nextDelFactory.delLocal();
558             e = composeDels(e, e2);
559         }
560         return postDelLocal(e);
561     }
562
563     public final JL delLocalClassDecl() {
564         JL e = delLocalClassDeclImpl();
565
566         if (nextDelFactory != null) {
567             JL e2 = nextDelFactory.delLocalClassDecl();
568             e = composeDels(e, e2);
569         }
570         return postDelLocalClassDecl(e);
571     }
572
573     public final JL delLocalDecl() {
574         JL e = delLocalDeclImpl();
575
576         if (nextDelFactory != null) {
577             JL e2 = nextDelFactory.delLocalDecl();
578             e = composeDels(e, e2);
579         }
580         return postDelLocalDecl(e);
581     }
582
583     public final JL delLoop() {
584         JL e = delLoopImpl();
585
586         if (nextDelFactory != null) {
587             JL e2 = nextDelFactory.delLoop();
588             e = composeDels(e, e2);
589         }
590         return postDelLoop(e);
591     }
592
593     public final JL delMethodDecl() {
594         JL e = delMethodDeclImpl();
595
596         if (nextDelFactory != null) {
597             JL e2 = nextDelFactory.delMethodDecl();
598             e = composeDels(e, e2);
599         }
600         return postDelMethodDecl(e);
601     }
602
603     public final JL delNewArray() {
604         JL e = delNewArrayImpl();
605
606         if (nextDelFactory != null) {
607             JL e2 = nextDelFactory.delNewArray();
608             e = composeDels(e, e2);
609         }
610         return postDelNewArray(e);
611     }
612
613     public final JL delNode() {
614         JL e = delNodeImpl();
615
616         if (nextDelFactory != null) {
617             JL e2 = nextDelFactory.delNode();
618             e = composeDels(e, e2);
619         }
620         return postDelNode(e);
621     }
622
623     public final JL delNew() {
624         JL e = delNewImpl();
625
626         if (nextDelFactory != null) {
627             JL e2 = nextDelFactory.delNew();
628             e = composeDels(e, e2);
629         }
630         return postDelNew(e);
631     }
632
633     public final JL delNullLit() {
634         JL e = delNullLitImpl();
635
636         if (nextDelFactory != null) {
637             JL e2 = nextDelFactory.delNullLit();
638             e = composeDels(e, e2);
639         }
640         return postDelNullLit(e);
641     }
642
643     public final JL delNumLit() {
644         JL e = delNumLitImpl();
645
646         if (nextDelFactory != null) {
647             JL e2 = nextDelFactory.delNumLit();
648             e = composeDels(e, e2);
649         }
650         return postDelNumLit(e);
651     }
652
653     public final JL delPackageNode() {
654         JL e = delPackageNodeImpl();
655
656         if (nextDelFactory != null) {
657             JL e2 = nextDelFactory.delPackageNode();
658             e = composeDels(e, e2);
659         }
660         return postDelPackageNode(e);
661     }
662
663     public final JL delProcedureDecl() {
664         JL e = delProcedureDeclImpl();
665
666         if (nextDelFactory != null) {
667             JL e2 = nextDelFactory.delProcedureDecl();
668             e = composeDels(e, e2);
669         }
670         return postDelProcedureDecl(e);
671     }
672
673     public final JL delReturn() {
674         JL e = delReturnImpl();
675
676         if (nextDelFactory != null) {
677             JL e2 = nextDelFactory.delReturn();
678             e = composeDels(e, e2);
679         }
680         return postDelReturn(e);
681     }
682
683     public final JL delSourceCollection() {
684         JL e = delSourceCollectionImpl();
685
686         if (nextDelFactory != null) {
687             JL e2 = nextDelFactory.delSourceCollection();
688             e = composeDels(e, e2);
689         }
690         return postDelSourceCollection(e);
691     }
692
693     public final JL delSourceFile() {
694         JL e = delSourceFileImpl();
695
696         if (nextDelFactory != null) {
697             JL e2 = nextDelFactory.delSourceFile();
698             e = composeDels(e, e2);
699         }
700         return postDelSourceFile(e);
701     }
702
703     public final JL delSpecial() {
704         JL e = delSpecialImpl();
705
706         if (nextDelFactory != null) {
707             JL e2 = nextDelFactory.delSpecial();
708             e = composeDels(e, e2);
709         }
710         return postDelSpecial(e);
711     }
712
713     public final JL delStmt() {
714         JL e = delStmtImpl();
715
716         if (nextDelFactory != null) {
717             JL e2 = nextDelFactory.delStmt();
718             e = composeDels(e, e2);
719         }
720         return postDelStmt(e);
721     }
722
723     public final JL delStringLit() {
724         JL e = delStringLitImpl();
725
726         if (nextDelFactory != null) {
727             JL e2 = nextDelFactory.delStringLit();
728             e = composeDels(e, e2);
729         }
730         return postDelStringLit(e);
731     }
732
733     public final JL delSwitchBlock() {
734         JL e = delSwitchBlockImpl();
735
736         if (nextDelFactory != null) {
737             JL e2 = nextDelFactory.delSwitchBlock();
738             e = composeDels(e, e2);
739         }
740         return postDelSwitchBlock(e);
741     }
742
743     public final JL delSwitchElement() {
744         JL e = delSwitchElementImpl();
745
746         if (nextDelFactory != null) {
747             JL e2 = nextDelFactory.delSwitchElement();
748             e = composeDels(e, e2);
749         }
750         return postDelSwitchElement(e);
751     }
752
753     public final JL delSwitch() {
754         JL e = delSwitchImpl();
755
756         if (nextDelFactory != null) {
757             JL e2 = nextDelFactory.delSwitch();
758             e = composeDels(e, e2);
759         }
760         return postDelSwitch(e);
761     }
762
763     public final JL delSynchronized() {
764         JL e = delSynchronizedImpl();
765
766         if (nextDelFactory != null) {
767             JL e2 = nextDelFactory.delSynchronized();
768             e = composeDels(e, e2);
769         }
770         return postDelSynchronized(e);
771     }
772
773     public final JL delTerm() {
774         JL e = delTermImpl();
775
776         if (nextDelFactory != null) {
777             JL e2 = nextDelFactory.delTerm();
778             e = composeDels(e, e2);
779         }
780         return postDelTerm(e);
781     }
782
783     public final JL delThrow() {
784         JL e = delThrowImpl();
785
786         if (nextDelFactory != null) {
787             JL e2 = nextDelFactory.delThrow();
788             e = composeDels(e, e2);
789         }
790         return postDelThrow(e);
791     }
792
793     public final JL delTry() {
794         JL e = delTryImpl();
795
796         if (nextDelFactory != null) {
797             JL e2 = nextDelFactory.delTry();
798             e = composeDels(e, e2);
799         }
800         return postDelTry(e);
801     }
802
803     public final JL delTypeNode() {
804         JL e = delTypeNodeImpl();
805
806         if (nextDelFactory != null) {
807             JL e2 = nextDelFactory.delTypeNode();
808             e = composeDels(e, e2);
809         }
810         return postDelTypeNode(e);
811     }
812
813     public final JL delUnary() {
814         JL e = delUnaryImpl();
815
816         if (nextDelFactory != null) {
817             JL e2 = nextDelFactory.delUnary();
818             e = composeDels(e, e2);
819         }
820         return postDelUnary(e);
821     }
822
823     public final JL delWhile() {
824         JL e = delWhileImpl();
825
826         if (nextDelFactory != null) {
827             JL e2 = nextDelFactory.delWhile();
828             e = composeDels(e, e2);
829         }
830         return postDelWhile(e);
831     }
832
833     // ********************************************
834
// Impl methods
835
// ********************************************
836

837     /**
838      * Create the delegate for a <code>AmbAssign</code> AST node.
839      * @return the delegate for a <code>AmbAssign</code> AST node.
840      */

841     protected JL delAmbAssignImpl() {
842         return delAssignImpl();
843     }
844
845     /**
846      * Create the delegate for a <code>AmbExpr</code> AST node.
847      * @return the delegate for a <code>AmbExpr</code> AST node.
848      */

849     protected JL delAmbExprImpl() {
850         return delExprImpl();
851     }
852
853     /**
854      * Create the delegate for a <code>AmbPrefix</code> AST node.
855      * @return the delegate for a <code>AmbPrefix</code> AST node.
856      */

857     protected JL delAmbPrefixImpl() {
858         return delNodeImpl();
859     }
860
861     /**
862      * Create the delegate for a <code>AmbQualifierNode</code> AST node.
863      * @return the delegate for a <code>AmbQualifierNode</code> AST node.
864      */

865     protected JL delAmbQualifierNodeImpl() {
866         return delNodeImpl();
867     }
868
869     /**
870      * Create the delegate for a <code>AmbReceiver</code> AST node.
871      * @return the delegate for a <code>AmbReceiver</code> AST node.
872      */

873     protected JL delAmbReceiverImpl() {
874         return delNodeImpl();
875     }
876
877     /**
878      * Create the delegate for a <code>AmbTypeNode</code> AST node.
879      * @return the delegate for a <code>AmbTypeNode</code> AST node.
880      */

881     protected JL delAmbTypeNodeImpl() {
882         return delTypeNodeImpl();
883     }
884
885     /**
886      * Create the delegate for a <code>ArrayAccess</code> AST node.
887      * @return the delegate for a <code>ArrayAccess</code> AST node.
888      */

889     protected JL delArrayAccessImpl() {
890         return delExprImpl();
891     }
892
893     /**
894      * Create the delegate for a <code>ArrayInit</code> AST node.
895      * @return the delegate for a <code>ArrayInit</code> AST node.
896      */

897     protected JL delArrayInitImpl() {
898         return delExprImpl();
899     }
900
901     /**
902      * Create the delegate for a <code>ArrayTypeNode</code> AST node.
903      * @return the delegate for a <code>ArrayTypeNode</code> AST node.
904      */

905     protected JL delArrayTypeNodeImpl() {
906         return delTypeNodeImpl();
907     }
908
909     /**
910      * Create the delegate for a <code>Assert</code> AST node.
911      * @return the delegate for a <code>Assert</code> AST node.
912      */

913     protected JL delAssertImpl() {
914         return delStmtImpl();
915     }
916
917     /**
918      * Create the delegate for a <code>Assign</code> AST node.
919      * @return the delegate for a <code>Assign</code> AST node.
920      */

921     protected JL delAssignImpl() {
922         return delExprImpl();
923     }
924
925     /**
926      * Create the delegate for a <code>LocalAssign</code> AST node.
927      * @return the delegate for a <code>LocalAssign</code> AST node.
928      */

929     protected JL delLocalAssignImpl() {
930         return delAssignImpl();
931     }
932
933     /**
934      * Create the delegate for a <code>FieldAssign</code> AST node.
935      * @return the delegate for a <code>FieldAssign</code> AST node.
936      */

937     protected JL delFieldAssignImpl() {
938         return delAssignImpl();
939     }
940
941     /**
942      * Create the delegate for a <code>ArrayAccessAssign</code> AST node.
943      * @return the delegate for a <code>ArrayAccessAssign</code> AST node.
944      */

945     protected JL delArrayAccessAssignImpl() {
946         return delAssignImpl();
947     }
948     protected JL delBinaryImpl() {
949         return delExprImpl();
950     }
951
952     /**
953      * Create the delegate for a <code>Block</code> AST node.
954      * @return the delegate for a <code>Block</code> AST node.
955      */

956     protected JL delBlockImpl() {
957         return delStmtImpl();
958     }
959
960     /**
961      * Create the delegate for a <code>BooleanLit</code> AST node.
962      * @return the delegate for a <code>BooleanLit</code> AST node.
963      */

964     protected JL delBooleanLitImpl() {
965         return delLitImpl();
966     }
967
968     /**
969      * Create the delegate for a <code>Branch</code> AST node.
970      * @return the delegate for a <code>Branch</code> AST node.
971      */

972     protected JL delBranchImpl() {
973         return delStmtImpl();
974     }
975
976     /**
977      * Create the delegate for a <code>Call</code> AST node.
978      * @return the delegate for a <code>Call</code> AST node.
979      */

980     protected JL delCallImpl() {
981         return delExprImpl();
982     }
983
984     /**
985      * Create the delegate for a <code>CanonicalTypeNode</code> AST node.
986      * @return the delegate for a <code>CanonicalTypeNode</code> AST node.
987      */

988     protected JL delCanonicalTypeNodeImpl() {
989         return delTypeNodeImpl();
990     }
991
992     /**
993      * Create the delegate for a <code>Case</code> AST node.
994      * @return the delegate for a <code>Case</code> AST node.
995      */

996     protected JL delCaseImpl() {
997         return delSwitchElementImpl();
998     }
999
1000    /**
1001     * Create the delegate for a <code>Cast</code> AST node.
1002     * @return the delegate for a <code>Cast</code> AST node.
1003     */

1004    protected JL delCastImpl() {
1005        return delExprImpl();
1006    }
1007
1008    /**
1009     * Create the delegate for a <code>Catch</code> AST node.
1010     * @return the delegate for a <code>Catch</code> AST node.
1011     */

1012    protected JL delCatchImpl() {
1013        return delStmtImpl();
1014    }
1015
1016    /**
1017     * Create the delegate for a <code>CharLit</code> AST node.
1018     * @return the delegate for a <code>CharLit</code> AST node.
1019     */

1020    protected JL delCharLitImpl() {
1021        return delNumLitImpl();
1022    }
1023
1024    /**
1025     * Create the delegate for a <code>ClassBody</code> AST node.
1026     * @return the delegate for a <code>ClassBody</code> AST node.
1027     */

1028    protected JL delClassBodyImpl() {
1029        return delTermImpl();
1030    }
1031
1032    /**
1033     * Create the delegate for a <code>ClassDecl</code> AST node.
1034     * @return the delegate for a <code>ClassDecl</code> AST node.
1035     */

1036    protected JL delClassDeclImpl() {
1037        return delTermImpl();
1038    }
1039
1040    /**
1041     * Create the delegate for a <code>ClassLit</code> AST node.
1042     * @return the delegate for a <code>ClassLit</code> AST node.
1043     */

1044    protected JL delClassLitImpl() {
1045        return delLitImpl();
1046    }
1047
1048    /**
1049     * Create the delegate for a <code>ClassMember</code> AST node.
1050     * @return the delegate for a <code>ClassMember</code> AST node.
1051     */

1052    protected JL delClassMemberImpl() {
1053        return delNodeImpl();
1054    }
1055
1056    /**
1057     * Create the delegate for a <code>CodeDecl</code> AST node.
1058     * @return the delegate for a <code>CodeDecl</code> AST node.
1059     */

1060    protected JL delCodeDeclImpl() {
1061        return delClassMemberImpl();
1062    }
1063
1064    /**
1065     * Create the delegate for a <code>Conditional</code> AST node.
1066     * @return the delegate for a <code>Conditional</code> AST node.
1067     */

1068    protected JL delConditionalImpl() {
1069        return delExprImpl();
1070    }
1071
1072    /**
1073     * Create the delegate for a <code>ConstructorCall</code> AST node.
1074     * @return the delegate for a <code>ConstructorCall</code> AST node.
1075     */

1076    protected JL delConstructorCallImpl() {
1077        return delStmtImpl();
1078    }
1079
1080    /**
1081     * Create the delegate for a <code>ConstructorDecl</code> AST node.
1082     * @return the delegate for a <code>ConstructorDecl</code> AST node.
1083     */

1084    protected JL delConstructorDeclImpl() {
1085        return delProcedureDeclImpl();
1086    }
1087
1088    /**
1089     * Create the delegate for a <code>Do</code> AST node.
1090     * @return the delegate for a <code>Do</code> AST node.
1091     */

1092    protected JL delDoImpl() {
1093        return delLoopImpl();
1094    }
1095
1096    /**
1097     * Create the delegate for a <code>Empty</code> AST node.
1098     * @return the delegate for a <code>Empty</code> AST node.
1099     */

1100    protected JL delEmptyImpl() {
1101        return delStmtImpl();
1102    }
1103
1104    /**
1105     * Create the delegate for a <code>Eval</code> AST node.
1106     * @return the delegate for a <code>Eval</code> AST node.
1107     */

1108    protected JL delEvalImpl() {
1109        return delStmtImpl();
1110    }
1111
1112    /**
1113     * Create the delegate for a <code>Expr</code> AST node.
1114     * @return the delegate for a <code>Expr</code> AST node.
1115     */

1116    protected JL delExprImpl() {
1117        return delTermImpl();
1118    }
1119
1120    /**
1121     * Create the delegate for a <code>Field</code> AST node.
1122     * @return the delegate for a <code>Field</code> AST node.
1123     */

1124    protected JL delFieldImpl() {
1125        return delExprImpl();
1126    }
1127
1128    /**
1129     * Create the delegate for a <code>FieldDecl</code> AST node.
1130     * @return the delegate for a <code>FieldDecl</code> AST node.
1131     */

1132    protected JL delFieldDeclImpl() {
1133        return delClassMemberImpl();
1134    }
1135
1136    /**
1137     * Create the delegate for a <code>FloatLit</code> AST node.
1138     * @return the delegate for a <code>FloatLit</code> AST node.
1139     */

1140    protected JL delFloatLitImpl() {
1141        return delLitImpl();
1142    }
1143
1144    /**
1145     * Create the delegate for a <code>For</code> AST node.
1146     * @return the delegate for a <code>For</code> AST node.
1147     */

1148    protected JL delForImpl() {
1149        return delLoopImpl();
1150    }
1151
1152    /**
1153     * Create the delegate for a <code>Formal</code> AST node.
1154     * @return the delegate for a <code>Formal</code> AST node.
1155     */

1156    protected JL delFormalImpl() {
1157        return delNodeImpl();
1158    }
1159
1160    /**
1161     * Create the delegate for a <code>If</code> AST node.
1162     * @return the delegate for a <code>If</code> AST node.
1163     */

1164    protected JL delIfImpl() {
1165        return delStmtImpl();
1166    }
1167
1168    /**
1169     * Create the delegate for a <code>Import</code> AST node.
1170     * @return the delegate for a <code>Import</code> AST node.
1171     */

1172    protected JL delImportImpl() {
1173        return delNodeImpl();
1174    }
1175
1176    /**
1177     * Create the delegate for a <code>Initializer</code> AST node.
1178     * @return the delegate for a <code>Initializer</code> AST node.
1179     */

1180    protected JL delInitializerImpl() {
1181        return delCodeDeclImpl();
1182    }
1183
1184    /**
1185     * Create the delegate for a <code>Instanceof</code> AST node.
1186     * @return the delegate for a <code>Instanceof</code> AST node.
1187     */

1188    protected JL delInstanceofImpl() {
1189        return delExprImpl();
1190    }
1191
1192    /**
1193     * Create the delegate for a <code>IntLit</code> AST node.
1194     * @return the delegate for a <code>IntLit</code> AST node.
1195     */

1196    protected JL delIntLitImpl() {
1197        return delNumLitImpl();
1198    }
1199
1200    /**
1201     * Create the delegate for a <code>Labeled</code> AST node.
1202     * @return the delegate for a <code>Labeled</code> AST node.
1203     */

1204    protected JL delLabeledImpl() {
1205        return delStmtImpl();
1206    }
1207
1208    /**
1209     * Create the delegate for a <code>Lit</code> AST node.
1210     * @return the delegate for a <code>Lit</code> AST node.
1211     */

1212    protected JL delLitImpl() {
1213        return delExprImpl();
1214    }
1215
1216    /**
1217     * Create the delegate for a <code>Local</code> AST node.
1218     * @return the delegate for a <code>Local</code> AST node.
1219     */

1220    protected JL delLocalImpl() {
1221        return delExprImpl();
1222    }
1223
1224    /**
1225     * Create the delegate for a <code>LocalClassDecl</code> AST node.
1226     * @return the delegate for a <code>LocalClassDecl</code> AST node.
1227     */

1228    protected JL delLocalClassDeclImpl() {
1229        return delStmtImpl();
1230    }
1231
1232    /**
1233     * Create the delegate for a <code>LocalDecl</code> AST node.
1234     * @return the delegate for a <code>LocalDecl</code> AST node.
1235     */

1236    protected JL delLocalDeclImpl() {
1237        return delNodeImpl();
1238    }
1239
1240    /**
1241     * Create the delegate for a <code>Loop</code> AST node.
1242     * @return the delegate for a <code>Loop</code> AST node.
1243     */

1244    protected JL delLoopImpl() {
1245        return delStmtImpl();
1246    }
1247
1248    /**
1249     * Create the delegate for a <code>MethodDecl</code> AST node.
1250     * @return the delegate for a <code>MethodDecl</code> AST node.
1251     */

1252    protected JL delMethodDeclImpl() {
1253        return delProcedureDeclImpl();
1254    }
1255
1256    /**
1257     * Create the delegate for a <code>NewArray</code> AST node.
1258     * @return the delegate for a <code>NewArray</code> AST node.
1259     */

1260    protected JL delNewArrayImpl() {
1261        return delExprImpl();
1262    }
1263
1264    /**
1265     * Create the delegate for a <code>Node</code> AST node.
1266     * @return the delegate for a <code>Node</code> AST node.
1267     */

1268    protected JL delNodeImpl() {
1269        return null;
1270    }
1271
1272    /**
1273     * Create the delegate for a <code>New</code> AST node.
1274     * @return the delegate for a <code>New</code> AST node.
1275     */

1276    protected JL delNewImpl() {
1277        return delExprImpl();
1278    }
1279
1280    /**
1281     * Create the delegate for a <code>NullLit</code> AST node.
1282     * @return the delegate for a <code>NullLit</code> AST node.
1283     */

1284    protected JL delNullLitImpl() {
1285        return delLitImpl();
1286    }
1287
1288    /**
1289     * Create the delegate for a <code>NumLit</code> AST node.
1290     * @return the delegate for a <code>NumLit</code> AST node.
1291     */

1292    protected JL delNumLitImpl() {
1293        return delLitImpl();
1294    }
1295
1296    /**
1297     * Create the delegate for a <code>PackageNode</code> AST node.
1298     * @return the delegate for a <code>PackageNode</code> AST node.
1299     */

1300    protected JL delPackageNodeImpl() {
1301        return delNodeImpl();
1302    }
1303
1304    /**
1305     * Create the delegate for a <code>ProcedureDecl</code> AST node.
1306     * @return the delegate for a <code>ProcedureDecl</code> AST node.
1307     */

1308    protected JL delProcedureDeclImpl() {
1309        return delCodeDeclImpl();
1310    }
1311
1312    /**
1313     * Create the delegate for a <code>Return</code> AST node.
1314     * @return the delegate for a <code>Return</code> AST node.
1315     */

1316    protected JL delReturnImpl() {
1317        return delStmtImpl();
1318    }
1319
1320    /**
1321     * Create the delegate for a <code>SourceCollection</code> AST node.
1322     * @return the delegate for a <code>SourceCollection</code> AST node.
1323     */

1324    protected JL delSourceCollectionImpl() {
1325        return delNodeImpl();
1326    }
1327
1328    /**
1329     * Create the delegate for a <code>SourceFile</code> AST node.
1330     * @return the delegate for a <code>SourceFile</code> AST node.
1331     */

1332    protected JL delSourceFileImpl() {
1333        return delNodeImpl();
1334    }
1335
1336    /**
1337     * Create the delegate for a <code>Special</code> AST node.
1338     * @return the delegate for a <code>Special</code> AST node.
1339     */

1340    protected JL delSpecialImpl() {
1341        return delExprImpl();
1342    }
1343
1344    /**
1345     * Create the delegate for a <code>Stmt</code> AST node.
1346     * @return the delegate for a <code>Stmt</code> AST node.
1347     */

1348    protected JL delStmtImpl() {
1349        return delTermImpl();
1350    }
1351
1352    /**
1353     * Create the delegate for a <code>StringLit</code> AST node.
1354     * @return the delegate for a <code>StringLit</code> AST node.
1355     */

1356    protected JL delStringLitImpl() {
1357        return delLitImpl();
1358    }
1359
1360    /**
1361     * Create the delegate for a <code>SwitchBlock</code> AST node.
1362     * @return the delegate for a <code>SwitchBlock</code> AST node.
1363     */

1364    protected JL delSwitchBlockImpl() {
1365        return delSwitchElementImpl();
1366    }
1367
1368    /**
1369     * Create the delegate for a <code>SwitchElement</code> AST node.
1370     * @return the delegate for a <code>SwitchElement</code> AST node.
1371     */

1372    protected JL delSwitchElementImpl() {
1373        return delStmtImpl();
1374    }
1375
1376    /**
1377     * Create the delegate for a <code>Switch</code> AST node.
1378     * @return the delegate for a <code>Switch</code> AST node.
1379     */

1380    protected JL delSwitchImpl() {
1381        return delStmtImpl();
1382    }
1383
1384    /**
1385     * Create the delegate for a <code>Synchronized</code> AST node.
1386     * @return the delegate for a <code>Synchronized</code> AST node.
1387     */

1388    protected JL delSynchronizedImpl() {
1389        return delStmtImpl();
1390    }
1391
1392    /**
1393     * Create the delegate for a <code>Term</code> AST node.
1394     * @return the delegate for a <code>Term</code> AST node.
1395     */

1396    protected JL delTermImpl() {
1397        return delNodeImpl();
1398    }
1399
1400    /**
1401     * Create the delegate for a <code>Throw</code> AST node.
1402     * @return the delegate for a <code>Throw</code> AST node.
1403     */

1404    protected JL delThrowImpl() {
1405        return delStmtImpl();
1406    }
1407
1408    /**
1409     * Create the delegate for a <code>Try</code> AST node.
1410     * @return the delegate for a <code>Try</code> AST node.
1411     */

1412    protected JL delTryImpl() {
1413        return delStmtImpl();
1414    }
1415
1416    /**
1417     * Create the delegate for a <code>TypeNode</code> AST node.
1418     * @return the delegate for a <code>TypeNode</code> AST node.
1419     */

1420    protected JL delTypeNodeImpl() {
1421        return delNodeImpl();
1422    }
1423
1424    /**
1425     * Create the delegate for a <code>Unary</code> AST node.
1426     * @return the delegate for a <code>Unary</code> AST node.
1427     */

1428    protected JL delUnaryImpl() {
1429        return delExprImpl();
1430    }
1431
1432    /**
1433     * Create the delegate for a <code>While</code> AST node.
1434     * @return the delegate for a <code>While</code> AST node.
1435     */

1436    protected JL delWhileImpl() {
1437        return delLoopImpl();
1438    }
1439
1440    // ********************************************
1441
// Post methods
1442
// ********************************************
1443

1444    protected JL postDelAmbAssign(JL del) {
1445        return postDelAssign(del);
1446    }
1447
1448    protected JL postDelAmbExpr(JL del) {
1449        return postDelExpr(del);
1450    }
1451
1452    protected JL postDelAmbPrefix(JL del) {
1453        return postDelNode(del);
1454    }
1455
1456    protected JL postDelAmbQualifierNode(JL del) {
1457        return postDelNode(del);
1458    }
1459
1460    protected JL postDelAmbReceiver(JL del) {
1461        return postDelNode(del);
1462    }
1463
1464    protected JL postDelAmbTypeNode(JL del) {
1465        return postDelTypeNode(del);
1466    }
1467
1468    protected JL postDelArrayAccess(JL del) {
1469        return postDelExpr(del);
1470    }
1471
1472    protected JL postDelArrayInit(JL del) {
1473        return postDelExpr(del);
1474    }
1475
1476    protected JL postDelArrayTypeNode(JL del) {
1477        return postDelTypeNode(del);
1478    }
1479
1480    protected JL postDelAssert(JL del) {
1481        return postDelStmt(del);
1482    }
1483
1484    protected JL postDelAssign(JL del) {
1485        return postDelExpr(del);
1486    }
1487
1488    protected JL postDelLocalAssign(JL del) {
1489        return postDelAssign(del);
1490    }
1491
1492    protected JL postDelFieldAssign(JL del) {
1493        return postDelAssign(del);
1494    }
1495
1496    protected JL postDelArrayAccessAssign(JL del) {
1497        return postDelAssign(del);
1498    }
1499
1500    protected JL postDelBinary(JL del) {
1501        return postDelExpr(del);
1502    }
1503
1504    protected JL postDelBlock(JL del) {
1505        return postDelStmt(del);
1506    }
1507
1508    protected JL postDelBooleanLit(JL del) {
1509        return postDelLit(del);
1510    }
1511
1512    protected JL postDelBranch(JL del) {
1513        return postDelStmt(del);
1514    }
1515
1516    protected JL postDelCall(JL del) {
1517        return postDelExpr(del);
1518    }
1519
1520    protected JL postDelCanonicalTypeNode(JL del) {
1521        return postDelTypeNode(del);
1522    }
1523
1524    protected JL postDelCase(JL del) {
1525        return postDelSwitchElement(del);
1526    }
1527
1528    protected JL postDelCast(JL del) {
1529        return postDelExpr(del);
1530    }
1531
1532    protected JL postDelCatch(JL del) {
1533        return postDelStmt(del);
1534    }
1535
1536    protected JL postDelCharLit(JL del) {
1537        return postDelNumLit(del);
1538    }
1539
1540    protected JL postDelClassBody(JL del) {
1541        return postDelTerm(del);
1542    }
1543
1544    protected JL postDelClassDecl(JL del) {
1545        return postDelTerm(del);
1546    }
1547
1548    protected JL postDelClassLit(JL del) {
1549        return postDelLit(del);
1550    }
1551
1552    protected JL postDelClassMember(JL del) {
1553        return postDelNode(del);
1554    }
1555
1556    protected JL postDelCodeDecl(JL del) {
1557        return postDelClassMember(del);
1558    }
1559
1560    protected JL postDelConditional(JL del) {
1561        return postDelExpr(del);
1562    }
1563
1564    protected JL postDelConstructorCall(JL del) {
1565        return postDelStmt(del);
1566    }
1567
1568    protected JL postDelConstructorDecl(JL del) {
1569        return postDelProcedureDecl(del);
1570    }
1571
1572    protected JL postDelDo(JL del) {
1573        return postDelLoop(del);
1574    }
1575
1576    protected JL postDelEmpty(JL del) {
1577        return postDelStmt(del);
1578    }
1579
1580    protected JL postDelEval(JL del) {
1581        return postDelStmt(del);
1582    }
1583
1584    protected JL postDelExpr(JL del) {
1585        return postDelTerm(del);
1586    }
1587
1588    protected JL postDelField(JL del) {
1589        return postDelExpr(del);
1590    }
1591
1592    protected JL postDelFieldDecl(JL del) {
1593        return postDelClassMember(del);
1594    }
1595
1596    protected JL postDelFloatLit(JL del) {
1597        return postDelLit(del);
1598    }
1599
1600    protected JL postDelFor(JL del) {
1601        return postDelLoop(del);
1602    }
1603
1604    protected JL postDelFormal(JL del) {
1605        return postDelNode(del);
1606    }
1607
1608    protected JL postDelIf(JL del) {
1609        return postDelStmt(del);
1610    }
1611
1612    protected JL postDelImport(JL del) {
1613        return postDelNode(del);
1614    }
1615
1616    protected JL postDelInitializer(JL del) {
1617        return postDelCodeDecl(del);
1618    }
1619
1620    protected JL postDelInstanceof(JL del) {
1621        return postDelExpr(del);
1622    }
1623
1624    protected JL postDelIntLit(JL del) {
1625        return postDelNumLit(del);
1626    }
1627
1628    protected JL postDelLabeled(JL del) {
1629        return postDelStmt(del);
1630    }
1631
1632    protected JL postDelLit(JL del) {
1633        return postDelExpr(del);
1634    }
1635
1636    protected JL postDelLocal(JL del) {
1637        return postDelExpr(del);
1638    }
1639
1640    protected JL postDelLocalClassDecl(JL del) {
1641        return postDelStmt(del);
1642    }
1643
1644    protected JL postDelLocalDecl(JL del) {
1645        return postDelNode(del);
1646    }
1647
1648    protected JL postDelLoop(JL del) {
1649        return postDelStmt(del);
1650    }
1651
1652    protected JL postDelMethodDecl(JL del) {
1653        return postDelProcedureDecl(del);
1654    }
1655
1656    protected JL postDelNewArray(JL del) {
1657        return postDelExpr(del);
1658    }
1659
1660    protected JL postDelNode(JL del) {
1661        return del;
1662    }
1663
1664    protected JL postDelNew(JL del) {
1665        return postDelExpr(del);
1666    }
1667
1668    protected JL postDelNullLit(JL del) {
1669        return postDelLit(del);
1670    }
1671
1672    protected JL postDelNumLit(JL del) {
1673        return postDelLit(del);
1674    }
1675
1676    protected JL postDelPackageNode(JL del) {
1677        return postDelNode(del);
1678    }
1679
1680    protected JL postDelProcedureDecl(JL del) {
1681        return postDelCodeDecl(del);
1682    }
1683
1684    protected JL postDelReturn(JL del) {
1685        return postDelStmt(del);
1686    }
1687
1688    protected JL postDelSourceCollection(JL del) {
1689        return postDelNode(del);
1690    }
1691
1692    protected JL postDelSourceFile(JL del) {
1693        return postDelNode(del);
1694    }
1695
1696    protected JL postDelSpecial(JL del) {
1697        return postDelExpr(del);
1698    }
1699
1700    protected JL postDelStmt(JL del) {
1701        return postDelTerm(del);
1702    }
1703
1704    protected JL postDelStringLit(JL del) {
1705        return postDelLit(del);
1706    }
1707
1708    protected JL postDelSwitchBlock(JL del) {
1709        return postDelSwitchElement(del);
1710    }
1711
1712    protected JL postDelSwitchElement(JL del) {
1713        return postDelStmt(del);
1714    }
1715
1716    protected JL postDelSwitch(JL del) {
1717        return postDelStmt(del);
1718    }
1719
1720    protected JL postDelSynchronized(JL del) {
1721        return postDelStmt(del);
1722    }
1723
1724    protected JL postDelTerm(JL del) {
1725        return postDelNode(del);
1726    }
1727
1728    protected JL postDelThrow(JL del) {
1729        return postDelStmt(del);
1730    }
1731
1732    protected JL postDelTry(JL del) {
1733        return postDelStmt(del);
1734    }
1735
1736    protected JL postDelTypeNode(JL del) {
1737        return postDelNode(del);
1738    }
1739
1740    protected JL postDelUnary(JL del) {
1741        return postDelExpr(del);
1742    }
1743
1744    protected JL postDelWhile(JL del) {
1745        return postDelLoop(del);
1746    }
1747
1748}
1749
Popular Tags