LiteLoader 1.6.4_02 - dev only - allow mods to specify classpath injection strategy in litemod.json

Mumfrey
1 parent c20429cd
Showing 3 changed files with 115 additions and 24 deletions
java/com/mumfrey/liteloader/core/ModFile.java
java/com/mumfrey/liteloader/launch/ClassPathInjector.java
java/com/mumfrey/liteloader/launch/LiteLoaderTweaker.java
@@ -95,9 +95,11 @@ public class ModFile extends File
 	private boolean injected;
  
 	/**
-	 * True if this mod contains base class edits (dirty horribleness) inject at the TOP of the class path
+	 * Position to inject the mod file at in the class path, if blank injects at the bottom as usual, alternatively
+	 * the developer can specify "top" to inject at the top, "base" to inject above the game jar, or "above: name" to
+	 * inject above a specified other library matching "name".
 	 */
-	private boolean injectAtTop;
+	private String injectAt;
  
 	/**
 	 * @param file
@@ -154,7 +156,7 @@ public class ModFile extends File
  
 		this.tweakClassName = this.metaData.get("tweakClass");
 		this.classTransformerClassName = this.metaData.get("classTransformerClass");
-		this.injectAtTop = "top".equalsIgnoreCase(this.metaData.get("injectAt"));
+		this.injectAt = this.metaData.get("injectAt");
 	}
  
 	protected String getDefaultName()
@@ -221,10 +223,18 @@ public class ModFile extends File
 	{
 		if (!this.injected)
 		{
-			if (this.injectAtTop)
+			if ("top".equals(this.injectAt))
 			{
 				ClassPathInjector.injectIntoClassPath(classLoader, this.toURI().toURL());
 			}
+			else if ("base".equals(this.injectAt))
+			{
+				ClassPathInjector.injectIntoClassPath(classLoader, this.toURI().toURL(), LiteLoaderTweaker.getJarUrl());
+			}
+			else if (this.injectAt != null && this.injectAt.startsWith("above:"))
+			{
+				ClassPathInjector.injectIntoClassPath(classLoader, this.toURI().toURL(), this.injectAt.substring(6));
+			}
  
 			if (injectIntoParent)
 			{
@@ -5,35 +5,54 @@ import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.ArrayList;
 import java.util.Stack;
+import java.util.logging.Level;
+import java.util.logging.Logger;
  
 import net.minecraft.launchwrapper.LaunchClassLoader;
 import sun.misc.URLClassPath;
  
 /**
- * Nasty horrible reflection hack to inject a classpath entry at the top of the classpath stack
+ * Nasty horrible reflection hack to inject a classpath entry at positons in classpath other than at the bottom
  * 
  * @author Adam Mummery-Smith
  */
 public abstract class ClassPathInjector
 {
+	private static Logger logger = Logger.getLogger("liteloader");
+	
+	/**
+	 * URLClassLoader::ucp -> instance of URLClassPath
+	 */
 	private static Field ucp;
+	
+	/**
+	 * URLClassLoader::urls -> instance of Stack<URL> 
+	 */
 	private static Field classPathURLs;
+	
+	/**
+	 * URLClassLoader::path -> instance of ArrayList<URL> 
+	 */
 	private static Field classPathPath;
  
+	private static boolean canInject;
+	
 	static
 	{
 		try
 		{
-			ucp = URLClassLoader.class.getDeclaredField("ucp");
-			ucp.setAccessible(true);
-			classPathURLs = URLClassPath.class.getDeclaredField("urls");
-			classPathURLs.setAccessible(true);
-			classPathPath = URLClassPath.class.getDeclaredField("path");
-			classPathPath.setAccessible(true);
+			ClassPathInjector.ucp = URLClassLoader.class.getDeclaredField("ucp");
+			ClassPathInjector.ucp.setAccessible(true);
+			ClassPathInjector.classPathURLs = URLClassPath.class.getDeclaredField("urls");
+			ClassPathInjector.classPathURLs.setAccessible(true);
+			ClassPathInjector.classPathPath = URLClassPath.class.getDeclaredField("path");
+			ClassPathInjector.classPathPath.setAccessible(true);
+			ClassPathInjector.canInject = true;
 		}
-		catch (Exception ex)
+		catch (Throwable th)
 		{
-			ex.printStackTrace();
+			ClassPathInjector.logger.log(Level.SEVERE, "ClassPathInjector: Error initialising ClassPathInjector, special class path injection disabled", th);
+			th.printStackTrace();
 		}
 	}
  
@@ -43,30 +62,82 @@ public abstract class ClassPathInjector
 	 * @param classLoader
 	 * @param url
 	 */
-	@SuppressWarnings({ "rawtypes", "unchecked" })
 	public static void injectIntoClassPath(URLClassLoader classLoader, URL url)
 	{
-		try
+		ClassPathInjector.injectIntoClassPath(classLoader, url, null);
+	}
+	
+	/**
+	 * Injects a URL into the classpath at the TOP of the stack
+	 * 
+	 * @param classLoader
+	 * @param url
+	 * @param above
+	 */
+	@SuppressWarnings({ "unchecked" })
+	public static void injectIntoClassPath(URLClassLoader classLoader, URL url, URL above)
+	{
+		if (ClassPathInjector.canInject)
 		{
-			URLClassPath classPath = (URLClassPath)ucp.get(classLoader);
-			
-			Stack urls = (Stack)classPathURLs.get(classPath);
-			ArrayList path = (ArrayList)classPathPath.get(classPath);
+			ClassPathInjector.logger.info(String.format("ClassPathInjector: attempting to inject %s into %s", url, classLoader.getClass().getSimpleName()));
  
-			synchronized (urls)
+			try
 			{
-				if (!path.contains(url))
+				URLClassPath classPath = (URLClassPath)ClassPathInjector.ucp.get(classLoader);
+				
+				Stack<URL> urls = (Stack<URL>)ClassPathInjector.classPathURLs.get(classPath);
+				ArrayList<URL> path = (ArrayList<URL>)ClassPathInjector.classPathPath.get(classPath);
+				
+				synchronized (urls)
 				{
-					urls.add(url);
-					path.add(0, url);
+					if (!path.contains(url))
+					{
+						urls.add(url);
+						
+						if (above == null)
+						{
+							path.add(0, url);
+						}
+						else
+						{
+							for (int pos = path.size() - 1; pos > 0; pos--)
+							{
+								if (above.equals(path.get(pos)))
+									path.add(pos, url);
+							}
+						}
+					}
 				}
 			}
+			catch (Exception ex)
+			{
+				ClassPathInjector.logger.warning(String.format("ClassPathInjector: failed to inject %s", url));
+			}
 		}
-		catch (Exception ex) {}
  
 		if (classLoader instanceof LaunchClassLoader)
 		{
 			((LaunchClassLoader)classLoader).addURL(url);
 		}
 	}
+
+	/**
+	 * @param classLoader
+	 * @param url
+	 * @param above
+	 */
+	public static void injectIntoClassPath(LaunchClassLoader classLoader, URL url, String above)
+	{
+		above = above.trim().toLowerCase();
+		if (above.length() < 1) return;
+		
+		for (URL classPathUrl : classLoader.getURLs())
+		{
+			if (classPathUrl.toString().toLowerCase().contains(above))
+			{
+				ClassPathInjector.injectIntoClassPath(classLoader, url, classPathUrl);
+				return;
+			}
+		}
+	}
 }
@@ -52,6 +52,8 @@ public class LiteLoaderTweaker implements ITweaker
  
 	private static Set<String> modTransformers = new HashSet<String>();
  
+	private static URL jarUrl;
+	
 	private List<String> singularLaunchArgs = new ArrayList<String>();
  
 	private Map<String, String> launchArgs;
@@ -104,6 +106,9 @@ public class LiteLoaderTweaker implements ITweaker
 			LiteLoaderTweaker.modsToLoad = this.modsOption.values(this.parsedOptions);
 		}
  
+		URL[] urls = Launch.classLoader.getURLs();
+		LiteLoaderTweaker.jarUrl = urls[urls.length - 1];
+		
 		this.preInit();
 	}
  
@@ -345,4 +350,9 @@ public class LiteLoaderTweaker implements ITweaker
  
 		return false;
 	}
+	
+	public static URL getJarUrl()
+	{
+		return LiteLoaderTweaker.jarUrl;
+	}
 }
 \ No newline at end of file