Package org.eclipse.jdt.internal.compiler.classfmt

Examples of org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader


  if (this.sourceFileName != null) return this.sourceFileName;

  this.sourceFileName = NO_SOURCE_FILE_NAME;
  if (this.openable.getSourceMapper() != null) {
    BinaryType type = (BinaryType) ((ClassFile) this.openable).getType();
    ClassFileReader reader = MatchLocator.classFileReader(type);
    if (reader != null) {
      String fileName = type.sourceFileName(reader);
      this.sourceFileName = fileName == null ? NO_SOURCE_FILE_NAME : fileName;
    }
  }
View Full Code Here


      }
    }
  } else {
    byte[] contents = Util.getResourceContentsAsByteArray(file);
    try {
      return new ClassFileReader(contents, file.getFullPath().toString().toCharArray(), fullyInitialize);
    } catch (ClassFormatException cfe) {
      //the structure remains unknown
      return null;
    }
  }
View Full Code Here

    String entryName = Util.concatWith(pkg.names, getElementName(), '/');
    ZipEntry ze = zip.getEntry(entryName);
    if (ze != null) {
      byte contents[] = org.eclipse.jdt.internal.compiler.util.Util.getZipEntryByteContent(ze, zip);
      String fileName = root.getHandleIdentifier() + IDependent.JAR_FILE_ENTRY_SEPARATOR + entryName;
      return new ClassFileReader(contents, fileName.toCharArray(), fullyInitialize);
    }
  } finally {
    JavaModelManager.getJavaModelManager().closeZipFile(zip);
  }
  return null;
View Full Code Here

      final byte[] contents = this.document.getByteContents();
      // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=107124
      // contents can potentially be null if a IOException occurs while retrieving the contents
      if (contents == null) return;
      final String path = this.document.getPath();
      ClassFileReader reader = new ClassFileReader(contents, path == null ? null : path.toCharArray());

      // first add type references
      char[] className = replace('/', '.', reader.getName()); // looks like java/lang/String
      // need to extract the package name and the simple name
      int packageNameIndex = CharOperation.lastIndexOf('.', className);
      char[] packageName = null;
      char[] name = null;
      if (packageNameIndex >= 0) {
        packageName = CharOperation.subarray(className, 0, packageNameIndex);
        name = CharOperation.subarray(className, packageNameIndex + 1, className.length);
      } else {
        packageName = CharOperation.NO_CHAR;
        name = className;
      }
      char[] enclosingTypeName = null;
      boolean isNestedType = reader.isNestedType();
      if (isNestedType) {
        if (reader.isAnonymous()) {
          name = CharOperation.NO_CHAR;
        } else {
          name = reader.getInnerSourceName();
        }
        if (reader.isLocal() || reader.isAnonymous()) {
          // set specific ['0'] value for local and anonymous to be able to filter them
          enclosingTypeName = ONE_ZERO;
        } else {
          char[] fullEnclosingName = reader.getEnclosingTypeName();
          int nameLength = fullEnclosingName.length - packageNameIndex - 1;
          if (nameLength <= 0) {
            // See PR 1GIR345: ITPJCORE:ALL - Indexer: NegativeArraySizeException
            return;
          }
          enclosingTypeName = new char[nameLength];
          System.arraycopy(fullEnclosingName, packageNameIndex + 1, enclosingTypeName, 0, nameLength);
        }
      }
      // type parameters
      char[][] typeParameterSignatures = null;
      char[] genericSignature = reader.getGenericSignature();
      if (genericSignature != null) {
        CharOperation.replace(genericSignature, '/', '.');
        typeParameterSignatures = Signature.getTypeParameters(genericSignature);
      }

      // eliminate invalid innerclasses (1G4KCF7)
      if (name == null) return;

      char[][] superinterfaces = replace('/', '.', reader.getInterfaceNames());
      char[][] enclosingTypeNames = enclosingTypeName == null ? null : new char[][] {enclosingTypeName};
      int modifiers = reader.getModifiers();
      switch (TypeDeclaration.kind(modifiers)) {
        case TypeDeclaration.CLASS_DECL :
          char[] superclass = replace('/', '.', reader.getSuperclassName());
          addClassDeclaration(modifiers, packageName, name, enclosingTypeNames, superclass, superinterfaces, typeParameterSignatures, false);
          break;
        case TypeDeclaration.INTERFACE_DECL :
          addInterfaceDeclaration(modifiers, packageName, name, enclosingTypeNames, superinterfaces, typeParameterSignatures, false);
          break;
        case TypeDeclaration.ENUM_DECL :
          superclass = replace('/', '.', reader.getSuperclassName());
          addEnumDeclaration(modifiers, packageName, name, enclosingTypeNames, superclass, superinterfaces, false);
          break;
        case TypeDeclaration.ANNOTATION_TYPE_DECL :
          addAnnotationTypeDeclaration(modifiers, packageName, name, enclosingTypeNames, false);
          break;
      }

      // Look for references in class annotations
      IBinaryAnnotation[] annotations = reader.getAnnotations();
      if (annotations != null) {
        for (int a=0, length=annotations.length; a<length; a++) {
          IBinaryAnnotation annotation = annotations[a];
          addBinaryAnnotation(annotation);
        }
      }
      long tagBits = reader.getTagBits() & TagBits.AllStandardAnnotationsMask;
      if (tagBits != 0) {
        addBinaryStandardAnnotations(tagBits);
      }
     
      int extraFlags = ExtraFlags.getExtraFlags(reader);

      // first reference all methods declarations and field declarations
      MethodInfo[] methods = (MethodInfo[]) reader.getMethods();
      boolean noConstructor = true;
      if (methods != null) {
        for (int i = 0, max = methods.length; i < max; i++) {
          MethodInfo method = methods[i];
          boolean isConstructor = method.isConstructor();
          char[] descriptor = method.getMethodDescriptor();
          char[][] parameterTypes = decodeParameterTypes(descriptor, isConstructor && isNestedType);
          char[] returnType = decodeReturnType(descriptor);
          char[][] exceptionTypes = replace('/', '.', method.getExceptionTypeNames());
          if (isConstructor) {
            noConstructor = false;
            char[] signature = method.getGenericSignature();
            if (signature == null) {
              if (reader.isNestedType() && ((modifiers & ClassFileConstants.AccStatic) == 0)) {
                signature = removeFirstSyntheticParameter(descriptor);
              } else {
                signature = descriptor;
              }
            }
            addConstructorDeclaration(
                name,
                parameterTypes == null ? 0 : parameterTypes.length,
                signature, 
                parameterTypes,
                method.getArgumentNames(),
                method.getModifiers(),
                packageName,
                modifiers,
                exceptionTypes,
                extraFlags);
          } else {
            if (!method.isClinit()) {
              addMethodDeclaration(method.getSelector(), parameterTypes, returnType, exceptionTypes);
            }
          }
          // look for references in method annotations
          annotations = method.getAnnotations();
          if (annotations != null) {
            for (int a=0, length=annotations.length; a<length; a++) {
              IBinaryAnnotation annotation = annotations[a];
              addBinaryAnnotation(annotation);
            }
          }
          tagBits = method.getTagBits() & TagBits.AllStandardAnnotationsMask;
          if (tagBits != 0) {
            addBinaryStandardAnnotations(tagBits);
          }
        }
      }
      if (noConstructor) {
        addDefaultConstructorDeclaration(className, packageName, modifiers, extraFlags);
      }
      FieldInfo[] fields = (FieldInfo[]) reader.getFields();
      if (fields != null) {
        for (int i = 0, max = fields.length; i < max; i++) {
          FieldInfo field = fields[i];
          char[] fieldName = field.getName();
          char[] fieldType = decodeFieldType(replace('/', '.', field.getTypeName()));
View Full Code Here

   * </ul>
   * Returns the jdk level
   */
  public static long getJdkLevel(Object targetLibrary) {
    try {
      ClassFileReader reader = null;
      if (targetLibrary instanceof IFolder) {
        IFile classFile = findFirstClassFile((IFolder) targetLibrary); // only internal classfolders are allowed
        if (classFile != null)
          reader = Util.newClassFileReader(classFile);
      } else {
        // root is a jar file or a zip file
        ZipFile jar = null;
        try {
          IPath path = null;
          if (targetLibrary instanceof IResource) {
            path = ((IResource)targetLibrary).getFullPath();
          } else if (targetLibrary instanceof File){
            File f = (File) targetLibrary;
            if (!f.isDirectory()) {
              path = new Path(((File)targetLibrary).getPath());
            }
          }
          if (path != null) {
            jar = JavaModelManager.getJavaModelManager().getZipFile(path);
            for (Enumeration e= jar.entries(); e.hasMoreElements();) {
              ZipEntry member= (ZipEntry) e.nextElement();
              String entryName= member.getName();
              if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(entryName)) {
                reader = ClassFileReader.read(jar, entryName);
                break;
              }
            }
          }
        } catch (CoreException e) {
          // ignore
        } finally {
          JavaModelManager.getJavaModelManager().closeZipFile(jar);
        }
      }
      if (reader != null) {
        return reader.getVersion();
      }
    } catch (CoreException e) {
      // ignore
    } catch(ClassFormatException e) {
      // ignore
View Full Code Here

               
                final byte[] clazzBytes = pStore.read( resourceName );
                if (clazzBytes != null) {
                    final char[] fileName = pClazzName.toCharArray();
                    try {
                        final ClassFileReader classFileReader = new ClassFileReader(clazzBytes, fileName, true);
                        return new NameEnvironmentAnswer(classFileReader, null);
                    } catch (final ClassFormatException e) {
                        throw new RuntimeException( "ClassFormatException in loading class '" + fileName + "' with JCI." );
                    }
                }
               
                InputStream is = null;
                ByteArrayOutputStream baos = null;
                try {
                    is = pClassLoader.getResourceAsStream(resourceName);
                    if (is == null) {
                        return null;
                    }
   
                    final byte[] buffer = new byte[8192];
                    baos = new ByteArrayOutputStream(buffer.length);
                    int count;
                        while ((count = is.read(buffer, 0, buffer.length)) > 0) {
                            baos.write(buffer, 0, count);
                        }
                        baos.flush();
                        final char[] fileName = pClazzName.toCharArray();
                        final ClassFileReader classFileReader = new ClassFileReader(baos.toByteArray(), fileName, true);
                        return new NameEnvironmentAnswer(classFileReader, null);
                } catch ( final IOException e ) {
                    throw new RuntimeException( "could not read class",
                                                e );
                } catch ( final ClassFormatException e ) {
View Full Code Here

                }
                bos.write(b, 0, n);
            }
            byte[] classBytes = bos.toByteArray();
           
            ClassFileReader classFileReader = new ClassFileReader(classBytes, className.toCharArray(), true);
            return new NameEnvironmentAnswer(classFileReader, null);
           
        } catch (IOException e) {
            throw new IllegalArgumentException(e);
        } catch (ClassFormatException e) {
View Full Code Here

                }
            }

            private NameEnvironmentAnswer createNameEnvironmentAnswer(final String pClazzName, final byte[] clazzBytes) throws ClassFormatException {               
                final char[] fileName = pClazzName.toCharArray();
                final ClassFileReader classFileReader = new ClassFileReader(clazzBytes, fileName, true);
                return new NameEnvironmentAnswer(classFileReader, null);
            }

            private boolean isSourceAvailable(final String pClazzName, final ResourceReader pReader) {
                // FIXME: this should not be tied to the extension
View Full Code Here

                try {
                    if (!name.startsWith("japidviews.")) {
                      // let super class loader to load the bytecode
                        byte[] bytes = crlr.getClassDefinition(name);
                        if (bytes != null) {
                            ClassFileReader classFileReader = new ClassFileReader(bytes, name.toCharArray(), true);
                            return new NameEnvironmentAnswer(classFileReader, null);
                        }
                        return null;
                    }

                    char[] fileName = name.toCharArray();
                    RendererClass applicationClass = classes.get(name);

                    // ApplicationClass exists
                    if (applicationClass != null) {

                        byte[] bytecode = applicationClass.getBytecode();
            if (bytecode != null) {
                            ClassFileReader classFileReader = new ClassFileReader(bytecode, fileName, true);
                            return new NameEnvironmentAnswer(classFileReader, null);
                        }
                        // Cascade compilation
                        ICompilationUnit compilationUnit = new CompilationUnit(name);
                        return new NameEnvironmentAnswer(compilationUnit, null);
                    }

                    // So it's a standard class
                    byte[] bytes = crlr.getClassDefinition(name);
                    if (bytes != null) {
                        ClassFileReader classFileReader = new ClassFileReader(bytes, fileName, true);
                        return new NameEnvironmentAnswer(classFileReader, null);
                    }

                    // So it does not exist
                    return null;
View Full Code Here

                                baos.write(buf, 0, count);
                            }
                            baos.flush();
                            classBytes = baos.toByteArray();
                            char[] fileName = className.toCharArray();
                            ClassFileReader classFileReader =
                                new ClassFileReader(classBytes, fileName,
                                                    true);
                            return
                                new NameEnvironmentAnswer(classFileReader, null);
                        }
                    } catch (IOException exc) {
View Full Code Here

TOP

Related Classes of org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.