Java 类net.minecraftforge.fml.common.asm.transformers.deobf.FMLDeobfuscatingRemapper 实例源码

private Accessor<ObjectType,FieldType> getDeobfuscated(ObjectType objectType) {
    Class objectClass = objectType.getClass();
    Set<String> obfedClasses = FMLDeobfuscatingRemapper.INSTANCE.getObfedClasses();
    for (String readableName: obfedClasses) {
        String obfedName = FMLDeobfuscatingRemapper.INSTANCE.map(readableName);
        logger.info(readableName+" to "+obfedName);
        remapper = FMLDeobfuscatingRemapper.INSTANCE;
        Map<String,String> fieldMap = this.fieldAccessor.get(remapper).get(readableName);
        if (fieldMap== null) continue;
        for (String key: fieldMap.keySet()) {
            logger.info("     "+key + " " + fieldMap.get(key));
        }
    }

    while ((objectClass != null)&&(objectClass != Object.class)) {
        String deobfuscatedClassName = FMLDeobfuscatingRemapper.INSTANCE.unmap(objectClass.getCanonicalName());
        if (deobfuscatedClassName == null) continue;
        if (deobfuscatedClassName.equals("")) continue;
        deobfuscatedName = FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(deobfuscatedClassName, fieldName, fieldName);
        deobfuscated = new Accessor<ObjectType,FieldType>(deobfuscatedName);
    }

    throw new RuntimeException("Could not remap field "+fieldName+ " in class "+objectType.getClass().getCanonicalName());
}

public static BlockMatcher parse(String s) throws Exception {
    if (s.startsWith(BaMsConfig.CLASS_PREFIX)) {
        String className = s.substring(BaMsConfig.CLASS_PREFIX.length());
        className = FMLDeobfuscatingRemapper.INSTANCE.map(className).replace('/', '.');
        return new BlockMatcher(Class.forName(className));
    }

    ResourceLocation name = new ResourceLocation(s);
    if (BaMsConfig.ORE_DICT_ID.equals(name.getResourceDomain())) {
        return new BlockMatcher(name.getResourcePath());
    }

    IBlockState state = BlockHelper.parseBlockState(s);
    if (state != null) {
        return new BlockMatcher(state);
    }

    return null;
}

@Override
public void injectData(Map<String, Object> data)
{
    liveEnv = (Boolean)data.get("runtimeDeobfuscationEnabled");
    cl = (LaunchClassLoader) data.get("classLoader");
    File mcDir = (File)data.get("mcLocation");
    fmlLocation = (File)data.get("coremodLocation");
    ClassPatchManager.INSTANCE.setup(FMLLaunchHandler.side());
    FMLDeobfuscatingRemapper.INSTANCE.setup(mcDir, cl, (String) data.get("deobfuscationFileName"));
}

public static String[] remapFieldNames(String className, String... fieldNames)
{
    String internalClassName = FMLDeobfuscatingRemapper.INSTANCE.unmap(className.replace('.', '/'));
    String[] mappedNames = new String[fieldNames.length];
    int i = 0;
    for (String fName : fieldNames)
    {
        mappedNames[i++] = FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(internalClassName, fName, null);
    }
    return mappedNames;
}

private static String getMethodName(String context, String name, String desc) {
    String deobf = FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(context, name, desc);
    // do further tweaks to the name for methods that aren't fully deobfuscated by FML
    for (int i = 0; i < methodAltNames.length; i++) {
        if (methodAltNames[i++].equals(deobf)) { // steps through list two at a time.
            deobf = methodAltNames[i]; // this is now the second of the pair.
            break;
        }
    }
    // may be the original name if neither FML nor we had any data.
    return deobf;
}

/**
 * Return true if method matches
 * 
 * @param methodName
 * @param methodDescription
 * @return true or false if not match
 */
public boolean match(String methodName, String methodDescription) {
    if (!methodDescription.equals(methodDescription))
        return false;
    if (methodName.equals(methodMcpName))
        return true;
    if (!ASMUtil.useSrgNames())
        return false;
    String mapped = FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(clazzName, methodName, methodDescription);
    return mapped.equals(methodSrgName);
}

public boolean match(String methodName, String methodDesc) {
    if (!methodDesc.equals(description))
        return false;
    if (methodName.equals(mcpName))
        return true;
    if (!ReflectionUtil.useSrgNames())
        return false;
    String mapped = FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(clsName, methodName, methodDesc);
    return mapped.equals(srgName);
}

public boolean match(String fieldName, String fieldDesc) {
    if (!fieldDesc.equals(description))
        return false;
    if (fieldName.equals(mcpName))
        return true;
    if (!ReflectionUtil.useSrgNames())
        return false;
    String mapped = FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(clsName, fieldName, fieldDesc);
    return mapped.equals(srgName);
}

boolean applies(MethodNode method) {
    if (LoadingPlugin.deobfuscatedEnvironment) {
        return method.name.equals(mcpName);
    } else {
        String method_as_srg = FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(obfClassName, method.name, method.desc);
        return srgName.equals(method_as_srg);
    }
}

public MutateCall setOwner(String owner) {
    this.find_mcp_owner = owner.replace(".", "/");
    if (!ASMTransformer.dev_environ) {
        owner = FMLDeobfuscatingRemapper.INSTANCE.unmap(find_mcp_owner);
    }
    this.find_notch_owner = owner.replace(".", "/");
    return this;
}

public static String getSuperClass(String name, boolean runtime) {
    name = toKey(name);
    SuperCache cache = declareClass(name);
    if (cache == null) {
        return "java.lang.Object";
    }

    cache.flatten();
    String s = cache.superclass;
    if (!runtime) {
        s = FMLDeobfuscatingRemapper.INSTANCE.unmap(s);
    }
    return s;
}

public boolean match(String methodName, String methodDesc) {
    if (!methodDesc.equals(description)) return false;
    if (methodName.equals(mcpName)) return true;
    if (!VisitorHelper.useSrgNames()) return false;
    String mapped = FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(clsName, methodName, methodDesc);
    return mapped.equals(srgName);
}

public boolean match(String fieldName, String fieldDesc) {
    if (!fieldDesc.equals(description)) return false;
    if (fieldName.equals(mcpName)) return true;
    if (!VisitorHelper.useSrgNames()) return false;
    String mapped = FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(clsName, fieldName, fieldDesc);
    return mapped.equals(srgName);
}

protected ObfuscatedStateMapper() {
    LOGGER.info("Using build mapping \"" + ForgeHaxProperties.getMcpMappingUrl() + "\"");

    MCPMappingLoader mcpMappingLoader = null;
    try {
        mcpMappingLoader = new MCPMappingLoader(ForgeHaxProperties.getMcpMappingUrl());
    } catch (Exception e) {
        LOGGER.error(e.getMessage());
        ASMStackLogger.printStackTrace(e);
    }

    LOGGER.info("Mapping data successfully initialize");

    Objects.requireNonNull(mcpMappingLoader, "MCPMappingLoader failed to lookup obfuscation data");

    if(isObfuscated())
        LOGGER.info("initializing ObfuscatedStateMapper WITH obfuscation");
    else
        LOGGER.info("initializing ObfuscatedStateMapper WITHOUT obfuscation");

    this.mcClasses = ImmutableBiMap.copyOf(FastReflectionForge.Fields.FMLDeobfuscatingRemapper_classNameBiMap.get(FMLDeobfuscatingRemapper.INSTANCE));

    this.mcpMethodData = buildMcpTypeData(
            mcpMappingLoader.getCsvMethodData(),
            mcpMappingLoader.getSrgFileData().class2MethodDataSet,
            getConvertedMap(
                    FastReflectionForge.Fields.FMLDeobfuscatingRemapper_rawMethodMaps.get(FMLDeobfuscatingRemapper.INSTANCE),
                    str -> str.split("\\(")[0]
            ),
            ((csvData, data) -> csvData.getMcpName() + data.getSrgDescriptor())
    );
    this.mcpFieldData = buildMcpTypeData(
            mcpMappingLoader.getCsvFieldData(),
            mcpMappingLoader.getSrgFileData().class2FieldDataSet,
            getConvertedMap(
                    FastReflectionForge.Fields.FMLDeobfuscatingRemapper_rawFieldMaps.get(FMLDeobfuscatingRemapper.INSTANCE),
                    str -> str.split(":")[0]
            ),
            ((csvData, data) -> csvData.getMcpName())
    );
}

public static void main(String[] args) throws IOException
    {
        String sourceJar = args[0]; //Clean Vanilla jar minecraft.jar or minecraft_server.jar
        String targetDir = args[1]; //Directory containing obfed output classes, typically mcp/reobf/minecraft
        String deobfData = args[2]; //Path to FML's deobfusication_data.lzma
        String outputDir = args[3]; //Path to place generated .binpatch
        String killTarget = args[4]; //"true" if we should destroy the target file if it generated a successful .binpatch

        LogManager.getLogger("GENDIFF").log(Level.INFO, String.format("Creating patches at %s for %s from %s", outputDir, sourceJar, targetDir));
        Delta delta = new Delta();
        FMLDeobfuscatingRemapper remapper = FMLDeobfuscatingRemapper.INSTANCE;
        remapper.setupLoadOnly(deobfData, false);
        JarFile sourceZip = new JarFile(sourceJar);
        boolean kill = killTarget.equalsIgnoreCase("true");

        File f = new File(outputDir);
        f.mkdirs();

        for (String name : remapper.getObfedClasses())
        {
//            Logger.getLogger("GENDIFF").info(String.format("Evaluating path for data :%s",name));
            String fileName = name;
            String jarName = name;
            if (RESERVED_NAMES.contains(name.toUpperCase(Locale.ENGLISH)))
            {
                fileName = "_"+name;
            }
            File targetFile = new File(targetDir, fileName.replace('/', File.separatorChar) + ".class");
            jarName = jarName+".class";
            if (targetFile.exists())
            {
                String sourceClassName = name.replace('/', '.');
                String targetClassName = remapper.map(name).replace('/', '.');
                JarEntry entry = sourceZip.getJarEntry(jarName);
                byte[] vanillaBytes = toByteArray(sourceZip, entry);
                byte[] patchedBytes = Files.toByteArray(targetFile);

                byte[] diff = delta.compute(vanillaBytes, patchedBytes);


                ByteArrayDataOutput diffOut = ByteStreams.newDataOutput(diff.length + 50);
                // Original name
                diffOut.writeUTF(name);
                // Source name
                diffOut.writeUTF(sourceClassName);
                // Target name
                diffOut.writeUTF(targetClassName);
                // exists at original
                diffOut.writeBoolean(entry != null);
                if (entry != null)
                {
                    diffOut.writeInt(Hashing.adler32().hashBytes(vanillaBytes).asInt());
                }
                // length of patch
                diffOut.writeInt(diff.length);
                // patch
                diffOut.write(diff);

                File target = new File(outputDir, targetClassName+".binpatch");
                target.getParentFile().mkdirs();
                Files.write(diffOut.toByteArray(), target);
                Logger.getLogger("GENDIFF").info(String.format("Wrote patch for %s (%s) at %s",name, targetClassName, target.getAbsolutePath()));
                if (kill)
                {
                    targetFile.delete();
                    Logger.getLogger("GENDIFF").info(String.format("  Deleted target: %s", targetFile.toString()));
                }
            }
        }
        sourceZip.close();
    }

@Override
public String remapClassName(String name)
{
    return FMLDeobfuscatingRemapper.INSTANCE.map(name.replace('.','/')).replace('/', '.');
}

@Override
public String unmapClassName(String name)
{
    return FMLDeobfuscatingRemapper.INSTANCE.unmap(name.replace('.', '/')).replace('/','.');
}

private static String descClass(String name) {
    if (isObfuscated) {
        return "L" + FMLDeobfuscatingRemapper.INSTANCE.unmap(name.replace(".", "/")) + ";";
    }
    return "L" + name.replace(".", "/") + ";";
}

@Override
public String map(String typeName) {

    return FMLDeobfuscatingRemapper.INSTANCE.unmap(typeName);
}

public static String getMappedName(String clsName) {
    return ReflectionUtil.useSrgNames() ? FMLDeobfuscatingRemapper.INSTANCE.unmap(clsName) : clsName;
}

@Override
public String unmapType(String typeName) {
    return FMLDeobfuscatingRemapper.INSTANCE.unmap(typeName);
}

@Override
public String mapType(String typeName) {
    return FMLDeobfuscatingRemapper.INSTANCE.map(typeName);
}

@Override
public String mapMethodName(String owner, String name, String desc) {
    return FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(owner.replace('.', '/'), name, desc);
}

@Override
public String mapFieldName(String owner, String name, String desc) {
    return FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(owner.replace('.', '/'), name, desc);
}

/**
 * Deobfuscates an obfuscated class name regardless of {@link #isObfuscated()}.
 */
public static String forceToDeobfClassName(String obfClassName)
{
    return FMLDeobfuscatingRemapper.INSTANCE.map(obfClassName.replace('.', '/')).replace('/', '.');
}

/**
 * Obfuscates a deobfuscated class name regardless of {@link #isObfuscated()}.
 */
public static String forceToObfClassName(String deobfClassName)
{
    return FMLDeobfuscatingRemapper.INSTANCE.unmap(deobfClassName.replace('.', '/')).replace('/', '.');
}

public static String toKey(String name) {
    if (ObfMapping.obfuscated) {
        name = FMLDeobfuscatingRemapper.INSTANCE.map(name.replace('.', '/')).replace('/', '.');
    }
    return name;
}

public static String unKey(String name) {
    if (ObfMapping.obfuscated) {
        name = FMLDeobfuscatingRemapper.INSTANCE.unmap(name.replace('.', '/')).replace('/', '.');
    }
    return name;
}

public static String getClassFor(String name) {
    return FMLDeobfuscatingRemapper.INSTANCE.unmap(name.replace("/", ".")).replace('.', '/');
}

/**
 * Deobfuscates an obfuscated class name regardless of {@link #isObfuscated()}.
 */
public static String forceToDeobfClassName(String obfClassName)
{
    return FMLDeobfuscatingRemapper.INSTANCE.map(obfClassName.replace('.', '/')).replace('/', '.');
}

/**
 * Obfuscates a deobfuscated class name regardless of {@link #isObfuscated()}.
 */
public static String forceToObfClassName(String deobfClassName)
{
    return FMLDeobfuscatingRemapper.INSTANCE.unmap(deobfClassName.replace('.', '/')).replace('/', '.');
}

public static String getSRGDescriptor(String signature)
{
    return FMLDeobfuscatingRemapper.INSTANCE.mapMethodDesc(signature);
}

public static String getSrgName(MethodInsnNode node)
{
    return IvDevRemapper.getSRGName(FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(node.owner, node.name, node.desc));
}

public static String getSrgName(String className, MethodNode node)
{
    return IvDevRemapper.getSRGName(FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(className, node.name, node.desc));
}

public static String getSrgName(FieldInsnNode node)
{
    return IvDevRemapper.getSRGName(FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(node.owner, node.name, node.desc));
}

public static String getSrgClassName(String className)
{
    return FMLDeobfuscatingRemapper.INSTANCE.map(className);
}

public static String getMappedName(String clsName) {
    return useSrgNames()? FMLDeobfuscatingRemapper.INSTANCE.unmap(clsName) : clsName;
}

/**
 * Get right maptype
 * 
 * @param clsName
 *            classname
 * @return maptype
 */
public static String getMappedName(String clsName) {
    return useSrgNames() ? FMLDeobfuscatingRemapper.INSTANCE.unmap(clsName) : clsName;
}

public String unmap(String typeName) {

            return FMLDeobfuscatingRemapper.INSTANCE.map(typeName);
        }