net.minecraft.launchwrapper.LaunchClassLoader Java Examples

@SuppressWarnings("unchecked")
public Meddle()
{
	// Prevent classloader collisions, mostly due to keeping
	// the deprecated DynamicMappings class.
	Launch.classLoader.addClassLoaderExclusion("org.objectweb.asm.");

	blacklistedTweaks.add(Meddle.class.getName());

	// Launchwrapper adds the package without a period on the end, which
	// covers any similarly-named packages.  We could solve by putting
	// Meddle's tweak class in a deeper package, but this works too
	// while maintaining backwards compatibility.

	try {
		Field exceptionsField = LaunchClassLoader.class.getDeclaredField("classLoaderExceptions");
		exceptionsField.setAccessible(true);
		classloaderExceptions = (Set<String>) exceptionsField.get(Launch.classLoader);
	} catch (Exception e) { e.printStackTrace(); }

	classloaderExceptions.remove("net.fybertech.meddle");
	classloaderExceptions.add("net.fybertech.meddle.");
}
 

/**
 * @return Whether or not the current environment contains obfuscated Minecraft code
 */
public static boolean isObfuscated()
{
	if (obfuscated == null)
	{
		try
		{
			byte[] bytes = ((LaunchClassLoader) ObfHelper.class.getClassLoader()).getClassBytes("net.minecraft.world.World");
			ObfHelper.setObfuscated(bytes == null);
		}
		catch (IOException e)
		{
			obfuscated = true;
		}
	}
	return obfuscated;
}
 

/**
 * @return Whether or not the current environment has been deobfuscated by FML
 */
public static boolean runsAfterDeobfRemapper()
{
	if (runsAfterDeobfRemapper == null)
	{
		try
		{
			byte[] bytes = ((LaunchClassLoader) ObfHelper.class.getClassLoader()).getClassBytes("net.minecraft.world.World");
			ObfHelper.setRunsAfterDeobfRemapper(bytes != null);
		}
		catch (IOException e)
		{
			runsAfterDeobfRemapper = false;
		}
	}
	return runsAfterDeobfRemapper;
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader)
{
    if (!hasRun)
    {
        FMLRelaunchLog.log.info("[LegacyJavaFixer] Replacing sort");
        sort();
        URL is = FMLInjectionAndSortingTweaker.class.getResource("/cpw/mods/fml/common/launcher/TerminalTweaker.class");
        if (is != null)
        {
            FMLRelaunchLog.log.info("[LegacyJavaFixer] Detected TerminalTweaker");
            @SuppressWarnings("unchecked")
            List<String> newTweaks = (List<String>) Launch.blackboard.get("TweakClasses");
            newTweaks.add("cpw.mods.fml.common.launcher.TerminalTweaker");
        }
    }
    hasRun = true;
}
 

@InvokeEvent
public void tickEvent(TickEvent event) {
    if (tickCounter % 20 * 60 == 0) {
        Minecraft.memoryReserve = new byte[0];
        try {
            Field resourceCache = LaunchClassLoader.class.getDeclaredField("resourceCache");
            resourceCache.setAccessible(true);
            ((Map) resourceCache.get(Launch.classLoader)).clear();

            Field packageManifests = LaunchClassLoader.class.getDeclaredField("packageManifests");
            packageManifests.setAccessible(true);
            ((Map) packageManifests.get(Launch.classLoader)).clear();
        } catch (IllegalAccessException | NoSuchFieldException e) {
            e.printStackTrace();
        }
    }

    tickCounter++;
}
 

/**
 * Singleton, use factory to get an instance
 * 
 * @param classLoader class loader
 */
LaunchClassLoaderUtil(LaunchClassLoader classLoader) {
    this.classLoader = classLoader;
    this.cachedClasses = LaunchClassLoaderUtil.<Map<String, Class<?>>>getField(classLoader, LaunchClassLoaderUtil.CACHED_CLASSES_FIELD);
    this.invalidClasses = LaunchClassLoaderUtil.<Set<String>>getField(classLoader, LaunchClassLoaderUtil.INVALID_CLASSES_FIELD);
    this.classLoaderExceptions = LaunchClassLoaderUtil.<Set<String>>getField(classLoader, LaunchClassLoaderUtil.CLASS_LOADER_EXCEPTIONS_FIELD);
    this.transformerExceptions = LaunchClassLoaderUtil.<Set<String>>getField(classLoader, LaunchClassLoaderUtil.TRANSFORMER_EXCEPTIONS_FIELD);
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader)
{
	// Register any transformer classes specified in mod manifests
	for (ModContainer mod : discoveredModsList)
	{
		if (mod.transformerClass != null) {
			try {
				Class.forName(mod.transformerClass, true, classLoader);
			} catch (ClassNotFoundException e) {}
			classLoader.registerTransformer(mod.transformerClass);
		}
	}
}
 

private static String untransformName(LaunchClassLoader launchClassLoader, String className) {
    try {
        Method untransformNameMethod = LaunchClassLoader.class.getDeclaredMethod("untransformName", String.class);
        untransformNameMethod.setAccessible(true);
        return (String) untransformNameMethod.invoke(launchClassLoader, className);
    } catch (ReflectiveOperationException e) {
        throw new RuntimeException(e);
    }
}
 

Class<?> findClass(String name, boolean checkGlobal) throws ClassNotFoundException {
    if (name.startsWith("net.minecraft.server.v1_12_R1")) {
        String remappedClass = jarMapping.classes.get(name.replaceAll("\\.", "\\/"));
        return ((LaunchClassLoader) MinecraftServer.getServerInstance().getClass().getClassLoader()).findClass(remappedClass);
    }

    if (name.startsWith("org.bukkit.")) {
        throw new ClassNotFoundException(name);
    }

    Class<?> result = classes.get(name);

    synchronized (name.intern()) {
        if (result == null) {
            if (checkGlobal) {
                result = loader.getClassByName(name);
            }

            if (result == null) {
                result = remappedFindClass(name);

                if (result != null) {
                    loader.setClass(name, result);
                }
            }

            if (result == null) {
                throw new ClassNotFoundException(name);
            }

            classes.put(name, result);
        }
    }
    return result;
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader) {
    Hyperium.LOGGER.info("[Addons] Loading Addons...");

    Hyperium.LOGGER.info("Initialising Bootstraps...");
    MixinBootstrap.init();
    AddonBootstrap.INSTANCE.init();

    Hyperium.LOGGER.info("Applying transformers...");

    MixinEnvironment environment = MixinEnvironment.getDefaultEnvironment();
    Mixins.addConfiguration("mixins.hyperium.json");

    if (isRunningOptifine) {
        environment.setObfuscationContext("notch"); // Switch's to notch mappings
    }

    if (environment.getObfuscationContext() == null) {
        environment.setObfuscationContext("notch"); // Switch's to notch mappings
    }

    try {
        classLoader.addURL(new File(System.getProperty("java.home"), "lib/ext/nashorn.jar").toURI().toURL());
    } catch (MalformedURLException e) {
        e.printStackTrace();
    }

    environment.setSide(MixinEnvironment.Side.CLIENT);
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader) {
    System.out.println("[LiquidBounce] Injecting with TweakerMixinLoader.");

    MixinBootstrap.init();
    Mixins.addConfiguration("liquidbounce.vanilla.mixins.json");
    MixinEnvironment.getDefaultEnvironment().setSide(MixinEnvironment.Side.CLIENT);

    classLoader.registerTransformer(AbstractJavaLinkerTransformer.class.getName());
}
 

private ITweaker injectCorePlugin() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
    String coreModName = this.handle.getAttribute(MixinPlatformAgentFMLLegacy.MFATT_FMLCOREPLUGIN);
    if (coreModName == null) {
        return null;
    }
    
    if (this.isAlreadyInjected(coreModName)) {
        MixinPlatformAgentAbstract.logger.debug("{} has core plugin {}. Skipping because it was already injected.", this.fileName, coreModName);
        return null;
    }
    
    MixinPlatformAgentAbstract.logger.debug("{} has core plugin {}. Injecting it into FML for co-initialisation:", this.fileName, coreModName);
    Method mdLoadCoreMod = this.clCoreModManager.getDeclaredMethod(GlobalProperties.getString(GlobalProperties.Keys.FML_LOAD_CORE_MOD,
            MixinPlatformAgentFMLLegacy.LOAD_CORE_MOD_METHOD), LaunchClassLoader.class, String.class, File.class);
    mdLoadCoreMod.setAccessible(true);
    ITweaker wrapper = (ITweaker)mdLoadCoreMod.invoke(null, Launch.classLoader, coreModName, this.file);
    if (wrapper == null) {
        MixinPlatformAgentAbstract.logger.debug("Core plugin {} could not be loaded.", coreModName);
        return null;
    }
    
    // If the injection tweaker is queued, we are most likely in development
    // and will NOT need to co-init the coremod
    this.initInjectionState = MixinPlatformAgentFMLLegacy.isTweakerQueued(MixinPlatformAgentFMLLegacy.FML_TWEAKER_INJECTION);

    MixinPlatformAgentFMLLegacy.loadedCoreMods.add(coreModName);
    return wrapper;
}
 

@SuppressWarnings("unchecked")
    private static <T> T getField(LaunchClassLoader classLoader, String fieldName) {
        try {
            Field field = LaunchClassLoader.class.getDeclaredField(fieldName);
            field.setAccessible(true);
            return (T)field.get(classLoader);
        } catch (Exception ex) {
//            ex.printStackTrace();
        }
        return null;
    }
 

private void loadJson(JsonObject node) throws IOException {
    boolean obfuscated = ((LaunchClassLoader) DepLoader.class.getClassLoader())
            .getClassBytes("net.minecraft.world.World") == null;

    String repo = node.has("repo") ? node.get("repo").getAsString() : null;
    String packed = node.has("packed") ? node.get("packed").getAsString() : null;
    String testClass = node.get("class").getAsString();

    String filename = node.get("file").getAsString();
    if (!obfuscated && node.has("dev"))
        filename = node.get("dev").getAsString();

    boolean coreLib = node.has("coreLib") && node.get("coreLib").getAsBoolean();

    Pattern pattern = null;
    try {
        if(node.has("pattern"))
            pattern = Pattern.compile(node.get("pattern").getAsString());
    } catch (PatternSyntaxException e) {
        logger.error("Invalid filename pattern: "+node.get("pattern"), e);
    }
    if(pattern == null)
        pattern = Pattern.compile("(\\w+).*?([\\d\\.]+)[-\\w]*\\.[^\\d]+");

    VersionedFile file = new VersionedFile(filename, pattern);
    if (!file.matches())
        throw new RuntimeException("Invalid filename format for dependency: " + filename);

    addDep(new Dependency(scanning, repo, packed, file, testClass, coreLib));
}
 

public DelegatedTransformer()
{
    delegatedTransformers = new ArrayList<IClassTransformer>();
    try
    {
        m_defineClass = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, Integer.TYPE, Integer.TYPE);
        m_defineClass.setAccessible(true);
        f_cachedClasses = LaunchClassLoader.class.getDeclaredField("cachedClasses");
        f_cachedClasses.setAccessible(true);
    }
    catch(Exception e)
    {
        throw new RuntimeException(e);
    }
}
 

private void addClasspath(String name) {
    try {
        ((LaunchClassLoader) DepLoader.class.getClassLoader()).addURL(new File(v_modsDir, name).toURI().toURL());
    } catch (MalformedURLException e) {
        throw new RuntimeException(e);
    }
}
 

private void loadJson(JsonObject node) throws IOException {
    boolean obfuscated = ((LaunchClassLoader) DepLoader.class.getClassLoader())
            .getClassBytes("net.minecraft.world.World") == null;

    String testClass = node.get("class").getAsString();
    if (DepLoader.class.getResource("/" + testClass.replace('.', '/') + ".class") != null)
        return;

    String repo = node.get("repo").getAsString();
    String filename = node.get("file").getAsString();
    if (!obfuscated && node.has("dev"))
        filename = node.get("dev").getAsString();

    boolean coreLib = node.has("coreLib") && node.get("coreLib").getAsBoolean();

    Pattern pattern = null;
    try {
        if(node.has("pattern"))
            pattern = Pattern.compile(node.get("pattern").getAsString());
    } catch (PatternSyntaxException e) {
        System.err.println("Invalid filename pattern: "+node.get("pattern"));
        e.printStackTrace();
    }
    if(pattern == null)
        pattern = Pattern.compile("(\\w+).*?([\\d\\.]+)[-\\w]*\\.[^\\d]+");

    VersionedFile file = new VersionedFile(filename, pattern);
    if (!file.matches())
        throw new RuntimeException("Invalid filename format for dependency: " + filename);

    addDep(new Dependency(repo, file, coreLib));
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader launchClassLoader) {
	isDevelopment = Boolean.parseBoolean(System.getProperty("fabric.development", "false"));
	Launch.blackboard.put("fabric.development", isDevelopment);
	setProperties(Launch.blackboard);

	this.launchClassLoader = launchClassLoader;
	launchClassLoader.addClassLoaderExclusion("org.objectweb.asm.");
	launchClassLoader.addClassLoaderExclusion("org.spongepowered.asm.");
	launchClassLoader.addClassLoaderExclusion("net.fabricmc.loader.");

	launchClassLoader.addClassLoaderExclusion("net.fabricmc.api.Environment");
	launchClassLoader.addClassLoaderExclusion("net.fabricmc.api.EnvType");

	GameProvider provider = new MinecraftGameProvider();
	provider.acceptArguments(arguments);

	if (!provider.locateGame(getEnvironmentType(), launchClassLoader)) {
		throw new RuntimeException("Could not locate Minecraft: provider locate failed");
	}

	@SuppressWarnings("deprecation")
	FabricLoader loader = FabricLoader.INSTANCE;
	loader.setGameProvider(provider);
	loader.load();
	loader.freeze();

	launchClassLoader.registerTransformer("net.fabricmc.loader.launch.FabricClassTransformer");

	if (!isDevelopment) {
		// Obfuscated environment
		Launch.blackboard.put("fabric.development", false);
		try {
			String target = getLaunchTarget();
			URL loc = launchClassLoader.findResource(target.replace('.', '/') + ".class");
			JarURLConnection locConn = (JarURLConnection) loc.openConnection();
			File jarFile = UrlUtil.asFile(locConn.getJarFileURL());
			if (!jarFile.exists()) {
				throw new RuntimeException("Could not locate Minecraft: " + jarFile.getAbsolutePath() + " not found");
			}

			FabricLauncherBase.deobfuscate(provider.getGameId(), provider.getNormalizedGameVersion(), provider.getLaunchDirectory(), jarFile.toPath(), this);
		} catch (IOException | UrlConversionException e) {
			throw new RuntimeException("Failed to deobfuscate Minecraft!", e);
		}
	}

	FabricLoader.INSTANCE.getAccessWidener().loadFromMods();

	MinecraftGameProvider.TRANSFORMER.locateEntrypoints(this);

	// Setup Mixin environment
	MixinBootstrap.init();
	FabricMixinBootstrap.init(getEnvironmentType(), FabricLoader.INSTANCE);
	MixinEnvironment.getDefaultEnvironment().setSide(getEnvironmentType() == EnvType.CLIENT ? MixinEnvironment.Side.CLIENT : MixinEnvironment.Side.SERVER);

	EntrypointUtils.invoke("preLaunch", PreLaunchEntrypoint.class, PreLaunchEntrypoint::onPreLaunch);
}
 

/**
 * Get the classloader
 */
LaunchClassLoader getClassLoader() {
    return this.classLoader;
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader) {
    MixinBootstrap.getPlatform().inject();
}
 

@Override
public final void injectIntoClassLoader(LaunchClassLoader classLoader) {
    MixinBootstrap.inject();
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader) {
    MixinBootstrap.init();
    MixinEnvironment.getDefaultEnvironment().setSide(isClient() ? MixinEnvironment.Side.CLIENT : MixinEnvironment.Side.SERVER);
    Mixins.addConfiguration("mixins.bbor.json");
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader) {
	classLoader.registerTransformer(Transformer.class.getName());
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader) {
	classLoader.registerTransformer(Transformer.class.getName());
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader) {
	classLoader.registerTransformer(Transformer.class.getName());
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader) {
	classLoader.registerTransformer(Transformer.class.getName());
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader) {
	classLoader.registerTransformer(Transformer.class.getName());
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader) {
	classLoader.registerTransformer(Transformer.class.getName());
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader) {
	classLoader.registerTransformer(Transformer.class.getName());
}
 

@Override
public void injectIntoClassLoader(LaunchClassLoader classLoader) {
	classLoader.registerTransformer(Transformer.class.getName());
}