Prepared better HEREDOC support; see comment for bug #1319276
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / TryStatement.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpdt.internal.compiler.ast;
12
13 import net.sourceforge.phpdt.internal.compiler.ASTVisitor;
14 import net.sourceforge.phpdt.internal.compiler.codegen.Label;
15 import net.sourceforge.phpdt.internal.compiler.flow.ExceptionHandlingFlowContext;
16 import net.sourceforge.phpdt.internal.compiler.flow.FinallyFlowContext;
17 import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
18 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
19 import net.sourceforge.phpdt.internal.compiler.flow.InsideSubRoutineFlowContext;
20 import net.sourceforge.phpdt.internal.compiler.flow.UnconditionalFlowInfo;
21 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
22 import net.sourceforge.phpdt.internal.compiler.lookup.LocalVariableBinding;
23 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
24 import net.sourceforge.phpdt.internal.compiler.lookup.MethodScope;
25 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
26 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
27
28 public class TryStatement extends Statement {
29         
30         public Block tryBlock;
31         public Block[] catchBlocks;
32         public Argument[] catchArguments;
33         public Block finallyBlock;
34         BlockScope scope;
35
36         public boolean subRoutineCannotReturn = true;
37         public UnconditionalFlowInfo subRoutineInits;
38         
39         // should rename into subRoutineComplete to be set to false by default
40
41         ReferenceBinding[] caughtExceptionTypes;
42         boolean tryBlockExit;
43         boolean[] catchExits;
44         public int[] preserveExceptionHandler;
45
46         Label subRoutineStartLabel;
47         public LocalVariableBinding anyExceptionVariable,
48                 returnAddressVariable,
49                 secretReturnValue;
50
51         public final static char[] SecretReturnName = " returnAddress".toCharArray(); //$NON-NLS-1$
52         public final static char[] SecretAnyHandlerName = " anyExceptionHandler".toCharArray(); //$NON-NLS-1$
53         public static final char[] SecretLocalDeclarationName = " returnValue".toCharArray(); //$NON-NLS-1$
54
55         // for local variables table attributes
56         int preTryInitStateIndex = -1;
57         int mergedInitStateIndex = -1;
58
59         public FlowInfo analyseCode(
60                 BlockScope currentScope,
61                 FlowContext flowContext,
62                 FlowInfo flowInfo) {
63
64                 // Consider the try block and catch block so as to compute the intersection of initializations and      
65                 // the minimum exit relative depth amongst all of them. Then consider the subroutine, and append its
66                 // initialization to the try/catch ones, if the subroutine completes normally. If the subroutine does not
67                 // complete, then only keep this result for the rest of the analysis
68
69                 // process the finally block (subroutine) - create a context for the subroutine
70
71                 preTryInitStateIndex =
72                         currentScope.methodScope().recordInitializationStates(flowInfo);
73
74                 if (anyExceptionVariable != null) {
75                         anyExceptionVariable.useFlag = LocalVariableBinding.USED;
76                 }
77                 if (returnAddressVariable != null) {
78                         returnAddressVariable.useFlag = LocalVariableBinding.USED;
79                 }
80                 InsideSubRoutineFlowContext insideSubContext;
81                 FinallyFlowContext finallyContext;
82                 UnconditionalFlowInfo subInfo;
83                 if (subRoutineStartLabel == null) {
84                         // no finally block
85                         insideSubContext = null;
86                         finallyContext = null;
87                         subInfo = null;
88                 } else {
89                         // analyse finally block first
90                         insideSubContext = new InsideSubRoutineFlowContext(flowContext, this);
91                         subInfo = 
92                                 finallyBlock
93                                         .analyseCode(
94                                                 currentScope,
95                                                 finallyContext = new FinallyFlowContext(flowContext, finallyBlock),
96                                                 flowInfo.copy())
97                                         .unconditionalInits();
98                         if (subInfo.isReachable()) {
99                                 subRoutineCannotReturn = false;
100                         }
101                         this.subRoutineInits = subInfo;
102                 }
103                 // process the try block in a context handling the local exceptions.
104                 ExceptionHandlingFlowContext handlingContext =
105                         new ExceptionHandlingFlowContext(
106                                 insideSubContext == null ? flowContext : insideSubContext,
107                                 tryBlock,
108                                 caughtExceptionTypes,
109                                 scope,
110                                 flowInfo.unconditionalInits());
111
112                 FlowInfo tryInfo;
113                 if (tryBlock.statements == null) {
114                         tryInfo = flowInfo;
115                         tryBlockExit = false;
116                 } else {
117                         tryInfo = tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy());
118                         tryBlockExit = !tryInfo.isReachable();
119                 }
120
121                 // check unreachable catch blocks
122 //              handlingContext.complainIfUnusedExceptionHandlers(catchBlocks, scope, this);
123
124                 // process the catch blocks - computing the minimal exit depth amongst try/catch
125                 if (catchArguments != null) {
126                         int catchCount;
127                         catchExits = new boolean[catchCount = catchBlocks.length];
128                         for (int i = 0; i < catchCount; i++) {
129                                 // keep track of the inits that could potentially have led to this exception handler (for final assignments diagnosis)
130                                 FlowInfo catchInfo =
131                                         flowInfo
132                                                 .copy()
133                                                 .unconditionalInits()
134                                                 .addPotentialInitializationsFrom(
135                                                         handlingContext.initsOnException(caughtExceptionTypes[i]).unconditionalInits())
136                                                 .addPotentialInitializationsFrom(tryInfo.unconditionalInits())
137                                                 .addPotentialInitializationsFrom(handlingContext.initsOnReturn);
138
139                                 // catch var is always set
140                                 catchInfo.markAsDefinitelyAssigned(catchArguments[i].binding);
141                                 /*
142                                 "If we are about to consider an unchecked exception handler, potential inits may have occured inside
143                                 the try block that need to be detected , e.g. 
144                                 try { x = 1; throwSomething();} catch(Exception e){ x = 2} "
145                                 "(uncheckedExceptionTypes notNil and: [uncheckedExceptionTypes at: index])
146                                 ifTrue: [catchInits addPotentialInitializationsFrom: tryInits]."
147                                 */
148                                 // TODO: should only tag as unreachable if the catchblock cannot be reached
149                                 //??? if (!handlingContext.initsOnException(caughtExceptionTypes[i]).isReachable()){
150                                 if (tryBlock.statements == null) {
151                                         catchInfo.setReachMode(FlowInfo.UNREACHABLE);
152                                 }
153                                 catchInfo =
154                                         catchBlocks[i].analyseCode(
155                                                 currentScope,
156                                                 insideSubContext == null ? flowContext : insideSubContext,
157                                                 catchInfo);
158                                 catchExits[i] = !catchInfo.isReachable();
159                                 tryInfo = tryInfo.mergedWith(catchInfo.unconditionalInits());
160                         }
161                 }
162                 if (subRoutineStartLabel == null) {
163                         mergedInitStateIndex =
164                                 currentScope.methodScope().recordInitializationStates(tryInfo);
165                         return tryInfo;
166                 }
167
168
169                 // we also need to check potential multiple assignments of final variables inside the finally block
170                 // need to include potential inits from returns inside the try/catch parts - 1GK2AOF
171                 finallyContext.complainOnRedundantFinalAssignments(
172                         tryInfo.isReachable() 
173                                 ? (tryInfo.addPotentialInitializationsFrom(insideSubContext.initsOnReturn))
174                                 : insideSubContext.initsOnReturn, 
175                         currentScope);
176                 if (subInfo == FlowInfo.DEAD_END) {
177                         mergedInitStateIndex =
178                                 currentScope.methodScope().recordInitializationStates(subInfo);
179                         return subInfo;
180                 } else {
181                         FlowInfo mergedInfo = tryInfo.addInitializationsFrom(subInfo);
182                         mergedInitStateIndex =
183                                 currentScope.methodScope().recordInitializationStates(mergedInfo);
184                         return mergedInfo;
185                 }
186         }
187
188         public boolean cannotReturn() {
189
190                 return subRoutineCannotReturn;
191         }
192
193         /**
194          * Try statement code generation
195          *
196          */
197 //      public void generateCode(BlockScope currentScope, CodeStream codeStream) {
198 //
199 //              if ((bits & IsReachableMASK) == 0) {
200 //                      return;
201 //              }
202 //              if (tryBlock.isEmptyBlock()) {
203 //                      if (subRoutineStartLabel != null) {
204 //                              // since not passing the finallyScope, the block generation will exitUserScope(finallyScope)
205 //                              finallyBlock.generateCode(scope, codeStream);
206 //                      }
207 //                      // May loose some local variable initializations : affecting the local variable attributes
208 //                      if (mergedInitStateIndex != -1) {
209 //                              codeStream.removeNotDefinitelyAssignedVariables(
210 //                                      currentScope,
211 //                                      mergedInitStateIndex);
212 //                      }
213 //                      // no local bytecode produced so no need for position remembering
214 //                      return;
215 //              }
216 //              int pc = codeStream.position;
217 //              Label endLabel = new Label(codeStream);
218 //              boolean requiresNaturalJsr = false;
219 //
220 //              // preparing exception labels
221 //              int maxCatches;
222 //              ExceptionLabel[] exceptionLabels =
223 //                      new ExceptionLabel[maxCatches =
224 //                              catchArguments == null ? 0 : catchArguments.length];
225 //              for (int i = 0; i < maxCatches; i++) {
226 //                      boolean preserveCurrentHandler =
227 //                              (preserveExceptionHandler[i
228 //                                      / ExceptionHandlingFlowContext.BitCacheSize]
229 //                                              & (1 << (i % ExceptionHandlingFlowContext.BitCacheSize)))
230 //                                      != 0;
231 //                      if (preserveCurrentHandler) {
232 //                              exceptionLabels[i] =
233 //                                      new ExceptionLabel(
234 //                                              codeStream,
235 //                                              (ReferenceBinding) catchArguments[i].binding.type);
236 //                      }
237 //              }
238 //              ExceptionLabel anyExceptionLabel = null;
239 //              if (subRoutineStartLabel != null) {
240 //                      subRoutineStartLabel.codeStream = codeStream;
241 //                      anyExceptionLabel = new ExceptionLabel(codeStream, null);
242 //              }
243 //              // generate the try block
244 //              tryBlock.generateCode(scope, codeStream);
245 //              boolean tryBlockHasSomeCode = codeStream.position != pc;
246 //              // flag telling if some bytecodes were issued inside the try block
247 //
248 //              // natural exit: only if necessary
249 //              boolean nonReturningSubRoutine =
250 //                      (subRoutineStartLabel != null) && subRoutineCannotReturn;
251 //              if ((!tryBlockExit) && tryBlockHasSomeCode) {
252 //                      int position = codeStream.position;
253 //                      if (nonReturningSubRoutine) {
254 //                              codeStream.goto_(subRoutineStartLabel);
255 //                      } else {
256 //                              requiresNaturalJsr = true;
257 //                              codeStream.goto_(endLabel);
258 //                      }
259 //                      codeStream.updateLastRecordedEndPC(position);
260 //                      //goto is tagged as part of the try block
261 //              }
262 //              // place end positions of user-defined exception labels
263 //              if (tryBlockHasSomeCode) {
264 //                      for (int i = 0; i < maxCatches; i++) {
265 //                              boolean preserveCurrentHandler =
266 //                                      (preserveExceptionHandler[i     / ExceptionHandlingFlowContext.BitCacheSize]
267 //                                                      & (1 << (i % ExceptionHandlingFlowContext.BitCacheSize)))
268 //                                              != 0;
269 //                              if (preserveCurrentHandler) {
270 //                                      exceptionLabels[i].placeEnd();
271 //                              }
272 //                      }
273 //                      /* generate sequence of handler, all starting by storing the TOS (exception
274 //                      thrown) into their own catch variables, the one specified in the source
275 //                      that must denote the handled exception.
276 //                      */
277 //                      if (catchArguments == null) {
278 //                              if (anyExceptionLabel != null) {
279 //                                      anyExceptionLabel.placeEnd();
280 //                              }
281 //                      } else {
282 //                              for (int i = 0; i < maxCatches; i++) {
283 //                                      boolean preserveCurrentHandler =
284 //                                              (preserveExceptionHandler[i / ExceptionHandlingFlowContext.BitCacheSize]
285 //                                                              & (1 << (i % ExceptionHandlingFlowContext.BitCacheSize)))
286 //                                                      != 0;
287 //                                      if (preserveCurrentHandler) {
288 //                                              // May loose some local variable initializations : affecting the local variable attributes
289 //                                              if (preTryInitStateIndex != -1) {
290 //                                                      codeStream.removeNotDefinitelyAssignedVariables(
291 //                                                              currentScope,
292 //                                                              preTryInitStateIndex);
293 //                                              }
294 //                                              exceptionLabels[i].place();
295 //                                              codeStream.incrStackSize(1);
296 //                                              // optimizing the case where the exception variable is not actually used
297 //                                              LocalVariableBinding catchVar;
298 //                                              int varPC = codeStream.position;
299 //                                              if ((catchVar = catchArguments[i].binding).resolvedPosition != -1) {
300 //                                                      codeStream.store(catchVar, false);
301 //                                                      catchVar.recordInitializationStartPC(codeStream.position);
302 //                                                      codeStream.addVisibleLocalVariable(catchVar);
303 //                                              } else {
304 //                                                      codeStream.pop();
305 //                                              }
306 //                                              codeStream.recordPositionsFrom(varPC, catchArguments[i].sourceStart);
307 //                                              // Keep track of the pcs at diverging point for computing the local attribute
308 //                                              // since not passing the catchScope, the block generation will exitUserScope(catchScope)
309 //                                              catchBlocks[i].generateCode(scope, codeStream);
310 //                                      }
311 //                                      if (i == maxCatches - 1) {
312 //                                              if (anyExceptionLabel != null) {
313 //                                                      anyExceptionLabel.placeEnd();
314 //                                              }
315 //                                              if (subRoutineStartLabel != null) {
316 //                                                      if (!catchExits[i] && preserveCurrentHandler) {
317 //                                                              requiresNaturalJsr = true;
318 //                                                              codeStream.goto_(endLabel);
319 //                                                      }
320 //                                              }
321 //                                      } else {
322 //                                              if (!catchExits[i] && preserveCurrentHandler) {
323 //                                                      if (nonReturningSubRoutine) {
324 //                                                              codeStream.goto_(subRoutineStartLabel);
325 //                                                      } else {
326 //                                                              requiresNaturalJsr = true;
327 //                                                              codeStream.goto_(endLabel);
328 //                                                      }
329 //                                              }
330 //                                      }
331 //                              }
332 //                      }
333 //                      // addition of a special handler so as to ensure that any uncaught exception (or exception thrown
334 //                      // inside catch blocks) will run the finally block
335 //                      int finallySequenceStartPC = codeStream.position;
336 //                      if (subRoutineStartLabel != null) {
337 //                              // the additional handler is doing: jsr finallyBlock and rethrow TOS-exception
338 //                              anyExceptionLabel.place();
339 //
340 //                              if (preTryInitStateIndex != -1) {
341 //                                      // reset initialization state, as for a normal catch block
342 //                                      codeStream.removeNotDefinitelyAssignedVariables(
343 //                                              currentScope,
344 //                                              preTryInitStateIndex);
345 //                              }
346 //
347 //                              codeStream.incrStackSize(1);
348 //                              if (nonReturningSubRoutine) {
349 //                                      codeStream.pop();
350 //                                      // "if subroutine cannot return, no need to jsr/jump to subroutine since it will be entered in sequence
351 //                              } else {
352 //                                      codeStream.store(anyExceptionVariable, false);
353 //                                      codeStream.jsr(subRoutineStartLabel);
354 //                                      codeStream.load(anyExceptionVariable);
355 //                                      codeStream.athrow();
356 //                              }
357 //                      }
358 //                      // end of catch sequence, place label that will correspond to the finally block beginning, or end of statement
359 //                      endLabel.place();
360 //                      if (subRoutineStartLabel != null) {
361 //                              if (nonReturningSubRoutine) {
362 //                                      requiresNaturalJsr = false;
363 //                              }
364 //                              Label veryEndLabel = new Label(codeStream);
365 //                              if (requiresNaturalJsr) {
366 //                                      codeStream.jsr(subRoutineStartLabel);
367 //                                      codeStream.goto_(veryEndLabel);
368 //                              }
369 //                              subRoutineStartLabel.place();
370 //                              if (!nonReturningSubRoutine) {
371 //                                      codeStream.incrStackSize(1);
372 //                                      codeStream.store(returnAddressVariable, false);
373 //                              }
374 //                              codeStream.recordPositionsFrom(
375 //                                      finallySequenceStartPC,
376 //                                      finallyBlock.sourceStart);
377 //                              // entire sequence for finally is associated to finally block
378 //                              finallyBlock.generateCode(scope, codeStream);
379 //                              if (!nonReturningSubRoutine) {
380 //                                      int position = codeStream.position;
381 //                                      codeStream.ret(returnAddressVariable.resolvedPosition);
382 //                                      codeStream.updateLastRecordedEndPC(position);
383 //                                      // the ret bytecode is part of the subroutine
384 //                              }
385 //                              if (requiresNaturalJsr) {
386 //                                      veryEndLabel.place();
387 //                              }
388 //                      }
389 //              } else {
390 //                      // try block had no effect, only generate the body of the finally block if any
391 //                      if (subRoutineStartLabel != null) {
392 //                              finallyBlock.generateCode(scope, codeStream);
393 //                      }
394 //              }
395 //              // May loose some local variable initializations : affecting the local variable attributes
396 //              if (mergedInitStateIndex != -1) {
397 //                      codeStream.removeNotDefinitelyAssignedVariables(
398 //                              currentScope,
399 //                              mergedInitStateIndex);
400 //                      codeStream.addDefinitelyAssignedVariables(currentScope, mergedInitStateIndex);
401 //              }
402 //              codeStream.recordPositionsFrom(pc, this.sourceStart);
403 //      }
404
405         public void resetStateForCodeGeneration() {
406                 if (this.subRoutineStartLabel != null) {
407                         this.subRoutineStartLabel.resetStateForCodeGeneration();
408                 }
409         }       
410         public StringBuffer printStatement(int indent, StringBuffer output) {
411                 printIndent(indent, output).append("try \n"); //$NON-NLS-1$
412                 tryBlock.printStatement(indent + 1, output); //$NON-NLS-1$
413
414                 //catches
415                 if (catchBlocks != null)
416                         for (int i = 0; i < catchBlocks.length; i++) {
417                                         output.append('\n');
418                                         printIndent(indent, output).append("catch ("); //$NON-NLS-1$
419                                         catchArguments[i].print(0, output).append(") "); //$NON-NLS-1$
420                                         catchBlocks[i].printStatement(indent + 1, output);
421                         }
422                 //finally
423                 if (finallyBlock != null) {
424                         output.append('\n');
425                         printIndent(indent, output).append("finally\n"); //$NON-NLS-1$
426                         finallyBlock.printStatement(indent + 1, output);
427                 }
428
429                 return output;
430         }
431         public void resolve(BlockScope upperScope) {
432
433                 // special scope for secret locals optimization.        
434                 this.scope = new BlockScope(upperScope);
435
436                 BlockScope tryScope = new BlockScope(scope);
437                 BlockScope finallyScope = null;
438                 
439                 if (finallyBlock != null
440                         && finallyBlock.statements != null) {
441
442                         finallyScope = new BlockScope(scope, false); // don't add it yet to parent scope
443
444                         // provision for returning and forcing the finally block to run
445                         MethodScope methodScope = scope.methodScope();
446
447                         // the type does not matter as long as it is not a base type
448                         this.returnAddressVariable =
449                                 new LocalVariableBinding(SecretReturnName, upperScope.getJavaLangObject(), AccDefault, false);
450                         finallyScope.addLocalVariable(returnAddressVariable);
451                         this.returnAddressVariable.constant = NotAConstant; // not inlinable
452                         this.subRoutineStartLabel = new Label();
453
454                         this.anyExceptionVariable =
455                                 new LocalVariableBinding(SecretAnyHandlerName, scope.getJavaLangThrowable(), AccDefault, false);
456                         finallyScope.addLocalVariable(this.anyExceptionVariable);
457                         this.anyExceptionVariable.constant = NotAConstant; // not inlinable
458
459                         if (!methodScope.isInsideInitializer()) {
460                                 MethodBinding methodBinding =
461                                         ((AbstractMethodDeclaration) methodScope.referenceContext).binding;
462                                 if (methodBinding != null) {
463                                         TypeBinding methodReturnType = methodBinding.returnType;
464                                         if (methodReturnType.id != T_void) {
465                                                 this.secretReturnValue =
466                                                         new LocalVariableBinding(
467                                                                 SecretLocalDeclarationName,
468                                                                 methodReturnType,
469                                                                 AccDefault,
470                                                                 false);
471                                                 finallyScope.addLocalVariable(this.secretReturnValue);
472                                                 this.secretReturnValue.constant = NotAConstant; // not inlinable
473                                         }
474                                 }
475                         }
476                         finallyBlock.resolveUsing(finallyScope);
477                         // force the finally scope to have variable positions shifted after its try scope and catch ones
478                         finallyScope.shiftScopes = new BlockScope[catchArguments == null ? 1 : catchArguments.length+1];
479                         finallyScope.shiftScopes[0] = tryScope;
480                 }
481                 this.tryBlock.resolveUsing(tryScope);
482
483                 // arguments type are checked against JavaLangThrowable in resolveForCatch(..)
484                 if (this.catchBlocks != null) {
485                         int length = this.catchArguments.length;
486                         TypeBinding[] argumentTypes = new TypeBinding[length];
487                         for (int i = 0; i < length; i++) {
488                                 BlockScope catchScope = new BlockScope(scope);
489                                 if (finallyScope != null){
490                                         finallyScope.shiftScopes[i+1] = catchScope;
491                                 }
492                                 // side effect on catchScope in resolveForCatch(..)
493                                 if ((argumentTypes[i] = catchArguments[i].resolveForCatch(catchScope)) == null)
494                                         return;
495                                 catchBlocks[i].resolveUsing(catchScope);
496                         }
497
498                         // Verify that the catch clause are ordered in the right way:
499                         // more specialized first.
500                         this.caughtExceptionTypes = new ReferenceBinding[length];
501                         for (int i = 0; i < length; i++) {
502                                 caughtExceptionTypes[i] = (ReferenceBinding) argumentTypes[i];
503                                 for (int j = 0; j < i; j++) {
504                                         if (caughtExceptionTypes[i].isCompatibleWith(argumentTypes[j])) {
505                                                 scope.problemReporter().wrongSequenceOfExceptionTypesError(this, i, j);
506                                                 // cannot return - since may still proceed if unreachable code is ignored (21203)
507                                         }
508                                 }
509                         }
510                 } else {
511                         caughtExceptionTypes = new ReferenceBinding[0];
512                 }
513                 
514                 if (finallyScope != null){
515                         // add finallyScope as last subscope, so it can be shifted behind try/catch subscopes.
516                         // the shifting is necessary to achieve no overlay in between the finally scope and its
517                         // sibling in term of local variable positions.
518                         this.scope.addSubscope(finallyScope);
519                 }
520         }
521
522         public String toString(int tab) {
523                 String s = tabString(tab);
524                 //try
525                 s = s + "try "; //$NON-NLS-1$
526                 if (tryBlock == Block.None)
527                         s = s + "{}"; //$NON-NLS-1$
528                 else
529                         s = s + "\n" + tryBlock.toString(tab + 1); //$NON-NLS-1$
530
531                 //catches
532                 if (catchBlocks != null)
533                         for (int i = 0; i < catchBlocks.length; i++)
534                                         s = s + "\n" + tabString(tab) + "catch (" //$NON-NLS-2$ //$NON-NLS-1$
535                                                 +catchArguments[i].toString(0) + ") " //$NON-NLS-1$
536                                                 +catchBlocks[i].toString(tab + 1);
537                 //finally
538                 if (finallyBlock != null) {
539                         if (finallyBlock == Block.None)
540                                 s = s + "\n" + tabString(tab) + "finally {}"; //$NON-NLS-2$ //$NON-NLS-1$
541                         else
542                                         s = s + "\n" + tabString(tab) + "finally\n" + //$NON-NLS-2$ //$NON-NLS-1$
543                         finallyBlock.toString(tab + 1);
544                 }
545
546                 return s;
547         }
548
549         public void traverse(
550             ASTVisitor visitor,
551                 BlockScope blockScope) {
552
553                 if (visitor.visit(this, blockScope)) {
554                         tryBlock.traverse(visitor, scope);
555                         if (catchArguments != null) {
556                                 for (int i = 0, max = catchBlocks.length; i < max; i++) {
557                                         catchArguments[i].traverse(visitor, scope);
558                                         catchBlocks[i].traverse(visitor, scope);
559                                 }
560                         }
561                         if (finallyBlock != null)
562                                 finallyBlock.traverse(visitor, scope);
563                 }
564                 visitor.endVisit(this, blockScope);
565         }
566 }