import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
@Override
public NameEnvironmentAnswer findType(final char[][] compoundTypeName) {
  try {
    final Function1<char[], String> _function = (char[] it) -> {
      return String.valueOf(it);
    };
    String _join = IterableExtensions.join(ListExtensions.<char[], String>map(((List<char[]>)Conversions.doWrapArray(compoundTypeName)), _function), "/");
    final String fileName = (_join + ".class");
    boolean _containsKey = this.cache.containsKey(fileName);
    if (_containsKey) {
      return this.cache.get(fileName);
    }
    final URL url = this.classLoader.getResource(fileName);
    if ((url == null)) {
      this.cache.put(fileName, null);
      return null;
    }
    final ClassFileReader reader = ClassFileReader.read(url.openStream(), fileName);
    final NameEnvironmentAnswer result = new NameEnvironmentAnswer(reader, null);
    this.cache.put(fileName, result);
    return result;
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
public NameEnvironmentAnswer findClass(
    String binaryFileName, String qualifiedPackageName, String qualifiedBinaryFileName) {
  if (!isPackage(qualifiedPackageName)) return null; // most common case

  try {
    ClassFileReader reader = ClassFileReader.read(this.zipFile, qualifiedBinaryFileName);
    if (reader != null) {
      if (this.accessRuleSet == null) return new NameEnvironmentAnswer(reader, null);
      String fileNameWithoutExtension =
          qualifiedBinaryFileName.substring(
              0, qualifiedBinaryFileName.length() - SuffixConstants.SUFFIX_CLASS.length);
      return new NameEnvironmentAnswer(
          reader,
          this.accessRuleSet.getViolatedRestriction(fileNameWithoutExtension.toCharArray()));
    }
  } catch (IOException | ClassFormatException e) { // treat as if class file is missing
  }
  return null;
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
private NameEnvironmentAnswer findType(String className)
{
    if (className.equals(this.className))
    {
        return new NameEnvironmentAnswer(this, null);
    }

    String resourceName = className.replace('.', '/') + ".class";

    try (InputStream is = UDFunction.udfClassLoader.getResourceAsStream(resourceName))
    {
        if (is != null)
        {
            byte[] classBytes = ByteStreams.toByteArray(is);
            char[] fileName = className.toCharArray();
            ClassFileReader classFileReader = new ClassFileReader(classBytes, fileName, true);
            return new NameEnvironmentAnswer(classFileReader, null);
        }
    }
    catch (IOException | ClassFormatException exc)
    {
        throw new RuntimeException(exc);
    }
    return null;
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
private IBinaryType getJarBinaryTypeInfo(PackageFragment pkg, boolean fullyInitialize) throws CoreException, IOException, ClassFormatException {
	JarPackageFragmentRoot root = (JarPackageFragmentRoot) pkg.getParent();
	ZipFile zip = null;
	try {
		zip = root.getJar();
		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;
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
private NameEnvironmentAnswer findType(final String name) {
    try {
        byte[] bytecode = classpath.get(name.replace(".", "/") + ".class");
        String source = files.get(name.replace(".", "/") + ".java");
        if (bytecode != null) {
            char[] fileName = name.toCharArray();
            ClassFileReader classFileReader = new ClassFileReader(bytecode, fileName, true);
            return new NameEnvironmentAnswer(classFileReader, null);
        } else if (source != null) {
            ICompilationUnit compilationUnit = new CompilationUnit(source.toCharArray(), name, "UTF-8");
            return new NameEnvironmentAnswer(compilationUnit, null);
        }
        return null;
    } catch (ClassFormatException e) {
        // Something very very bad
        throw new ProjectCompilerException("compiler error", e);
    }
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
Map<String, String> gleanNamedType(File classfile) throws IOException {
  // use jdt class reader to avoid extra runtime dependency, otherwise could use asm

  try {
    ClassFileReader type = ClassFileReader.read(classfile);
    IBinaryAnnotation[] annotations = type.getAnnotations();
    if (annotations != null) {
      for (IBinaryAnnotation annotation : annotations) {
        if ("Ljavax/inject/Named;".equals(new String(annotation.getTypeName()))) {
          return Collections.singletonMap(new String(type.getName()).replace('/', '.'), null);
        }
      }
    }
  } catch (ClassFormatException e) {
    // silently ignore classes we can't read/parse
  }

  return null;
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
private NameEnvironmentAnswer findType(String className) {
    if (className.equals(source.getQualifiedClassName())) {
        return new NameEnvironmentAnswer(new CompilationUnit(source), null);
    }

    InputStream is = null;
    try {
        String resourceName = className.replace('.', '/') + ".class";
        is = classLoader.getResourceAsStream(resourceName);
        if (is != null) {
            byte[] bytes = IoUtils.toByteArray(is);
            char[] fileName = resourceName.toCharArray();
            ClassFileReader classFileReader = new ClassFileReader(bytes, fileName, true);
            return new NameEnvironmentAnswer(classFileReader, null);
        }
    } catch (org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException e) {
        log.error("Compilation error", e);
    } finally {
        IoUtils.closeQuietly(is);
    }
    return null;
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
public static ClassFileReader newClassFileReader(IResource resource)
    throws CoreException, ClassFormatException, IOException {
  InputStream in = null;
  try {
    in = ((IFile) resource).getContents(true);
    return ClassFileReader.read(in, resource.getFullPath().toString());
  } finally {
    if (in != null) in.close();
  }
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
public static NameEnvironmentAnswer getClassFileReader(ClassFileReader classFileReader) throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
	return new NameEnvironmentAnswer(classFileReader, null);
	// if (constrNameEnvAnsBin2Args != null)
	// return constrNameEnvAnsBin2Args.newInstance(new Object[] {
	// classFileReader, null });
	// return constrNameEnvAnsBin.newInstance(new Object[] { classFileReader });
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
IMethod createBinaryMethodHandle(IType type, char[] methodSelector, char[][] argumentTypeNames) {
	ClassFileReader reader = MatchLocator.classFileReader(type);
	if (reader != null) {
		IBinaryMethod[] methods = reader.getMethods();
		if (methods != null) {
			int argCount = argumentTypeNames == null ? 0 : argumentTypeNames.length;
			nextMethod : for (int i = 0, methodsLength = methods.length; i < methodsLength; i++) {
				IBinaryMethod binaryMethod = methods[i];
				char[] selector = binaryMethod.isConstructor() ? type.getElementName().toCharArray() : binaryMethod.getSelector();
				if (CharOperation.equals(selector, methodSelector)) {
					char[] signature = binaryMethod.getGenericSignature();
					if (signature == null) signature = binaryMethod.getMethodDescriptor();
					char[][] parameterTypes = Signature.getParameterTypes(signature);
					if (argCount != parameterTypes.length) continue nextMethod;
					if (argumentTypeNames != null) {
						for (int j = 0; j < argCount; j++) {
							char[] parameterTypeName = ClassFileMatchLocator.convertClassFileFormat(parameterTypes[j]);
							if (!CharOperation.endsWith(Signature.toCharArray(Signature.getTypeErasure(parameterTypeName)), CharOperation.replaceOnCopy(argumentTypeNames[j], '$', '.')))
								continue nextMethod;
							parameterTypes[j] = parameterTypeName;
						}
					}
					return (IMethod) createMethodHandle(type, new String(selector), CharOperation.toStrings(parameterTypes));
				}
			}
		}
	}
	return null;
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
private String getSourceFileName() {
	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;
		}
	}
	return this.sourceFileName;
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
public ImportReference[] buildImports(ClassFileReader reader) {
	// add remaining references to the list of type names
	// (code extracted from BinaryIndexer#extractReferenceFromConstantPool(...))
	int[] constantPoolOffsets = reader.getConstantPoolOffsets();
	int constantPoolCount = constantPoolOffsets.length;
	for (int i = 0; i < constantPoolCount; i++) {
		int tag = reader.u1At(constantPoolOffsets[i]);
		char[] name = null;
		switch (tag) {
			case ClassFileConstants.MethodRefTag :
			case ClassFileConstants.InterfaceMethodRefTag :
				int constantPoolIndex = reader.u2At(constantPoolOffsets[i] + 3);
				int utf8Offset = constantPoolOffsets[reader.u2At(constantPoolOffsets[constantPoolIndex] + 3)];
				name = reader.utf8At(utf8Offset + 3, reader.u2At(utf8Offset + 1));
				break;
			case ClassFileConstants.ClassTag :
				utf8Offset = constantPoolOffsets[reader.u2At(constantPoolOffsets[i] + 1)];
				name = reader.utf8At(utf8Offset + 3, reader.u2At(utf8Offset + 1));
				break;
		}
		if (name == null || (name.length > 0 && name[0] == '['))
			break; // skip over array references
		this.typeNames.add(CharOperation.splitOn('/', name));
	}

	// convert type names into import references
	int typeNamesLength = this.typeNames.size();
	ImportReference[] imports = new ImportReference[typeNamesLength];
	char[][][] set = this.typeNames.set;
	int index = 0;
	for (int i = 0, length = set.length; i < length; i++) {
		char[][] typeName = set[i];
		if (typeName != null) {
			imports[index++] = new ImportReference(typeName, new long[typeName.length]/*dummy positions*/, false/*not on demand*/, 0);
		}
	}
	return imports;
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
public static ClassFileReader newClassFileReader(IResource resource) throws CoreException, ClassFormatException, IOException {
	InputStream in = null;
	try {
		in = ((IFile) resource).getContents(true);
		return ClassFileReader.read(in, resource.getFullPath().toString());
	} finally {
		if (in != null)
			in.close();
	}
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
public static int getExtraFlags(ClassFileReader reader) {
	int extraFlags = 0;
	
	if (reader.isNestedType()) {
		extraFlags |= ExtraFlags.IsMemberType;
	}
	
	if (reader.isLocal()) {
		extraFlags |= ExtraFlags.IsLocalType;
	}
	
	IBinaryNestedType[] memberTypes = reader.getMemberTypes();
	int memberTypeCounter = memberTypes == null ? 0 : memberTypes.length;
	if (memberTypeCounter > 0) {
		done : for (int i = 0; i < memberTypeCounter; i++) {
			int modifiers = memberTypes[i].getModifiers();
			// if the member type is static and not private
			if ((modifiers & ClassFileConstants.AccStatic) != 0 && (modifiers & ClassFileConstants.AccPrivate) == 0) {
				extraFlags |= ExtraFlags.HasNonPrivateStaticMemberTypes;
				break done;
			}
		}
		
	}
	
	return extraFlags;
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
private NameEnvironmentAnswer findType(String type) {
    try {
        byte[] bytes;
        Source source;
        if (Act.isDev()) {
            source = classLoader.source(type);
            if (null != source) {
                return new NameEnvironmentAnswer(source.compilationUnit(), null);
            }
        }
        bytes = classLoader.enhancedBytecode(type);
        if (bytes != null) {
            ClassFileReader classFileReader = new ClassFileReader(bytes, type.toCharArray(), true);
            return new NameEnvironmentAnswer(classFileReader, null);
        } else {
            if (type.startsWith("org.osgl") || type.startsWith("java.") || type.startsWith("javax.")) {
                return null;
            }
        }
        if (Act.isDev()) {
            return null;
        }
        source = classLoader.source(type);
        if (null == source) {
            return null;
        } else {
            return new NameEnvironmentAnswer(source.compilationUnit(), null);
        }
    } catch (ClassFormatException e) {
        throw E.unexpected(e);
    }
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
private byte[] digestClassFile(File outputFile, byte[] definition) {
  try {
    ClassFileReader reader = new ClassFileReader(definition, outputFile.getAbsolutePath().toCharArray());
    return digester.digest(reader);
  } catch (ClassFormatException e) {
    // ignore this class
  }
  return null;
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
@Override
public NameEnvironmentAnswer findType(String packageName, String typeName, AccessRestriction accessRestriction) {
  try {
    String qualifiedFileName = packageName + "/" + typeName + SUFFIX_STRING_class;
    ClassFileReader reader = ClassFileReader.read(this.zipFile, qualifiedFileName);
    if (reader != null) {
      return new NameEnvironmentAnswer(reader, accessRestriction);
    }
  } catch (ClassFormatException | IOException e) {
    // treat as if class file is missing
  }
  return null;
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
@Override
public NameEnvironmentAnswer findType(String packageName, String typeName, AccessRestriction accessRestriction) {
  try {
    Path classFile = getFile(packageName, typeName);
    if (classFile != null) {
      try (InputStream is = Files.newInputStream(classFile)) {
        return new NameEnvironmentAnswer(ClassFileReader.read(is, classFile.getFileName().toString(), false), accessRestriction);
      }
    }
  } catch (ClassFormatException | IOException e) {
    // treat as if type is missing
  }
  return null;
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
protected NameEnvironmentAnswer createFindTypeAnswer(String className, byte[] classBytes) {
	final char[] fileName = className.toCharArray();
	try {
		final ClassFileReader classFileReader = new ClassFileReader(classBytes, fileName, true);
		return new NameEnvironmentAnswer(classFileReader, null);
	} catch (final ClassFormatException e) {
		// Wrong class format
		return null;
	}
}
 

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader; //导入依赖的package包/类
public NameEnvironmentAnswer findType(final QualifiedName className) {
  try {
    boolean _containsKey = this.cache.containsKey(className);
    if (_containsKey) {
      return this.cache.get(className);
    }
    final IEObjectDescription candidate = IterableExtensions.<IEObjectDescription>head(this.resourceDescriptions.getExportedObjects(TypesPackage.Literals.JVM_DECLARED_TYPE, className, false));
    NameEnvironmentAnswer result = null;
    if ((candidate != null)) {
      final IResourceDescription resourceDescription = this.resourceDescriptions.getResourceDescription(candidate.getEObjectURI().trimFragment());
      final Resource res = this.resource.getResourceSet().getResource(resourceDescription.getURI(), false);
      String _xifexpression = null;
      if ((res instanceof JavaResource)) {
        _xifexpression = ((JavaResource) res).getOriginalSource();
      } else {
        _xifexpression = this.stubGenerator.getJavaStubSource(candidate, resourceDescription);
      }
      final String source = _xifexpression;
      char[] _charArray = source.toCharArray();
      String _string = className.toString("/");
      String _plus = (_string + ".java");
      CompilationUnit _compilationUnit = new CompilationUnit(_charArray, _plus, null);
      NameEnvironmentAnswer _nameEnvironmentAnswer = new NameEnvironmentAnswer(_compilationUnit, null);
      result = _nameEnvironmentAnswer;
    } else {
      String _string_1 = className.toString("/");
      final String fileName = (_string_1 + ".class");
      final URL url = this.classLoader.getResource(fileName);
      if ((url == null)) {
        this.cache.put(className, null);
        return null;
      }
      final ClassFileReader reader = ClassFileReader.read(url.openStream(), fileName);
      NameEnvironmentAnswer _nameEnvironmentAnswer_1 = new NameEnvironmentAnswer(reader, null);
      result = _nameEnvironmentAnswer_1;
    }
    this.cache.put(className, result);
    return result;
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}