changed the "description" attribute in phpsyntax.xml into multi-line text between...
[phpeclipse.git] / 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 }