001 /*BEGIN_COPYRIGHT_BLOCK
002 *
003 * Copyright (c) 2001-2010, JavaPLT group at Rice University (drjava@rice.edu)
004 * All rights reserved.
005 *
006 * Redistribution and use in source and binary forms, with or without
007 * modification, are permitted provided that the following conditions are met:
008 * * Redistributions of source code must retain the above copyright
009 * notice, this list of conditions and the following disclaimer.
010 * * Redistributions in binary form must reproduce the above copyright
011 * notice, this list of conditions and the following disclaimer in the
012 * documentation and/or other materials provided with the distribution.
013 * * Neither the names of DrJava, the JavaPLT group, Rice University, nor the
014 * names of its contributors may be used to endorse or promote products
015 * derived from this software without specific prior written permission.
016 *
017 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
018 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
019 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
020 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
021 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
022 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
023 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
024 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
025 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
026 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
027 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
028 *
029 * This software is Open Source Initiative approved Open Source Software.
030 * Open Source Initative Approved is a trademark of the Open Source Initiative.
031 *
032 * This file is part of DrJava. Download the current version of this project
033 * from http://www.drjava.org/ or http://sourceforge.net/projects/drjava/
034 *
035 * END_COPYRIGHT_BLOCK*/
036
037 package edu.rice.cs.javalanglevels;
038
039 import edu.rice.cs.javalanglevels.tree.*;
040
041 /** It would be nice if this file could be automatically generated. Currently,
042 * it must be generated by copying any changes to the AST from
043 * JExpressionIFDepthFirstVistor_void and pasting them here. Then the
044 * if (prune(that)) ... line must be pasted into each for... method.
045 */
046
047 /** An abstract implementation of a visitor over JExpressionIF that does not return a value.
048 * This visitor implements the visitor interface with methods that
049 * first visit children, and then call visitCASEOnly().
050 * (CASE is replaced by the case name.) After each DOFirst method is called,
051 * the method pruneAt(JExpressionIF) is used to determine if the depth-first
052 * traversal should be pruned at the specified node. If not, traversal continues
053 * through each of the child nodes, followed by the only method. If so,
054 * control returns immediately to the parent node. Default implementation of
055 * pruneAt always returns true.
056 * The default implementation of the forCASEOnly methods call
057 * protected method defaultCase(). This method defaults to no-op.
058 */
059 public class JExpressionIFPrunableDepthFirstVisitor implements JExpressionIFVisitor<Void> {
060 /* Methods to visit an item. */
061 public Void forJExpressionDoFirst(JExpression that) { return defaultDoFirst(that); }
062 public Void forJExpressionOnly(JExpression that) { return defaultCase(that); }
063 public Void forSourceFileDoFirst(SourceFile that) { return forJExpressionDoFirst(that); }
064 public Void forSourceFileOnly(SourceFile that) { return forJExpressionOnly(that);}
065 public Void forModifiersAndVisibilityDoFirst(ModifiersAndVisibility that) { return forJExpressionDoFirst(that); }
066 public Void forModifiersAndVisibilityOnly(ModifiersAndVisibility that) { return forJExpressionOnly(that); }
067 public Void forCompoundWordDoFirst(CompoundWord that) { return forJExpressionDoFirst(that); }
068 public Void forCompoundWordOnly(CompoundWord that) { return forJExpressionOnly(that); }
069 public Void forWordDoFirst(Word that) { return forJExpressionDoFirst(that); }
070 public Void forWordOnly(Word that) { return forJExpressionOnly(that); }
071 public Void forTypeDefBaseDoFirst(TypeDefBase that) { return forJExpressionDoFirst(that); }
072 public Void forTypeDefBaseOnly(TypeDefBase that) { return forJExpressionOnly(that); }
073 public Void forClassDefDoFirst(ClassDef that) { return forTypeDefBaseDoFirst(that); }
074 public Void forClassDefOnly(ClassDef that) { return forTypeDefBaseOnly(that); }
075 public Void forInnerClassDefDoFirst(InnerClassDef that) {
076 // System.err.println("JEIFPDFV.forInnerClassDefDoFirst called for " + that.getName());
077 return forClassDefDoFirst(that);
078 }
079 public Void forInnerClassDefOnly(InnerClassDef that) { return forClassDefOnly(that); }
080 public Void forInterfaceDefDoFirst(InterfaceDef that) { return forTypeDefBaseDoFirst(that); }
081 public Void forInterfaceDefOnly(InterfaceDef that) { return forTypeDefBaseOnly(that); }
082 public Void forInnerInterfaceDefDoFirst(InnerInterfaceDef that) { return forInterfaceDefDoFirst(that); }
083 public Void forInnerInterfaceDefOnly(InnerInterfaceDef that) { return forInterfaceDefOnly(that); }
084 public Void forConstructorDefDoFirst(ConstructorDef that) { return forJExpressionDoFirst(that); }
085 public Void forConstructorDefOnly(ConstructorDef that) { return forJExpressionOnly(that); }
086 public Void forInitializerDoFirst(Initializer that) { return forJExpressionDoFirst(that); }
087 public Void forInitializerOnly(Initializer that) { return forJExpressionOnly(that); }
088 public Void forInstanceInitializerDoFirst(InstanceInitializer that) { return forInitializerDoFirst(that); }
089 public Void forInstanceInitializerOnly(InstanceInitializer that) { return forInitializerOnly(that); }
090 public Void forStaticInitializerDoFirst(StaticInitializer that) { return forInitializerDoFirst(that); }
091 public Void forStaticInitializerOnly(StaticInitializer that) { return forInitializerOnly(that); }
092
093 public Void forPackageStatementDoFirst(PackageStatement that) { return forJExpressionDoFirst(that); }
094 public Void forPackageStatementOnly(PackageStatement that) { return forJExpressionOnly(that); }
095 public Void forImportStatementDoFirst(ImportStatement that) { return forJExpressionDoFirst(that); }
096 public Void forImportStatementOnly(ImportStatement that) { return forJExpressionOnly(that); }
097 public Void forClassImportStatementDoFirst(ClassImportStatement that) { return forImportStatementDoFirst(that); }
098 public Void forClassImportStatementOnly(ClassImportStatement that) { return forImportStatementOnly(that); }
099 public Void forPackageImportStatementDoFirst(PackageImportStatement that) { return forImportStatementDoFirst(that); }
100 public Void forPackageImportStatementOnly(PackageImportStatement that) { return forImportStatementOnly(that); }
101 public Void forStatementDoFirst(Statement that) { return forJExpressionDoFirst(that); }
102 public Void forStatementOnly(Statement that) { return forJExpressionOnly(that); }
103
104 public Void forLabeledStatementDoFirst(LabeledStatement that) { return forStatementDoFirst(that); }
105 public Void forLabeledStatementOnly(LabeledStatement that) { return forStatementOnly(that); }
106 public Void forBlockDoFirst(Block that) { return forStatementDoFirst(that); }
107
108 public Void forBlockOnly(Block that) { return forStatementOnly(that); }
109 public Void forExpressionStatementDoFirst(ExpressionStatement that) { return forStatementDoFirst(that); }
110 public Void forExpressionStatementOnly(ExpressionStatement that) { return forStatementOnly(that); }
111 public Void forSwitchStatementDoFirst(SwitchStatement that) { return forStatementDoFirst(that); }
112 public Void forSwitchStatementOnly(SwitchStatement that) { return forStatementOnly(that); }
113 public Void forIfThenStatementDoFirst(IfThenStatement that) { return forStatementDoFirst(that); }
114 public Void forIfThenStatementOnly(IfThenStatement that) { return forStatementOnly(that); }
115 public Void forIfThenElseStatementDoFirst(IfThenElseStatement that) { return forIfThenStatementDoFirst(that); }
116 public Void forIfThenElseStatementOnly(IfThenElseStatement that) { return forIfThenStatementOnly(that); }
117 public Void forWhileStatementDoFirst(WhileStatement that) { return forStatementDoFirst(that); }
118 public Void forWhileStatementOnly(WhileStatement that) { return forStatementOnly(that); }
119 public Void forDoStatementDoFirst(DoStatement that) { return forStatementDoFirst(that); }
120 public Void forDoStatementOnly(DoStatement that) { return forStatementOnly(that); }
121 public Void forForStatementDoFirst(ForStatement that) { return forStatementDoFirst(that); }
122 public Void forForStatementOnly(ForStatement that) { return forStatementOnly(that); }
123 public Void forBreakStatementDoFirst(BreakStatement that) { return forStatementDoFirst(that); }
124 public Void forBreakStatementOnly(BreakStatement that) { return forStatementOnly(that); }
125 public Void forLabeledBreakStatementDoFirst(LabeledBreakStatement that) { return forBreakStatementDoFirst(that); }
126 public Void forLabeledBreakStatementOnly(LabeledBreakStatement that) { return forBreakStatementOnly(that); }
127 public Void forUnlabeledBreakStatementDoFirst(UnlabeledBreakStatement that) { return forBreakStatementDoFirst(that); }
128 public Void forUnlabeledBreakStatementOnly(UnlabeledBreakStatement that) { return forBreakStatementOnly(that); }
129 public Void forContinueStatementDoFirst(ContinueStatement that) { return forStatementDoFirst(that); }
130 public Void forContinueStatementOnly(ContinueStatement that) { return forStatementOnly(that); }
131 public Void forLabeledContinueStatementDoFirst(LabeledContinueStatement that) {
132 return forContinueStatementDoFirst(that);
133 }
134 public Void forLabeledContinueStatementOnly(LabeledContinueStatement that) { return forContinueStatementOnly(that); }
135 public Void forUnlabeledContinueStatementDoFirst(UnlabeledContinueStatement that) {
136 return forContinueStatementDoFirst(that);
137 }
138 public Void forUnlabeledContinueStatementOnly(UnlabeledContinueStatement that) {
139 return forContinueStatementOnly(that);
140 }
141 public Void forReturnStatementDoFirst(ReturnStatement that) { return forStatementDoFirst(that); }
142 public Void forReturnStatementOnly(ReturnStatement that) { return forStatementOnly(that); }
143 public Void forVoidReturnStatementDoFirst(VoidReturnStatement that) { return forReturnStatementDoFirst(that); }
144 public Void forVoidReturnStatementOnly(VoidReturnStatement that) { return forReturnStatementOnly(that); }
145 public Void forValueReturnStatementDoFirst(ValueReturnStatement that) { return forReturnStatementDoFirst(that); }
146 public Void forValueReturnStatementOnly(ValueReturnStatement that) { return forReturnStatementOnly(that); }
147 public Void forThrowStatementDoFirst(ThrowStatement that) { return forStatementDoFirst(that); }
148 public Void forThrowStatementOnly(ThrowStatement that) { return forStatementOnly(that); }
149 public Void forSynchronizedStatementDoFirst(SynchronizedStatement that) { return forStatementDoFirst(that); }
150 public Void forSynchronizedStatementOnly(SynchronizedStatement that) { return forStatementOnly(that); }
151 public Void forTryCatchStatementDoFirst(TryCatchStatement that) { return forStatementDoFirst(that); }
152 public Void forTryCatchStatementOnly(TryCatchStatement that) { return forStatementOnly(that); }
153 public Void forTryCatchFinallyStatementDoFirst(TryCatchFinallyStatement that) {
154 return forTryCatchStatementDoFirst(that);
155 }
156 public Void forTryCatchFinallyStatementOnly(TryCatchFinallyStatement that) { return forTryCatchStatementOnly(that); }
157 public Void forNormalTryCatchStatementDoFirst(NormalTryCatchStatement that) {
158 return forTryCatchStatementDoFirst(that);
159 }
160 public Void forNormalTryCatchStatementOnly(NormalTryCatchStatement that) { return forTryCatchStatementOnly(that); }
161 public Void forEmptyStatementDoFirst(EmptyStatement that) { return forStatementDoFirst(that); }
162 public Void forEmptyStatementOnly(EmptyStatement that) { return forStatementOnly(that); }
163 public Void forMethodDefDoFirst(MethodDef that) { return forJExpressionDoFirst(that); }
164 public Void forMethodDefOnly(MethodDef that) { return forJExpressionOnly(that); }
165 public Void forConcreteMethodDefDoFirst(ConcreteMethodDef that) { return forMethodDefDoFirst(that); }
166 public Void forConcreteMethodDefOnly(ConcreteMethodDef that) { return forMethodDefOnly(that); }
167 public Void forAbstractMethodDefDoFirst(AbstractMethodDef that) { return forMethodDefDoFirst(that); }
168 public Void forAbstractMethodDefOnly(AbstractMethodDef that) { return forMethodDefOnly(that); }
169 public Void forFormalParameterDoFirst(FormalParameter that) { return forJExpressionDoFirst(that); }
170 public Void forFormalParameterOnly(FormalParameter that) { return forJExpressionOnly(that); }
171 public Void forVariableDeclarationDoFirst(VariableDeclaration that) { return forJExpressionDoFirst(that); }
172 public Void forVariableDeclarationOnly(VariableDeclaration that) { return forJExpressionOnly(that); }
173 public Void forVariableDeclaratorDoFirst(VariableDeclarator that) { return forJExpressionDoFirst(that); }
174 public Void forVariableDeclaratorOnly(VariableDeclarator that) { return forJExpressionOnly(that); }
175 public Void forUninitializedVariableDeclaratorDoFirst(UninitializedVariableDeclarator that) {
176 return forVariableDeclaratorDoFirst(that);
177 }
178 public Void forUninitializedVariableDeclaratorOnly(UninitializedVariableDeclarator that) {
179 return forVariableDeclaratorOnly(that);
180 }
181 public Void forInitializedVariableDeclaratorDoFirst(InitializedVariableDeclarator that) {
182 return forVariableDeclaratorDoFirst(that);
183 }
184 public Void forInitializedVariableDeclaratorOnly(InitializedVariableDeclarator that) {
185 return forVariableDeclaratorOnly(that);
186 }
187 public Void forTypeParameterDoFirst(TypeParameter that) { return forJExpressionDoFirst(that); }
188 public Void forTypeParameterOnly(TypeParameter that) { return forJExpressionOnly(that); }
189 public Void forArrayInitializerDoFirst(ArrayInitializer that) { return forJExpressionDoFirst(that); }
190 public Void forArrayInitializerOnly(ArrayInitializer that) { return forJExpressionOnly(that); }
191 public Void forTypeDoFirst(Type that) { return forJExpressionDoFirst(that); }
192 public Void forTypeOnly(Type that) { return forJExpressionOnly(that); }
193 public Void forPrimitiveTypeDoFirst(PrimitiveType that) { return forTypeDoFirst(that); }
194 public Void forPrimitiveTypeOnly(PrimitiveType that) { return forTypeOnly(that); }
195 public Void forArrayTypeDoFirst(ArrayType that) { return forTypeDoFirst(that); }
196 public Void forArrayTypeOnly(ArrayType that) { return forTypeOnly(that); }
197 public Void forReferenceTypeDoFirst(ReferenceType that) { return forTypeDoFirst(that); }
198 public Void forReferenceTypeOnly(ReferenceType that) { return forTypeOnly(that); }
199 public Void forMemberTypeDoFirst(MemberType that) { return forReferenceTypeDoFirst(that); }
200 public Void forMemberTypeOnly(MemberType that) { return forReferenceTypeOnly(that); }
201 public Void forClassOrInterfaceTypeDoFirst(ClassOrInterfaceType that) { return forReferenceTypeDoFirst(that); }
202 public Void forClassOrInterfaceTypeOnly(ClassOrInterfaceType that) { return forReferenceTypeOnly(that); }
203 public Void forTypeVariableDoFirst(TypeVariable that) { return forReferenceTypeDoFirst(that); }
204 public Void forTypeVariableOnly(TypeVariable that) { return forReferenceTypeOnly(that); }
205 public Void forVoidReturnDoFirst(VoidReturn that) { return forJExpressionDoFirst(that); }
206 public Void forVoidReturnOnly(VoidReturn that) { return forJExpressionOnly(that); }
207 public Void forSwitchCaseDoFirst(SwitchCase that) { return forJExpressionDoFirst(that); }
208 public Void forSwitchCaseOnly(SwitchCase that) { return forJExpressionOnly(that); }
209 public Void forLabeledCaseDoFirst(LabeledCase that) { return forSwitchCaseDoFirst(that); }
210 public Void forLabeledCaseOnly(LabeledCase that) { return forSwitchCaseOnly(that); }
211 public Void forDefaultCaseDoFirst(DefaultCase that) { return forSwitchCaseDoFirst(that); }
212 public Void forDefaultCaseOnly(DefaultCase that) { return forSwitchCaseOnly(that); }
213 public Void forCatchBlockDoFirst(CatchBlock that) { return forJExpressionDoFirst(that); }
214 public Void forCatchBlockOnly(CatchBlock that) { return forJExpressionOnly(that); }
215 public Void forExpressionDoFirst(Expression that) { return forJExpressionDoFirst(that); }
216 public Void forExpressionOnly(Expression that) { return forJExpressionOnly(that); }
217 public Void forAssignmentExpressionDoFirst(AssignmentExpression that) { return forExpressionDoFirst(that); }
218 public Void forAssignmentExpressionOnly(AssignmentExpression that) { return forExpressionOnly(that); }
219 public Void forSimpleAssignmentExpressionDoFirst(SimpleAssignmentExpression that) {
220 return forAssignmentExpressionDoFirst(that);
221 }
222 public Void forSimpleAssignmentExpressionOnly(SimpleAssignmentExpression that) {
223 return forAssignmentExpressionOnly(that);
224 }
225 public Void forPlusAssignmentExpressionDoFirst(PlusAssignmentExpression that) {
226 return forAssignmentExpressionDoFirst(that);
227 }
228 public Void forPlusAssignmentExpressionOnly(PlusAssignmentExpression that) {
229 return forAssignmentExpressionOnly(that);
230 }
231 public Void forNumericAssignmentExpressionDoFirst(NumericAssignmentExpression that) {
232 return forAssignmentExpressionDoFirst(that);
233 }
234 public Void forNumericAssignmentExpressionOnly(NumericAssignmentExpression that) {
235 return forAssignmentExpressionOnly(that);
236 }
237 public Void forMinusAssignmentExpressionDoFirst(MinusAssignmentExpression that) {
238 return forNumericAssignmentExpressionDoFirst(that);
239 }
240 public Void forMinusAssignmentExpressionOnly(MinusAssignmentExpression that) {
241 return forNumericAssignmentExpressionOnly(that);
242 }
243 public Void forMultiplyAssignmentExpressionDoFirst(MultiplyAssignmentExpression that) {
244 return forNumericAssignmentExpressionDoFirst(that);
245 }
246 public Void forMultiplyAssignmentExpressionOnly(MultiplyAssignmentExpression that) {
247 return forNumericAssignmentExpressionOnly(that);
248 }
249 public Void forDivideAssignmentExpressionDoFirst(DivideAssignmentExpression that) {
250 return forNumericAssignmentExpressionDoFirst(that);
251 }
252 public Void forDivideAssignmentExpressionOnly(DivideAssignmentExpression that) {
253 return forNumericAssignmentExpressionOnly(that);
254 }
255 public Void forModAssignmentExpressionDoFirst(ModAssignmentExpression that) {
256 return forNumericAssignmentExpressionDoFirst(that);
257 }
258 public Void forModAssignmentExpressionOnly(ModAssignmentExpression that) {
259 return forNumericAssignmentExpressionOnly(that);
260 }
261 public Void forShiftAssignmentExpressionDoFirst(ShiftAssignmentExpression that) {
262 return forAssignmentExpressionDoFirst(that);
263 }
264 public Void forShiftAssignmentExpressionOnly(ShiftAssignmentExpression that) {
265 return forAssignmentExpressionOnly(that);
266 }
267 public Void forLeftShiftAssignmentExpressionDoFirst(LeftShiftAssignmentExpression that) {
268 return forShiftAssignmentExpressionDoFirst(that);
269 }
270 public Void forLeftShiftAssignmentExpressionOnly(LeftShiftAssignmentExpression that) {
271 return forShiftAssignmentExpressionOnly(that);
272 }
273 public Void forRightSignedShiftAssignmentExpressionDoFirst(RightSignedShiftAssignmentExpression that) {
274 return forShiftAssignmentExpressionDoFirst(that);
275 }
276 public Void forRightSignedShiftAssignmentExpressionOnly(RightSignedShiftAssignmentExpression that) {
277 return forShiftAssignmentExpressionOnly(that);
278 }
279 public Void forRightUnsignedShiftAssignmentExpressionDoFirst(RightUnsignedShiftAssignmentExpression that) {
280 return forShiftAssignmentExpressionDoFirst(that);
281 }
282 public Void forRightUnsignedShiftAssignmentExpressionOnly(RightUnsignedShiftAssignmentExpression that) {
283 return forShiftAssignmentExpressionOnly(that);
284 }
285 public Void forBitwiseAssignmentExpressionDoFirst(BitwiseAssignmentExpression that) {
286 return forAssignmentExpressionDoFirst(that);
287 }
288 public Void forBitwiseAssignmentExpressionOnly(BitwiseAssignmentExpression that) {
289 return forAssignmentExpressionOnly(that);
290 }
291 public Void forBitwiseAndAssignmentExpressionDoFirst(BitwiseAndAssignmentExpression that) {
292 return forBitwiseAssignmentExpressionDoFirst(that);
293 }
294 public Void forBitwiseAndAssignmentExpressionOnly(BitwiseAndAssignmentExpression that) {
295 return forBitwiseAssignmentExpressionOnly(that);
296 }
297 public Void forBitwiseOrAssignmentExpressionDoFirst(BitwiseOrAssignmentExpression that) {
298 return forBitwiseAssignmentExpressionDoFirst(that);
299 }
300 public Void forBitwiseOrAssignmentExpressionOnly(BitwiseOrAssignmentExpression that) {
301 return forBitwiseAssignmentExpressionOnly(that);
302 }
303 public Void forBitwiseXorAssignmentExpressionDoFirst(BitwiseXorAssignmentExpression that) {
304 return forBitwiseAssignmentExpressionDoFirst(that);
305 }
306 public Void forBitwiseXorAssignmentExpressionOnly(BitwiseXorAssignmentExpression that) {
307 return forBitwiseAssignmentExpressionOnly(that);
308 }
309 public Void forBinaryExpressionDoFirst(BinaryExpression that) { return forExpressionDoFirst(that); }
310 public Void forBinaryExpressionOnly(BinaryExpression that) { return forExpressionOnly(that); }
311 public Void forBooleanExpressionDoFirst(BooleanExpression that) { return forBinaryExpressionDoFirst(that); }
312 public Void forBooleanExpressionOnly(BooleanExpression that) { return forBinaryExpressionOnly(that); }
313 public Void forOrExpressionDoFirst(OrExpression that) { return forBooleanExpressionDoFirst(that); }
314 public Void forOrExpressionOnly(OrExpression that) { return forBooleanExpressionOnly(that); }
315 public Void forAndExpressionDoFirst(AndExpression that) { return forBooleanExpressionDoFirst(that); }
316 public Void forAndExpressionOnly(AndExpression that) { return forBooleanExpressionOnly(that); }
317 public Void forBitwiseBinaryExpressionDoFirst(BitwiseBinaryExpression that) {
318 return forBinaryExpressionDoFirst(that);
319 }
320 public Void forBitwiseBinaryExpressionOnly(BitwiseBinaryExpression that) { return forBinaryExpressionOnly(that); }
321 public Void forBitwiseOrExpressionDoFirst(BitwiseOrExpression that) {
322 return forBitwiseBinaryExpressionDoFirst(that);
323 }
324 public Void forBitwiseOrExpressionOnly(BitwiseOrExpression that) { return forBitwiseBinaryExpressionOnly(that); }
325 public Void forBitwiseXorExpressionDoFirst(BitwiseXorExpression that) {
326 return forBitwiseBinaryExpressionDoFirst(that);
327 }
328 public Void forBitwiseXorExpressionOnly(BitwiseXorExpression that) { return forBitwiseBinaryExpressionOnly(that); }
329 public Void forBitwiseAndExpressionDoFirst(BitwiseAndExpression that) {
330 return forBitwiseBinaryExpressionDoFirst(that);
331 }
332 public Void forBitwiseAndExpressionOnly(BitwiseAndExpression that) { return forBitwiseBinaryExpressionOnly(that); }
333 public Void forEqualityExpressionDoFirst(EqualityExpression that) { return forBinaryExpressionDoFirst(that); }
334 public Void forEqualityExpressionOnly(EqualityExpression that) { return forBinaryExpressionOnly(that); }
335 public Void forEqualsExpressionDoFirst(EqualsExpression that) { return forEqualityExpressionDoFirst(that); }
336 public Void forEqualsExpressionOnly(EqualsExpression that) { return forEqualityExpressionOnly(that); }
337 public Void forNotEqualExpressionDoFirst(NotEqualExpression that) { return forEqualityExpressionDoFirst(that); }
338 public Void forNotEqualExpressionOnly(NotEqualExpression that) { return forEqualityExpressionOnly(that); }
339 public Void forComparisonExpressionDoFirst(ComparisonExpression that) { return forBinaryExpressionDoFirst(that); }
340 public Void forComparisonExpressionOnly(ComparisonExpression that) { return forBinaryExpressionOnly(that); }
341 public Void forLessThanExpressionDoFirst(LessThanExpression that) { return forComparisonExpressionDoFirst(that); }
342 public Void forLessThanExpressionOnly(LessThanExpression that) { return forComparisonExpressionOnly(that); }
343 public Void forLessThanOrEqualExpressionDoFirst(LessThanOrEqualExpression that) {
344 return forComparisonExpressionDoFirst(that);
345 }
346 public Void forLessThanOrEqualExpressionOnly(LessThanOrEqualExpression that) {
347 return forComparisonExpressionOnly(that);
348 }
349 public Void forGreaterThanExpressionDoFirst(GreaterThanExpression that) {
350 return forComparisonExpressionDoFirst(that);
351 }
352 public Void forGreaterThanExpressionOnly(GreaterThanExpression that) { return forComparisonExpressionOnly(that); }
353 public Void forGreaterThanOrEqualExpressionDoFirst(GreaterThanOrEqualExpression that) {
354 return forComparisonExpressionDoFirst(that);
355 }
356 public Void forGreaterThanOrEqualExpressionOnly(GreaterThanOrEqualExpression that) {
357 return forComparisonExpressionOnly(that);
358 }
359 public Void forShiftBinaryExpressionDoFirst(ShiftBinaryExpression that) { return forBinaryExpressionDoFirst(that); }
360 public Void forShiftBinaryExpressionOnly(ShiftBinaryExpression that) { return forBinaryExpressionOnly(that); }
361 public Void forLeftShiftExpressionDoFirst(LeftShiftExpression that) { return forShiftBinaryExpressionDoFirst(that); }
362 public Void forLeftShiftExpressionOnly(LeftShiftExpression that) { return forShiftBinaryExpressionOnly(that); }
363 public Void forRightSignedShiftExpressionDoFirst(RightSignedShiftExpression that) {
364 return forShiftBinaryExpressionDoFirst(that);
365 }
366 public Void forRightSignedShiftExpressionOnly(RightSignedShiftExpression that) {
367 return forShiftBinaryExpressionOnly(that);
368 }
369 public Void forRightUnsignedShiftExpressionDoFirst(RightUnsignedShiftExpression that) {
370 return forShiftBinaryExpressionDoFirst(that);
371 }
372 public Void forRightUnsignedShiftExpressionOnly(RightUnsignedShiftExpression that) {
373 return forShiftBinaryExpressionOnly(that);
374 }
375 public Void forPlusExpressionDoFirst(PlusExpression that) { return forBinaryExpressionDoFirst(that); }
376 public Void forPlusExpressionOnly(PlusExpression that) { return forBinaryExpressionOnly(that); }
377 public Void forNumericBinaryExpressionDoFirst(NumericBinaryExpression that) {
378 return forBinaryExpressionDoFirst(that);
379 }
380 public Void forNumericBinaryExpressionOnly(NumericBinaryExpression that) { return forBinaryExpressionOnly(that); }
381 public Void forMinusExpressionDoFirst(MinusExpression that) { return forNumericBinaryExpressionDoFirst(that); }
382 public Void forMinusExpressionOnly(MinusExpression that) { return forNumericBinaryExpressionOnly(that); }
383 public Void forMultiplyExpressionDoFirst(MultiplyExpression that) { return forNumericBinaryExpressionDoFirst(that); }
384 public Void forMultiplyExpressionOnly(MultiplyExpression that) { return forNumericBinaryExpressionOnly(that); }
385 public Void forDivideExpressionDoFirst(DivideExpression that) { return forNumericBinaryExpressionDoFirst(that); }
386 public Void forDivideExpressionOnly(DivideExpression that) { return forNumericBinaryExpressionOnly(that); }
387 public Void forModExpressionDoFirst(ModExpression that) { return forNumericBinaryExpressionDoFirst(that); }
388 public Void forModExpressionOnly(ModExpression that) { return forNumericBinaryExpressionOnly(that); }
389 public Void forNoOpExpressionDoFirst(NoOpExpression that) { return forBinaryExpressionDoFirst(that); }
390 public Void forNoOpExpressionOnly(NoOpExpression that) { return forBinaryExpressionOnly(that); }
391 public Void forUnaryExpressionDoFirst(UnaryExpression that) { return forExpressionDoFirst(that); }
392 public Void forUnaryExpressionOnly(UnaryExpression that) { return forExpressionOnly(that); }
393 public Void forIncrementExpressionDoFirst(IncrementExpression that) { return forUnaryExpressionDoFirst(that); }
394 public Void forIncrementExpressionOnly(IncrementExpression that) { return forUnaryExpressionOnly(that); }
395 public Void forPrefixIncrementExpressionDoFirst(PrefixIncrementExpression that) {
396 return forIncrementExpressionDoFirst(that);
397 }
398 public Void forPrefixIncrementExpressionOnly(PrefixIncrementExpression that) {
399 return forIncrementExpressionOnly(that);
400 }
401 public Void forPositivePrefixIncrementExpressionDoFirst(PositivePrefixIncrementExpression that) {
402 return forPrefixIncrementExpressionDoFirst(that);
403 }
404 public Void forPositivePrefixIncrementExpressionOnly(PositivePrefixIncrementExpression that) {
405 return forPrefixIncrementExpressionOnly(that);
406 }
407 public Void forNegativePrefixIncrementExpressionDoFirst(NegativePrefixIncrementExpression that) {
408 return forPrefixIncrementExpressionDoFirst(that);
409 }
410 public Void forNegativePrefixIncrementExpressionOnly(NegativePrefixIncrementExpression that) {
411 return forPrefixIncrementExpressionOnly(that);
412 }
413 public Void forPostfixIncrementExpressionDoFirst(PostfixIncrementExpression that) {
414 return forIncrementExpressionDoFirst(that);
415 }
416 public Void forPostfixIncrementExpressionOnly(PostfixIncrementExpression that) {
417 return forIncrementExpressionOnly(that);
418 }
419 public Void forPositivePostfixIncrementExpressionDoFirst(PositivePostfixIncrementExpression that) {
420 return forPostfixIncrementExpressionDoFirst(that);
421 }
422 public Void forPositivePostfixIncrementExpressionOnly(PositivePostfixIncrementExpression that) {
423 return forPostfixIncrementExpressionOnly(that);
424 }
425 public Void forNegativePostfixIncrementExpressionDoFirst(NegativePostfixIncrementExpression that) {
426 return forPostfixIncrementExpressionDoFirst(that);
427 }
428 public Void forNegativePostfixIncrementExpressionOnly(NegativePostfixIncrementExpression that) {
429 return forPostfixIncrementExpressionOnly(that);
430 }
431 public Void forNumericUnaryExpressionDoFirst(NumericUnaryExpression that) { return forUnaryExpressionDoFirst(that); }
432 public Void forNumericUnaryExpressionOnly(NumericUnaryExpression that) { return forUnaryExpressionOnly(that); }
433 public Void forPositiveExpressionDoFirst(PositiveExpression that) { return forNumericUnaryExpressionDoFirst(that); }
434 public Void forPositiveExpressionOnly(PositiveExpression that) { return forNumericUnaryExpressionOnly(that); }
435 public Void forNegativeExpressionDoFirst(NegativeExpression that) { return forNumericUnaryExpressionDoFirst(that); }
436 public Void forNegativeExpressionOnly(NegativeExpression that) { return forNumericUnaryExpressionOnly(that); }
437 public Void forBitwiseNotExpressionDoFirst(BitwiseNotExpression that) { return forUnaryExpressionDoFirst(that); }
438 public Void forBitwiseNotExpressionOnly(BitwiseNotExpression that) { return forUnaryExpressionOnly(that); }
439 public Void forNotExpressionDoFirst(NotExpression that) { return forUnaryExpressionDoFirst(that); }
440 public Void forNotExpressionOnly(NotExpression that) { return forUnaryExpressionOnly(that); }
441 public Void forConditionalExpressionDoFirst(ConditionalExpression that) { return forExpressionDoFirst(that); }
442 public Void forConditionalExpressionOnly(ConditionalExpression that) { return forExpressionOnly(that); }
443 public Void forInstanceofExpressionDoFirst(InstanceofExpression that) { return forExpressionDoFirst(that); }
444 public Void forInstanceofExpressionOnly(InstanceofExpression that) { return forExpressionOnly(that); }
445 public Void forCastExpressionDoFirst(CastExpression that) { return forExpressionDoFirst(that); }
446 public Void forCastExpressionOnly(CastExpression that) { return forExpressionOnly(that); }
447 public Void forPrimaryDoFirst(Primary that) { return forExpressionDoFirst(that); }
448 public Void forPrimaryOnly(Primary that) { return forExpressionOnly(that); }
449 public Void forLexicalLiteralDoFirst(LexicalLiteral that) { return forPrimaryDoFirst(that); }
450 public Void forLexicalLiteralOnly(LexicalLiteral that) { return forPrimaryOnly(that); }
451 public Void forIntegerLiteralDoFirst(IntegerLiteral that) { return forLexicalLiteralDoFirst(that); }
452 public Void forIntegerLiteralOnly(IntegerLiteral that) { return forLexicalLiteralOnly(that); }
453 public Void forLongLiteralDoFirst(LongLiteral that) { return forLexicalLiteralDoFirst(that); }
454 public Void forLongLiteralOnly(LongLiteral that) { return forLexicalLiteralOnly(that); }
455 public Void forDoubleLiteralDoFirst(DoubleLiteral that) { return forLexicalLiteralDoFirst(that); }
456 public Void forDoubleLiteralOnly(DoubleLiteral that) { return forLexicalLiteralOnly(that); }
457 public Void forFloatLiteralDoFirst(FloatLiteral that) { return forLexicalLiteralDoFirst(that); }
458 public Void forFloatLiteralOnly(FloatLiteral that) { return forLexicalLiteralOnly(that); }
459 public Void forBooleanLiteralDoFirst(BooleanLiteral that) { return forLexicalLiteralDoFirst(that); }
460 public Void forBooleanLiteralOnly(BooleanLiteral that) { return forLexicalLiteralOnly(that); }
461 public Void forCharLiteralDoFirst(CharLiteral that) { return forLexicalLiteralDoFirst(that); }
462 public Void forCharLiteralOnly(CharLiteral that) { return forLexicalLiteralOnly(that); }
463 public Void forStringLiteralDoFirst(StringLiteral that) { return forLexicalLiteralDoFirst(that); }
464 public Void forStringLiteralOnly(StringLiteral that) { return forLexicalLiteralOnly(that); }
465 public Void forNullLiteralDoFirst(NullLiteral that) { return forLexicalLiteralDoFirst(that); }
466 public Void forNullLiteralOnly(NullLiteral that) { return forLexicalLiteralOnly(that); }
467 public Void forInstantiationDoFirst(Instantiation that) { return forPrimaryDoFirst(that); }
468 public Void forInstantiationOnly(Instantiation that) { return forPrimaryOnly(that); }
469 public Void forClassInstantiationDoFirst(ClassInstantiation that) { return forInstantiationDoFirst(that); }
470 public Void forClassInstantiationOnly(ClassInstantiation that) { return forInstantiationOnly(that); }
471 public Void forNamedClassInstantiationDoFirst(NamedClassInstantiation that) {
472 return forClassInstantiationDoFirst(that);
473 }
474 public Void forNamedClassInstantiationOnly(NamedClassInstantiation that) { return forClassInstantiationOnly(that); }
475 public Void forSimpleNamedClassInstantiationDoFirst(SimpleNamedClassInstantiation that) {
476 return forNamedClassInstantiationDoFirst(that);
477 }
478 public Void forSimpleNamedClassInstantiationOnly(SimpleNamedClassInstantiation that) {
479 return forNamedClassInstantiationOnly(that);
480 }
481 public Void forComplexNamedClassInstantiationDoFirst(ComplexNamedClassInstantiation that) {
482 return forNamedClassInstantiationDoFirst(that);
483 }
484 public Void forComplexNamedClassInstantiationOnly(ComplexNamedClassInstantiation that) {
485 return forNamedClassInstantiationOnly(that);
486 }
487 public Void forAnonymousClassInstantiationDoFirst(AnonymousClassInstantiation that) {
488 return forClassInstantiationDoFirst(that);
489 }
490 public Void forAnonymousClassInstantiationOnly(AnonymousClassInstantiation that) {
491 return forClassInstantiationOnly(that);
492 }
493 public Void forSimpleAnonymousClassInstantiationDoFirst(SimpleAnonymousClassInstantiation that) {
494 return forAnonymousClassInstantiationDoFirst(that);
495 }
496 public Void forSimpleAnonymousClassInstantiationOnly(SimpleAnonymousClassInstantiation that) {
497 return forAnonymousClassInstantiationOnly(that);
498 }
499 public Void forComplexAnonymousClassInstantiationDoFirst(ComplexAnonymousClassInstantiation that) {
500 return forAnonymousClassInstantiationDoFirst(that);
501 }
502 public Void forComplexAnonymousClassInstantiationOnly(ComplexAnonymousClassInstantiation that) {
503 return forAnonymousClassInstantiationOnly(that);
504 }
505 public Void forArrayInstantiationDoFirst(ArrayInstantiation that) { return forInstantiationDoFirst(that); }
506 public Void forArrayInstantiationOnly(ArrayInstantiation that) { return forInstantiationOnly(that); }
507 public Void forUninitializedArrayInstantiationDoFirst(UninitializedArrayInstantiation that) {
508 return forArrayInstantiationDoFirst(that);
509 }
510 public Void forUninitializedArrayInstantiationOnly(UninitializedArrayInstantiation that) {
511 return forArrayInstantiationOnly(that);
512 }
513 public Void forSimpleUninitializedArrayInstantiationDoFirst(SimpleUninitializedArrayInstantiation that) {
514 return forUninitializedArrayInstantiationDoFirst(that);
515 }
516 public Void forSimpleUninitializedArrayInstantiationOnly(SimpleUninitializedArrayInstantiation that) {
517 return forUninitializedArrayInstantiationOnly(that);
518 }
519 public Void forComplexUninitializedArrayInstantiationDoFirst(ComplexUninitializedArrayInstantiation that) {
520 return forUninitializedArrayInstantiationDoFirst(that);
521 }
522 public Void forComplexUninitializedArrayInstantiationOnly(ComplexUninitializedArrayInstantiation that) {
523 return forUninitializedArrayInstantiationOnly(that);
524 }
525 public Void forInitializedArrayInstantiationDoFirst(InitializedArrayInstantiation that) {
526 return forArrayInstantiationDoFirst(that);
527 }
528 public Void forInitializedArrayInstantiationOnly(InitializedArrayInstantiation that) {
529 return forArrayInstantiationOnly(that);
530 }
531 public Void forSimpleInitializedArrayInstantiationDoFirst(SimpleInitializedArrayInstantiation that) {
532 return forInitializedArrayInstantiationDoFirst(that);
533 }
534 public Void forSimpleInitializedArrayInstantiationOnly(SimpleInitializedArrayInstantiation that) {
535 return forInitializedArrayInstantiationOnly(that);
536 }
537 public Void forComplexInitializedArrayInstantiationDoFirst(ComplexInitializedArrayInstantiation that) {
538 return forInitializedArrayInstantiationDoFirst(that);
539 }
540 public Void forComplexInitializedArrayInstantiationOnly(ComplexInitializedArrayInstantiation that) {
541 return forInitializedArrayInstantiationOnly(that);
542 }
543 public Void forVariableReferenceDoFirst(VariableReference that) { return forPrimaryDoFirst(that); }
544 public Void forVariableReferenceOnly(VariableReference that) { return forPrimaryOnly(that); }
545 public Void forNameReferenceDoFirst(NameReference that) { return forVariableReferenceDoFirst(that); }
546 public Void forNameReferenceOnly(NameReference that) { return forVariableReferenceOnly(that); }
547 public Void forSimpleNameReferenceDoFirst(SimpleNameReference that) { return forNameReferenceDoFirst(that); }
548 public Void forSimpleNameReferenceOnly(SimpleNameReference that) { return forNameReferenceOnly(that); }
549 public Void forComplexNameReferenceDoFirst(ComplexNameReference that) { return forNameReferenceDoFirst(that); }
550 public Void forComplexNameReferenceOnly(ComplexNameReference that) { return forNameReferenceOnly(that); }
551 public Void forThisReferenceDoFirst(ThisReference that) { return forVariableReferenceDoFirst(that); }
552 public Void forThisReferenceOnly(ThisReference that) { return forVariableReferenceOnly(that); }
553 public Void forSimpleThisReferenceDoFirst(SimpleThisReference that) { return forThisReferenceDoFirst(that); }
554 public Void forSimpleThisReferenceOnly(SimpleThisReference that) { return forThisReferenceOnly(that); }
555 public Void forComplexThisReferenceDoFirst(ComplexThisReference that) { return forThisReferenceDoFirst(that); }
556 public Void forComplexThisReferenceOnly(ComplexThisReference that) { return forThisReferenceOnly(that); }
557 public Void forSuperReferenceDoFirst(SuperReference that) { return forVariableReferenceDoFirst(that); }
558 public Void forSuperReferenceOnly(SuperReference that) { return forVariableReferenceOnly(that); }
559 public Void forSimpleSuperReferenceDoFirst(SimpleSuperReference that) { return forSuperReferenceDoFirst(that); }
560 public Void forSimpleSuperReferenceOnly(SimpleSuperReference that) { return forSuperReferenceOnly(that); }
561 public Void forComplexSuperReferenceDoFirst(ComplexSuperReference that) { return forSuperReferenceDoFirst(that); }
562 public Void forComplexSuperReferenceOnly(ComplexSuperReference that) { return forSuperReferenceOnly(that); }
563 public Void forFunctionInvocationDoFirst(FunctionInvocation that) { return forPrimaryDoFirst(that); }
564 public Void forFunctionInvocationOnly(FunctionInvocation that) { return forPrimaryOnly(that); }
565 public Void forMethodInvocationDoFirst(MethodInvocation that) { return forFunctionInvocationDoFirst(that); }
566 public Void forMethodInvocationOnly(MethodInvocation that) { return forFunctionInvocationOnly(that); }
567 public Void forSimpleMethodInvocationDoFirst(SimpleMethodInvocation that) { return forMethodInvocationDoFirst(that); }
568 public Void forSimpleMethodInvocationOnly(SimpleMethodInvocation that) { return forMethodInvocationOnly(that); }
569 public Void forComplexMethodInvocationDoFirst(ComplexMethodInvocation that) {
570 return forMethodInvocationDoFirst(that);
571 }
572 public Void forComplexMethodInvocationOnly(ComplexMethodInvocation that) { return forMethodInvocationOnly(that); }
573 public Void forThisConstructorInvocationDoFirst(ThisConstructorInvocation that) {
574 return forFunctionInvocationDoFirst(that);
575 }
576 public Void forThisConstructorInvocationOnly(ThisConstructorInvocation that) {
577 return forFunctionInvocationOnly(that);
578 }
579 public Void forSimpleThisConstructorInvocationDoFirst(SimpleThisConstructorInvocation that) {
580 return forThisConstructorInvocationDoFirst(that);
581 }
582 public Void forSimpleThisConstructorInvocationOnly(SimpleThisConstructorInvocation that) {
583 return forThisConstructorInvocationOnly(that);
584 }
585 public Void forComplexThisConstructorInvocationDoFirst(ComplexThisConstructorInvocation that) {
586 return forThisConstructorInvocationDoFirst(that);
587 }
588 public Void forComplexThisConstructorInvocationOnly(ComplexThisConstructorInvocation that) {
589 return forThisConstructorInvocationOnly(that);
590 }
591 public Void forSuperConstructorInvocationDoFirst(SuperConstructorInvocation that) {
592 return forFunctionInvocationDoFirst(that);
593 }
594 public Void forSuperConstructorInvocationOnly(SuperConstructorInvocation that) {
595 return forFunctionInvocationOnly(that);
596 }
597 public Void forSimpleSuperConstructorInvocationDoFirst(SimpleSuperConstructorInvocation that) {
598 return forSuperConstructorInvocationDoFirst(that);
599 }
600 public Void forSimpleSuperConstructorInvocationOnly(SimpleSuperConstructorInvocation that) {
601 return forSuperConstructorInvocationOnly(that);
602 }
603 public Void forComplexSuperConstructorInvocationDoFirst(ComplexSuperConstructorInvocation that) {
604 return forSuperConstructorInvocationDoFirst(that);
605 }
606 public Void forComplexSuperConstructorInvocationOnly(ComplexSuperConstructorInvocation that) {
607 return forSuperConstructorInvocationOnly(that);
608 }
609 public Void forClassLiteralDoFirst(ClassLiteral that) { return forPrimaryDoFirst(that); }
610 public Void forClassLiteralOnly(ClassLiteral that) { return forPrimaryOnly(that); }
611 public Void forArrayAccessDoFirst(ArrayAccess that) { return forPrimaryDoFirst(that); }
612 public Void forArrayAccessOnly(ArrayAccess that) { return forPrimaryOnly(that); }
613 public Void forParenthesizedDoFirst(Parenthesized that) { return forPrimaryDoFirst(that); }
614 public Void forParenthesizedOnly(Parenthesized that) { return forPrimaryOnly(that); }
615 public Void forEmptyExpressionDoFirst(EmptyExpression that) { return forPrimaryDoFirst(that); }
616 public Void forEmptyExpressionOnly(EmptyExpression that) { return forPrimaryOnly(that); }
617 // public void forEmptyDimensionExpressionDoFirst(EmptyDimensionExpression that) {
618 // forPrimaryDoFirst(that);
619 // }
620
621 // public void forEmptyDimensionExpressionOnly(EmptyDimensionExpression that) {
622 // forPrimaryOnly(that);
623 // }
624
625 public Void forBodyDoFirst(Body that) { return forJExpressionDoFirst(that); }
626 public Void forBodyOnly(Body that) { return forJExpressionOnly(that); }
627 public Void forBracedBodyDoFirst(BracedBody that) { return forBodyDoFirst(that); }
628 public Void forBracedBodyOnly(BracedBody that) { return forBodyOnly(that); }
629 public Void forUnbracedBodyDoFirst(UnbracedBody that) { return forBodyDoFirst(that); }
630 public Void forUnbracedBodyOnly(UnbracedBody that) { return forBodyOnly(that); }
631 public Void forExpressionListDoFirst(ExpressionList that) { return forJExpressionDoFirst(that); }
632 public Void forExpressionListOnly(ExpressionList that) { return forJExpressionOnly(that); }
633 public Void forParenthesizedExpressionListDoFirst(ParenthesizedExpressionList that) {
634 return forExpressionListDoFirst(that);
635 }
636 public Void forParenthesizedExpressionListOnly(ParenthesizedExpressionList that) {
637 return forExpressionListOnly(that);
638 }
639 public Void forUnparenthesizedExpressionListDoFirst(UnparenthesizedExpressionList that) {
640 return forExpressionListDoFirst(that);
641 }
642 public Void forUnparenthesizedExpressionListOnly(UnparenthesizedExpressionList that) {
643 return forExpressionListOnly(that);
644 }
645 public Void forDimensionExpressionListDoFirst(DimensionExpressionList that) { return forExpressionListDoFirst(that); }
646 public Void forDimensionExpressionListOnly(DimensionExpressionList that) { return forExpressionListOnly(that); }
647 public Void forEmptyForConditionDoFirst(EmptyForCondition that) { return forJExpressionDoFirst(that); }
648 public Void forEmptyForConditionOnly(EmptyForCondition that) { return forJExpressionOnly(that); }
649
650 /* Implementation of JExpressionIFVisitor_void methods to implement depth-first traversal. */
651 public Void forSourceFile(SourceFile that) {
652 forSourceFileDoFirst(that);
653 if (prune(that)) return null;
654 for (int i = 0; i < that.getPackageStatements().length; i++) that.getPackageStatements()[i].visit(this);
655 for (int i = 0; i < that.getImportStatements().length; i++) that.getImportStatements()[i].visit(this);
656 for (int i = 0; i < that.getTypes().length; i++) that.getTypes()[i].visit(this);
657 return forSourceFileOnly(that);
658 }
659 public Void forModifiersAndVisibility(ModifiersAndVisibility that) {
660 forModifiersAndVisibilityDoFirst(that);
661 if (prune(that)) return null;
662 return forModifiersAndVisibilityOnly(that);
663 }
664 public Void forCompoundWord(CompoundWord that) {
665 forCompoundWordDoFirst(that);
666 if (prune(that)) return null;
667 for (int i = 0; i < that.getWords().length; i++) that.getWords()[i].visit(this);
668 return forCompoundWordOnly(that);
669 }
670 public Void forWord(Word that) {
671 forWordDoFirst(that);
672 if (prune(that)) return null;
673 return forWordOnly(that);
674 }
675
676 public Void forClassDef(ClassDef that) {
677 forClassDefDoFirst(that);
678 if (prune(that)) return null;
679 that.getMav().visit(this);
680 that.getName().visit(this);
681 for (int i = 0; i < that.getTypeParameters().length; i++) that.getTypeParameters()[i].visit(this);
682
683 that.getSuperclass().visit(this);
684
685 for (int i = 0; i < that.getInterfaces().length; i++) that.getInterfaces()[i].visit(this);
686
687 that.getBody().visit(this);
688 return forClassDefOnly(that);
689 }
690
691 public Void forInnerClassDef(InnerClassDef that) {
692 // System.err.println("Visiting inner class " + that.getName() + " in JExpIfPrunDFV from " + this);
693 forInnerClassDefDoFirst(that);
694 if (prune(that)) return null;
695 // System.err.println("Passed the prune control point in JEIFPDFV.forInnerClassDef for " + that.getName());
696 that.getMav().visit(this);
697 that.getName().visit(this);
698
699 for (int i = 0; i < that.getTypeParameters().length; i++) that.getTypeParameters()[i].visit(this);
700 that.getSuperclass().visit(this);
701 for (int i = 0; i < that.getInterfaces().length; i++) that.getInterfaces()[i].visit(this);
702
703 that.getBody().visit(this);
704 return forInnerClassDefOnly(that);
705 }
706
707 public Void forInterfaceDef(InterfaceDef that) {
708 forInterfaceDefDoFirst(that);
709 if (prune(that)) return null;
710 that.getMav().visit(this);
711 for (int i = 0; i < that.getTypeParameters().length; i++) that.getTypeParameters()[i].visit(this);
712 for (int i = 0; i < that.getInterfaces().length; i++) that.getInterfaces()[i].visit(this);
713 that.getBody().visit(this);
714 return forInterfaceDefOnly(that);
715 }
716 public Void forInnerInterfaceDef(InnerInterfaceDef that) {
717 forInnerInterfaceDefDoFirst(that);
718 if (prune(that)) return null;
719 that.getMav().visit(this);
720 for (int i = 0; i < that.getTypeParameters().length; i++) that.getTypeParameters()[i].visit(this);
721 for (int i = 0; i < that.getInterfaces().length; i++) that.getInterfaces()[i].visit(this);
722 that.getBody().visit(this);
723 return forInnerInterfaceDefOnly(that);
724 }
725 public Void forConstructorDef(ConstructorDef that) {
726 forConstructorDefDoFirst(that);
727 if (prune(that)) return null;
728 that.getName().visit(this);
729 that.getMav().visit(this);
730 for (int i = 0; i < that.getParameters().length; i++) that.getParameters()[i].visit(this);
731 for (int i = 0; i < that.getThrows().length; i++) that.getThrows()[i].visit(this);
732 that.getStatements().visit(this);
733 return forConstructorDefOnly(that);
734 }
735 public Void forInstanceInitializer(InstanceInitializer that) {
736 forInstanceInitializerDoFirst(that);
737 if (prune(that)) return null;
738 that.getCode().visit(this);
739 return forInstanceInitializerOnly(that);
740 }
741 public Void forStaticInitializer(StaticInitializer that) {
742 forStaticInitializerDoFirst(that);
743 if (prune(that)) return null;
744 that.getCode().visit(this);
745 return forStaticInitializerOnly(that);
746 }
747 public Void forPackageStatement(PackageStatement that) {
748 forPackageStatementDoFirst(that);
749 if (prune(that)) return null;
750 that.getCWord().visit(this);
751 return forPackageStatementOnly(that);
752 }
753 public Void forClassImportStatement(ClassImportStatement that) {
754 forClassImportStatementDoFirst(that);
755 if (prune(that)) return null;
756 that.getCWord().visit(this);
757 return forClassImportStatementOnly(that);
758 }
759 public Void forPackageImportStatement(PackageImportStatement that) {
760 forPackageImportStatementDoFirst(that);
761 if (prune(that)) return null;
762 that.getCWord().visit(this);
763 return forPackageImportStatementOnly(that);
764 }
765 public Void forLabeledStatement(LabeledStatement that) {
766 forLabeledStatementDoFirst(that);
767 if (prune(that)) return null;
768 that.getLabel().visit(this);
769 that.getStatement().visit(this);
770 return forLabeledStatementOnly(that);
771 }
772 public Void forBlock(Block that) {
773 forBlockDoFirst(that);
774 if (prune(that)) return null;
775 that.getStatements().visit(this);
776 return forBlockOnly(that);
777 }
778 public Void forExpressionStatement(ExpressionStatement that) {
779 forExpressionStatementDoFirst(that);
780 if (prune(that)) return null;
781 that.getExpression().visit(this);
782 return forExpressionStatementOnly(that);
783 }
784 public Void forSwitchStatement(SwitchStatement that) {
785 forSwitchStatementDoFirst(that);
786 if (prune(that)) return null;
787 that.getTest().visit(this);
788 for (int i = 0; i < that.getCases().length; i++) that.getCases()[i].visit(this);
789 return forSwitchStatementOnly(that);
790 }
791 public Void forIfThenStatement(IfThenStatement that) {
792 forIfThenStatementDoFirst(that);
793 if (prune(that)) return null;
794 that.getTestExpression().visit(this);
795 that.getThenStatement().visit(this);
796 return forIfThenStatementOnly(that);
797 }
798 public Void forIfThenElseStatement(IfThenElseStatement that) {
799 forIfThenElseStatementDoFirst(that);
800 if (prune(that)) return null;
801 that.getTestExpression().visit(this);
802 that.getThenStatement().visit(this);
803 that.getElseStatement().visit(this);
804 return forIfThenElseStatementOnly(that);
805 }
806 public Void forWhileStatement(WhileStatement that) {
807 forWhileStatementDoFirst(that);
808 if (prune(that)) return null;
809 that.getCondition().visit(this);
810 that.getCode().visit(this);
811 return forWhileStatementOnly(that);
812 }
813 public Void forDoStatement(DoStatement that) {
814 forDoStatementDoFirst(that);
815 if (prune(that)) return null;
816 that.getCode().visit(this);
817 that.getCondition().visit(this);
818 return forDoStatementOnly(that);
819 }
820 public Void forForStatement(ForStatement that) {
821 forForStatementDoFirst(that);
822 if (prune(that)) return null;
823 that.getInit().visit(this);
824 that.getCondition().visit(this);
825 that.getUpdate().visit(this);
826 that.getCode().visit(this);
827 return forForStatementOnly(that);
828 }
829 public Void forLabeledBreakStatement(LabeledBreakStatement that) {
830 forLabeledBreakStatementDoFirst(that);
831 if (prune(that)) return null;
832 that.getLabel().visit(this);
833 return forLabeledBreakStatementOnly(that);
834 }
835 public Void forUnlabeledBreakStatement(UnlabeledBreakStatement that) {
836 forUnlabeledBreakStatementDoFirst(that);
837 if (prune(that)) return null;
838 return forUnlabeledBreakStatementOnly(that);
839 }
840 public Void forLabeledContinueStatement(LabeledContinueStatement that) {
841 forLabeledContinueStatementDoFirst(that);
842 if (prune(that)) return null;
843 that.getLabel().visit(this);
844 return forLabeledContinueStatementOnly(that);
845 }
846 public Void forUnlabeledContinueStatement(UnlabeledContinueStatement that) {
847 forUnlabeledContinueStatementDoFirst(that);
848 if (prune(that)) return null;
849 return forUnlabeledContinueStatementOnly(that);
850 }
851 public Void forVoidReturnStatement(VoidReturnStatement that) {
852 forVoidReturnStatementDoFirst(that);
853 if (prune(that)) return null;
854 return forVoidReturnStatementOnly(that);
855 }
856 public Void forValueReturnStatement(ValueReturnStatement that) {
857 forValueReturnStatementDoFirst(that);
858 if (prune(that)) return null;
859 that.getValue().visit(this);
860 return forValueReturnStatementOnly(that);
861 }
862 public Void forThrowStatement(ThrowStatement that) {
863 forThrowStatementDoFirst(that);
864 if (prune(that)) return null;
865 that.getThrown().visit(this);
866 return forThrowStatementOnly(that);
867 }
868 public Void forSynchronizedStatement(SynchronizedStatement that) {
869 forSynchronizedStatementDoFirst(that);
870 if (prune(that)) return null;
871 that.getLockExpr().visit(this);
872 that.getBlock().visit(this);
873 return forSynchronizedStatementOnly(that);
874 }
875 public Void forTryCatchFinallyStatement(TryCatchFinallyStatement that) {
876 forTryCatchFinallyStatementDoFirst(that);
877 if (prune(that)) return null;
878 that.getTryBlock().visit(this);
879 for (int i = 0; i < that.getCatchBlocks().length; i++) that.getCatchBlocks()[i].visit(this);
880 that.getFinallyBlock().visit(this);
881 return forTryCatchFinallyStatementOnly(that);
882 }
883 public Void forNormalTryCatchStatement(NormalTryCatchStatement that) {
884 forNormalTryCatchStatementDoFirst(that);
885 if (prune(that)) return null;
886 that.getTryBlock().visit(this);
887 for (int i = 0; i < that.getCatchBlocks().length; i++) that.getCatchBlocks()[i].visit(this);
888 return forNormalTryCatchStatementOnly(that);
889 }
890 public Void forEmptyStatement(EmptyStatement that) {
891 forEmptyStatementDoFirst(that);
892 if (prune(that)) return null;
893 return forEmptyStatementOnly(that);
894 }
895 public Void forConcreteMethodDef(ConcreteMethodDef that) {
896 forConcreteMethodDefDoFirst(that);
897 if (prune(that)) return null;
898 that.getMav().visit(this);
899 for (int i = 0; i < that.getTypeParams().length; i++) that.getTypeParams()[i].visit(this);
900 that.getResult().visit(this);
901 for (int i = 0; i < that.getParams().length; i++) that.getParams()[i].visit(this);
902 for (int i = 0; i < that.getThrows().length; i++) that.getThrows()[i].visit(this);
903 that.getBody().visit(this);
904 return forConcreteMethodDefOnly(that);
905 }
906 public Void forAbstractMethodDef(AbstractMethodDef that) {
907 forAbstractMethodDefDoFirst(that);
908 if (prune(that)) return null;
909 that.getMav().visit(this);
910 for (int i = 0; i < that.getTypeParams().length; i++) that.getTypeParams()[i].visit(this);
911 that.getResult().visit(this);
912 for (int i = 0; i < that.getParams().length; i++) that.getParams()[i].visit(this);
913 for (int i = 0; i < that.getThrows().length; i++) that.getThrows()[i].visit(this);
914 return forAbstractMethodDefOnly(that);
915 }
916 public Void forFormalParameter(FormalParameter that) {
917 forFormalParameterDoFirst(that);
918 if (prune(that)) return null;
919 that.getDeclarator().visit(this);
920 return forFormalParameterOnly(that);
921 }
922 public Void forVariableDeclaration(VariableDeclaration that) {
923 forVariableDeclarationDoFirst(that);
924 if (prune(that)) return null;
925 that.getMav().visit(this);
926 for (int i = 0; i < that.getDeclarators().length; i++) that.getDeclarators()[i].visit(this);
927 return forVariableDeclarationOnly(that);
928 }
929 public Void forUninitializedVariableDeclarator(UninitializedVariableDeclarator that) {
930 forUninitializedVariableDeclaratorDoFirst(that);
931 if (prune(that)) return null;
932 that.getType().visit(this);
933 return forUninitializedVariableDeclaratorOnly(that);
934 }
935 public Void forInitializedVariableDeclarator(InitializedVariableDeclarator that) {
936 forInitializedVariableDeclaratorDoFirst(that);
937 if (prune(that)) return null;
938 that.getType().visit(this);
939 that.getInitializer().visit(this);
940 return forInitializedVariableDeclaratorOnly(that);
941 }
942 public Void forTypeParameter(TypeParameter that) {
943 forTypeParameterDoFirst(that);
944 if (prune(that)) return null;
945 that.getVariable().visit(this);
946 that.getBound().visit(this);
947 return forTypeParameterOnly(that);
948 }
949 public Void forArrayInitializer(ArrayInitializer that) {
950 forArrayInitializerDoFirst(that);
951 if (prune(that)) return null;
952 for (int i = 0; i < that.getItems().length; i++) that.getItems()[i].visit(this);
953 return forArrayInitializerOnly(that);
954 }
955 public Void forPrimitiveType(PrimitiveType that) {
956 forPrimitiveTypeDoFirst(that);
957 if (prune(that)) return null;
958 return forPrimitiveTypeOnly(that);
959 }
960 public Void forArrayType(ArrayType that) {
961 forArrayTypeDoFirst(that);
962 if (prune(that)) return null;
963 that.getElementType().visit(this);
964 return forArrayTypeOnly(that);
965 }
966 public Void forMemberType(MemberType that) {
967 forMemberTypeDoFirst(that);
968 if (prune(that)) return null;
969 that.getLeft().visit(this);
970 that.getRight().visit(this);
971 return forMemberTypeOnly(that);
972 }
973 public Void forClassOrInterfaceType(ClassOrInterfaceType that) {
974 forClassOrInterfaceTypeDoFirst(that);
975 if (prune(that)) return null;
976 for (int i = 0; i < that.getTypeArguments().length; i++) that.getTypeArguments()[i].visit(this);
977 return forClassOrInterfaceTypeOnly(that);
978 }
979 public Void forTypeVariable(TypeVariable that) {
980 forTypeVariableDoFirst(that);
981 if (prune(that)) return null;
982 return forTypeVariableOnly(that);
983 }
984 public Void forVoidReturn(VoidReturn that) {
985 forVoidReturnDoFirst(that);
986 if (prune(that)) return null;
987 return forVoidReturnOnly(that);
988 }
989 public Void forLabeledCase(LabeledCase that) {
990 forLabeledCaseDoFirst(that);
991 if (prune(that)) return null;
992 that.getLabel().visit(this);
993 that.getCode().visit(this);
994 return forLabeledCaseOnly(that);
995 }
996 public Void forDefaultCase(DefaultCase that) {
997 forDefaultCaseDoFirst(that);
998 if (prune(that)) return null;
999 that.getCode().visit(this);
1000 return forDefaultCaseOnly(that);
1001 }
1002 public Void forCatchBlock(CatchBlock that) {
1003 forCatchBlockDoFirst(that);
1004 if (prune(that)) return null;
1005 that.getException().visit(this);
1006 that.getBlock().visit(this);
1007 return forCatchBlockOnly(that);
1008 }
1009 public Void forSimpleAssignmentExpression(SimpleAssignmentExpression that) {
1010 forSimpleAssignmentExpressionDoFirst(that);
1011 if (prune(that)) return null;
1012 that.getName().visit(this);
1013 that.getValue().visit(this);
1014 return forSimpleAssignmentExpressionOnly(that);
1015 }
1016 public Void forPlusAssignmentExpression(PlusAssignmentExpression that) {
1017 forPlusAssignmentExpressionDoFirst(that);
1018 if (prune(that)) return null;
1019 that.getName().visit(this);
1020 that.getValue().visit(this);
1021 return forPlusAssignmentExpressionOnly(that);
1022 }
1023 public Void forMinusAssignmentExpression(MinusAssignmentExpression that) {
1024 forMinusAssignmentExpressionDoFirst(that);
1025 if (prune(that)) return null;
1026 that.getName().visit(this);
1027 that.getValue().visit(this);
1028 return forMinusAssignmentExpressionOnly(that);
1029 }
1030 public Void forMultiplyAssignmentExpression(MultiplyAssignmentExpression that) {
1031 forMultiplyAssignmentExpressionDoFirst(that);
1032 if (prune(that)) return null;
1033 that.getName().visit(this);
1034 that.getValue().visit(this);
1035 return forMultiplyAssignmentExpressionOnly(that);
1036 }
1037 public Void forDivideAssignmentExpression(DivideAssignmentExpression that) {
1038 forDivideAssignmentExpressionDoFirst(that);
1039 if (prune(that)) return null;
1040 that.getName().visit(this);
1041 that.getValue().visit(this);
1042 return forDivideAssignmentExpressionOnly(that);
1043 }
1044 public Void forModAssignmentExpression(ModAssignmentExpression that) {
1045 forModAssignmentExpressionDoFirst(that);
1046 if (prune(that)) return null;
1047 that.getName().visit(this);
1048 that.getValue().visit(this);
1049 return forModAssignmentExpressionOnly(that);
1050 }
1051 public Void forLeftShiftAssignmentExpression(LeftShiftAssignmentExpression that) {
1052 forLeftShiftAssignmentExpressionDoFirst(that);
1053 if (prune(that)) return null;
1054 that.getName().visit(this);
1055 that.getValue().visit(this);
1056 return forLeftShiftAssignmentExpressionOnly(that);
1057 }
1058 public Void forRightSignedShiftAssignmentExpression(RightSignedShiftAssignmentExpression that) {
1059 forRightSignedShiftAssignmentExpressionDoFirst(that);
1060 if (prune(that)) return null;
1061 that.getName().visit(this);
1062 that.getValue().visit(this);
1063 return forRightSignedShiftAssignmentExpressionOnly(that);
1064 }
1065 public Void forRightUnsignedShiftAssignmentExpression(RightUnsignedShiftAssignmentExpression that) {
1066 forRightUnsignedShiftAssignmentExpressionDoFirst(that);
1067 if (prune(that)) return null;
1068 that.getName().visit(this);
1069 that.getValue().visit(this);
1070 return forRightUnsignedShiftAssignmentExpressionOnly(that);
1071 }
1072 public Void forBitwiseAndAssignmentExpression(BitwiseAndAssignmentExpression that) {
1073 forBitwiseAndAssignmentExpressionDoFirst(that);
1074 if (prune(that)) return null;
1075 that.getName().visit(this);
1076 that.getValue().visit(this);
1077 return forBitwiseAndAssignmentExpressionOnly(that);
1078 }
1079 public Void forBitwiseOrAssignmentExpression(BitwiseOrAssignmentExpression that) {
1080 forBitwiseOrAssignmentExpressionDoFirst(that);
1081 if (prune(that)) return null;
1082 that.getName().visit(this);
1083 that.getValue().visit(this);
1084 return forBitwiseOrAssignmentExpressionOnly(that);
1085 }
1086 public Void forBitwiseXorAssignmentExpression(BitwiseXorAssignmentExpression that) {
1087 forBitwiseXorAssignmentExpressionDoFirst(that);
1088 if (prune(that)) return null;
1089 that.getName().visit(this);
1090 that.getValue().visit(this);
1091 return forBitwiseXorAssignmentExpressionOnly(that);
1092 }
1093 public Void forOrExpression(OrExpression that) {
1094 forOrExpressionDoFirst(that);
1095 if (prune(that)) return null;
1096 that.getLeft().visit(this);
1097 that.getRight().visit(this);
1098 return forOrExpressionOnly(that);
1099 }
1100 public Void forAndExpression(AndExpression that) {
1101 forAndExpressionDoFirst(that);
1102 if (prune(that)) return null;
1103 that.getLeft().visit(this);
1104 that.getRight().visit(this);
1105 return forAndExpressionOnly(that);
1106 }
1107 public Void forBitwiseOrExpression(BitwiseOrExpression that) {
1108 forBitwiseOrExpressionDoFirst(that);
1109 if (prune(that)) return null;
1110 that.getLeft().visit(this);
1111 that.getRight().visit(this);
1112 return forBitwiseOrExpressionOnly(that);
1113 }
1114 public Void forBitwiseXorExpression(BitwiseXorExpression that) {
1115 forBitwiseXorExpressionDoFirst(that);
1116 if (prune(that)) return null;
1117 that.getLeft().visit(this);
1118 that.getRight().visit(this);
1119 return forBitwiseXorExpressionOnly(that);
1120 }
1121 public Void forBitwiseAndExpression(BitwiseAndExpression that) {
1122 forBitwiseAndExpressionDoFirst(that);
1123 if (prune(that)) return null;
1124 that.getLeft().visit(this);
1125 that.getRight().visit(this);
1126 return forBitwiseAndExpressionOnly(that);
1127 }
1128 public Void forEqualsExpression(EqualsExpression that) {
1129 forEqualsExpressionDoFirst(that);
1130 if (prune(that)) return null;
1131 that.getLeft().visit(this);
1132 that.getRight().visit(this);
1133 return forEqualsExpressionOnly(that);
1134 }
1135 public Void forNotEqualExpression(NotEqualExpression that) {
1136 forNotEqualExpressionDoFirst(that);
1137 if (prune(that)) return null;
1138 that.getLeft().visit(this);
1139 that.getRight().visit(this);
1140 return forNotEqualExpressionOnly(that);
1141 }
1142 public Void forLessThanExpression(LessThanExpression that) {
1143 forLessThanExpressionDoFirst(that);
1144 if (prune(that)) return null;
1145 that.getLeft().visit(this);
1146 that.getRight().visit(this);
1147 return forLessThanExpressionOnly(that);
1148 }
1149 public Void forLessThanOrEqualExpression(LessThanOrEqualExpression that) {
1150 forLessThanOrEqualExpressionDoFirst(that);
1151 if (prune(that)) return null;
1152 that.getLeft().visit(this);
1153 that.getRight().visit(this);
1154 return forLessThanOrEqualExpressionOnly(that);
1155 }
1156 public Void forGreaterThanExpression(GreaterThanExpression that) {
1157 forGreaterThanExpressionDoFirst(that);
1158 if (prune(that)) return null;
1159 that.getLeft().visit(this);
1160 that.getRight().visit(this);
1161 return forGreaterThanExpressionOnly(that);
1162 }
1163 public Void forGreaterThanOrEqualExpression(GreaterThanOrEqualExpression that) {
1164 forGreaterThanOrEqualExpressionDoFirst(that);
1165 if (prune(that)) return null;
1166 that.getLeft().visit(this);
1167 that.getRight().visit(this);
1168 return forGreaterThanOrEqualExpressionOnly(that);
1169 }
1170 public Void forLeftShiftExpression(LeftShiftExpression that) {
1171 forLeftShiftExpressionDoFirst(that);
1172 if (prune(that)) return null;
1173 that.getLeft().visit(this);
1174 that.getRight().visit(this);
1175 return forLeftShiftExpressionOnly(that);
1176 }
1177 public Void forRightSignedShiftExpression(RightSignedShiftExpression that) {
1178 forRightSignedShiftExpressionDoFirst(that);
1179 if (prune(that)) return null;
1180 that.getLeft().visit(this);
1181 that.getRight().visit(this);
1182 return forRightSignedShiftExpressionOnly(that);
1183 }
1184 public Void forRightUnsignedShiftExpression(RightUnsignedShiftExpression that) {
1185 forRightUnsignedShiftExpressionDoFirst(that);
1186 if (prune(that)) return null;
1187 that.getLeft().visit(this);
1188 that.getRight().visit(this);
1189 return forRightUnsignedShiftExpressionOnly(that);
1190 }
1191 public Void forPlusExpression(PlusExpression that) {
1192 forPlusExpressionDoFirst(that);
1193 if (prune(that)) return null;
1194 that.getLeft().visit(this);
1195 that.getRight().visit(this);
1196 return forPlusExpressionOnly(that);
1197 }
1198 public Void forMinusExpression(MinusExpression that) {
1199 forMinusExpressionDoFirst(that);
1200 if (prune(that)) return null;
1201 that.getLeft().visit(this);
1202 that.getRight().visit(this);
1203 return forMinusExpressionOnly(that);
1204 }
1205 public Void forMultiplyExpression(MultiplyExpression that) {
1206 forMultiplyExpressionDoFirst(that);
1207 if (prune(that)) return null;
1208 that.getLeft().visit(this);
1209 that.getRight().visit(this);
1210 return forMultiplyExpressionOnly(that);
1211 }
1212 public Void forDivideExpression(DivideExpression that) {
1213 forDivideExpressionDoFirst(that);
1214 if (prune(that)) return null;
1215 that.getLeft().visit(this);
1216 that.getRight().visit(this);
1217 return forDivideExpressionOnly(that);
1218 }
1219 public Void forModExpression(ModExpression that) {
1220 forModExpressionDoFirst(that);
1221 if (prune(that)) return null;
1222 that.getLeft().visit(this);
1223 that.getRight().visit(this);
1224 return forModExpressionOnly(that);
1225 }
1226 public Void forNoOpExpression(NoOpExpression that) {
1227 forNoOpExpressionDoFirst(that);
1228 if (prune(that)) return null;
1229 that.getLeft().visit(this);
1230 that.getRight().visit(this);
1231 return forNoOpExpressionOnly(that);
1232 }
1233 public Void forPositivePrefixIncrementExpression(PositivePrefixIncrementExpression that) {
1234 forPositivePrefixIncrementExpressionDoFirst(that);
1235 if (prune(that)) return null;
1236 that.getValue().visit(this);
1237 return forPositivePrefixIncrementExpressionOnly(that);
1238 }
1239 public Void forNegativePrefixIncrementExpression(NegativePrefixIncrementExpression that) {
1240 forNegativePrefixIncrementExpressionDoFirst(that);
1241 if (prune(that)) return null;
1242 that.getValue().visit(this);
1243 return forNegativePrefixIncrementExpressionOnly(that);
1244 }
1245 public Void forPositivePostfixIncrementExpression(PositivePostfixIncrementExpression that) {
1246 forPositivePostfixIncrementExpressionDoFirst(that);
1247 if (prune(that)) return null;
1248 that.getValue().visit(this);
1249 return forPositivePostfixIncrementExpressionOnly(that);
1250 }
1251 public Void forNegativePostfixIncrementExpression(NegativePostfixIncrementExpression that) {
1252 forNegativePostfixIncrementExpressionDoFirst(that);
1253 if (prune(that)) return null;
1254 that.getValue().visit(this);
1255 return forNegativePostfixIncrementExpressionOnly(that);
1256 }
1257 public Void forPositiveExpression(PositiveExpression that) {
1258 forPositiveExpressionDoFirst(that);
1259 if (prune(that)) return null;
1260 that.getValue().visit(this);
1261 return forPositiveExpressionOnly(that);
1262 }
1263 public Void forNegativeExpression(NegativeExpression that) {
1264 forNegativeExpressionDoFirst(that);
1265 if (prune(that)) return null;
1266 that.getValue().visit(this);
1267 return forNegativeExpressionOnly(that);
1268 }
1269 public Void forBitwiseNotExpression(BitwiseNotExpression that) {
1270 forBitwiseNotExpressionDoFirst(that);
1271 if (prune(that)) return null;
1272 that.getValue().visit(this);
1273 return forBitwiseNotExpressionOnly(that);
1274 }
1275 public Void forNotExpression(NotExpression that) {
1276 forNotExpressionDoFirst(that);
1277 if (prune(that)) return null;
1278 that.getValue().visit(this);
1279 return forNotExpressionOnly(that);
1280 }
1281 public Void forConditionalExpression(ConditionalExpression that) {
1282 forConditionalExpressionDoFirst(that);
1283 if (prune(that)) return null;
1284 that.getCondition().visit(this);
1285 that.getForTrue().visit(this);
1286 that.getForFalse().visit(this);
1287 return forConditionalExpressionOnly(that);
1288 }
1289 public Void forInstanceofExpression(InstanceofExpression that) {
1290 forInstanceofExpressionDoFirst(that);
1291 if (prune(that)) return null;
1292 that.getValue().visit(this);
1293 that.getType().visit(this);
1294 return forInstanceofExpressionOnly(that);
1295 }
1296 public Void forCastExpression(CastExpression that) {
1297 forCastExpressionDoFirst(that);
1298 if (prune(that)) return null;
1299 that.getType().visit(this);
1300 that.getValue().visit(this);
1301 return forCastExpressionOnly(that);
1302 }
1303 public Void forIntegerLiteral(IntegerLiteral that) {
1304 forIntegerLiteralDoFirst(that);
1305 if (prune(that)) return null;
1306 return forIntegerLiteralOnly(that);
1307 }
1308 public Void forLongLiteral(LongLiteral that) {
1309 forLongLiteralDoFirst(that);
1310 if (prune(that)) return null;
1311 return forLongLiteralOnly(that);
1312 }
1313 public Void forDoubleLiteral(DoubleLiteral that) {
1314 forDoubleLiteralDoFirst(that);
1315 if (prune(that)) return null;
1316 return forDoubleLiteralOnly(that);
1317 }
1318 public Void forFloatLiteral(FloatLiteral that) {
1319 forFloatLiteralDoFirst(that);
1320 if (prune(that)) return null;
1321 return forFloatLiteralOnly(that);
1322 }
1323 public Void forBooleanLiteral(BooleanLiteral that) {
1324 forBooleanLiteralDoFirst(that);
1325 if (prune(that)) return null;
1326 return forBooleanLiteralOnly(that);
1327 }
1328 public Void forCharLiteral(CharLiteral that) {
1329 forCharLiteralDoFirst(that);
1330 if (prune(that)) return null;
1331 return forCharLiteralOnly(that);
1332 }
1333 public Void forStringLiteral(StringLiteral that) {
1334 forStringLiteralDoFirst(that);
1335 if (prune(that)) return null;
1336 return forStringLiteralOnly(that);
1337 }
1338 public Void forNullLiteral(NullLiteral that) {
1339 forNullLiteralDoFirst(that);
1340 if (prune(that)) return null;
1341 return forNullLiteralOnly(that);
1342 }
1343 public Void forSimpleNamedClassInstantiation(SimpleNamedClassInstantiation that) {
1344 forSimpleNamedClassInstantiationDoFirst(that);
1345 if (prune(that)) return null;
1346 that.getType().visit(this);
1347 that.getArguments().visit(this);
1348 return forSimpleNamedClassInstantiationOnly(that);
1349 }
1350 public Void forComplexNamedClassInstantiation(ComplexNamedClassInstantiation that) {
1351 forComplexNamedClassInstantiationDoFirst(that);
1352 if (prune(that)) return null;
1353 that.getEnclosing().visit(this);
1354 that.getType().visit(this);
1355 that.getArguments().visit(this);
1356 return forComplexNamedClassInstantiationOnly(that);
1357 }
1358 public Void forSimpleAnonymousClassInstantiation(SimpleAnonymousClassInstantiation that) {
1359 forSimpleAnonymousClassInstantiationDoFirst(that);
1360 if (prune(that)) return null;
1361 that.getType().visit(this);
1362 that.getArguments().visit(this);
1363 that.getBody().visit(this);
1364 return forSimpleAnonymousClassInstantiationOnly(that);
1365 }
1366 public Void forComplexAnonymousClassInstantiation(ComplexAnonymousClassInstantiation that) {
1367 forComplexAnonymousClassInstantiationDoFirst(that);
1368 if (prune(that)) return null;
1369 that.getEnclosing().visit(this);
1370 that.getType().visit(this);
1371 that.getArguments().visit(this);
1372 that.getBody().visit(this);
1373 return forComplexAnonymousClassInstantiationOnly(that);
1374 }
1375 public Void forSimpleUninitializedArrayInstantiation(SimpleUninitializedArrayInstantiation that) {
1376 forSimpleUninitializedArrayInstantiationDoFirst(that);
1377 if (prune(that)) return null;
1378 that.getType().visit(this);
1379 that.getDimensionSizes().visit(this);
1380 return forSimpleUninitializedArrayInstantiationOnly(that);
1381 }
1382 public Void forComplexUninitializedArrayInstantiation(ComplexUninitializedArrayInstantiation that) {
1383 forComplexUninitializedArrayInstantiationDoFirst(that);
1384 if (prune(that)) return null;
1385 that.getEnclosing().visit(this);
1386 that.getType().visit(this);
1387 that.getDimensionSizes().visit(this);
1388 return forComplexUninitializedArrayInstantiationOnly(that);
1389 }
1390 public Void forSimpleInitializedArrayInstantiation(SimpleInitializedArrayInstantiation that) {
1391 forSimpleInitializedArrayInstantiationDoFirst(that);
1392 if (prune(that)) return null;
1393 that.getType().visit(this);
1394 that.getInitializer().visit(this);
1395 return forSimpleInitializedArrayInstantiationOnly(that);
1396 }
1397 public Void forComplexInitializedArrayInstantiation(ComplexInitializedArrayInstantiation that) {
1398 forComplexInitializedArrayInstantiationDoFirst(that);
1399 if (prune(that)) return null;
1400 that.getEnclosing().visit(this);
1401 that.getType().visit(this);
1402 that.getInitializer().visit(this);
1403 return forComplexInitializedArrayInstantiationOnly(that);
1404 }
1405 public Void forSimpleNameReference(SimpleNameReference that) {
1406 forSimpleNameReferenceDoFirst(that);
1407 if (prune(that)) return null;
1408 that.getName().visit(this);
1409 return forSimpleNameReferenceOnly(that);
1410 }
1411 public Void forComplexNameReference(ComplexNameReference that) {
1412 forComplexNameReferenceDoFirst(that);
1413 if (prune(that)) return null;
1414 that.getEnclosing().visit(this);
1415 that.getName().visit(this);
1416 return forComplexNameReferenceOnly(that);
1417 }
1418 public Void forSimpleThisReference(SimpleThisReference that) {
1419 forSimpleThisReferenceDoFirst(that);
1420 if (prune(that)) return null;
1421 return forSimpleThisReferenceOnly(that);
1422 }
1423 public Void forComplexThisReference(ComplexThisReference that) {
1424 forComplexThisReferenceDoFirst(that);
1425 if (prune(that)) return null;
1426 that.getEnclosing().visit(this);
1427 return forComplexThisReferenceOnly(that);
1428 }
1429 public Void forSimpleSuperReference(SimpleSuperReference that) {
1430 forSimpleSuperReferenceDoFirst(that);
1431 if (prune(that)) return null;
1432 return forSimpleSuperReferenceOnly(that);
1433 }
1434 public Void forComplexSuperReference(ComplexSuperReference that) {
1435 forComplexSuperReferenceDoFirst(that);
1436 if (prune(that)) return null;
1437 that.getEnclosing().visit(this);
1438 return forComplexSuperReferenceOnly(that);
1439 }
1440 public Void forSimpleMethodInvocation(SimpleMethodInvocation that) {
1441 forSimpleMethodInvocationDoFirst(that);
1442 if (prune(that)) return null;
1443 that.getName().visit(this);
1444 that.getArguments().visit(this);
1445 return forSimpleMethodInvocationOnly(that);
1446 }
1447 public Void forComplexMethodInvocation(ComplexMethodInvocation that) {
1448 forComplexMethodInvocationDoFirst(that);
1449 if (prune(that)) return null;
1450 that.getEnclosing().visit(this);
1451 that.getName().visit(this);
1452 that.getArguments().visit(this);
1453 return forComplexMethodInvocationOnly(that);
1454 }
1455 public Void forSimpleThisConstructorInvocation(SimpleThisConstructorInvocation that) {
1456 forSimpleThisConstructorInvocationDoFirst(that);
1457 if (prune(that)) return null;
1458 that.getArguments().visit(this);
1459 return forSimpleThisConstructorInvocationOnly(that);
1460 }
1461 public Void forComplexThisConstructorInvocation(ComplexThisConstructorInvocation that) {
1462 forComplexThisConstructorInvocationDoFirst(that);
1463 if (prune(that)) return null;
1464 that.getEnclosing().visit(this);
1465 that.getArguments().visit(this);
1466 return forComplexThisConstructorInvocationOnly(that);
1467 }
1468 public Void forSimpleSuperConstructorInvocation(SimpleSuperConstructorInvocation that) {
1469 forSimpleSuperConstructorInvocationDoFirst(that);
1470 if (prune(that)) return null;
1471 that.getArguments().visit(this);
1472 return forSimpleSuperConstructorInvocationOnly(that);
1473 }
1474 public Void forComplexSuperConstructorInvocation(ComplexSuperConstructorInvocation that) {
1475 forComplexSuperConstructorInvocationDoFirst(that);
1476 if (prune(that)) return null;
1477 that.getEnclosing().visit(this);
1478 that.getArguments().visit(this);
1479 return forComplexSuperConstructorInvocationOnly(that);
1480 }
1481 public Void forClassLiteral(ClassLiteral that) {
1482 forClassLiteralDoFirst(that);
1483 if (prune(that)) return null;
1484 that.getType().visit(this);
1485 return forClassLiteralOnly(that);
1486 }
1487 public Void forArrayAccess(ArrayAccess that) {
1488 forArrayAccessDoFirst(that);
1489 if (prune(that)) return null;
1490 that.getArray().visit(this);
1491 that.getIndex().visit(this);
1492 return forArrayAccessOnly(that);
1493 }
1494 public Void forParenthesized(Parenthesized that) {
1495 forParenthesizedDoFirst(that);
1496 if (prune(that)) return null;
1497 that.getValue().visit(this);
1498 return forParenthesizedOnly(that);
1499 }
1500 public Void forEmptyExpression(EmptyExpression that) {
1501 forEmptyExpressionDoFirst(that);
1502 if (prune(that)) return null;
1503 return forEmptyExpressionOnly(that);
1504 }
1505 // public void forEmptyDimensionExpression(EmptyDimensionExpression that) {
1506 // forEmptyDimensionExpressionDoFirst(that);
1507 // if (prune(that)) return;
1508 // forEmptyDimensionExpressionOnly(that);
1509 // }
1510
1511 public Void forBracedBody(BracedBody that) {
1512 forBracedBodyDoFirst(that);
1513 if (prune(that)) return null;
1514 for (int i = 0; i < that.getStatements().length; i++) that.getStatements()[i].visit(this);
1515 return forBracedBodyOnly(that);
1516 }
1517 public Void forUnbracedBody(UnbracedBody that) {
1518 forUnbracedBodyDoFirst(that);
1519 if (prune(that)) return null;
1520 for (int i = 0; i < that.getStatements().length; i++) that.getStatements()[i].visit(this);
1521 return forUnbracedBodyOnly(that);
1522 }
1523 public Void forParenthesizedExpressionList(ParenthesizedExpressionList that) {
1524 forParenthesizedExpressionListDoFirst(that);
1525 if (prune(that)) return null;
1526 for (int i = 0; i < that.getExpressions().length; i++) that.getExpressions()[i].visit(this);
1527 return forParenthesizedExpressionListOnly(that);
1528 }
1529 public Void forUnparenthesizedExpressionList(UnparenthesizedExpressionList that) {
1530 forUnparenthesizedExpressionListDoFirst(that);
1531 if (prune(that)) return null;
1532 for (int i = 0; i < that.getExpressions().length; i++) that.getExpressions()[i].visit(this);
1533 return forUnparenthesizedExpressionListOnly(that);
1534 }
1535 public Void forDimensionExpressionList(DimensionExpressionList that) {
1536 forDimensionExpressionListDoFirst(that);
1537 if (prune(that)) return null;
1538 for (int i = 0; i < that.getExpressions().length; i++) that.getExpressions()[i].visit(this);
1539 return forDimensionExpressionListOnly(that); }
1540 public Void forEmptyForCondition(EmptyForCondition that) {
1541 forEmptyForConditionDoFirst(that);
1542 if (prune(that)) return null;
1543 return forEmptyForConditionOnly(that);
1544 }
1545 /** This method is called by default from cases that do not override forCASEDoFirst. */
1546 protected Void defaultDoFirst(JExpressionIF that) { return null; }
1547 /** This method is called by default from cases that do not override forCASEOnly. */
1548 protected Void defaultCase(JExpressionIF that) { return null; }
1549 protected boolean prune(JExpressionIF that) { return true; }
1550 }