import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
public void closeFile() {
	for (OpenFile co : hmap) {
		int pos = house.indexOfTab(co.name);
		if (pos >= 0)
			house.remove(pos);
		co.close();
	}

	final State oldState = state;
	Model.this.state = null;
	if (oldState != null) {
		Closer.tryClose(oldState);
	}

	hmap.clear();
	tree.setModel(new DefaultTreeModel(null));
	metadataSystem = new MetadataSystem(typeLoader);
	file = null;
	treeExpansionState = null;
	open = false;
	mainWindow.onFileLoadEnded(file, open);
}
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
MetadataSystem createMetadataSystem() {
    return new MetadataSystem(loader) {
        Set<String> loadedTypes = new HashSet<>();
        
        @Override
        protected TypeDefinition resolveType(String descriptor, boolean mightBePrimitive) {
            if(missingClasses.contains(descriptor)) {
                return null;
            }
            try {
                if(loadedTypes.add(descriptor))
                    incStat("ClassLoadingEfficiency.Total");
                if(classes.add(descriptor))
                    incStat("ClassLoadingEfficiency");
                return super.resolveType(descriptor, mightBePrimitive);
            } catch (Throwable t) {
                addError(new ErrorMessage(null, descriptor, null, null, -1, t));
                missingClasses.add(descriptor);
                return null;
            }
        }
    };
}
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
private void doSaveClassDecompiled(File inFile, File outFile) throws Exception {
	DecompilerSettings settings = cloneSettings();
	LuytenTypeLoader typeLoader = new LuytenTypeLoader();
	MetadataSystem metadataSystem = new MetadataSystem(typeLoader);
	TypeReference type = metadataSystem.lookupType(inFile.getCanonicalPath());

	DecompilationOptions decompilationOptions = new DecompilationOptions();
	decompilationOptions.setSettings(settings);
	decompilationOptions.setFullDecompilation(true);

	boolean isUnicodeEnabled = decompilationOptions.getSettings().isUnicodeOutputEnabled();
	TypeDefinition resolvedType = null;
	if (type == null || ((resolvedType = type.resolve()) == null)) {
		throw new Exception("Unable to resolve type.");
	}
	StringWriter stringwriter = new StringWriter();
	PlainTextOutput plainTextOutput = new PlainTextOutput(stringwriter);
	plainTextOutput.setUnicodeOutputEnabled(isUnicodeEnabled);
	settings.getLanguage().decompileType(resolvedType, plainTextOutput, decompilationOptions);
	String decompiledSource = stringwriter.toString();

	System.out.println("[SaveAll]: " + inFile.getName() + " -> " + outFile.getName());
	try (FileOutputStream fos = new FileOutputStream(outFile);
			OutputStreamWriter writer = isUnicodeEnabled ? new OutputStreamWriter(fos, "UTF-8")
					: new OutputStreamWriter(fos);
			BufferedWriter bw = new BufferedWriter(writer);) {
		bw.write(decompiledSource);
		bw.flush();
	}
}
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
private TypeDefinition lookUp(MetadataSystem ms, String className) {
    TypeReference tr = ms.lookupType(className);
    if(tr == null) {
        missingClasses.add(className);
        return null;
    }
    return ms.resolve(tr);
}
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
private void analyzingClasses(Set<String> classes) {
    MetadataSystem ms = createMetadataSystem();
    classesCount.set(0);
    for (String className : classes) {
        if(classesCount.get() % options.classesPerFlush == 0)
            ms = createMetadataSystem();
        if (!fireEvent("Analyzing classes", className, classesCount.get(), classes.size()))
            return;
        analyzeClass(ms, className);
    }
    if (!fireEvent("Analyzing classes", null, classes.size(), classes.size()))
        return;
}
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
void analyzeClass(MetadataSystem ms, String name) {
    classesCount.incrementAndGet();
    TypeDefinition type;
    try {
        type = lookUp(ms, name);
    } catch (Throwable t) {
        addError(new ErrorMessage(null, name, null, null, -1, t));
        return;
    }
    if (type != null)
        registry.analyzeClass(type);
}
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
@Override
public void visitClass(String className) {
    String name = className.replace('/', '.');
    try {
        ctx.incStat("Detectors.Total");
        if (addDetector(MetadataSystem.class.getClassLoader().loadClass(name))) {
            ctx.incStat("Detectors");
            if (external) {
                ctx.incStat("Detectors from HuntBugs plugins");
            }
        }
    } catch (ClassNotFoundException e) {
        ctx.addError(new ErrorMessage(name, null, null, null, -1, e));
    }
}
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
/**
 * Decompiles the given .class file and creates the specified output source file.
 *
 * @param classFilePath the .class file to be decompiled.
 * @param outputDir The directory where decompiled .java files will be placed.
 */
@Override
public DecompilationResult decompileClassFile(Path rootDir, Path classFilePath, Path outputDir)
            throws DecompilationException
{
    Checks.checkDirectoryToBeRead(rootDir.toFile(), "Classes root dir");
    File classFile = classFilePath.toFile();
    Checks.checkFileToBeRead(classFile, "Class file");
    Checks.checkDirectoryToBeFilled(outputDir.toFile(), "Output directory");

    log.info("Decompiling .class '" + classFilePath + "' to '" + outputDir + "' from: '" + rootDir + "'");

    String name = classFilePath.normalize().toAbsolutePath().toString().substring(rootDir.toAbsolutePath().toString().length() + 1);
    final String typeName = StringUtils.removeEnd(name, ".class");// .replace('/', '.');

    DecompilationResult result = new DecompilationResult();
    try
    {
        DecompilerSettings settings = getDefaultSettings(outputDir.toFile());
        this.procyonConf.setDecompilerSettings(settings); // TODO: This is horrible mess.

        ITypeLoader typeLoader = new CompositeTypeLoader(new ClasspathTypeLoader(rootDir.toString()), new ClasspathTypeLoader());
        MetadataSystem metadataSystem = new MetadataSystem(typeLoader);
        File outputFile = this.decompileType(settings, metadataSystem, typeName);
        result.addDecompiled(Collections.singletonList(classFilePath.toString()), outputFile.getAbsolutePath());
    }
    catch (Throwable e)
    {
        DecompilationFailure failure = new DecompilationFailure("Error during decompilation of "
                    + classFilePath.toString() + ":\n    " + e.getMessage(), Collections.singletonList(name), e);
        log.severe(failure.getMessage());
        result.addFailure(failure);
    }

    return result;
}
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
/**
 * The metadata cache can become huge over time. This simply flushes it periodically.
 */
private void refreshMetadataCache(final Queue<MetadataSystem> metadataSystemCache, final DecompilerSettings settings)
{
    metadataSystemCache.clear();
    for (int i = 0; i < this.getNumberOfThreads(); i++)
    {
        metadataSystemCache.add(new NoRetryMetadataSystem(settings.getTypeLoader()));
    }
}
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
public DecompileExecutor(DecompilerSettings settings, MetadataSystem metadataSystem, String typeName)
{
    this.settings = settings;
    this.metadataSystem = metadataSystem;
    this.typeName = typeName;
    setDaemon(true);
}
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
public void setDecompilerReferences(MetadataSystem metadataSystem, DecompilerSettings settings,
                                    DecompilationOptions decompilationOptions) {
    this.metadataSystem = metadataSystem;
    this.settings = settings;
    this.decompilationOptions = decompilationOptions;
}
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
public CompilationUnit getSourceTree(String className) {
	
	// we don't know if this class name is obfuscated or deobfuscated
	// we need to tell the decompiler the deobfuscated name so it doesn't get freaked out
	// the decompiler only sees classes after deobfuscation, so we need to load it by the deobfuscated name if there is one
	
	// first, assume class name is deobf
	String deobfClassName = className;
	
	// if it wasn't actually deobf, then we can find a mapping for it and get the deobf name
	ClassMapping classMapping = m_mappings.getClassByObf(className);
	if (classMapping != null && classMapping.getDeobfName() != null) {
		deobfClassName = classMapping.getDeobfName();
	}
	
	// set the type loader
	TranslatingTypeLoader loader = new TranslatingTypeLoader(
		m_jar,
		m_jarIndex,
		getTranslator(TranslationDirection.Obfuscating),
		getTranslator(TranslationDirection.Deobfuscating)
	); 
	m_settings.setTypeLoader(loader);

	// see if procyon can find the type
	TypeReference type = new MetadataSystem(loader).lookupType(deobfClassName);
	if (type == null) {
		throw new Error(String.format("Unable to find type: %s (deobf: %s)\nTried class names: %s",
			className, deobfClassName, loader.getClassNamesToTry(deobfClassName)
		));
	}
	TypeDefinition resolvedType = type.resolve();
	
	// decompile it!
	DecompilerContext context = new DecompilerContext();
	context.setCurrentType(resolvedType);
	context.setSettings(m_settings);
	AstBuilder builder = new AstBuilder(context);
	builder.addType(resolvedType);
	builder.runTransformations(null);
	return builder.getCompilationUnit();
}
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
public void setDecompilerReferences(MetadataSystem metadataSystem, DecompilerSettings settings,
		DecompilationOptions decompilationOptions) {
	this.metadataSystem = metadataSystem;
	this.settings = settings;
	this.decompilationOptions = decompilationOptions;
}
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
public CompilationUnit getSourceTree(String className) {

        // we don't know if this class name is obfuscated or deobfuscated
        // we need to tell the decompiler the deobfuscated name so it doesn't get freaked out
        // the decompiler only sees classes after deobfuscation, so we need to load it by the deobfuscated name if there is one

        // first, assume class name is deobf
        String deobfClassName = className;

        // if it wasn't actually deobf, then we can find a mapping for it and get the deobf name
        ClassMapping classMapping = this.mappings.getClassByObf(className);
        if (classMapping != null && classMapping.getDeobfName() != null) {
            deobfClassName = classMapping.getDeobfName();
        }

        // set the type loader
        TranslatingTypeLoader loader = new TranslatingTypeLoader(
                this.jar,
                this.jarIndex,
                getTranslator(TranslationDirection.Obfuscating),
                getTranslator(TranslationDirection.Deobfuscating)
        );
        this.settings.setTypeLoader(loader);

        // see if procyon can find the type
        TypeReference type = new MetadataSystem(loader).lookupType(deobfClassName);
        if (type == null) {
            throw new Error(String.format("Unable to find type: %s (deobf: %s)\nTried class names: %s",
                    className, deobfClassName, loader.getClassNamesToTry(deobfClassName)
            ));
        }
        TypeDefinition resolvedType = type.resolve();

        // decompile it!
        DecompilerContext context = new DecompilerContext();
        context.setCurrentType(resolvedType);
        context.setSettings(this.settings);
        AstBuilder builder = new AstBuilder(context);
        builder.addType(resolvedType);
        builder.runTransformations(null);
        return builder.getCompilationUnit();
    }
 

import com.strobel.assembler.metadata.MetadataSystem; //导入依赖的package包/类
public CompilationUnit getSourceTree(String className)
{
	
	// we don't know if this class name is obfuscated or deobfuscated
	// we need to tell the decompiler the deobfuscated name so it doesn't
	// get freaked out
	// the decompiler only sees classes after deobfuscation, so we need to
	// load it by the deobfuscated name if there is one
	
	// first, assume class name is deobf
	String deobfClassName = className;
	
	// if it wasn't actually deobf, then we can find a mapping for it and
	// get the deobf name
	ClassMapping classMapping = m_mappings.getClassByObf(className);
	if(classMapping != null && classMapping.getDeobfName() != null)
		deobfClassName = classMapping.getDeobfName();
	
	// set the type loader
	TranslatingTypeLoader loader =
		new TranslatingTypeLoader(m_jar, m_jarIndex,
			getTranslator(TranslationDirection.Obfuscating),
			getTranslator(TranslationDirection.Deobfuscating));
	m_settings.setTypeLoader(loader);
	
	// see if procyon can find the type
	TypeReference type =
		new MetadataSystem(loader).lookupType(deobfClassName);
	if(type == null)
		throw new Error(String.format(
			"Unable to find type: %s (deobf: %s)\nTried class names: %s",
			className, deobfClassName,
			loader.getClassNamesToTry(deobfClassName)));
	TypeDefinition resolvedType = type.resolve();
	
	// decompile it!
	DecompilerContext context = new DecompilerContext();
	context.setCurrentType(resolvedType);
	context.setSettings(m_settings);
	AstBuilder builder = new AstBuilder(context);
	builder.addType(resolvedType);
	builder.runTransformations(null);
	return builder.getCompilationUnit();
}