net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/flow/ExceptionHandlingFlowContext.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.flow;
  12
  13 import java.util.ArrayList;
  14
  15 import net.sourceforge.phpdt.internal.compiler.ast.ASTNode;
  16 import net.sourceforge.phpdt.internal.compiler.codegen.ObjectCache;
  17 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
  18 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
  19 import net.sourceforge.phpdt.internal.compiler.lookup.Scope;
  20 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
  21
  22 /**
  23  * Reflects the context of code analysis, keeping track of enclosing try
  24  * statements, exception handlers, etc...
  25  */
  26 public class ExceptionHandlingFlowContext extends FlowContext {
  27
  28         public ReferenceBinding[] handledExceptions;
  29
  30         public final static int BitCacheSize = 32; // 32 bits per int
  31
  32         int[] isReached;
  33
  34         int[] isNeeded;
  35
  36         UnconditionalFlowInfo[] initsOnExceptions;
  37
  38         ObjectCache indexes = new ObjectCache();
  39
  40         boolean isMethodContext;
  41
  42         public UnconditionalFlowInfo initsOnReturn;
  43
  44         // for dealing with anonymous constructor thrown exceptions
  45         public ArrayList extendedExceptions;
  46
  47         public ExceptionHandlingFlowContext(FlowContext parent,
  48                         ASTNode associatedNode, ReferenceBinding[] handledExceptions,
  49                         BlockScope scope, UnconditionalFlowInfo flowInfo) {
  50
  51                 super(parent, associatedNode);
  52                 isMethodContext = scope == scope.methodScope();
  53                 this.handledExceptions = handledExceptions;
  54                 int count = handledExceptions.length, cacheSize = (count / BitCacheSize) + 1;
  55                 this.isReached = new int[cacheSize]; // none is reached by default
  56                 this.isNeeded = new int[cacheSize]; // none is needed by default
  57                 this.initsOnExceptions = new UnconditionalFlowInfo[count];
  58                 for (int i = 0; i < count; i++) {
  59                         this.indexes.put(handledExceptions[i], i); // key type -> value
  60                                                                                                                 // index
  61                         boolean isUnchecked = (scope
  62                                         .compareUncheckedException(handledExceptions[i]) != NotRelated);
  63                         int cacheIndex = i / BitCacheSize, bitMask = 1 << (i % BitCacheSize);
  64                         if (isUnchecked) {
  65                                 isReached[cacheIndex] |= bitMask;
  66                                 this.initsOnExceptions[i] = flowInfo.copy()
  67                                                 .unconditionalInits();
  68                         } else {
  69                                 this.initsOnExceptions[i] = FlowInfo.DEAD_END;
  70                         }
  71                 }
  72                 System.arraycopy(this.isReached, 0, this.isNeeded, 0, cacheSize);
  73                 this.initsOnReturn = FlowInfo.DEAD_END;
  74         }
  75
  76         // public void complainIfUnusedExceptionHandlers(
  77         // ASTNode[] exceptionHandlers,
  78         // BlockScope scope,
  79         // TryStatement tryStatement) {
  80         // // report errors for unreachable exception handlers
  81         // for (int i = 0, count = handledExceptions.length; i < count; i++) {
  82         // int index = indexes.get(handledExceptions[i]);
  83         // int cacheIndex = index / BitCacheSize;
  84         // int bitMask = 1 << (index % BitCacheSize);
  85         // if ((isReached[cacheIndex] & bitMask) == 0) {
  86         // scope.problemReporter().unreachableExceptionHandler(
  87         // handledExceptions[index],
  88         // exceptionHandlers[index]);
  89         // } else {
  90         // if ((isNeeded[cacheIndex] & bitMask) == 0) {
  91         // scope.problemReporter().maskedExceptionHandler(
  92         // handledExceptions[index],
  93         // exceptionHandlers[index]);
  94         // }
  95         // }
  96         // }
  97         // // will optimized out unnecessary catch block during code gen
  98         // tryStatement.preserveExceptionHandler = isNeeded;
  99         // }
 100
 101         public String individualToString() {
 102
 103                 StringBuffer buffer = new StringBuffer("Exception flow context"); //$NON-NLS-1$
 104                 int length = handledExceptions.length;
 105                 for (int i = 0; i < length; i++) {
 106                         int cacheIndex = i / BitCacheSize;
 107                         int bitMask = 1 << (i % BitCacheSize);
 108                         buffer.append('[').append(handledExceptions[i].readableName());
 109                         if ((isReached[cacheIndex] & bitMask) != 0) {
 110                                 if ((isNeeded[cacheIndex] & bitMask) == 0) {
 111                                         buffer.append("-masked"); //$NON-NLS-1$
 112                                 } else {
 113                                         buffer.append("-reached"); //$NON-NLS-1$
 114                                 }
 115                         } else {
 116                                 buffer.append("-not reached"); //$NON-NLS-1$
 117                         }
 118                         buffer.append('-').append(initsOnExceptions[i].toString()).append(
 119                                         ']');
 120                 }
 121                 buffer
 122                                 .append("[initsOnReturn -").append(initsOnReturn.toString()).append(']'); //$NON-NLS-1$
 123                 return buffer.toString();
 124         }
 125
 126         public UnconditionalFlowInfo initsOnException(ReferenceBinding exceptionType) {
 127
 128                 int index;
 129                 if ((index = indexes.get(exceptionType)) < 0) {
 130                         return FlowInfo.DEAD_END;
 131                 }
 132                 return initsOnExceptions[index];
 133         }
 134
 135         public UnconditionalFlowInfo initsOnReturn() {
 136                 return this.initsOnReturn;
 137         }
 138
 139         public void recordHandlingException(ReferenceBinding exceptionType,
 140                         UnconditionalFlowInfo flowInfo, TypeBinding raisedException,
 141                         ASTNode invocationSite, boolean wasAlreadyDefinitelyCaught) {
 142
 143                 int index = indexes.get(exceptionType);
 144                 // if already flagged as being reached (unchecked exception handler)
 145                 int cacheIndex = index / BitCacheSize;
 146                 int bitMask = 1 << (index % BitCacheSize);
 147                 if (!wasAlreadyDefinitelyCaught) {
 148                         this.isNeeded[cacheIndex] |= bitMask;
 149                 }
 150                 this.isReached[cacheIndex] |= bitMask;
 151
 152                 initsOnExceptions[index] = initsOnExceptions[index] == FlowInfo.DEAD_END ? flowInfo
 153                                 .copy().unconditionalInits()
 154                                 : initsOnExceptions[index].mergedWith(flowInfo);
 155         }
 156
 157         public void recordReturnFrom(FlowInfo flowInfo) {
 158
 159                 if (!flowInfo.isReachable())
 160                         return;
 161                 if (initsOnReturn == FlowInfo.DEAD_END) {
 162                         initsOnReturn = flowInfo.copy().unconditionalInits();
 163                 } else {
 164                         initsOnReturn = initsOnReturn.mergedWith(flowInfo
 165                                         .unconditionalInits());
 166                 }
 167         }
 168
 169         /*
 170          * Compute a merged list of unhandled exception types (keeping only the most
 171          * generic ones). This is necessary to add synthetic thrown exceptions for
 172          * anonymous type constructors (JLS 8.6).
 173          */
 174         public void mergeUnhandledException(TypeBinding newException) {
 175
 176                 if (this.extendedExceptions == null) {
 177                         this.extendedExceptions = new ArrayList(5);
 178                         for (int i = 0; i < this.handledExceptions.length; i++) {
 179                                 this.extendedExceptions.add(this.handledExceptions[i]);
 180                         }
 181                 }
 182
 183                 boolean isRedundant = false;
 184
 185                 for (int i = this.extendedExceptions.size() - 1; i >= 0; i--) {
 186                         switch (Scope.compareTypes(newException,
 187                                         (TypeBinding) this.extendedExceptions.get(i))) {
 188                         case MoreGeneric:
 189                                 this.extendedExceptions.remove(i);
 190                                 break;
 191                         case EqualOrMoreSpecific:
 192                                 isRedundant = true;
 193                                 break;
 194                         case NotRelated:
 195                                 break;
 196                         }
 197                 }
 198                 if (!isRedundant) {
 199                         this.extendedExceptions.add(newException);
 200                 }
 201         }
 202 }