001 package edu.rice.cs.javalanglevels.tree;
002
003 /** An abstract implementation of a visitor over JExpressionIF that does not return a value.
004 ** This visitor implements the visitor interface with methods that
005 ** first visit children, and then call visitCASEOnly().
006 ** (CASE is replaced by the case name.)
007 ** The default implementation of the forCASEOnly methods call
008 ** protected method defaultCase(). This method defaults to no-op.
009 **/
010 public class JExpressionIFDepthFirstVisitor_void implements JExpressionIFVisitor_void {
011 /* Methods to visit an item. */
012 public void forJExpressionDoFirst(JExpression that) {
013 defaultDoFirst(that);
014 }
015
016 public void forJExpressionOnly(JExpression that) {
017 defaultCase(that);
018 }
019
020 public void forSourceFileDoFirst(SourceFile that) {
021 forJExpressionDoFirst(that);
022 }
023
024 public void forSourceFileOnly(SourceFile that) {
025 forJExpressionOnly(that);
026 }
027
028 public void forModifiersAndVisibilityDoFirst(ModifiersAndVisibility that) {
029 forJExpressionDoFirst(that);
030 }
031
032 public void forModifiersAndVisibilityOnly(ModifiersAndVisibility that) {
033 forJExpressionOnly(that);
034 }
035
036 public void forCompoundWordDoFirst(CompoundWord that) {
037 forJExpressionDoFirst(that);
038 }
039
040 public void forCompoundWordOnly(CompoundWord that) {
041 forJExpressionOnly(that);
042 }
043
044 public void forWordDoFirst(Word that) {
045 forJExpressionDoFirst(that);
046 }
047
048 public void forWordOnly(Word that) {
049 forJExpressionOnly(that);
050 }
051
052 public void forTypeDefBaseDoFirst(TypeDefBase that) {
053 forJExpressionDoFirst(that);
054 }
055
056 public void forTypeDefBaseOnly(TypeDefBase that) {
057 forJExpressionOnly(that);
058 }
059
060 public void forClassDefDoFirst(ClassDef that) {
061 forTypeDefBaseDoFirst(that);
062 }
063
064 public void forClassDefOnly(ClassDef that) {
065 forTypeDefBaseOnly(that);
066 }
067
068 public void forInnerClassDefDoFirst(InnerClassDef that) {
069 forClassDefDoFirst(that);
070 }
071
072 public void forInnerClassDefOnly(InnerClassDef that) {
073 forClassDefOnly(that);
074 }
075
076 public void forInterfaceDefDoFirst(InterfaceDef that) {
077 forTypeDefBaseDoFirst(that);
078 }
079
080 public void forInterfaceDefOnly(InterfaceDef that) {
081 forTypeDefBaseOnly(that);
082 }
083
084 public void forInnerInterfaceDefDoFirst(InnerInterfaceDef that) {
085 forInterfaceDefDoFirst(that);
086 }
087
088 public void forInnerInterfaceDefOnly(InnerInterfaceDef that) {
089 forInterfaceDefOnly(that);
090 }
091
092 public void forConstructorDefDoFirst(ConstructorDef that) {
093 forJExpressionDoFirst(that);
094 }
095
096 public void forConstructorDefOnly(ConstructorDef that) {
097 forJExpressionOnly(that);
098 }
099
100 public void forInitializerDoFirst(Initializer that) {
101 forJExpressionDoFirst(that);
102 }
103
104 public void forInitializerOnly(Initializer that) {
105 forJExpressionOnly(that);
106 }
107
108 public void forInstanceInitializerDoFirst(InstanceInitializer that) {
109 forInitializerDoFirst(that);
110 }
111
112 public void forInstanceInitializerOnly(InstanceInitializer that) {
113 forInitializerOnly(that);
114 }
115
116 public void forStaticInitializerDoFirst(StaticInitializer that) {
117 forInitializerDoFirst(that);
118 }
119
120 public void forStaticInitializerOnly(StaticInitializer that) {
121 forInitializerOnly(that);
122 }
123
124 public void forPackageStatementDoFirst(PackageStatement that) {
125 forJExpressionDoFirst(that);
126 }
127
128 public void forPackageStatementOnly(PackageStatement that) {
129 forJExpressionOnly(that);
130 }
131
132 public void forImportStatementDoFirst(ImportStatement that) {
133 forJExpressionDoFirst(that);
134 }
135
136 public void forImportStatementOnly(ImportStatement that) {
137 forJExpressionOnly(that);
138 }
139
140 public void forClassImportStatementDoFirst(ClassImportStatement that) {
141 forImportStatementDoFirst(that);
142 }
143
144 public void forClassImportStatementOnly(ClassImportStatement that) {
145 forImportStatementOnly(that);
146 }
147
148 public void forPackageImportStatementDoFirst(PackageImportStatement that) {
149 forImportStatementDoFirst(that);
150 }
151
152 public void forPackageImportStatementOnly(PackageImportStatement that) {
153 forImportStatementOnly(that);
154 }
155
156 public void forStatementDoFirst(Statement that) {
157 forJExpressionDoFirst(that);
158 }
159
160 public void forStatementOnly(Statement that) {
161 forJExpressionOnly(that);
162 }
163
164 public void forLabeledStatementDoFirst(LabeledStatement that) {
165 forStatementDoFirst(that);
166 }
167
168 public void forLabeledStatementOnly(LabeledStatement that) {
169 forStatementOnly(that);
170 }
171
172 public void forBlockDoFirst(Block that) {
173 forStatementDoFirst(that);
174 }
175
176 public void forBlockOnly(Block that) {
177 forStatementOnly(that);
178 }
179
180 public void forExpressionStatementDoFirst(ExpressionStatement that) {
181 forStatementDoFirst(that);
182 }
183
184 public void forExpressionStatementOnly(ExpressionStatement that) {
185 forStatementOnly(that);
186 }
187
188 public void forSwitchStatementDoFirst(SwitchStatement that) {
189 forStatementDoFirst(that);
190 }
191
192 public void forSwitchStatementOnly(SwitchStatement that) {
193 forStatementOnly(that);
194 }
195
196 public void forIfThenStatementDoFirst(IfThenStatement that) {
197 forStatementDoFirst(that);
198 }
199
200 public void forIfThenStatementOnly(IfThenStatement that) {
201 forStatementOnly(that);
202 }
203
204 public void forIfThenElseStatementDoFirst(IfThenElseStatement that) {
205 forIfThenStatementDoFirst(that);
206 }
207
208 public void forIfThenElseStatementOnly(IfThenElseStatement that) {
209 forIfThenStatementOnly(that);
210 }
211
212 public void forWhileStatementDoFirst(WhileStatement that) {
213 forStatementDoFirst(that);
214 }
215
216 public void forWhileStatementOnly(WhileStatement that) {
217 forStatementOnly(that);
218 }
219
220 public void forDoStatementDoFirst(DoStatement that) {
221 forStatementDoFirst(that);
222 }
223
224 public void forDoStatementOnly(DoStatement that) {
225 forStatementOnly(that);
226 }
227
228 public void forForStatementDoFirst(ForStatement that) {
229 forStatementDoFirst(that);
230 }
231
232 public void forForStatementOnly(ForStatement that) {
233 forStatementOnly(that);
234 }
235
236 public void forBreakStatementDoFirst(BreakStatement that) {
237 forStatementDoFirst(that);
238 }
239
240 public void forBreakStatementOnly(BreakStatement that) {
241 forStatementOnly(that);
242 }
243
244 public void forLabeledBreakStatementDoFirst(LabeledBreakStatement that) {
245 forBreakStatementDoFirst(that);
246 }
247
248 public void forLabeledBreakStatementOnly(LabeledBreakStatement that) {
249 forBreakStatementOnly(that);
250 }
251
252 public void forUnlabeledBreakStatementDoFirst(UnlabeledBreakStatement that) {
253 forBreakStatementDoFirst(that);
254 }
255
256 public void forUnlabeledBreakStatementOnly(UnlabeledBreakStatement that) {
257 forBreakStatementOnly(that);
258 }
259
260 public void forContinueStatementDoFirst(ContinueStatement that) {
261 forStatementDoFirst(that);
262 }
263
264 public void forContinueStatementOnly(ContinueStatement that) {
265 forStatementOnly(that);
266 }
267
268 public void forLabeledContinueStatementDoFirst(LabeledContinueStatement that) {
269 forContinueStatementDoFirst(that);
270 }
271
272 public void forLabeledContinueStatementOnly(LabeledContinueStatement that) {
273 forContinueStatementOnly(that);
274 }
275
276 public void forUnlabeledContinueStatementDoFirst(UnlabeledContinueStatement that) {
277 forContinueStatementDoFirst(that);
278 }
279
280 public void forUnlabeledContinueStatementOnly(UnlabeledContinueStatement that) {
281 forContinueStatementOnly(that);
282 }
283
284 public void forReturnStatementDoFirst(ReturnStatement that) {
285 forStatementDoFirst(that);
286 }
287
288 public void forReturnStatementOnly(ReturnStatement that) {
289 forStatementOnly(that);
290 }
291
292 public void forVoidReturnStatementDoFirst(VoidReturnStatement that) {
293 forReturnStatementDoFirst(that);
294 }
295
296 public void forVoidReturnStatementOnly(VoidReturnStatement that) {
297 forReturnStatementOnly(that);
298 }
299
300 public void forValueReturnStatementDoFirst(ValueReturnStatement that) {
301 forReturnStatementDoFirst(that);
302 }
303
304 public void forValueReturnStatementOnly(ValueReturnStatement that) {
305 forReturnStatementOnly(that);
306 }
307
308 public void forThrowStatementDoFirst(ThrowStatement that) {
309 forStatementDoFirst(that);
310 }
311
312 public void forThrowStatementOnly(ThrowStatement that) {
313 forStatementOnly(that);
314 }
315
316 public void forSynchronizedStatementDoFirst(SynchronizedStatement that) {
317 forStatementDoFirst(that);
318 }
319
320 public void forSynchronizedStatementOnly(SynchronizedStatement that) {
321 forStatementOnly(that);
322 }
323
324 public void forTryCatchStatementDoFirst(TryCatchStatement that) {
325 forStatementDoFirst(that);
326 }
327
328 public void forTryCatchStatementOnly(TryCatchStatement that) {
329 forStatementOnly(that);
330 }
331
332 public void forTryCatchFinallyStatementDoFirst(TryCatchFinallyStatement that) {
333 forTryCatchStatementDoFirst(that);
334 }
335
336 public void forTryCatchFinallyStatementOnly(TryCatchFinallyStatement that) {
337 forTryCatchStatementOnly(that);
338 }
339
340 public void forNormalTryCatchStatementDoFirst(NormalTryCatchStatement that) {
341 forTryCatchStatementDoFirst(that);
342 }
343
344 public void forNormalTryCatchStatementOnly(NormalTryCatchStatement that) {
345 forTryCatchStatementOnly(that);
346 }
347
348 public void forEmptyStatementDoFirst(EmptyStatement that) {
349 forStatementDoFirst(that);
350 }
351
352 public void forEmptyStatementOnly(EmptyStatement that) {
353 forStatementOnly(that);
354 }
355
356 public void forMethodDefDoFirst(MethodDef that) {
357 forJExpressionDoFirst(that);
358 }
359
360 public void forMethodDefOnly(MethodDef that) {
361 forJExpressionOnly(that);
362 }
363
364 public void forConcreteMethodDefDoFirst(ConcreteMethodDef that) {
365 forMethodDefDoFirst(that);
366 }
367
368 public void forConcreteMethodDefOnly(ConcreteMethodDef that) {
369 forMethodDefOnly(that);
370 }
371
372 public void forAbstractMethodDefDoFirst(AbstractMethodDef that) {
373 forMethodDefDoFirst(that);
374 }
375
376 public void forAbstractMethodDefOnly(AbstractMethodDef that) {
377 forMethodDefOnly(that);
378 }
379
380 public void forFormalParameterDoFirst(FormalParameter that) {
381 forJExpressionDoFirst(that);
382 }
383
384 public void forFormalParameterOnly(FormalParameter that) {
385 forJExpressionOnly(that);
386 }
387
388 public void forVariableDeclarationDoFirst(VariableDeclaration that) {
389 forJExpressionDoFirst(that);
390 }
391
392 public void forVariableDeclarationOnly(VariableDeclaration that) {
393 forJExpressionOnly(that);
394 }
395
396 public void forVariableDeclaratorDoFirst(VariableDeclarator that) {
397 forJExpressionDoFirst(that);
398 }
399
400 public void forVariableDeclaratorOnly(VariableDeclarator that) {
401 forJExpressionOnly(that);
402 }
403
404 public void forUninitializedVariableDeclaratorDoFirst(UninitializedVariableDeclarator that) {
405 forVariableDeclaratorDoFirst(that);
406 }
407
408 public void forUninitializedVariableDeclaratorOnly(UninitializedVariableDeclarator that) {
409 forVariableDeclaratorOnly(that);
410 }
411
412 public void forInitializedVariableDeclaratorDoFirst(InitializedVariableDeclarator that) {
413 forVariableDeclaratorDoFirst(that);
414 }
415
416 public void forInitializedVariableDeclaratorOnly(InitializedVariableDeclarator that) {
417 forVariableDeclaratorOnly(that);
418 }
419
420 public void forTypeParameterDoFirst(TypeParameter that) {
421 forJExpressionDoFirst(that);
422 }
423
424 public void forTypeParameterOnly(TypeParameter that) {
425 forJExpressionOnly(that);
426 }
427
428 public void forArrayInitializerDoFirst(ArrayInitializer that) {
429 forJExpressionDoFirst(that);
430 }
431
432 public void forArrayInitializerOnly(ArrayInitializer that) {
433 forJExpressionOnly(that);
434 }
435
436 public void forTypeDoFirst(Type that) {
437 forJExpressionDoFirst(that);
438 }
439
440 public void forTypeOnly(Type that) {
441 forJExpressionOnly(that);
442 }
443
444 public void forPrimitiveTypeDoFirst(PrimitiveType that) {
445 forTypeDoFirst(that);
446 }
447
448 public void forPrimitiveTypeOnly(PrimitiveType that) {
449 forTypeOnly(that);
450 }
451
452 public void forArrayTypeDoFirst(ArrayType that) {
453 forTypeDoFirst(that);
454 }
455
456 public void forArrayTypeOnly(ArrayType that) {
457 forTypeOnly(that);
458 }
459
460 public void forReferenceTypeDoFirst(ReferenceType that) {
461 forTypeDoFirst(that);
462 }
463
464 public void forReferenceTypeOnly(ReferenceType that) {
465 forTypeOnly(that);
466 }
467
468 public void forMemberTypeDoFirst(MemberType that) {
469 forReferenceTypeDoFirst(that);
470 }
471
472 public void forMemberTypeOnly(MemberType that) {
473 forReferenceTypeOnly(that);
474 }
475
476 public void forClassOrInterfaceTypeDoFirst(ClassOrInterfaceType that) {
477 forReferenceTypeDoFirst(that);
478 }
479
480 public void forClassOrInterfaceTypeOnly(ClassOrInterfaceType that) {
481 forReferenceTypeOnly(that);
482 }
483
484 public void forTypeVariableDoFirst(TypeVariable that) {
485 forReferenceTypeDoFirst(that);
486 }
487
488 public void forTypeVariableOnly(TypeVariable that) {
489 forReferenceTypeOnly(that);
490 }
491
492 public void forVoidReturnDoFirst(VoidReturn that) {
493 forJExpressionDoFirst(that);
494 }
495
496 public void forVoidReturnOnly(VoidReturn that) {
497 forJExpressionOnly(that);
498 }
499
500 public void forSwitchCaseDoFirst(SwitchCase that) {
501 forJExpressionDoFirst(that);
502 }
503
504 public void forSwitchCaseOnly(SwitchCase that) {
505 forJExpressionOnly(that);
506 }
507
508 public void forLabeledCaseDoFirst(LabeledCase that) {
509 forSwitchCaseDoFirst(that);
510 }
511
512 public void forLabeledCaseOnly(LabeledCase that) {
513 forSwitchCaseOnly(that);
514 }
515
516 public void forDefaultCaseDoFirst(DefaultCase that) {
517 forSwitchCaseDoFirst(that);
518 }
519
520 public void forDefaultCaseOnly(DefaultCase that) {
521 forSwitchCaseOnly(that);
522 }
523
524 public void forCatchBlockDoFirst(CatchBlock that) {
525 forJExpressionDoFirst(that);
526 }
527
528 public void forCatchBlockOnly(CatchBlock that) {
529 forJExpressionOnly(that);
530 }
531
532 public void forExpressionDoFirst(Expression that) {
533 forJExpressionDoFirst(that);
534 }
535
536 public void forExpressionOnly(Expression that) {
537 forJExpressionOnly(that);
538 }
539
540 public void forAssignmentExpressionDoFirst(AssignmentExpression that) {
541 forExpressionDoFirst(that);
542 }
543
544 public void forAssignmentExpressionOnly(AssignmentExpression that) {
545 forExpressionOnly(that);
546 }
547
548 public void forSimpleAssignmentExpressionDoFirst(SimpleAssignmentExpression that) {
549 forAssignmentExpressionDoFirst(that);
550 }
551
552 public void forSimpleAssignmentExpressionOnly(SimpleAssignmentExpression that) {
553 forAssignmentExpressionOnly(that);
554 }
555
556 public void forPlusAssignmentExpressionDoFirst(PlusAssignmentExpression that) {
557 forAssignmentExpressionDoFirst(that);
558 }
559
560 public void forPlusAssignmentExpressionOnly(PlusAssignmentExpression that) {
561 forAssignmentExpressionOnly(that);
562 }
563
564 public void forNumericAssignmentExpressionDoFirst(NumericAssignmentExpression that) {
565 forAssignmentExpressionDoFirst(that);
566 }
567
568 public void forNumericAssignmentExpressionOnly(NumericAssignmentExpression that) {
569 forAssignmentExpressionOnly(that);
570 }
571
572 public void forMinusAssignmentExpressionDoFirst(MinusAssignmentExpression that) {
573 forNumericAssignmentExpressionDoFirst(that);
574 }
575
576 public void forMinusAssignmentExpressionOnly(MinusAssignmentExpression that) {
577 forNumericAssignmentExpressionOnly(that);
578 }
579
580 public void forMultiplyAssignmentExpressionDoFirst(MultiplyAssignmentExpression that) {
581 forNumericAssignmentExpressionDoFirst(that);
582 }
583
584 public void forMultiplyAssignmentExpressionOnly(MultiplyAssignmentExpression that) {
585 forNumericAssignmentExpressionOnly(that);
586 }
587
588 public void forDivideAssignmentExpressionDoFirst(DivideAssignmentExpression that) {
589 forNumericAssignmentExpressionDoFirst(that);
590 }
591
592 public void forDivideAssignmentExpressionOnly(DivideAssignmentExpression that) {
593 forNumericAssignmentExpressionOnly(that);
594 }
595
596 public void forModAssignmentExpressionDoFirst(ModAssignmentExpression that) {
597 forNumericAssignmentExpressionDoFirst(that);
598 }
599
600 public void forModAssignmentExpressionOnly(ModAssignmentExpression that) {
601 forNumericAssignmentExpressionOnly(that);
602 }
603
604 public void forShiftAssignmentExpressionDoFirst(ShiftAssignmentExpression that) {
605 forAssignmentExpressionDoFirst(that);
606 }
607
608 public void forShiftAssignmentExpressionOnly(ShiftAssignmentExpression that) {
609 forAssignmentExpressionOnly(that);
610 }
611
612 public void forLeftShiftAssignmentExpressionDoFirst(LeftShiftAssignmentExpression that) {
613 forShiftAssignmentExpressionDoFirst(that);
614 }
615
616 public void forLeftShiftAssignmentExpressionOnly(LeftShiftAssignmentExpression that) {
617 forShiftAssignmentExpressionOnly(that);
618 }
619
620 public void forRightSignedShiftAssignmentExpressionDoFirst(RightSignedShiftAssignmentExpression that) {
621 forShiftAssignmentExpressionDoFirst(that);
622 }
623
624 public void forRightSignedShiftAssignmentExpressionOnly(RightSignedShiftAssignmentExpression that) {
625 forShiftAssignmentExpressionOnly(that);
626 }
627
628 public void forRightUnsignedShiftAssignmentExpressionDoFirst(RightUnsignedShiftAssignmentExpression that) {
629 forShiftAssignmentExpressionDoFirst(that);
630 }
631
632 public void forRightUnsignedShiftAssignmentExpressionOnly(RightUnsignedShiftAssignmentExpression that) {
633 forShiftAssignmentExpressionOnly(that);
634 }
635
636 public void forBitwiseAssignmentExpressionDoFirst(BitwiseAssignmentExpression that) {
637 forAssignmentExpressionDoFirst(that);
638 }
639
640 public void forBitwiseAssignmentExpressionOnly(BitwiseAssignmentExpression that) {
641 forAssignmentExpressionOnly(that);
642 }
643
644 public void forBitwiseAndAssignmentExpressionDoFirst(BitwiseAndAssignmentExpression that) {
645 forBitwiseAssignmentExpressionDoFirst(that);
646 }
647
648 public void forBitwiseAndAssignmentExpressionOnly(BitwiseAndAssignmentExpression that) {
649 forBitwiseAssignmentExpressionOnly(that);
650 }
651
652 public void forBitwiseOrAssignmentExpressionDoFirst(BitwiseOrAssignmentExpression that) {
653 forBitwiseAssignmentExpressionDoFirst(that);
654 }
655
656 public void forBitwiseOrAssignmentExpressionOnly(BitwiseOrAssignmentExpression that) {
657 forBitwiseAssignmentExpressionOnly(that);
658 }
659
660 public void forBitwiseXorAssignmentExpressionDoFirst(BitwiseXorAssignmentExpression that) {
661 forBitwiseAssignmentExpressionDoFirst(that);
662 }
663
664 public void forBitwiseXorAssignmentExpressionOnly(BitwiseXorAssignmentExpression that) {
665 forBitwiseAssignmentExpressionOnly(that);
666 }
667
668 public void forBinaryExpressionDoFirst(BinaryExpression that) {
669 forExpressionDoFirst(that);
670 }
671
672 public void forBinaryExpressionOnly(BinaryExpression that) {
673 forExpressionOnly(that);
674 }
675
676 public void forBooleanExpressionDoFirst(BooleanExpression that) {
677 forBinaryExpressionDoFirst(that);
678 }
679
680 public void forBooleanExpressionOnly(BooleanExpression that) {
681 forBinaryExpressionOnly(that);
682 }
683
684 public void forOrExpressionDoFirst(OrExpression that) {
685 forBooleanExpressionDoFirst(that);
686 }
687
688 public void forOrExpressionOnly(OrExpression that) {
689 forBooleanExpressionOnly(that);
690 }
691
692 public void forAndExpressionDoFirst(AndExpression that) {
693 forBooleanExpressionDoFirst(that);
694 }
695
696 public void forAndExpressionOnly(AndExpression that) {
697 forBooleanExpressionOnly(that);
698 }
699
700 public void forBitwiseBinaryExpressionDoFirst(BitwiseBinaryExpression that) {
701 forBinaryExpressionDoFirst(that);
702 }
703
704 public void forBitwiseBinaryExpressionOnly(BitwiseBinaryExpression that) {
705 forBinaryExpressionOnly(that);
706 }
707
708 public void forBitwiseOrExpressionDoFirst(BitwiseOrExpression that) {
709 forBitwiseBinaryExpressionDoFirst(that);
710 }
711
712 public void forBitwiseOrExpressionOnly(BitwiseOrExpression that) {
713 forBitwiseBinaryExpressionOnly(that);
714 }
715
716 public void forBitwiseXorExpressionDoFirst(BitwiseXorExpression that) {
717 forBitwiseBinaryExpressionDoFirst(that);
718 }
719
720 public void forBitwiseXorExpressionOnly(BitwiseXorExpression that) {
721 forBitwiseBinaryExpressionOnly(that);
722 }
723
724 public void forBitwiseAndExpressionDoFirst(BitwiseAndExpression that) {
725 forBitwiseBinaryExpressionDoFirst(that);
726 }
727
728 public void forBitwiseAndExpressionOnly(BitwiseAndExpression that) {
729 forBitwiseBinaryExpressionOnly(that);
730 }
731
732 public void forEqualityExpressionDoFirst(EqualityExpression that) {
733 forBinaryExpressionDoFirst(that);
734 }
735
736 public void forEqualityExpressionOnly(EqualityExpression that) {
737 forBinaryExpressionOnly(that);
738 }
739
740 public void forEqualsExpressionDoFirst(EqualsExpression that) {
741 forEqualityExpressionDoFirst(that);
742 }
743
744 public void forEqualsExpressionOnly(EqualsExpression that) {
745 forEqualityExpressionOnly(that);
746 }
747
748 public void forNotEqualExpressionDoFirst(NotEqualExpression that) {
749 forEqualityExpressionDoFirst(that);
750 }
751
752 public void forNotEqualExpressionOnly(NotEqualExpression that) {
753 forEqualityExpressionOnly(that);
754 }
755
756 public void forComparisonExpressionDoFirst(ComparisonExpression that) {
757 forBinaryExpressionDoFirst(that);
758 }
759
760 public void forComparisonExpressionOnly(ComparisonExpression that) {
761 forBinaryExpressionOnly(that);
762 }
763
764 public void forLessThanExpressionDoFirst(LessThanExpression that) {
765 forComparisonExpressionDoFirst(that);
766 }
767
768 public void forLessThanExpressionOnly(LessThanExpression that) {
769 forComparisonExpressionOnly(that);
770 }
771
772 public void forLessThanOrEqualExpressionDoFirst(LessThanOrEqualExpression that) {
773 forComparisonExpressionDoFirst(that);
774 }
775
776 public void forLessThanOrEqualExpressionOnly(LessThanOrEqualExpression that) {
777 forComparisonExpressionOnly(that);
778 }
779
780 public void forGreaterThanExpressionDoFirst(GreaterThanExpression that) {
781 forComparisonExpressionDoFirst(that);
782 }
783
784 public void forGreaterThanExpressionOnly(GreaterThanExpression that) {
785 forComparisonExpressionOnly(that);
786 }
787
788 public void forGreaterThanOrEqualExpressionDoFirst(GreaterThanOrEqualExpression that) {
789 forComparisonExpressionDoFirst(that);
790 }
791
792 public void forGreaterThanOrEqualExpressionOnly(GreaterThanOrEqualExpression that) {
793 forComparisonExpressionOnly(that);
794 }
795
796 public void forShiftBinaryExpressionDoFirst(ShiftBinaryExpression that) {
797 forBinaryExpressionDoFirst(that);
798 }
799
800 public void forShiftBinaryExpressionOnly(ShiftBinaryExpression that) {
801 forBinaryExpressionOnly(that);
802 }
803
804 public void forLeftShiftExpressionDoFirst(LeftShiftExpression that) {
805 forShiftBinaryExpressionDoFirst(that);
806 }
807
808 public void forLeftShiftExpressionOnly(LeftShiftExpression that) {
809 forShiftBinaryExpressionOnly(that);
810 }
811
812 public void forRightSignedShiftExpressionDoFirst(RightSignedShiftExpression that) {
813 forShiftBinaryExpressionDoFirst(that);
814 }
815
816 public void forRightSignedShiftExpressionOnly(RightSignedShiftExpression that) {
817 forShiftBinaryExpressionOnly(that);
818 }
819
820 public void forRightUnsignedShiftExpressionDoFirst(RightUnsignedShiftExpression that) {
821 forShiftBinaryExpressionDoFirst(that);
822 }
823
824 public void forRightUnsignedShiftExpressionOnly(RightUnsignedShiftExpression that) {
825 forShiftBinaryExpressionOnly(that);
826 }
827
828 public void forPlusExpressionDoFirst(PlusExpression that) {
829 forBinaryExpressionDoFirst(that);
830 }
831
832 public void forPlusExpressionOnly(PlusExpression that) {
833 forBinaryExpressionOnly(that);
834 }
835
836 public void forNumericBinaryExpressionDoFirst(NumericBinaryExpression that) {
837 forBinaryExpressionDoFirst(that);
838 }
839
840 public void forNumericBinaryExpressionOnly(NumericBinaryExpression that) {
841 forBinaryExpressionOnly(that);
842 }
843
844 public void forMinusExpressionDoFirst(MinusExpression that) {
845 forNumericBinaryExpressionDoFirst(that);
846 }
847
848 public void forMinusExpressionOnly(MinusExpression that) {
849 forNumericBinaryExpressionOnly(that);
850 }
851
852 public void forMultiplyExpressionDoFirst(MultiplyExpression that) {
853 forNumericBinaryExpressionDoFirst(that);
854 }
855
856 public void forMultiplyExpressionOnly(MultiplyExpression that) {
857 forNumericBinaryExpressionOnly(that);
858 }
859
860 public void forDivideExpressionDoFirst(DivideExpression that) {
861 forNumericBinaryExpressionDoFirst(that);
862 }
863
864 public void forDivideExpressionOnly(DivideExpression that) {
865 forNumericBinaryExpressionOnly(that);
866 }
867
868 public void forModExpressionDoFirst(ModExpression that) {
869 forNumericBinaryExpressionDoFirst(that);
870 }
871
872 public void forModExpressionOnly(ModExpression that) {
873 forNumericBinaryExpressionOnly(that);
874 }
875
876 public void forNoOpExpressionDoFirst(NoOpExpression that) {
877 forBinaryExpressionDoFirst(that);
878 }
879
880 public void forNoOpExpressionOnly(NoOpExpression that) {
881 forBinaryExpressionOnly(that);
882 }
883
884 public void forUnaryExpressionDoFirst(UnaryExpression that) {
885 forExpressionDoFirst(that);
886 }
887
888 public void forUnaryExpressionOnly(UnaryExpression that) {
889 forExpressionOnly(that);
890 }
891
892 public void forIncrementExpressionDoFirst(IncrementExpression that) {
893 forUnaryExpressionDoFirst(that);
894 }
895
896 public void forIncrementExpressionOnly(IncrementExpression that) {
897 forUnaryExpressionOnly(that);
898 }
899
900 public void forPrefixIncrementExpressionDoFirst(PrefixIncrementExpression that) {
901 forIncrementExpressionDoFirst(that);
902 }
903
904 public void forPrefixIncrementExpressionOnly(PrefixIncrementExpression that) {
905 forIncrementExpressionOnly(that);
906 }
907
908 public void forPositivePrefixIncrementExpressionDoFirst(PositivePrefixIncrementExpression that) {
909 forPrefixIncrementExpressionDoFirst(that);
910 }
911
912 public void forPositivePrefixIncrementExpressionOnly(PositivePrefixIncrementExpression that) {
913 forPrefixIncrementExpressionOnly(that);
914 }
915
916 public void forNegativePrefixIncrementExpressionDoFirst(NegativePrefixIncrementExpression that) {
917 forPrefixIncrementExpressionDoFirst(that);
918 }
919
920 public void forNegativePrefixIncrementExpressionOnly(NegativePrefixIncrementExpression that) {
921 forPrefixIncrementExpressionOnly(that);
922 }
923
924 public void forPostfixIncrementExpressionDoFirst(PostfixIncrementExpression that) {
925 forIncrementExpressionDoFirst(that);
926 }
927
928 public void forPostfixIncrementExpressionOnly(PostfixIncrementExpression that) {
929 forIncrementExpressionOnly(that);
930 }
931
932 public void forPositivePostfixIncrementExpressionDoFirst(PositivePostfixIncrementExpression that) {
933 forPostfixIncrementExpressionDoFirst(that);
934 }
935
936 public void forPositivePostfixIncrementExpressionOnly(PositivePostfixIncrementExpression that) {
937 forPostfixIncrementExpressionOnly(that);
938 }
939
940 public void forNegativePostfixIncrementExpressionDoFirst(NegativePostfixIncrementExpression that) {
941 forPostfixIncrementExpressionDoFirst(that);
942 }
943
944 public void forNegativePostfixIncrementExpressionOnly(NegativePostfixIncrementExpression that) {
945 forPostfixIncrementExpressionOnly(that);
946 }
947
948 public void forNumericUnaryExpressionDoFirst(NumericUnaryExpression that) {
949 forUnaryExpressionDoFirst(that);
950 }
951
952 public void forNumericUnaryExpressionOnly(NumericUnaryExpression that) {
953 forUnaryExpressionOnly(that);
954 }
955
956 public void forPositiveExpressionDoFirst(PositiveExpression that) {
957 forNumericUnaryExpressionDoFirst(that);
958 }
959
960 public void forPositiveExpressionOnly(PositiveExpression that) {
961 forNumericUnaryExpressionOnly(that);
962 }
963
964 public void forNegativeExpressionDoFirst(NegativeExpression that) {
965 forNumericUnaryExpressionDoFirst(that);
966 }
967
968 public void forNegativeExpressionOnly(NegativeExpression that) {
969 forNumericUnaryExpressionOnly(that);
970 }
971
972 public void forBitwiseNotExpressionDoFirst(BitwiseNotExpression that) {
973 forUnaryExpressionDoFirst(that);
974 }
975
976 public void forBitwiseNotExpressionOnly(BitwiseNotExpression that) {
977 forUnaryExpressionOnly(that);
978 }
979
980 public void forNotExpressionDoFirst(NotExpression that) {
981 forUnaryExpressionDoFirst(that);
982 }
983
984 public void forNotExpressionOnly(NotExpression that) {
985 forUnaryExpressionOnly(that);
986 }
987
988 public void forConditionalExpressionDoFirst(ConditionalExpression that) {
989 forExpressionDoFirst(that);
990 }
991
992 public void forConditionalExpressionOnly(ConditionalExpression that) {
993 forExpressionOnly(that);
994 }
995
996 public void forInstanceofExpressionDoFirst(InstanceofExpression that) {
997 forExpressionDoFirst(that);
998 }
999
1000 public void forInstanceofExpressionOnly(InstanceofExpression that) {
1001 forExpressionOnly(that);
1002 }
1003
1004 public void forCastExpressionDoFirst(CastExpression that) {
1005 forExpressionDoFirst(that);
1006 }
1007
1008 public void forCastExpressionOnly(CastExpression that) {
1009 forExpressionOnly(that);
1010 }
1011
1012 public void forPrimaryDoFirst(Primary that) {
1013 forExpressionDoFirst(that);
1014 }
1015
1016 public void forPrimaryOnly(Primary that) {
1017 forExpressionOnly(that);
1018 }
1019
1020 public void forLexicalLiteralDoFirst(LexicalLiteral that) {
1021 forPrimaryDoFirst(that);
1022 }
1023
1024 public void forLexicalLiteralOnly(LexicalLiteral that) {
1025 forPrimaryOnly(that);
1026 }
1027
1028 public void forIntegerLiteralDoFirst(IntegerLiteral that) {
1029 forLexicalLiteralDoFirst(that);
1030 }
1031
1032 public void forIntegerLiteralOnly(IntegerLiteral that) {
1033 forLexicalLiteralOnly(that);
1034 }
1035
1036 public void forLongLiteralDoFirst(LongLiteral that) {
1037 forLexicalLiteralDoFirst(that);
1038 }
1039
1040 public void forLongLiteralOnly(LongLiteral that) {
1041 forLexicalLiteralOnly(that);
1042 }
1043
1044 public void forDoubleLiteralDoFirst(DoubleLiteral that) {
1045 forLexicalLiteralDoFirst(that);
1046 }
1047
1048 public void forDoubleLiteralOnly(DoubleLiteral that) {
1049 forLexicalLiteralOnly(that);
1050 }
1051
1052 public void forFloatLiteralDoFirst(FloatLiteral that) {
1053 forLexicalLiteralDoFirst(that);
1054 }
1055
1056 public void forFloatLiteralOnly(FloatLiteral that) {
1057 forLexicalLiteralOnly(that);
1058 }
1059
1060 public void forBooleanLiteralDoFirst(BooleanLiteral that) {
1061 forLexicalLiteralDoFirst(that);
1062 }
1063
1064 public void forBooleanLiteralOnly(BooleanLiteral that) {
1065 forLexicalLiteralOnly(that);
1066 }
1067
1068 public void forCharLiteralDoFirst(CharLiteral that) {
1069 forLexicalLiteralDoFirst(that);
1070 }
1071
1072 public void forCharLiteralOnly(CharLiteral that) {
1073 forLexicalLiteralOnly(that);
1074 }
1075
1076 public void forStringLiteralDoFirst(StringLiteral that) {
1077 forLexicalLiteralDoFirst(that);
1078 }
1079
1080 public void forStringLiteralOnly(StringLiteral that) {
1081 forLexicalLiteralOnly(that);
1082 }
1083
1084 public void forNullLiteralDoFirst(NullLiteral that) {
1085 forLexicalLiteralDoFirst(that);
1086 }
1087
1088 public void forNullLiteralOnly(NullLiteral that) {
1089 forLexicalLiteralOnly(that);
1090 }
1091
1092 public void forInstantiationDoFirst(Instantiation that) {
1093 forPrimaryDoFirst(that);
1094 }
1095
1096 public void forInstantiationOnly(Instantiation that) {
1097 forPrimaryOnly(that);
1098 }
1099
1100 public void forClassInstantiationDoFirst(ClassInstantiation that) {
1101 forInstantiationDoFirst(that);
1102 }
1103
1104 public void forClassInstantiationOnly(ClassInstantiation that) {
1105 forInstantiationOnly(that);
1106 }
1107
1108 public void forNamedClassInstantiationDoFirst(NamedClassInstantiation that) {
1109 forClassInstantiationDoFirst(that);
1110 }
1111
1112 public void forNamedClassInstantiationOnly(NamedClassInstantiation that) {
1113 forClassInstantiationOnly(that);
1114 }
1115
1116 public void forSimpleNamedClassInstantiationDoFirst(SimpleNamedClassInstantiation that) {
1117 forNamedClassInstantiationDoFirst(that);
1118 }
1119
1120 public void forSimpleNamedClassInstantiationOnly(SimpleNamedClassInstantiation that) {
1121 forNamedClassInstantiationOnly(that);
1122 }
1123
1124 public void forComplexNamedClassInstantiationDoFirst(ComplexNamedClassInstantiation that) {
1125 forNamedClassInstantiationDoFirst(that);
1126 }
1127
1128 public void forComplexNamedClassInstantiationOnly(ComplexNamedClassInstantiation that) {
1129 forNamedClassInstantiationOnly(that);
1130 }
1131
1132 public void forAnonymousClassInstantiationDoFirst(AnonymousClassInstantiation that) {
1133 forClassInstantiationDoFirst(that);
1134 }
1135
1136 public void forAnonymousClassInstantiationOnly(AnonymousClassInstantiation that) {
1137 forClassInstantiationOnly(that);
1138 }
1139
1140 public void forSimpleAnonymousClassInstantiationDoFirst(SimpleAnonymousClassInstantiation that) {
1141 forAnonymousClassInstantiationDoFirst(that);
1142 }
1143
1144 public void forSimpleAnonymousClassInstantiationOnly(SimpleAnonymousClassInstantiation that) {
1145 forAnonymousClassInstantiationOnly(that);
1146 }
1147
1148 public void forComplexAnonymousClassInstantiationDoFirst(ComplexAnonymousClassInstantiation that) {
1149 forAnonymousClassInstantiationDoFirst(that);
1150 }
1151
1152 public void forComplexAnonymousClassInstantiationOnly(ComplexAnonymousClassInstantiation that) {
1153 forAnonymousClassInstantiationOnly(that);
1154 }
1155
1156 public void forArrayInstantiationDoFirst(ArrayInstantiation that) {
1157 forInstantiationDoFirst(that);
1158 }
1159
1160 public void forArrayInstantiationOnly(ArrayInstantiation that) {
1161 forInstantiationOnly(that);
1162 }
1163
1164 public void forUninitializedArrayInstantiationDoFirst(UninitializedArrayInstantiation that) {
1165 forArrayInstantiationDoFirst(that);
1166 }
1167
1168 public void forUninitializedArrayInstantiationOnly(UninitializedArrayInstantiation that) {
1169 forArrayInstantiationOnly(that);
1170 }
1171
1172 public void forSimpleUninitializedArrayInstantiationDoFirst(SimpleUninitializedArrayInstantiation that) {
1173 forUninitializedArrayInstantiationDoFirst(that);
1174 }
1175
1176 public void forSimpleUninitializedArrayInstantiationOnly(SimpleUninitializedArrayInstantiation that) {
1177 forUninitializedArrayInstantiationOnly(that);
1178 }
1179
1180 public void forComplexUninitializedArrayInstantiationDoFirst(ComplexUninitializedArrayInstantiation that) {
1181 forUninitializedArrayInstantiationDoFirst(that);
1182 }
1183
1184 public void forComplexUninitializedArrayInstantiationOnly(ComplexUninitializedArrayInstantiation that) {
1185 forUninitializedArrayInstantiationOnly(that);
1186 }
1187
1188 public void forInitializedArrayInstantiationDoFirst(InitializedArrayInstantiation that) {
1189 forArrayInstantiationDoFirst(that);
1190 }
1191
1192 public void forInitializedArrayInstantiationOnly(InitializedArrayInstantiation that) {
1193 forArrayInstantiationOnly(that);
1194 }
1195
1196 public void forSimpleInitializedArrayInstantiationDoFirst(SimpleInitializedArrayInstantiation that) {
1197 forInitializedArrayInstantiationDoFirst(that);
1198 }
1199
1200 public void forSimpleInitializedArrayInstantiationOnly(SimpleInitializedArrayInstantiation that) {
1201 forInitializedArrayInstantiationOnly(that);
1202 }
1203
1204 public void forComplexInitializedArrayInstantiationDoFirst(ComplexInitializedArrayInstantiation that) {
1205 forInitializedArrayInstantiationDoFirst(that);
1206 }
1207
1208 public void forComplexInitializedArrayInstantiationOnly(ComplexInitializedArrayInstantiation that) {
1209 forInitializedArrayInstantiationOnly(that);
1210 }
1211
1212 public void forVariableReferenceDoFirst(VariableReference that) {
1213 forPrimaryDoFirst(that);
1214 }
1215
1216 public void forVariableReferenceOnly(VariableReference that) {
1217 forPrimaryOnly(that);
1218 }
1219
1220 public void forNameReferenceDoFirst(NameReference that) {
1221 forVariableReferenceDoFirst(that);
1222 }
1223
1224 public void forNameReferenceOnly(NameReference that) {
1225 forVariableReferenceOnly(that);
1226 }
1227
1228 public void forSimpleNameReferenceDoFirst(SimpleNameReference that) {
1229 forNameReferenceDoFirst(that);
1230 }
1231
1232 public void forSimpleNameReferenceOnly(SimpleNameReference that) {
1233 forNameReferenceOnly(that);
1234 }
1235
1236 public void forComplexNameReferenceDoFirst(ComplexNameReference that) {
1237 forNameReferenceDoFirst(that);
1238 }
1239
1240 public void forComplexNameReferenceOnly(ComplexNameReference that) {
1241 forNameReferenceOnly(that);
1242 }
1243
1244 public void forThisReferenceDoFirst(ThisReference that) {
1245 forVariableReferenceDoFirst(that);
1246 }
1247
1248 public void forThisReferenceOnly(ThisReference that) {
1249 forVariableReferenceOnly(that);
1250 }
1251
1252 public void forSimpleThisReferenceDoFirst(SimpleThisReference that) {
1253 forThisReferenceDoFirst(that);
1254 }
1255
1256 public void forSimpleThisReferenceOnly(SimpleThisReference that) {
1257 forThisReferenceOnly(that);
1258 }
1259
1260 public void forComplexThisReferenceDoFirst(ComplexThisReference that) {
1261 forThisReferenceDoFirst(that);
1262 }
1263
1264 public void forComplexThisReferenceOnly(ComplexThisReference that) {
1265 forThisReferenceOnly(that);
1266 }
1267
1268 public void forSuperReferenceDoFirst(SuperReference that) {
1269 forVariableReferenceDoFirst(that);
1270 }
1271
1272 public void forSuperReferenceOnly(SuperReference that) {
1273 forVariableReferenceOnly(that);
1274 }
1275
1276 public void forSimpleSuperReferenceDoFirst(SimpleSuperReference that) {
1277 forSuperReferenceDoFirst(that);
1278 }
1279
1280 public void forSimpleSuperReferenceOnly(SimpleSuperReference that) {
1281 forSuperReferenceOnly(that);
1282 }
1283
1284 public void forComplexSuperReferenceDoFirst(ComplexSuperReference that) {
1285 forSuperReferenceDoFirst(that);
1286 }
1287
1288 public void forComplexSuperReferenceOnly(ComplexSuperReference that) {
1289 forSuperReferenceOnly(that);
1290 }
1291
1292 public void forFunctionInvocationDoFirst(FunctionInvocation that) {
1293 forPrimaryDoFirst(that);
1294 }
1295
1296 public void forFunctionInvocationOnly(FunctionInvocation that) {
1297 forPrimaryOnly(that);
1298 }
1299
1300 public void forMethodInvocationDoFirst(MethodInvocation that) {
1301 forFunctionInvocationDoFirst(that);
1302 }
1303
1304 public void forMethodInvocationOnly(MethodInvocation that) {
1305 forFunctionInvocationOnly(that);
1306 }
1307
1308 public void forSimpleMethodInvocationDoFirst(SimpleMethodInvocation that) {
1309 forMethodInvocationDoFirst(that);
1310 }
1311
1312 public void forSimpleMethodInvocationOnly(SimpleMethodInvocation that) {
1313 forMethodInvocationOnly(that);
1314 }
1315
1316 public void forComplexMethodInvocationDoFirst(ComplexMethodInvocation that) {
1317 forMethodInvocationDoFirst(that);
1318 }
1319
1320 public void forComplexMethodInvocationOnly(ComplexMethodInvocation that) {
1321 forMethodInvocationOnly(that);
1322 }
1323
1324 public void forThisConstructorInvocationDoFirst(ThisConstructorInvocation that) {
1325 forFunctionInvocationDoFirst(that);
1326 }
1327
1328 public void forThisConstructorInvocationOnly(ThisConstructorInvocation that) {
1329 forFunctionInvocationOnly(that);
1330 }
1331
1332 public void forSimpleThisConstructorInvocationDoFirst(SimpleThisConstructorInvocation that) {
1333 forThisConstructorInvocationDoFirst(that);
1334 }
1335
1336 public void forSimpleThisConstructorInvocationOnly(SimpleThisConstructorInvocation that) {
1337 forThisConstructorInvocationOnly(that);
1338 }
1339
1340 public void forComplexThisConstructorInvocationDoFirst(ComplexThisConstructorInvocation that) {
1341 forThisConstructorInvocationDoFirst(that);
1342 }
1343
1344 public void forComplexThisConstructorInvocationOnly(ComplexThisConstructorInvocation that) {
1345 forThisConstructorInvocationOnly(that);
1346 }
1347
1348 public void forSuperConstructorInvocationDoFirst(SuperConstructorInvocation that) {
1349 forFunctionInvocationDoFirst(that);
1350 }
1351
1352 public void forSuperConstructorInvocationOnly(SuperConstructorInvocation that) {
1353 forFunctionInvocationOnly(that);
1354 }
1355
1356 public void forSimpleSuperConstructorInvocationDoFirst(SimpleSuperConstructorInvocation that) {
1357 forSuperConstructorInvocationDoFirst(that);
1358 }
1359
1360 public void forSimpleSuperConstructorInvocationOnly(SimpleSuperConstructorInvocation that) {
1361 forSuperConstructorInvocationOnly(that);
1362 }
1363
1364 public void forComplexSuperConstructorInvocationDoFirst(ComplexSuperConstructorInvocation that) {
1365 forSuperConstructorInvocationDoFirst(that);
1366 }
1367
1368 public void forComplexSuperConstructorInvocationOnly(ComplexSuperConstructorInvocation that) {
1369 forSuperConstructorInvocationOnly(that);
1370 }
1371
1372 public void forClassLiteralDoFirst(ClassLiteral that) {
1373 forPrimaryDoFirst(that);
1374 }
1375
1376 public void forClassLiteralOnly(ClassLiteral that) {
1377 forPrimaryOnly(that);
1378 }
1379
1380 public void forArrayAccessDoFirst(ArrayAccess that) {
1381 forPrimaryDoFirst(that);
1382 }
1383
1384 public void forArrayAccessOnly(ArrayAccess that) {
1385 forPrimaryOnly(that);
1386 }
1387
1388 public void forParenthesizedDoFirst(Parenthesized that) {
1389 forPrimaryDoFirst(that);
1390 }
1391
1392 public void forParenthesizedOnly(Parenthesized that) {
1393 forPrimaryOnly(that);
1394 }
1395
1396 public void forEmptyExpressionDoFirst(EmptyExpression that) {
1397 forPrimaryDoFirst(that);
1398 }
1399
1400 public void forEmptyExpressionOnly(EmptyExpression that) {
1401 forPrimaryOnly(that);
1402 }
1403
1404 public void forBodyDoFirst(Body that) {
1405 forJExpressionDoFirst(that);
1406 }
1407
1408 public void forBodyOnly(Body that) {
1409 forJExpressionOnly(that);
1410 }
1411
1412 public void forBracedBodyDoFirst(BracedBody that) {
1413 forBodyDoFirst(that);
1414 }
1415
1416 public void forBracedBodyOnly(BracedBody that) {
1417 forBodyOnly(that);
1418 }
1419
1420 public void forUnbracedBodyDoFirst(UnbracedBody that) {
1421 forBodyDoFirst(that);
1422 }
1423
1424 public void forUnbracedBodyOnly(UnbracedBody that) {
1425 forBodyOnly(that);
1426 }
1427
1428 public void forExpressionListDoFirst(ExpressionList that) {
1429 forJExpressionDoFirst(that);
1430 }
1431
1432 public void forExpressionListOnly(ExpressionList that) {
1433 forJExpressionOnly(that);
1434 }
1435
1436 public void forParenthesizedExpressionListDoFirst(ParenthesizedExpressionList that) {
1437 forExpressionListDoFirst(that);
1438 }
1439
1440 public void forParenthesizedExpressionListOnly(ParenthesizedExpressionList that) {
1441 forExpressionListOnly(that);
1442 }
1443
1444 public void forUnparenthesizedExpressionListDoFirst(UnparenthesizedExpressionList that) {
1445 forExpressionListDoFirst(that);
1446 }
1447
1448 public void forUnparenthesizedExpressionListOnly(UnparenthesizedExpressionList that) {
1449 forExpressionListOnly(that);
1450 }
1451
1452 public void forDimensionExpressionListDoFirst(DimensionExpressionList that) {
1453 forExpressionListDoFirst(that);
1454 }
1455
1456 public void forDimensionExpressionListOnly(DimensionExpressionList that) {
1457 forExpressionListOnly(that);
1458 }
1459
1460 public void forEmptyForConditionDoFirst(EmptyForCondition that) {
1461 forJExpressionDoFirst(that);
1462 }
1463
1464 public void forEmptyForConditionOnly(EmptyForCondition that) {
1465 forJExpressionOnly(that);
1466 }
1467
1468 /* Implementation of JExpressionIFVisitor_void methods to implement depth-first traversal. */
1469 public void forSourceFile(SourceFile that) {
1470 forSourceFileDoFirst(that);
1471 for (int i = 0; i < that.getPackageStatements().length; i++) that.getPackageStatements()[i].visit(this);
1472 for (int i = 0; i < that.getImportStatements().length; i++) that.getImportStatements()[i].visit(this);
1473 for (int i = 0; i < that.getTypes().length; i++) that.getTypes()[i].visit(this);
1474 forSourceFileOnly(that);
1475 }
1476
1477 public void forModifiersAndVisibility(ModifiersAndVisibility that) {
1478 forModifiersAndVisibilityDoFirst(that);
1479 forModifiersAndVisibilityOnly(that);
1480 }
1481
1482 public void forCompoundWord(CompoundWord that) {
1483 forCompoundWordDoFirst(that);
1484 for (int i = 0; i < that.getWords().length; i++) that.getWords()[i].visit(this);
1485 forCompoundWordOnly(that);
1486 }
1487
1488 public void forWord(Word that) {
1489 forWordDoFirst(that);
1490 forWordOnly(that);
1491 }
1492
1493 public void forClassDef(ClassDef that) {
1494 forClassDefDoFirst(that);
1495 that.getMav().visit(this);
1496 that.getName().visit(this);
1497 for (int i = 0; i < that.getTypeParameters().length; i++) that.getTypeParameters()[i].visit(this);
1498 that.getSuperclass().visit(this);
1499 for (int i = 0; i < that.getInterfaces().length; i++) that.getInterfaces()[i].visit(this);
1500 that.getBody().visit(this);
1501 forClassDefOnly(that);
1502 }
1503
1504 public void forInnerClassDef(InnerClassDef that) {
1505 forInnerClassDefDoFirst(that);
1506 that.getMav().visit(this);
1507 that.getName().visit(this);
1508 for (int i = 0; i < that.getTypeParameters().length; i++) that.getTypeParameters()[i].visit(this);
1509 that.getSuperclass().visit(this);
1510 for (int i = 0; i < that.getInterfaces().length; i++) that.getInterfaces()[i].visit(this);
1511 that.getBody().visit(this);
1512 forInnerClassDefOnly(that);
1513 }
1514
1515 public void forInterfaceDef(InterfaceDef that) {
1516 forInterfaceDefDoFirst(that);
1517 that.getMav().visit(this);
1518 that.getName().visit(this);
1519 for (int i = 0; i < that.getTypeParameters().length; i++) that.getTypeParameters()[i].visit(this);
1520 for (int i = 0; i < that.getInterfaces().length; i++) that.getInterfaces()[i].visit(this);
1521 that.getBody().visit(this);
1522 forInterfaceDefOnly(that);
1523 }
1524
1525 public void forInnerInterfaceDef(InnerInterfaceDef that) {
1526 forInnerInterfaceDefDoFirst(that);
1527 that.getMav().visit(this);
1528 that.getName().visit(this);
1529 for (int i = 0; i < that.getTypeParameters().length; i++) that.getTypeParameters()[i].visit(this);
1530 for (int i = 0; i < that.getInterfaces().length; i++) that.getInterfaces()[i].visit(this);
1531 that.getBody().visit(this);
1532 forInnerInterfaceDefOnly(that);
1533 }
1534
1535 public void forConstructorDef(ConstructorDef that) {
1536 forConstructorDefDoFirst(that);
1537 that.getName().visit(this);
1538 that.getMav().visit(this);
1539 for (int i = 0; i < that.getParameters().length; i++) that.getParameters()[i].visit(this);
1540 for (int i = 0; i < that.getThrows().length; i++) that.getThrows()[i].visit(this);
1541 that.getStatements().visit(this);
1542 forConstructorDefOnly(that);
1543 }
1544
1545 public void forInstanceInitializer(InstanceInitializer that) {
1546 forInstanceInitializerDoFirst(that);
1547 that.getCode().visit(this);
1548 forInstanceInitializerOnly(that);
1549 }
1550
1551 public void forStaticInitializer(StaticInitializer that) {
1552 forStaticInitializerDoFirst(that);
1553 that.getCode().visit(this);
1554 forStaticInitializerOnly(that);
1555 }
1556
1557 public void forPackageStatement(PackageStatement that) {
1558 forPackageStatementDoFirst(that);
1559 that.getCWord().visit(this);
1560 forPackageStatementOnly(that);
1561 }
1562
1563 public void forClassImportStatement(ClassImportStatement that) {
1564 forClassImportStatementDoFirst(that);
1565 that.getCWord().visit(this);
1566 forClassImportStatementOnly(that);
1567 }
1568
1569 public void forPackageImportStatement(PackageImportStatement that) {
1570 forPackageImportStatementDoFirst(that);
1571 that.getCWord().visit(this);
1572 forPackageImportStatementOnly(that);
1573 }
1574
1575 public void forLabeledStatement(LabeledStatement that) {
1576 forLabeledStatementDoFirst(that);
1577 that.getLabel().visit(this);
1578 that.getStatement().visit(this);
1579 forLabeledStatementOnly(that);
1580 }
1581
1582 public void forBlock(Block that) {
1583 forBlockDoFirst(that);
1584 that.getStatements().visit(this);
1585 forBlockOnly(that);
1586 }
1587
1588 public void forExpressionStatement(ExpressionStatement that) {
1589 forExpressionStatementDoFirst(that);
1590 that.getExpression().visit(this);
1591 forExpressionStatementOnly(that);
1592 }
1593
1594 public void forSwitchStatement(SwitchStatement that) {
1595 forSwitchStatementDoFirst(that);
1596 that.getTest().visit(this);
1597 for (int i = 0; i < that.getCases().length; i++) that.getCases()[i].visit(this);
1598 forSwitchStatementOnly(that);
1599 }
1600
1601 public void forIfThenStatement(IfThenStatement that) {
1602 forIfThenStatementDoFirst(that);
1603 that.getTestExpression().visit(this);
1604 that.getThenStatement().visit(this);
1605 forIfThenStatementOnly(that);
1606 }
1607
1608 public void forIfThenElseStatement(IfThenElseStatement that) {
1609 forIfThenElseStatementDoFirst(that);
1610 that.getTestExpression().visit(this);
1611 that.getThenStatement().visit(this);
1612 that.getElseStatement().visit(this);
1613 forIfThenElseStatementOnly(that);
1614 }
1615
1616 public void forWhileStatement(WhileStatement that) {
1617 forWhileStatementDoFirst(that);
1618 that.getCondition().visit(this);
1619 that.getCode().visit(this);
1620 forWhileStatementOnly(that);
1621 }
1622
1623 public void forDoStatement(DoStatement that) {
1624 forDoStatementDoFirst(that);
1625 that.getCode().visit(this);
1626 that.getCondition().visit(this);
1627 forDoStatementOnly(that);
1628 }
1629
1630 public void forForStatement(ForStatement that) {
1631 forForStatementDoFirst(that);
1632 that.getInit().visit(this);
1633 that.getCondition().visit(this);
1634 that.getUpdate().visit(this);
1635 that.getCode().visit(this);
1636 forForStatementOnly(that);
1637 }
1638
1639 public void forLabeledBreakStatement(LabeledBreakStatement that) {
1640 forLabeledBreakStatementDoFirst(that);
1641 that.getLabel().visit(this);
1642 forLabeledBreakStatementOnly(that);
1643 }
1644
1645 public void forUnlabeledBreakStatement(UnlabeledBreakStatement that) {
1646 forUnlabeledBreakStatementDoFirst(that);
1647 forUnlabeledBreakStatementOnly(that);
1648 }
1649
1650 public void forLabeledContinueStatement(LabeledContinueStatement that) {
1651 forLabeledContinueStatementDoFirst(that);
1652 that.getLabel().visit(this);
1653 forLabeledContinueStatementOnly(that);
1654 }
1655
1656 public void forUnlabeledContinueStatement(UnlabeledContinueStatement that) {
1657 forUnlabeledContinueStatementDoFirst(that);
1658 forUnlabeledContinueStatementOnly(that);
1659 }
1660
1661 public void forVoidReturnStatement(VoidReturnStatement that) {
1662 forVoidReturnStatementDoFirst(that);
1663 forVoidReturnStatementOnly(that);
1664 }
1665
1666 public void forValueReturnStatement(ValueReturnStatement that) {
1667 forValueReturnStatementDoFirst(that);
1668 that.getValue().visit(this);
1669 forValueReturnStatementOnly(that);
1670 }
1671
1672 public void forThrowStatement(ThrowStatement that) {
1673 forThrowStatementDoFirst(that);
1674 that.getThrown().visit(this);
1675 forThrowStatementOnly(that);
1676 }
1677
1678 public void forSynchronizedStatement(SynchronizedStatement that) {
1679 forSynchronizedStatementDoFirst(that);
1680 that.getLockExpr().visit(this);
1681 that.getBlock().visit(this);
1682 forSynchronizedStatementOnly(that);
1683 }
1684
1685 public void forTryCatchFinallyStatement(TryCatchFinallyStatement that) {
1686 forTryCatchFinallyStatementDoFirst(that);
1687 that.getTryBlock().visit(this);
1688 for (int i = 0; i < that.getCatchBlocks().length; i++) that.getCatchBlocks()[i].visit(this);
1689 that.getFinallyBlock().visit(this);
1690 forTryCatchFinallyStatementOnly(that);
1691 }
1692
1693 public void forNormalTryCatchStatement(NormalTryCatchStatement that) {
1694 forNormalTryCatchStatementDoFirst(that);
1695 that.getTryBlock().visit(this);
1696 for (int i = 0; i < that.getCatchBlocks().length; i++) that.getCatchBlocks()[i].visit(this);
1697 forNormalTryCatchStatementOnly(that);
1698 }
1699
1700 public void forEmptyStatement(EmptyStatement that) {
1701 forEmptyStatementDoFirst(that);
1702 forEmptyStatementOnly(that);
1703 }
1704
1705 public void forConcreteMethodDef(ConcreteMethodDef that) {
1706 forConcreteMethodDefDoFirst(that);
1707 that.getMav().visit(this);
1708 for (int i = 0; i < that.getTypeParams().length; i++) that.getTypeParams()[i].visit(this);
1709 that.getResult().visit(this);
1710 that.getName().visit(this);
1711 for (int i = 0; i < that.getParams().length; i++) that.getParams()[i].visit(this);
1712 for (int i = 0; i < that.getThrows().length; i++) that.getThrows()[i].visit(this);
1713 that.getBody().visit(this);
1714 forConcreteMethodDefOnly(that);
1715 }
1716
1717 public void forAbstractMethodDef(AbstractMethodDef that) {
1718 forAbstractMethodDefDoFirst(that);
1719 that.getMav().visit(this);
1720 for (int i = 0; i < that.getTypeParams().length; i++) that.getTypeParams()[i].visit(this);
1721 that.getResult().visit(this);
1722 that.getName().visit(this);
1723 for (int i = 0; i < that.getParams().length; i++) that.getParams()[i].visit(this);
1724 for (int i = 0; i < that.getThrows().length; i++) that.getThrows()[i].visit(this);
1725 forAbstractMethodDefOnly(that);
1726 }
1727
1728 public void forFormalParameter(FormalParameter that) {
1729 forFormalParameterDoFirst(that);
1730 that.getDeclarator().visit(this);
1731 forFormalParameterOnly(that);
1732 }
1733
1734 public void forVariableDeclaration(VariableDeclaration that) {
1735 forVariableDeclarationDoFirst(that);
1736 that.getMav().visit(this);
1737 for (int i = 0; i < that.getDeclarators().length; i++) that.getDeclarators()[i].visit(this);
1738 forVariableDeclarationOnly(that);
1739 }
1740
1741 public void forUninitializedVariableDeclarator(UninitializedVariableDeclarator that) {
1742 forUninitializedVariableDeclaratorDoFirst(that);
1743 that.getType().visit(this);
1744 that.getName().visit(this);
1745 forUninitializedVariableDeclaratorOnly(that);
1746 }
1747
1748 public void forInitializedVariableDeclarator(InitializedVariableDeclarator that) {
1749 forInitializedVariableDeclaratorDoFirst(that);
1750 that.getType().visit(this);
1751 that.getName().visit(this);
1752 that.getInitializer().visit(this);
1753 forInitializedVariableDeclaratorOnly(that);
1754 }
1755
1756 public void forTypeParameter(TypeParameter that) {
1757 forTypeParameterDoFirst(that);
1758 that.getVariable().visit(this);
1759 that.getBound().visit(this);
1760 forTypeParameterOnly(that);
1761 }
1762
1763 public void forArrayInitializer(ArrayInitializer that) {
1764 forArrayInitializerDoFirst(that);
1765 for (int i = 0; i < that.getItems().length; i++) that.getItems()[i].visit(this);
1766 forArrayInitializerOnly(that);
1767 }
1768
1769 public void forPrimitiveType(PrimitiveType that) {
1770 forPrimitiveTypeDoFirst(that);
1771 forPrimitiveTypeOnly(that);
1772 }
1773
1774 public void forArrayType(ArrayType that) {
1775 forArrayTypeDoFirst(that);
1776 that.getElementType().visit(this);
1777 forArrayTypeOnly(that);
1778 }
1779
1780 public void forMemberType(MemberType that) {
1781 forMemberTypeDoFirst(that);
1782 that.getLeft().visit(this);
1783 that.getRight().visit(this);
1784 forMemberTypeOnly(that);
1785 }
1786
1787 public void forClassOrInterfaceType(ClassOrInterfaceType that) {
1788 forClassOrInterfaceTypeDoFirst(that);
1789 for (int i = 0; i < that.getTypeArguments().length; i++) that.getTypeArguments()[i].visit(this);
1790 forClassOrInterfaceTypeOnly(that);
1791 }
1792
1793 public void forTypeVariable(TypeVariable that) {
1794 forTypeVariableDoFirst(that);
1795 forTypeVariableOnly(that);
1796 }
1797
1798 public void forVoidReturn(VoidReturn that) {
1799 forVoidReturnDoFirst(that);
1800 forVoidReturnOnly(that);
1801 }
1802
1803 public void forLabeledCase(LabeledCase that) {
1804 forLabeledCaseDoFirst(that);
1805 that.getLabel().visit(this);
1806 that.getCode().visit(this);
1807 forLabeledCaseOnly(that);
1808 }
1809
1810 public void forDefaultCase(DefaultCase that) {
1811 forDefaultCaseDoFirst(that);
1812 that.getCode().visit(this);
1813 forDefaultCaseOnly(that);
1814 }
1815
1816 public void forCatchBlock(CatchBlock that) {
1817 forCatchBlockDoFirst(that);
1818 that.getException().visit(this);
1819 that.getBlock().visit(this);
1820 forCatchBlockOnly(that);
1821 }
1822
1823 public void forSimpleAssignmentExpression(SimpleAssignmentExpression that) {
1824 forSimpleAssignmentExpressionDoFirst(that);
1825 that.getName().visit(this);
1826 that.getValue().visit(this);
1827 forSimpleAssignmentExpressionOnly(that);
1828 }
1829
1830 public void forPlusAssignmentExpression(PlusAssignmentExpression that) {
1831 forPlusAssignmentExpressionDoFirst(that);
1832 that.getName().visit(this);
1833 that.getValue().visit(this);
1834 forPlusAssignmentExpressionOnly(that);
1835 }
1836
1837 public void forMinusAssignmentExpression(MinusAssignmentExpression that) {
1838 forMinusAssignmentExpressionDoFirst(that);
1839 that.getName().visit(this);
1840 that.getValue().visit(this);
1841 forMinusAssignmentExpressionOnly(that);
1842 }
1843
1844 public void forMultiplyAssignmentExpression(MultiplyAssignmentExpression that) {
1845 forMultiplyAssignmentExpressionDoFirst(that);
1846 that.getName().visit(this);
1847 that.getValue().visit(this);
1848 forMultiplyAssignmentExpressionOnly(that);
1849 }
1850
1851 public void forDivideAssignmentExpression(DivideAssignmentExpression that) {
1852 forDivideAssignmentExpressionDoFirst(that);
1853 that.getName().visit(this);
1854 that.getValue().visit(this);
1855 forDivideAssignmentExpressionOnly(that);
1856 }
1857
1858 public void forModAssignmentExpression(ModAssignmentExpression that) {
1859 forModAssignmentExpressionDoFirst(that);
1860 that.getName().visit(this);
1861 that.getValue().visit(this);
1862 forModAssignmentExpressionOnly(that);
1863 }
1864
1865 public void forLeftShiftAssignmentExpression(LeftShiftAssignmentExpression that) {
1866 forLeftShiftAssignmentExpressionDoFirst(that);
1867 that.getName().visit(this);
1868 that.getValue().visit(this);
1869 forLeftShiftAssignmentExpressionOnly(that);
1870 }
1871
1872 public void forRightSignedShiftAssignmentExpression(RightSignedShiftAssignmentExpression that) {
1873 forRightSignedShiftAssignmentExpressionDoFirst(that);
1874 that.getName().visit(this);
1875 that.getValue().visit(this);
1876 forRightSignedShiftAssignmentExpressionOnly(that);
1877 }
1878
1879 public void forRightUnsignedShiftAssignmentExpression(RightUnsignedShiftAssignmentExpression that) {
1880 forRightUnsignedShiftAssignmentExpressionDoFirst(that);
1881 that.getName().visit(this);
1882 that.getValue().visit(this);
1883 forRightUnsignedShiftAssignmentExpressionOnly(that);
1884 }
1885
1886 public void forBitwiseAndAssignmentExpression(BitwiseAndAssignmentExpression that) {
1887 forBitwiseAndAssignmentExpressionDoFirst(that);
1888 that.getName().visit(this);
1889 that.getValue().visit(this);
1890 forBitwiseAndAssignmentExpressionOnly(that);
1891 }
1892
1893 public void forBitwiseOrAssignmentExpression(BitwiseOrAssignmentExpression that) {
1894 forBitwiseOrAssignmentExpressionDoFirst(that);
1895 that.getName().visit(this);
1896 that.getValue().visit(this);
1897 forBitwiseOrAssignmentExpressionOnly(that);
1898 }
1899
1900 public void forBitwiseXorAssignmentExpression(BitwiseXorAssignmentExpression that) {
1901 forBitwiseXorAssignmentExpressionDoFirst(that);
1902 that.getName().visit(this);
1903 that.getValue().visit(this);
1904 forBitwiseXorAssignmentExpressionOnly(that);
1905 }
1906
1907 public void forOrExpression(OrExpression that) {
1908 forOrExpressionDoFirst(that);
1909 that.getLeft().visit(this);
1910 that.getRight().visit(this);
1911 forOrExpressionOnly(that);
1912 }
1913
1914 public void forAndExpression(AndExpression that) {
1915 forAndExpressionDoFirst(that);
1916 that.getLeft().visit(this);
1917 that.getRight().visit(this);
1918 forAndExpressionOnly(that);
1919 }
1920
1921 public void forBitwiseOrExpression(BitwiseOrExpression that) {
1922 forBitwiseOrExpressionDoFirst(that);
1923 that.getLeft().visit(this);
1924 that.getRight().visit(this);
1925 forBitwiseOrExpressionOnly(that);
1926 }
1927
1928 public void forBitwiseXorExpression(BitwiseXorExpression that) {
1929 forBitwiseXorExpressionDoFirst(that);
1930 that.getLeft().visit(this);
1931 that.getRight().visit(this);
1932 forBitwiseXorExpressionOnly(that);
1933 }
1934
1935 public void forBitwiseAndExpression(BitwiseAndExpression that) {
1936 forBitwiseAndExpressionDoFirst(that);
1937 that.getLeft().visit(this);
1938 that.getRight().visit(this);
1939 forBitwiseAndExpressionOnly(that);
1940 }
1941
1942 public void forEqualsExpression(EqualsExpression that) {
1943 forEqualsExpressionDoFirst(that);
1944 that.getLeft().visit(this);
1945 that.getRight().visit(this);
1946 forEqualsExpressionOnly(that);
1947 }
1948
1949 public void forNotEqualExpression(NotEqualExpression that) {
1950 forNotEqualExpressionDoFirst(that);
1951 that.getLeft().visit(this);
1952 that.getRight().visit(this);
1953 forNotEqualExpressionOnly(that);
1954 }
1955
1956 public void forLessThanExpression(LessThanExpression that) {
1957 forLessThanExpressionDoFirst(that);
1958 that.getLeft().visit(this);
1959 that.getRight().visit(this);
1960 forLessThanExpressionOnly(that);
1961 }
1962
1963 public void forLessThanOrEqualExpression(LessThanOrEqualExpression that) {
1964 forLessThanOrEqualExpressionDoFirst(that);
1965 that.getLeft().visit(this);
1966 that.getRight().visit(this);
1967 forLessThanOrEqualExpressionOnly(that);
1968 }
1969
1970 public void forGreaterThanExpression(GreaterThanExpression that) {
1971 forGreaterThanExpressionDoFirst(that);
1972 that.getLeft().visit(this);
1973 that.getRight().visit(this);
1974 forGreaterThanExpressionOnly(that);
1975 }
1976
1977 public void forGreaterThanOrEqualExpression(GreaterThanOrEqualExpression that) {
1978 forGreaterThanOrEqualExpressionDoFirst(that);
1979 that.getLeft().visit(this);
1980 that.getRight().visit(this);
1981 forGreaterThanOrEqualExpressionOnly(that);
1982 }
1983
1984 public void forLeftShiftExpression(LeftShiftExpression that) {
1985 forLeftShiftExpressionDoFirst(that);
1986 that.getLeft().visit(this);
1987 that.getRight().visit(this);
1988 forLeftShiftExpressionOnly(that);
1989 }
1990
1991 public void forRightSignedShiftExpression(RightSignedShiftExpression that) {
1992 forRightSignedShiftExpressionDoFirst(that);
1993 that.getLeft().visit(this);
1994 that.getRight().visit(this);
1995 forRightSignedShiftExpressionOnly(that);
1996 }
1997
1998 public void forRightUnsignedShiftExpression(RightUnsignedShiftExpression that) {
1999 forRightUnsignedShiftExpressionDoFirst(that);
2000 that.getLeft().visit(this);
2001 that.getRight().visit(this);
2002 forRightUnsignedShiftExpressionOnly(that);
2003 }
2004
2005 public void forPlusExpression(PlusExpression that) {
2006 forPlusExpressionDoFirst(that);
2007 that.getLeft().visit(this);
2008 that.getRight().visit(this);
2009 forPlusExpressionOnly(that);
2010 }
2011
2012 public void forMinusExpression(MinusExpression that) {
2013 forMinusExpressionDoFirst(that);
2014 that.getLeft().visit(this);
2015 that.getRight().visit(this);
2016 forMinusExpressionOnly(that);
2017 }
2018
2019 public void forMultiplyExpression(MultiplyExpression that) {
2020 forMultiplyExpressionDoFirst(that);
2021 that.getLeft().visit(this);
2022 that.getRight().visit(this);
2023 forMultiplyExpressionOnly(that);
2024 }
2025
2026 public void forDivideExpression(DivideExpression that) {
2027 forDivideExpressionDoFirst(that);
2028 that.getLeft().visit(this);
2029 that.getRight().visit(this);
2030 forDivideExpressionOnly(that);
2031 }
2032
2033 public void forModExpression(ModExpression that) {
2034 forModExpressionDoFirst(that);
2035 that.getLeft().visit(this);
2036 that.getRight().visit(this);
2037 forModExpressionOnly(that);
2038 }
2039
2040 public void forNoOpExpression(NoOpExpression that) {
2041 forNoOpExpressionDoFirst(that);
2042 that.getLeft().visit(this);
2043 that.getRight().visit(this);
2044 forNoOpExpressionOnly(that);
2045 }
2046
2047 public void forPositivePrefixIncrementExpression(PositivePrefixIncrementExpression that) {
2048 forPositivePrefixIncrementExpressionDoFirst(that);
2049 that.getValue().visit(this);
2050 forPositivePrefixIncrementExpressionOnly(that);
2051 }
2052
2053 public void forNegativePrefixIncrementExpression(NegativePrefixIncrementExpression that) {
2054 forNegativePrefixIncrementExpressionDoFirst(that);
2055 that.getValue().visit(this);
2056 forNegativePrefixIncrementExpressionOnly(that);
2057 }
2058
2059 public void forPositivePostfixIncrementExpression(PositivePostfixIncrementExpression that) {
2060 forPositivePostfixIncrementExpressionDoFirst(that);
2061 that.getValue().visit(this);
2062 forPositivePostfixIncrementExpressionOnly(that);
2063 }
2064
2065 public void forNegativePostfixIncrementExpression(NegativePostfixIncrementExpression that) {
2066 forNegativePostfixIncrementExpressionDoFirst(that);
2067 that.getValue().visit(this);
2068 forNegativePostfixIncrementExpressionOnly(that);
2069 }
2070
2071 public void forPositiveExpression(PositiveExpression that) {
2072 forPositiveExpressionDoFirst(that);
2073 that.getValue().visit(this);
2074 forPositiveExpressionOnly(that);
2075 }
2076
2077 public void forNegativeExpression(NegativeExpression that) {
2078 forNegativeExpressionDoFirst(that);
2079 that.getValue().visit(this);
2080 forNegativeExpressionOnly(that);
2081 }
2082
2083 public void forBitwiseNotExpression(BitwiseNotExpression that) {
2084 forBitwiseNotExpressionDoFirst(that);
2085 that.getValue().visit(this);
2086 forBitwiseNotExpressionOnly(that);
2087 }
2088
2089 public void forNotExpression(NotExpression that) {
2090 forNotExpressionDoFirst(that);
2091 that.getValue().visit(this);
2092 forNotExpressionOnly(that);
2093 }
2094
2095 public void forConditionalExpression(ConditionalExpression that) {
2096 forConditionalExpressionDoFirst(that);
2097 that.getCondition().visit(this);
2098 that.getForTrue().visit(this);
2099 that.getForFalse().visit(this);
2100 forConditionalExpressionOnly(that);
2101 }
2102
2103 public void forInstanceofExpression(InstanceofExpression that) {
2104 forInstanceofExpressionDoFirst(that);
2105 that.getValue().visit(this);
2106 that.getType().visit(this);
2107 forInstanceofExpressionOnly(that);
2108 }
2109
2110 public void forCastExpression(CastExpression that) {
2111 forCastExpressionDoFirst(that);
2112 that.getType().visit(this);
2113 that.getValue().visit(this);
2114 forCastExpressionOnly(that);
2115 }
2116
2117 public void forIntegerLiteral(IntegerLiteral that) {
2118 forIntegerLiteralDoFirst(that);
2119 forIntegerLiteralOnly(that);
2120 }
2121
2122 public void forLongLiteral(LongLiteral that) {
2123 forLongLiteralDoFirst(that);
2124 forLongLiteralOnly(that);
2125 }
2126
2127 public void forDoubleLiteral(DoubleLiteral that) {
2128 forDoubleLiteralDoFirst(that);
2129 forDoubleLiteralOnly(that);
2130 }
2131
2132 public void forFloatLiteral(FloatLiteral that) {
2133 forFloatLiteralDoFirst(that);
2134 forFloatLiteralOnly(that);
2135 }
2136
2137 public void forBooleanLiteral(BooleanLiteral that) {
2138 forBooleanLiteralDoFirst(that);
2139 forBooleanLiteralOnly(that);
2140 }
2141
2142 public void forCharLiteral(CharLiteral that) {
2143 forCharLiteralDoFirst(that);
2144 forCharLiteralOnly(that);
2145 }
2146
2147 public void forStringLiteral(StringLiteral that) {
2148 forStringLiteralDoFirst(that);
2149 forStringLiteralOnly(that);
2150 }
2151
2152 public void forNullLiteral(NullLiteral that) {
2153 forNullLiteralDoFirst(that);
2154 forNullLiteralOnly(that);
2155 }
2156
2157 public void forSimpleNamedClassInstantiation(SimpleNamedClassInstantiation that) {
2158 forSimpleNamedClassInstantiationDoFirst(that);
2159 that.getType().visit(this);
2160 that.getArguments().visit(this);
2161 forSimpleNamedClassInstantiationOnly(that);
2162 }
2163
2164 public void forComplexNamedClassInstantiation(ComplexNamedClassInstantiation that) {
2165 forComplexNamedClassInstantiationDoFirst(that);
2166 that.getEnclosing().visit(this);
2167 that.getType().visit(this);
2168 that.getArguments().visit(this);
2169 forComplexNamedClassInstantiationOnly(that);
2170 }
2171
2172 public void forSimpleAnonymousClassInstantiation(SimpleAnonymousClassInstantiation that) {
2173 forSimpleAnonymousClassInstantiationDoFirst(that);
2174 that.getType().visit(this);
2175 that.getArguments().visit(this);
2176 that.getBody().visit(this);
2177 forSimpleAnonymousClassInstantiationOnly(that);
2178 }
2179
2180 public void forComplexAnonymousClassInstantiation(ComplexAnonymousClassInstantiation that) {
2181 forComplexAnonymousClassInstantiationDoFirst(that);
2182 that.getEnclosing().visit(this);
2183 that.getType().visit(this);
2184 that.getArguments().visit(this);
2185 that.getBody().visit(this);
2186 forComplexAnonymousClassInstantiationOnly(that);
2187 }
2188
2189 public void forSimpleUninitializedArrayInstantiation(SimpleUninitializedArrayInstantiation that) {
2190 forSimpleUninitializedArrayInstantiationDoFirst(that);
2191 that.getType().visit(this);
2192 that.getDimensionSizes().visit(this);
2193 forSimpleUninitializedArrayInstantiationOnly(that);
2194 }
2195
2196 public void forComplexUninitializedArrayInstantiation(ComplexUninitializedArrayInstantiation that) {
2197 forComplexUninitializedArrayInstantiationDoFirst(that);
2198 that.getEnclosing().visit(this);
2199 that.getType().visit(this);
2200 that.getDimensionSizes().visit(this);
2201 forComplexUninitializedArrayInstantiationOnly(that);
2202 }
2203
2204 public void forSimpleInitializedArrayInstantiation(SimpleInitializedArrayInstantiation that) {
2205 forSimpleInitializedArrayInstantiationDoFirst(that);
2206 that.getType().visit(this);
2207 that.getInitializer().visit(this);
2208 forSimpleInitializedArrayInstantiationOnly(that);
2209 }
2210
2211 public void forComplexInitializedArrayInstantiation(ComplexInitializedArrayInstantiation that) {
2212 forComplexInitializedArrayInstantiationDoFirst(that);
2213 that.getEnclosing().visit(this);
2214 that.getType().visit(this);
2215 that.getInitializer().visit(this);
2216 forComplexInitializedArrayInstantiationOnly(that);
2217 }
2218
2219 public void forSimpleNameReference(SimpleNameReference that) {
2220 forSimpleNameReferenceDoFirst(that);
2221 that.getName().visit(this);
2222 forSimpleNameReferenceOnly(that);
2223 }
2224
2225 public void forComplexNameReference(ComplexNameReference that) {
2226 forComplexNameReferenceDoFirst(that);
2227 that.getEnclosing().visit(this);
2228 that.getName().visit(this);
2229 forComplexNameReferenceOnly(that);
2230 }
2231
2232 public void forSimpleThisReference(SimpleThisReference that) {
2233 forSimpleThisReferenceDoFirst(that);
2234 forSimpleThisReferenceOnly(that);
2235 }
2236
2237 public void forComplexThisReference(ComplexThisReference that) {
2238 forComplexThisReferenceDoFirst(that);
2239 that.getEnclosing().visit(this);
2240 forComplexThisReferenceOnly(that);
2241 }
2242
2243 public void forSimpleSuperReference(SimpleSuperReference that) {
2244 forSimpleSuperReferenceDoFirst(that);
2245 forSimpleSuperReferenceOnly(that);
2246 }
2247
2248 public void forComplexSuperReference(ComplexSuperReference that) {
2249 forComplexSuperReferenceDoFirst(that);
2250 that.getEnclosing().visit(this);
2251 forComplexSuperReferenceOnly(that);
2252 }
2253
2254 public void forSimpleMethodInvocation(SimpleMethodInvocation that) {
2255 forSimpleMethodInvocationDoFirst(that);
2256 that.getName().visit(this);
2257 that.getArguments().visit(this);
2258 forSimpleMethodInvocationOnly(that);
2259 }
2260
2261 public void forComplexMethodInvocation(ComplexMethodInvocation that) {
2262 forComplexMethodInvocationDoFirst(that);
2263 that.getEnclosing().visit(this);
2264 that.getName().visit(this);
2265 that.getArguments().visit(this);
2266 forComplexMethodInvocationOnly(that);
2267 }
2268
2269 public void forSimpleThisConstructorInvocation(SimpleThisConstructorInvocation that) {
2270 forSimpleThisConstructorInvocationDoFirst(that);
2271 that.getArguments().visit(this);
2272 forSimpleThisConstructorInvocationOnly(that);
2273 }
2274
2275 public void forComplexThisConstructorInvocation(ComplexThisConstructorInvocation that) {
2276 forComplexThisConstructorInvocationDoFirst(that);
2277 that.getEnclosing().visit(this);
2278 that.getArguments().visit(this);
2279 forComplexThisConstructorInvocationOnly(that);
2280 }
2281
2282 public void forSimpleSuperConstructorInvocation(SimpleSuperConstructorInvocation that) {
2283 forSimpleSuperConstructorInvocationDoFirst(that);
2284 that.getArguments().visit(this);
2285 forSimpleSuperConstructorInvocationOnly(that);
2286 }
2287
2288 public void forComplexSuperConstructorInvocation(ComplexSuperConstructorInvocation that) {
2289 forComplexSuperConstructorInvocationDoFirst(that);
2290 that.getEnclosing().visit(this);
2291 that.getArguments().visit(this);
2292 forComplexSuperConstructorInvocationOnly(that);
2293 }
2294
2295 public void forClassLiteral(ClassLiteral that) {
2296 forClassLiteralDoFirst(that);
2297 that.getType().visit(this);
2298 forClassLiteralOnly(that);
2299 }
2300
2301 public void forArrayAccess(ArrayAccess that) {
2302 forArrayAccessDoFirst(that);
2303 that.getArray().visit(this);
2304 that.getIndex().visit(this);
2305 forArrayAccessOnly(that);
2306 }
2307
2308 public void forParenthesized(Parenthesized that) {
2309 forParenthesizedDoFirst(that);
2310 that.getValue().visit(this);
2311 forParenthesizedOnly(that);
2312 }
2313
2314 public void forEmptyExpression(EmptyExpression that) {
2315 forEmptyExpressionDoFirst(that);
2316 forEmptyExpressionOnly(that);
2317 }
2318
2319 public void forBracedBody(BracedBody that) {
2320 forBracedBodyDoFirst(that);
2321 for (int i = 0; i < that.getStatements().length; i++) that.getStatements()[i].visit(this);
2322 forBracedBodyOnly(that);
2323 }
2324
2325 public void forUnbracedBody(UnbracedBody that) {
2326 forUnbracedBodyDoFirst(that);
2327 for (int i = 0; i < that.getStatements().length; i++) that.getStatements()[i].visit(this);
2328 forUnbracedBodyOnly(that);
2329 }
2330
2331 public void forParenthesizedExpressionList(ParenthesizedExpressionList that) {
2332 forParenthesizedExpressionListDoFirst(that);
2333 for (int i = 0; i < that.getExpressions().length; i++) that.getExpressions()[i].visit(this);
2334 forParenthesizedExpressionListOnly(that);
2335 }
2336
2337 public void forUnparenthesizedExpressionList(UnparenthesizedExpressionList that) {
2338 forUnparenthesizedExpressionListDoFirst(that);
2339 for (int i = 0; i < that.getExpressions().length; i++) that.getExpressions()[i].visit(this);
2340 forUnparenthesizedExpressionListOnly(that);
2341 }
2342
2343 public void forDimensionExpressionList(DimensionExpressionList that) {
2344 forDimensionExpressionListDoFirst(that);
2345 for (int i = 0; i < that.getExpressions().length; i++) that.getExpressions()[i].visit(this);
2346 forDimensionExpressionListOnly(that);
2347 }
2348
2349 public void forEmptyForCondition(EmptyForCondition that) {
2350 forEmptyForConditionDoFirst(that);
2351 forEmptyForConditionOnly(that);
2352 }
2353
2354 /** This method is called by default from cases that do not
2355 ** override forCASEDoFirst.
2356 **/
2357 protected void defaultDoFirst(JExpressionIF that) {}
2358 /** This method is called by default from cases that do not
2359 ** override forCASEOnly.
2360 **/
2361 protected void defaultCase(JExpressionIF that) {}
2362 }