net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/classfmt/MethodInfo.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v0.5
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v05.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  ******************************************************************************/
  11 package net.sourceforge.phpdt.internal.compiler.classfmt;
  12
  13 import net.sourceforge.phpdt.internal.compiler.codegen.AttributeNamesConstants;
  14 import net.sourceforge.phpdt.internal.compiler.env.IBinaryMethod;
  15 import net.sourceforge.phpdt.internal.compiler.util.CharOperation;
  16
  17 public class MethodInfo extends ClassFileStruct implements IBinaryMethod, AttributeNamesConstants, Comparable {
  18         private char[][] exceptionNames;
  19         private int[] constantPoolOffsets;
  20         private boolean isDeprecated;
  21         private boolean isSynthetic;
  22         private int accessFlags;
  23         private char[] name;
  24         private char[] signature;
  25         private int attributesCount;
  26         private int attributeBytes;
  27         static private final char[][] noException = new char[0][0];
  28         private int decodeIndex;
  29 /**
  30  * @param classFileBytes byte[]
  31  * @param offsets int[]
  32  * @param offset int
  33  */
  34 public MethodInfo (byte classFileBytes[], int offsets[], int offset) throws ClassFormatException {
  35         super(classFileBytes, offset);
  36         constantPoolOffsets = offsets;
  37         accessFlags = -1;
  38         int attributesCount = u2At(6);
  39         int readOffset = 8;
  40         for (int i = 0; i < attributesCount; i++) {
  41                 readOffset += (6 + u4At(readOffset + 2));
  42         }
  43         attributeBytes = readOffset;
  44 }
  45 /**
  46  * @see IGenericMethod#getArgumentNames()
  47  */
  48 public char[][] getArgumentNames() {
  49         return null;
  50 }
  51 /**
  52  * Answer the resolved names of the exception types in the
  53  * class file format as specified in section 4.2 of the Java 2 VM spec
  54  * or null if the array is empty.
  55  *
  56  * For example, java.lang.String is java/lang/String.
  57  * @return char[][]
  58  */
  59 public char[][] getExceptionTypeNames() {
  60         if (exceptionNames == null) {
  61                 readExceptionAttributes();
  62         }
  63         return exceptionNames;
  64 }
  65 /**
  66  * Answer the receiver's method descriptor which describes the parameter &
  67  * return types as specified in section 4.3.3 of the Java 2 VM spec.
  68  *
  69  * For example:
  70  *   - int foo(String) is (Ljava/lang/String;)I
  71  *   - void foo(Object[]) is (I)[Ljava/lang/Object;
  72  * @return char[]
  73  */
  74 public char[] getMethodDescriptor() {
  75         if (signature == null) {
  76                 // read the name
  77                 int utf8Offset = constantPoolOffsets[u2At(4)] - structOffset;
  78                 signature = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
  79         }
  80         return signature;
  81 }
  82 /**
  83  * Answer an int whose bits are set according the access constants
  84  * defined by the VM spec.
  85  * Set the AccDeprecated and AccSynthetic bits if necessary
  86  * @return int
  87  */
  88 public int getModifiers() {
  89         if (accessFlags == -1) {
  90                 // compute the accessflag. Don't forget the deprecated attribute
  91                 accessFlags = u2At(0);
  92                 readDeprecatedAndSyntheticAttributes();
  93                 if (isDeprecated) {
  94                         accessFlags |= AccDeprecated;
  95                 }
  96                 if (isSynthetic) {
  97                         accessFlags |= AccSynthetic;
  98                 }
  99         }
 100         return accessFlags;
 101 }
 102 /**
 103  * Answer the name of the method.
 104  *
 105  * For a constructor, answer <init> & <clinit> for a clinit method.
 106  * @return char[]
 107  */
 108 public char[] getSelector() {
 109         if (name == null) {
 110                 // read the name
 111                 int utf8Offset = constantPoolOffsets[u2At(2)] - structOffset;
 112                 name = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
 113         }
 114         return name;
 115 }
 116 /**
 117  * Answer true if the method is a class initializer, false otherwise.
 118  * @return boolean
 119  */
 120 public boolean isClinit() {
 121         char[] selector = getSelector();
 122         return selector[0] == '<' && selector.length == 8; // Can only match <clinit>
 123 }
 124 /**
 125  * Answer true if the method is a constructor, false otherwise.
 126  * @return boolean
 127  */
 128 public boolean isConstructor() {
 129         char[] selector = getSelector();
 130         return selector[0] == '<' && selector.length == 6; // Can only match <init>
 131 }
 132 /**
 133  * Return true if the field is a synthetic method, false otherwise.
 134  * @return boolean
 135  */
 136 public boolean isSynthetic() {
 137         return (getModifiers() & AccSynthetic) != 0;
 138 }
 139 private void readDeprecatedAndSyntheticAttributes() {
 140         int attributesCount = u2At(6);
 141         int readOffset = 8;
 142         for (int i = 0; i < attributesCount; i++) {
 143                 int utf8Offset = constantPoolOffsets[u2At(readOffset)] - structOffset;
 144                 char[] attributeName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
 145                 if (CharOperation.equals(attributeName, DeprecatedName)) {
 146                         isDeprecated = true;
 147                 } else if (CharOperation.equals(attributeName, SyntheticName)) {
 148                         isSynthetic = true;
 149                 }
 150                 readOffset += (6 + u4At(readOffset + 2));
 151         }
 152 }
 153 private void readExceptionAttributes() {
 154         int attributesCount = u2At(6);
 155         int readOffset = 8;
 156         for (int i = 0; i < attributesCount; i++) {
 157                 int utf8Offset = constantPoolOffsets[u2At(readOffset)] - structOffset;
 158                 char[] attributeName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
 159                 if (CharOperation.equals(attributeName, ExceptionsName)) {
 160                         // read the number of exception entries
 161                         int entriesNumber = u2At(readOffset + 6);
 162                         // place the readOffset at the beginning of the exceptions table
 163                         readOffset += 8;
 164                         if (entriesNumber == 0) {
 165                                 exceptionNames = noException;
 166                         } else {
 167                                 exceptionNames = new char[entriesNumber][];
 168                                 for (int j = 0; j < entriesNumber; j++) {
 169                                         utf8Offset =
 170                                                 constantPoolOffsets[u2At(
 171                                                         constantPoolOffsets[u2At(readOffset)] - structOffset + 1)]
 172                                                         - structOffset;
 173                                         exceptionNames[j] = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
 174                                         readOffset += 2;
 175                                 }
 176                         }
 177                 } else {
 178                         readOffset += (6 + u4At(readOffset + 2));
 179                 }
 180         }
 181         if (exceptionNames == null) {
 182                 exceptionNames = noException;
 183         }
 184 }
 185 /**
 186  * Answer the size of the receiver in bytes.
 187  *
 188  * @return int
 189  */
 190 public int sizeInBytes() {
 191         return attributeBytes;
 192 }
 193 public String toString() {
 194         int modifiers = getModifiers();
 195         StringBuffer buffer = new StringBuffer(this.getClass().getName());
 196         return buffer
 197                 .append("{") //$NON-NLS-1$
 198                 .append(
 199                         ((modifiers & AccDeprecated) != 0 ? "deprecated " : "") //$NON-NLS-1$ //$NON-NLS-2$
 200                                 + ((modifiers & 0x0001) == 1 ? "public " : "") //$NON-NLS-1$ //$NON-NLS-2$
 201                                 + ((modifiers & 0x0002) == 0x0002 ? "private " : "") //$NON-NLS-1$ //$NON-NLS-2$
 202                                 + ((modifiers & 0x0004) == 0x0004 ? "protected " : "") //$NON-NLS-1$ //$NON-NLS-2$
 203                                 + ((modifiers & 0x0008) == 0x000008 ? "static " : "") //$NON-NLS-1$ //$NON-NLS-2$
 204                                 + ((modifiers & 0x0010) == 0x0010 ? "final " : "") //$NON-NLS-1$ //$NON-NLS-2$
 205                                 + ((modifiers & 0x0040) == 0x0040 ? "volatile " : "") //$NON-NLS-1$ //$NON-NLS-2$
 206                                 + ((modifiers & 0x0080) == 0x0080 ? "transient " : "")) //$NON-NLS-1$ //$NON-NLS-2$
 207                 .append(getSelector())
 208                 .append(getMethodDescriptor())
 209                 .append("}") //$NON-NLS-1$
 210                 .toString();
 211 }
 212 public int compareTo(Object o) {
 213         if (!(o instanceof MethodInfo)) {
 214                 throw new ClassCastException();
 215         }
 216
 217         MethodInfo otherMethod = (MethodInfo) o;
 218         int result = new String(this.getSelector()).compareTo(new String(otherMethod.getSelector()));
 219         if (result != 0) return result;
 220         return new String(this.getMethodDescriptor()).compareTo(new String(otherMethod.getMethodDescriptor()));
 221 }
 222
 223 /**
 224  * This method is used to fully initialize the contents of the receiver. All methodinfos, fields infos
 225  * will be therefore fully initialized and we can get rid of the bytes.
 226  */
 227 void initialize() {
 228         getModifiers();
 229         getSelector();
 230         getMethodDescriptor();
 231         getExceptionTypeNames();
 232         reset();
 233 }
 234 protected void reset() {
 235         this.constantPoolOffsets = null;
 236         super.reset();
 237 }
 238 }