first scanner /parser copied from the jdt java version
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / classfmt / ClassFileReader.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.*;
14 import net.sourceforge.phpdt.internal.compiler.env.*;
15 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
16 import net.sourceforge.phpdt.internal.compiler.impl.NullConstant;
17 import net.sourceforge.phpdt.internal.compiler.lookup.TypeIds;
18 import net.sourceforge.phpdt.internal.compiler.util.*;
19
20 import java.io.*;
21 import java.util.Arrays;
22
23 public class ClassFileReader extends ClassFileStruct implements AttributeNamesConstants, IBinaryType {
24         private int constantPoolCount;
25         private int[] constantPoolOffsets;
26         private int accessFlags;
27         private char[] className;
28         private char[] superclassName;
29         private int interfacesCount;
30         private char[][] interfaceNames;
31         private int fieldsCount;
32         private FieldInfo[] fields;
33         private int methodsCount;
34         private MethodInfo[] methods;
35         private InnerClassInfo[] innerInfos;
36         private char[] sourceFileName;
37         // initialized in case the .class file is a nested type
38         private InnerClassInfo innerInfo;
39         private char[] classFileName;
40         private int classNameIndex;
41         private int innerInfoIndex;
42 /**
43  * @param classFileBytes byte[]
44  *              Actual bytes of a .class file
45  * 
46  * @param fileName char[]
47  *              Actual name of the file that contains the bytes, can be null
48  * 
49  * @param fullyInitialize boolean
50  *              Flag to fully initialize the new object
51  * @exception ClassFormatException
52  */
53 public ClassFileReader(byte[] classFileBytes, char[] fileName, boolean fullyInitialize) throws ClassFormatException {
54         // This method looks ugly but is actually quite simple, the constantPool is constructed
55         // in 3 passes.  All non-primitive constant pool members that usually refer to other members
56         // by index are tweaked to have their value in inst vars, this minor cost at read-time makes
57         // all subsequent uses of the constant pool element faster.
58         super(classFileBytes, 0);
59         this.classFileName = fileName;
60         int readOffset = 10;
61         try {
62                 constantPoolCount = this.u2At(8);
63                 // Pass #1 - Fill in all primitive constants
64                 this.constantPoolOffsets = new int[constantPoolCount];
65                 for (int i = 1; i < constantPoolCount; i++) {
66                         int tag = this.u1At(readOffset);
67                         switch (tag) {
68                                 case Utf8Tag :
69                                         this.constantPoolOffsets[i] = readOffset;
70                                         readOffset += u2At(readOffset + 1);
71                                         readOffset += ConstantUtf8FixedSize;
72                                         break;
73                                 case IntegerTag :
74                                         this.constantPoolOffsets[i] = readOffset;
75                                         readOffset += ConstantIntegerFixedSize;
76                                         break;
77                                 case FloatTag :
78                                         this.constantPoolOffsets[i] = readOffset;
79                                         readOffset += ConstantFloatFixedSize;
80                                         break;
81                                 case LongTag :
82                                         this.constantPoolOffsets[i] = readOffset;
83                                         readOffset += ConstantLongFixedSize;
84                                         i++;
85                                         break;
86                                 case DoubleTag :
87                                         this.constantPoolOffsets[i] = readOffset;
88                                         readOffset += ConstantDoubleFixedSize;
89                                         i++;
90                                         break;
91                                 case ClassTag :
92                                         this.constantPoolOffsets[i] = readOffset;
93                                         readOffset += ConstantClassFixedSize;
94                                         break;
95                                 case StringTag :
96                                         this.constantPoolOffsets[i] = readOffset;
97                                         readOffset += ConstantStringFixedSize;
98                                         break;
99                                 case FieldRefTag :
100                                         this.constantPoolOffsets[i] = readOffset;
101                                         readOffset += ConstantFieldRefFixedSize;
102                                         break;
103                                 case MethodRefTag :
104                                         this.constantPoolOffsets[i] = readOffset;
105                                         readOffset += ConstantMethodRefFixedSize;
106                                         break;
107                                 case InterfaceMethodRefTag :
108                                         this.constantPoolOffsets[i] = readOffset;
109                                         readOffset += ConstantInterfaceMethodRefFixedSize;
110                                         break;
111                                 case NameAndTypeTag :
112                                         this.constantPoolOffsets[i] = readOffset;
113                                         readOffset += ConstantNameAndTypeFixedSize;
114                         }
115                 }
116                 // Read and validate access flags
117                 this.accessFlags = u2At(readOffset);
118                 readOffset += 2;
119
120                 // Read the classname, use exception handlers to catch bad format
121                 this.classNameIndex = u2At(readOffset);
122                 this.className = getConstantClassNameAt(this.classNameIndex);
123                 readOffset += 2;
124
125                 // Read the superclass name, can be null for java.lang.Object
126                 int superclassNameIndex = u2At(readOffset);
127                 readOffset += 2;
128                 // if superclassNameIndex is equals to 0 there is no need to set a value for the 
129                 // field this.superclassName. null is fine.
130                 if (superclassNameIndex != 0) {
131                         this.superclassName = getConstantClassNameAt(superclassNameIndex);
132                 }
133
134                 // Read the interfaces, use exception handlers to catch bad format
135                 this.interfacesCount = u2At(readOffset);
136                 readOffset += 2;
137                 if (this.interfacesCount != 0) {
138                         this.interfaceNames = new char[this.interfacesCount][];
139                         for (int i = 0; i < this.interfacesCount; i++) {
140                                 this.interfaceNames[i] = getConstantClassNameAt(u2At(readOffset));
141                                 readOffset += 2;
142                         }
143                 }
144                 // Read the this.fields, use exception handlers to catch bad format
145                 this.fieldsCount = u2At(readOffset);
146                 readOffset += 2;
147                 if (this.fieldsCount != 0) {
148                         FieldInfo field;
149                         this.fields = new FieldInfo[this.fieldsCount];
150                         for (int i = 0; i < this.fieldsCount; i++) {
151                                 field = new FieldInfo(reference, this.constantPoolOffsets, readOffset);
152                                 this.fields[i] = field;
153                                 readOffset += field.sizeInBytes();
154                         }
155                 }
156                 // Read the this.methods
157                 this.methodsCount = u2At(readOffset);
158                 readOffset += 2;
159                 if (this.methodsCount != 0) {
160                         this.methods = new MethodInfo[this.methodsCount];
161                         MethodInfo method;
162                         for (int i = 0; i < this.methodsCount; i++) {
163                                 method = new MethodInfo(reference, this.constantPoolOffsets, readOffset);
164                                 this.methods[i] = method;
165                                 readOffset += method.sizeInBytes();
166                         }
167                 }
168
169                 // Read the attributes
170                 int attributesCount = u2At(readOffset);
171                 readOffset += 2;
172
173                 for (int i = 0; i < attributesCount; i++) {
174                         int utf8Offset = this.constantPoolOffsets[u2At(readOffset)];
175                         char[] attributeName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
176                         if (CharOperation.equals(attributeName, DeprecatedName)) {
177                                 this.accessFlags |= AccDeprecated;
178                         } else {
179                                 if (CharOperation.equals(attributeName, InnerClassName)) {
180                                         int innerOffset = readOffset + 6;
181                                         int number_of_classes = u2At(innerOffset);
182                                         if (number_of_classes != 0) {
183                                                 this.innerInfos = new InnerClassInfo[number_of_classes];
184                                                 for (int j = 0; j < number_of_classes; j++) {
185                                                         this.innerInfos[j] = 
186                                                                 new InnerClassInfo(reference, this.constantPoolOffsets, innerOffset + 2); 
187                                                         if (this.classNameIndex == this.innerInfos[j].innerClassNameIndex) {
188                                                                 this.innerInfo = this.innerInfos[j];
189                                                                 this.innerInfoIndex = j;
190                                                         }
191                                                         innerOffset += 8;
192                                                 }
193                                         }
194                                 } else {
195                                         if (CharOperation.equals(attributeName, SourceName)) {
196                                                 utf8Offset = this.constantPoolOffsets[u2At(readOffset + 6)];
197                                                 this.sourceFileName = utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
198                                         } else {
199                                                 if (CharOperation.equals(attributeName, SyntheticName)) {
200                                                         this.accessFlags |= AccSynthetic;
201                                                 }
202                                         }
203                                 }
204                         }
205                         readOffset += (6 + u4At(readOffset + 2));
206                 }
207                 if (fullyInitialize) {
208                         this.initialize();
209                 }
210         } catch (Exception e) {
211                 throw new ClassFormatException(
212                         ClassFormatException.ErrTruncatedInput, 
213                         readOffset); 
214         }
215 }
216
217 /**
218  * @param classFileBytes Actual bytes of a .class file
219  * @param fileName      Actual name of the file that contains the bytes, can be null
220  * 
221  * @exception ClassFormatException
222  */
223 public ClassFileReader(byte classFileBytes[], char[] fileName) throws ClassFormatException {
224         this(classFileBytes, fileName, false);
225 }
226
227 /**
228  *      Answer the receiver's access flags.  The value of the access_flags
229  *      item is a mask of modifiers used with class and interface declarations.
230  *  @return int 
231  */
232 public int accessFlags() {
233         return this.accessFlags;
234 }
235 /**
236  * Answer the char array that corresponds to the class name of the constant class.
237  * constantPoolIndex is the index in the constant pool that is a constant class entry.
238  *
239  * @param int constantPoolIndex
240  * @return char[]
241  */
242 private char[] getConstantClassNameAt(int constantPoolIndex) {
243         int utf8Offset = this.constantPoolOffsets[u2At(this.constantPoolOffsets[constantPoolIndex] + 1)];
244         return utf8At(utf8Offset + 3, u2At(utf8Offset + 1));
245 }
246 /**
247  * Answer the int array that corresponds to all the offsets of each entry in the constant pool
248  *
249  * @return int[]
250  */
251 public int[] getConstantPoolOffsets() {
252         return this.constantPoolOffsets;
253 }
254 /*
255  * Answer the resolved compoundName of the enclosing type
256  * or null if the receiver is a top level type.
257  */
258 public char[] getEnclosingTypeName() {
259         if (this.innerInfo != null && !this.isAnonymous()) {
260                 return this.innerInfo.getEnclosingTypeName();
261         }
262         return null;
263 }
264 /**
265  * Answer the receiver's this.fields or null if the array is empty.
266  * @return org.eclipse.jdt.internal.compiler.api.IBinaryField[]
267  */
268 public IBinaryField[] getFields() {
269         return this.fields;
270 }
271 /**
272  * Answer the file name which defines the type.
273  * The format is unspecified.
274  */
275 public char[] getFileName() {
276         return this.classFileName;
277 }
278 /**
279  * Answer the source name if the receiver is a inner type. Return null if it is an anonymous class or if the receiver is a top-level class.
280  * e.g.
281  * public class A {
282  *      public class B {
283  *      }
284  *      public void foo() {
285  *              class C {}
286  *      }
287  *      public Runnable bar() {
288  *              return new Runnable() {
289  *                      public void run() {}
290  *              };
291  *      }
292  * }
293  * It returns {'B'} for the member A$B
294  * It returns null for A
295  * It returns {'C'} for the local class A$1$C
296  * It returns null for the anonymous A$1
297  * @return char[]
298  */
299 public char[] getInnerSourceName() {
300         if (this.innerInfo != null)
301                 return this.innerInfo.getSourceName();
302         return null;
303 }
304 /**
305  * Answer the resolved names of the receiver's interfaces in the
306  * class file format as specified in section 4.2 of the Java 2 VM spec
307  * or null if the array is empty.
308  *
309  * For example, java.lang.String is java/lang/String.
310  * @return char[][]
311  */
312 public char[][] getInterfaceNames() {
313         return this.interfaceNames;
314 }
315 /**
316  * Answer the receiver's nested types or null if the array is empty.
317  *
318  * This nested type info is extracted from the inner class attributes.
319  * Ask the name environment to find a member type using its compound name
320  * @return org.eclipse.jdt.internal.compiler.api.IBinaryNestedType[]
321  */
322 public IBinaryNestedType[] getMemberTypes() {
323         // we might have some member types of the current type
324         if (this.innerInfos == null) return null;
325
326         int length = this.innerInfos.length;
327         int startingIndex = this.innerInfo != null ? this.innerInfoIndex + 1 : 0;
328         if (length != startingIndex) {
329                 IBinaryNestedType[] memberTypes = 
330                         new IBinaryNestedType[length - this.innerInfoIndex]; 
331                 int memberTypeIndex = 0;
332                 for (int i = startingIndex; i < length; i++) {
333                         InnerClassInfo currentInnerInfo = this.innerInfos[i];
334                         int outerClassNameIdx = currentInnerInfo.outerClassNameIndex;
335                         int innerNameIndex = currentInnerInfo.innerNameIndex;
336                         /*
337                          * Checking that outerClassNameIDx is different from 0 should be enough to determine if an inner class
338                          * attribute entry is a member class, but due to the bug:
339                          * http://dev.eclipse.org/bugs/show_bug.cgi?id=14592
340                          * we needed to add an extra check. So we check that innerNameIndex is different from 0 as well.
341                          */
342                         if (outerClassNameIdx != 0 && innerNameIndex != 0 && outerClassNameIdx == this.classNameIndex) {
343                                 memberTypes[memberTypeIndex++] = currentInnerInfo;
344                         }
345                 }
346                 if (memberTypeIndex == 0) return null;
347                 if (memberTypeIndex != memberTypes.length) {
348                         // we need to resize the memberTypes array. Some local or anonymous classes
349                         // are present in the current class.
350                         System.arraycopy(
351                                 memberTypes, 
352                                 0, 
353                                 (memberTypes = new IBinaryNestedType[memberTypeIndex]), 
354                                 0, 
355                                 memberTypeIndex); 
356                 }
357                 return memberTypes;
358         }
359         return null;
360 }
361 /**
362  * Answer the receiver's this.methods or null if the array is empty.
363  * @return org.eclipse.jdt.internal.compiler.api.env.IBinaryMethod[]
364  */
365 public IBinaryMethod[] getMethods() {
366         return this.methods;
367 }
368 /**
369  * Answer an int whose bits are set according the access constants
370  * defined by the VM spec.
371  * Set the AccDeprecated and AccSynthetic bits if necessary
372  * @return int
373  */
374 public int getModifiers() {
375         if (this.innerInfo != null) {
376                 return this.innerInfo.getModifiers();
377         }
378         return this.accessFlags;
379 }
380 /**
381  * Answer the resolved name of the type in the
382  * class file format as specified in section 4.2 of the Java 2 VM spec.
383  *
384  * For example, java.lang.String is java/lang/String.
385  * @return char[]
386  */
387 public char[] getName() {
388         return this.className;
389 }
390 /**
391  * Answer the resolved name of the receiver's superclass in the
392  * class file format as specified in section 4.2 of the Java 2 VM spec
393  * or null if it does not have one.
394  *
395  * For example, java.lang.String is java/lang/String.
396  * @return char[]
397  */
398 public char[] getSuperclassName() {
399         return this.superclassName;
400 }
401 /**
402  * Answer true if the receiver is an anonymous type, false otherwise
403  *
404  * @return <CODE>boolean</CODE>
405  */
406 public boolean isAnonymous() {
407         if (this.innerInfo == null) return false;
408         char[] sourceName = this.innerInfo.getSourceName();
409         return (sourceName == null || sourceName.length == 0);
410 }
411 /**
412  * Answer whether the receiver contains the resolved binary form
413  * or the unresolved source form of the type.
414  * @return boolean
415  */
416 public boolean isBinaryType() {
417         return true;
418 }
419 /**
420  * Answer true if the receiver is a class. False otherwise.
421  * @return boolean
422  */
423 public boolean isClass() {
424         return (getModifiers() & AccInterface) == 0;
425 }
426 /**
427  * Answer true if the receiver is an interface. False otherwise.
428  * @return boolean
429  */
430 public boolean isInterface() {
431         return (getModifiers() & AccInterface) != 0;
432 }
433 /**
434  * Answer true if the receiver is a local type, false otherwise
435  *
436  * @return <CODE>boolean</CODE>
437  */
438 public boolean isLocal() {
439         return 
440                 this.innerInfo != null 
441                 && this.innerInfo.getEnclosingTypeName() == null 
442                 && this.innerInfo.getSourceName() != null;
443 }
444 /**
445  * Answer true if the receiver is a member type, false otherwise
446  *
447  * @return <CODE>boolean</CODE>
448  */
449 public boolean isMember() {
450         return this.innerInfo != null && this.innerInfo.getEnclosingTypeName() != null;
451 }
452 /**
453  * Answer true if the receiver is a nested type, false otherwise
454  *
455  * @return <CODE>boolean</CODE>
456  */
457 public boolean isNestedType() {
458         return this.innerInfo != null;
459 }
460 public static ClassFileReader read(File file) throws ClassFormatException, IOException {
461         return read(file, false);
462 }
463 public static ClassFileReader read(File file, boolean fullyInitialize) throws ClassFormatException, IOException {
464         byte classFileBytes[] = Util.getFileByteContent(file);
465         ClassFileReader classFileReader = new ClassFileReader(classFileBytes, file.getAbsolutePath().toCharArray());
466         if (fullyInitialize) {
467                 classFileReader.initialize();
468         }
469         return classFileReader;
470 }
471 public static ClassFileReader read(String fileName) throws ClassFormatException, java.io.IOException {
472         return read(fileName, false);
473 }
474 public static ClassFileReader read(String fileName, boolean fullyInitialize) throws ClassFormatException, java.io.IOException {
475         return read(new File(fileName), fullyInitialize);
476 }
477 public static ClassFileReader read(
478         java.util.zip.ZipFile zip, 
479         String filename)
480         throws ClassFormatException, java.io.IOException {
481                 return read(zip, filename, false);
482 }
483 public static ClassFileReader read(
484         java.util.zip.ZipFile zip, 
485         String filename,
486         boolean fullyInitialize)
487         throws ClassFormatException, java.io.IOException {
488         java.util.zip.ZipEntry ze = zip.getEntry(filename);
489         if (ze == null)
490                 return null;
491         byte classFileBytes[] = Util.getZipEntryByteContent(ze, zip);
492         ClassFileReader classFileReader = new ClassFileReader(classFileBytes, filename.toCharArray());
493         if (fullyInitialize) {
494                 classFileReader.initialize();
495         }
496         return classFileReader;
497 }
498
499 /**
500  * Answer the source file name attribute. Return null if there is no source file attribute for the receiver.
501  * 
502  * @return char[]
503  */
504 public char[] sourceFileName() {
505         return this.sourceFileName;
506 }
507 public String toString() {
508         java.io.ByteArrayOutputStream out = new java.io.ByteArrayOutputStream();
509         java.io.PrintWriter print = new java.io.PrintWriter(out);
510         
511         print.println(this.getClass().getName() + "{"); //$NON-NLS-1$
512         print.println(" this.className: " + new String(getName())); //$NON-NLS-1$
513         print.println(" this.superclassName: " + (getSuperclassName() == null ? "null" : new String(getSuperclassName()))); //$NON-NLS-2$ //$NON-NLS-1$
514         print.println(" access_flags: " + ClassFileStruct.printTypeModifiers(this.accessFlags()) + "(" + this.accessFlags() + ")"); //$NON-NLS-1$ //$NON-NLS-3$ //$NON-NLS-2$
515
516         print.flush();
517         return out.toString();
518 }
519 /**
520  * Check if the receiver has structural changes compare to the byte array in argument.
521  * Structural changes are:
522  * - modifiers changes for the class, the this.fields or the this.methods
523  * - signature changes for this.fields or this.methods.
524  * - changes in the number of this.fields or this.methods
525  * - changes for field constants
526  * - changes for thrown exceptions
527  * - change for the super class or any super interfaces.
528  * - changes for member types name or modifiers
529  * If any of these changes occurs, the method returns true. false otherwise. 
530  * The synthetic fields are included and the members are not required to be sorted.
531  * @param newBytes the bytes of the .class file we want to compare the receiver to
532  * @return boolean Returns true is there is a structural change between the two .class files, false otherwise
533  */
534 public boolean hasStructuralChanges(byte[] newBytes) {
535         return hasStructuralChanges(newBytes, true, true);
536 }
537 /**
538  * Check if the receiver has structural changes compare to the byte array in argument.
539  * Structural changes are:
540  * - modifiers changes for the class, the this.fields or the this.methods
541  * - signature changes for this.fields or this.methods.
542  * - changes in the number of this.fields or this.methods
543  * - changes for field constants
544  * - changes for thrown exceptions
545  * - change for the super class or any super interfaces.
546  * - changes for member types name or modifiers
547  * If any of these changes occurs, the method returns true. false otherwise.
548  * @param newBytes the bytes of the .class file we want to compare the receiver to
549  * @param orderRequired a boolean indicating whether the members should be sorted or not
550  * @param excludesSynthetics a boolean indicating whether the synthetic members should be used in the comparison
551  * @return boolean Returns true is there is a structural change between the two .class files, false otherwise
552  */
553 public boolean hasStructuralChanges(byte[] newBytes, boolean orderRequired, boolean excludesSynthetic) {
554         try {
555                 ClassFileReader newClassFile =
556                         new ClassFileReader(newBytes, this.classFileName);
557                 // type level comparison
558                 // modifiers
559                 if (this.getModifiers() != newClassFile.getModifiers())
560                         return true;
561                 // superclass
562                 if (!CharOperation.equals(this.getSuperclassName(), newClassFile.getSuperclassName()))
563                         return true;
564                 // interfaces
565                 char[][] newInterfacesNames = newClassFile.getInterfaceNames();
566                 if (this.interfaceNames != newInterfacesNames) { // TypeConstants.NoSuperInterfaces
567                         int newInterfacesLength = newInterfacesNames == null ? 0 : newInterfacesNames.length;
568                         if (newInterfacesLength != this.interfacesCount)
569                                 return true;
570                         for (int i = 0, max = this.interfacesCount; i < max; i++)
571                                 if (!CharOperation.equals(this.interfaceNames[i], newInterfacesNames[i]))
572                                         return true;
573                 }
574
575                 // member types
576                 IBinaryNestedType[] currentMemberTypes = (IBinaryNestedType[]) this.getMemberTypes();
577                 IBinaryNestedType[] otherMemberTypes = (IBinaryNestedType[]) newClassFile.getMemberTypes();
578                 if (currentMemberTypes != otherMemberTypes) { // TypeConstants.NoMemberTypes
579                         int currentMemberTypeLength = currentMemberTypes == null ? 0 : currentMemberTypes.length;
580                         int otherMemberTypeLength = otherMemberTypes == null ? 0 : otherMemberTypes.length;
581                         if (currentMemberTypeLength != otherMemberTypeLength)
582                                 return true;
583                         for (int i = 0; i < currentMemberTypeLength; i++)
584                                 if (!CharOperation.equals(currentMemberTypes[i].getName(), otherMemberTypes[i].getName())
585                                         || currentMemberTypes[i].getModifiers() != otherMemberTypes[i].getModifiers())
586                                                 return true;
587                 }
588
589                 // fields
590                 FieldInfo[] otherFieldInfos = (FieldInfo[]) newClassFile.getFields();
591                 int otherFieldInfosLength = otherFieldInfos == null ? 0 : otherFieldInfos.length;
592                 boolean compareFields = true;
593                 if (this.fieldsCount == otherFieldInfosLength) {
594                         int i = 0;
595                         for (; i < this.fieldsCount; i++)
596                                 if (hasStructuralFieldChanges(this.fields[i], otherFieldInfos[i])) break;
597                         if ((compareFields = i != this.fieldsCount) && !orderRequired && !excludesSynthetic)
598                                 return true;
599                 }
600                 if (compareFields) {
601                         if (this.fieldsCount != otherFieldInfosLength && !excludesSynthetic)
602                                 return true;
603                         if (orderRequired) {
604                                 if (this.fieldsCount != 0)
605                                         Arrays.sort(this.fields);
606                                 if (otherFieldInfosLength != 0)
607                                         Arrays.sort(otherFieldInfos);
608                         }
609                         if (excludesSynthetic) {
610                                 if (hasNonSyntheticFieldChanges(this.fields, otherFieldInfos))
611                                         return true;
612                         } else {
613                                 for (int i = 0; i < this.fieldsCount; i++)
614                                         if (hasStructuralFieldChanges(this.fields[i], otherFieldInfos[i]))
615                                                 return true;
616                         }
617                 }
618                 
619                 // methods
620                 MethodInfo[] otherMethodInfos = (MethodInfo[]) newClassFile.getMethods();
621                 int otherMethodInfosLength = otherMethodInfos == null ? 0 : otherMethodInfos.length;
622                 boolean compareMethods = true;
623                 if (this.methodsCount == otherMethodInfosLength) {
624                         int i = 0;
625                         for (; i < this.methodsCount; i++)
626                                 if (hasStructuralMethodChanges(this.methods[i], otherMethodInfos[i])) break;
627                         if ((compareMethods = i != this.methodsCount) && !orderRequired && !excludesSynthetic)
628                                 return true;
629                 }
630                 if (compareMethods) {
631                         if (this.methodsCount != otherMethodInfosLength && !excludesSynthetic)
632                                 return true;
633                         if (orderRequired) {
634                                 if (this.methodsCount != 0)
635                                         Arrays.sort(this.methods);
636                                 if (otherMethodInfosLength != 0)
637                                         Arrays.sort(otherMethodInfos);  
638                         }
639                         if (excludesSynthetic) {
640                                 if (hasNonSyntheticMethodChanges(this.methods, otherMethodInfos))
641                                         return true;
642                         } else {
643                                 for (int i = 0; i < this.methodsCount; i++)
644                                         if (hasStructuralMethodChanges(this.methods[i], otherMethodInfos[i]))
645                                                 return true;
646                         }
647                 }
648
649                 return false;
650         } catch (ClassFormatException e) {
651                 return true;
652         }
653 }
654 private boolean hasNonSyntheticFieldChanges(FieldInfo[] currentFieldInfos, FieldInfo[] otherFieldInfos) {
655         int length1 = currentFieldInfos == null ? 0 : currentFieldInfos.length;
656         int length2 = otherFieldInfos == null ? 0 : otherFieldInfos.length;
657         int index1 = 0;
658         int index2 = 0;
659
660         end : while (index1 < length1 && index2 < length2) {
661                 while (currentFieldInfos[index1].isSynthetic()) {
662                         if (++index1 >= length1) break end;
663                 }
664                 while (otherFieldInfos[index2].isSynthetic()) {
665                         if (++index2 >= length2) break end;
666                 }
667                 if (hasStructuralFieldChanges(currentFieldInfos[index1++], otherFieldInfos[index2++]))
668                         return true;
669         }
670
671         while (index1 < length1) {
672                 if (!currentFieldInfos[index1++].isSynthetic()) return true;
673         }
674         while (index2 < length2) {
675                 if (!otherFieldInfos[index2++].isSynthetic()) return true;
676         }
677         return false;
678 }
679 private boolean hasStructuralFieldChanges(FieldInfo currentFieldInfo, FieldInfo otherFieldInfo) {
680         if (currentFieldInfo.getModifiers() != otherFieldInfo.getModifiers())
681                 return true;
682         if (!CharOperation.equals(currentFieldInfo.getName(), otherFieldInfo.getName()))
683                 return true;
684         if (!CharOperation.equals(currentFieldInfo.getTypeName(), otherFieldInfo.getTypeName()))
685                 return true;
686         if (currentFieldInfo.hasConstant() != otherFieldInfo.hasConstant())
687                 return true;
688         if (currentFieldInfo.hasConstant()) {
689                 Constant currentConstant = currentFieldInfo.getConstant();
690                 Constant otherConstant = otherFieldInfo.getConstant();
691                 if (currentConstant.typeID() != otherConstant.typeID())
692                         return true;
693                 if (!currentConstant.getClass().equals(otherConstant.getClass()))
694                         return true;
695                 switch (currentConstant.typeID()) {
696                         case TypeIds.T_int :
697                                 return currentConstant.intValue() != otherConstant.intValue();
698                         case TypeIds.T_byte :
699                                 return currentConstant.byteValue() != otherConstant.byteValue();
700                         case TypeIds.T_short :
701                                 return currentConstant.shortValue() != otherConstant.shortValue();
702                         case TypeIds.T_char :
703                                 return currentConstant.charValue() != otherConstant.charValue();
704                         case TypeIds.T_float :
705                                 return currentConstant.floatValue() != otherConstant.floatValue();
706                         case TypeIds.T_double :
707                                 return currentConstant.doubleValue() != otherConstant.doubleValue();
708                         case TypeIds.T_boolean :
709                                 return currentConstant.booleanValue() != otherConstant.booleanValue();
710                         case TypeIds.T_String :
711                                 return !currentConstant.stringValue().equals(otherConstant.stringValue());
712                         case TypeIds.T_null :
713                                 return otherConstant != NullConstant.Default;
714                 }
715         }
716         return false;
717 }
718 private boolean hasNonSyntheticMethodChanges(MethodInfo[] currentMethodInfos, MethodInfo[] otherMethodInfos) {
719         int length1 = currentMethodInfos == null ? 0 : currentMethodInfos.length;
720         int length2 = otherMethodInfos == null ? 0 : otherMethodInfos.length;
721         int index1 = 0;
722         int index2 = 0;
723
724         MethodInfo m;
725         end : while (index1 < length1 && index2 < length2) {
726                 while ((m = currentMethodInfos[index1]).isSynthetic() || m.isClinit()) {
727                         if (++index1 >= length1) break end;
728                 }
729                 while ((m = otherMethodInfos[index2]).isSynthetic() || m.isClinit()) {
730                         if (++index2 >= length2) break end;
731                 }
732                 if (hasStructuralMethodChanges(currentMethodInfos[index1++], otherMethodInfos[index2++]))
733                         return true;
734         }
735
736         while (index1 < length1) {
737                 if (!((m = currentMethodInfos[index1++]).isSynthetic() || m.isClinit())) return true;
738         }
739         while (index2 < length2) {
740                 if (!((m = otherMethodInfos[index2++]).isSynthetic() || m.isClinit())) return true;
741         }
742         return false;
743 }
744 private boolean hasStructuralMethodChanges(MethodInfo currentMethodInfo, MethodInfo otherMethodInfo) {
745         if (currentMethodInfo.getModifiers() != otherMethodInfo.getModifiers())
746                 return true;
747         if (!CharOperation.equals(currentMethodInfo.getSelector(), otherMethodInfo.getSelector()))
748                 return true;
749         if (!CharOperation.equals(currentMethodInfo.getMethodDescriptor(), otherMethodInfo.getMethodDescriptor()))
750                 return true;
751
752         char[][] currentThrownExceptions = currentMethodInfo.getExceptionTypeNames();
753         char[][] otherThrownExceptions = otherMethodInfo.getExceptionTypeNames();
754         if (currentThrownExceptions != otherThrownExceptions) { // TypeConstants.NoExceptions
755                 int currentThrownExceptionsLength = currentThrownExceptions == null ? 0 : currentThrownExceptions.length;
756                 int otherThrownExceptionsLength = otherThrownExceptions == null ? 0 : otherThrownExceptions.length;
757                 if (currentThrownExceptionsLength != otherThrownExceptionsLength)
758                         return true;
759                 for (int k = 0; k < currentThrownExceptionsLength; k++)
760                         if (!CharOperation.equals(currentThrownExceptions[k], otherThrownExceptions[k]))
761                                 return true;
762         }
763         return false;
764 }
765 /**
766  * This method is used to fully initialize the contents of the receiver. All methodinfos, fields infos
767  * will be therefore fully initialized and we can get rid of the bytes.
768  */
769 private void initialize() {
770         for (int i = 0, max = fieldsCount; i < max; i++) {
771                 fields[i].initialize();
772         }
773         for (int i = 0, max = methodsCount; i < max; i++) {
774                 methods[i].initialize();
775         }
776         if (innerInfos != null) {
777                 for (int i = 0, max = innerInfos.length; i < max; i++) {
778                         innerInfos[i].initialize();
779                 }
780         }
781         this.reset();
782 }
783 protected void reset() {
784         this.constantPoolOffsets = null;
785         super.reset();
786 }
787
788 }