updating MCPBot Mappings, additional javadoc, minor refactoring of JSON transformer defs

Mumfrey
1 parent 2fbe188c
Showing 9 changed files with 328 additions and 76 deletions
debug/obfuscation.properties
java/client/com/mumfrey/liteloader/gl/GL.java
java/common/com/mumfrey/liteloader/transformers/event/json/JsonDescriptor.java
java/common/com/mumfrey/liteloader/transformers/event/json/JsonEvent.java
java/common/com/mumfrey/liteloader/transformers/event/json/JsonEvents.java
java/common/com/mumfrey/liteloader/transformers/event/json/JsonInjection.java
java/common/com/mumfrey/liteloader/transformers/event/json/JsonInjectionType.java
java/common/com/mumfrey/liteloader/transformers/event/json/JsonMethods.java
java/common/com/mumfrey/liteloader/transformers/event/json/JsonObfuscationTable.java
 field_71424_I=mcProfiler
 field_78729_o=entityRenderMap
field_110546_b=reloadListeners
 field_147393_d=networkManager
-field_82596_a=registryObjects
field_148759_a=underlyingIntegerMap
#field_148749_a=
-#field_148748_b=
field_147559_m=mapSpecialRenderers
+field_82596_a=registryObjects
field_148759_a=underlyingIntegerMap
field_148749_a=identityMap
+field_148748_b=objectList
field_147559_m=mapSpecialRenderers
 field_145855_i=nameToClassMap
 field_145853_j=classToNameMap
func_148833_a=processPacket
func_71411_J=runGameLoop
func_71407_l=runTick
func_78480_b=updateCameraAndRender
 func_78471_a=renderWorld
func_175180_a=renderGameOverlay
func_76320_a=startSection
@@ -1156,7 +1156,7 @@ public class GL
 	public static void glResetColor()
 	{
-		GlStateManager.func_179117_G();
+		GlStateManager.resetColor();
 	}
 	public static void glCallList(int list)
@@ -7,25 +7,48 @@ import com.google.gson.annotations.SerializedName;
 import com.mumfrey.liteloader.core.runtime.Obf;
 import com.mumfrey.liteloader.transformers.event.MethodInfo;
+/**
+ * A JSON method descriptor, 
+ *
+ * @author Adam Mummery-Smith
+ */
 public class JsonDescriptor implements Serializable
 {
 	private static final long serialVersionUID = 1L;
+	/**
+	 * Key used to refer to this method descriptor elsewhere
+	 */
 	@SerializedName("key")
 	private String key;
+	/**
+	 * Name of the class which owns this method
+	 */
 	@SerializedName("owner")
 	private String owner;
+	/**
+	 * Method name
+	 */
 	@SerializedName("name")
 	private String name;
+	/**
+	 * Method return type, assumes VOID if none specified
+	 */
 	@SerializedName("return")
 	private String returnType;
+	/**
+	 * Argument types for the method
+	 */
 	@SerializedName("args")
 	private String[] argumentTypes;
+	/**
+	 * Get the key used to refer to this method descriptor
+	 */
 	public String getKey()
 	{
 		if (this.key == null)
@@ -36,6 +59,10 @@ public class JsonDescriptor implements Serializable
 		return this.key;
 	}
+	/**
+	 * @param obfTable
+	 * @return
+	 */
 	public MethodInfo parse(JsonObfuscationTable obfTable)
 	{
 		if (this.owner == null || this.name == null)
@@ -46,21 +73,19 @@ public class JsonDescriptor implements Serializable
 		Obf owner = obfTable.parseClass(this.owner);
 		Obf name = obfTable.parseMethod(this.name);
-		if (this.returnType == null)
+		if (this.argumentTypes == null && this.returnType == null)
 		{
-			if (this.argumentTypes != null)
-			{
-				throw new InvalidEventJsonException("Method descriptor was invalid, args specified with no return type!");
-			}
-			
 			return new MethodInfo(owner, name);
 		}
-		Object returnType = obfTable.parseType(this.returnType);
+		Object returnType = obfTable.parseType(this.returnType == null ? "VOID" : this.returnType);
 		Object[] args = (this.argumentTypes != null ? new Object[this.argumentTypes.length] : new Object[0]);
-		for (int arg = 0; arg < this.argumentTypes.length; arg++)
+		if (this.argumentTypes != null)
 		{
-			args[arg] = obfTable.parseType(this.argumentTypes[arg]);
+			for (int arg = 0; arg < this.argumentTypes.length; arg++)
+			{
+				args[arg] = obfTable.parseType(this.argumentTypes[arg]);
+			}
 		}
 		return new MethodInfo(owner, name, returnType, args);
@@ -9,29 +9,55 @@ import com.mumfrey.liteloader.transformers.event.Event;
 import com.mumfrey.liteloader.transformers.event.InjectionPoint;
 import com.mumfrey.liteloader.transformers.event.MethodInfo;
+/**
+ * An event definition in JSON, serialisable class read by Gson
+ * 
+ * @author Adam Mummery-Smith
+ */
 public class JsonEvent implements Serializable
 {
 	private static final long serialVersionUID = 1L;
 	private static int nextEventID = 0;
+	/**
+	 * Event name
+	 */
 	@SerializedName("name")
 	private String name;
+	/**
+	 * Whether the event is cancellable
+	 */
 	@SerializedName("cancellable")
 	private boolean cancellable;
+	/**
+	 * Event priority (relative to other events at the same injection point)
+	 */
 	@SerializedName("priority")
 	private int priority = 1000;
+	/**
+	 * Injection points specified in the JSON file
+	 */
 	@SerializedName("injections")
 	private List<JsonInjection> jsonInjections;
+	/**
+	 * Listeners defined in the JSON file
+	 */
 	@SerializedName("listeners")
 	private List<String> jsonListeners;
+	/**
+	 * Listener methods parsed from the JSON
+	 */
 	private transient List<MethodInfo> listeners = new ArrayList<MethodInfo>();
+	/**
+	 * Get the name of this event
+	 */
 	public String getName()
 	{
 		if (this.name == null)
@@ -42,52 +68,75 @@ public class JsonEvent implements Serializable
 		return this.name;
 	}
+	/**
+	 * Get whether this event is cancellable or not
+	 */
 	public boolean isCancellable()
 	{
 		return this.cancellable;
 	}
+	/**
+	 * Get the event priority
+	 */
 	public int getPriority()
 	{
 		return this.priority;
 	}
+	/**
+	 * Get the list of listeners parsed from the JSON
+	 */
 	public List<MethodInfo> getListeners()
 	{
 		return this.listeners;
 	}
-	public void parse(JsonEvents json)
+	/**
+	 * Parse the JSON to initialise this object
+	 */
+	public void parse(JsonMethods methods)
 	{
-		this.parseInjectionPoints(json);
-		this.parseListeners(json);
+		this.parseInjectionPoints(methods);
+		this.parseListeners(methods);
 	}
-	private void parseInjectionPoints(JsonEvents json)
+	/**
+	 * @param methods
+	 */
+	private void parseInjectionPoints(JsonMethods methods)
 	{
-		if (this.jsonInjections == null || this.jsonInjections.size() == 0)
+		if (this.jsonInjections == null || this.jsonInjections.isEmpty())
 		{
 			throw new InvalidEventJsonException("Event " + this.getName() + " does not have any defined injections");
 		}
 		for (JsonInjection injection : this.jsonInjections)
 		{
-			injection.parse(json);
+			injection.parse(methods);
 		}
 	}
-	private void parseListeners(JsonEvents json)
+	/**
+	 * @param methods
+	 */
+	private void parseListeners(JsonMethods methods)
 	{
-		if (this.jsonListeners == null || this.jsonListeners.size() == 0)
+		if (this.jsonListeners == null || this.jsonListeners.isEmpty())
 		{
 			throw new InvalidEventJsonException("Event " + this.getName() + " does not have any defined listeners");
 		}
 		for (String listener : this.jsonListeners)
 		{
-			this.listeners.add(json.getMethod(listener));
+			this.listeners.add(methods.get(listener));
 		}
 	}
+	
+	/**
+	 * @param transformer
+	 * @return
+	 */
 	public Event register(ModEventInjectionTransformer transformer)
 	{
 		Event event = Event.getOrCreate(this.getName(), this.isCancellable(), this.getPriority());
 package com.mumfrey.liteloader.transformers.event.json;
 import java.io.Serializable;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.annotations.SerializedName;
-import com.mumfrey.liteloader.transformers.event.MethodInfo;
 /**
- * Serialisable class which represents a set of event injection definitions
+ * Serialisable class which represents a set of event injection definitions. Instances of this class are
+ * created by deserialising with JSON. The JSON string should be passed to the static {@link #parse} method
+ * which returns an instance of the class.
+ * 
+ * After parsing, the events defined here can be injected into an event transformer instance by calling the
+ * {@link #register} method
  * 
  * @author Adam Mummery-Smith
  */
@@ -23,36 +25,56 @@ public class JsonEvents implements Serializable
 	private static final Gson gson = new GsonBuilder().setPrettyPrinting().create();
+	/**
+	 * Tokens are an instruction to the parser to look up a value rather than using a literal
+	 */
 	private static final Pattern tokenPattern = Pattern.compile("^\\$\\{([a-zA-Z0-9_\\-\\.\\$]+)\\}$");
+	/**
+	 * Serialised obfusctation entries
+	 */
 	@SerializedName("obfuscation")
 	private JsonObfuscationTable obfuscation;
+	/**
+	 * Serialised method descriptors
+	 */
 	@SerializedName("descriptors")
 	private List<JsonDescriptor> descriptors;
+	/**
+	 * Serialised events
+	 */
 	@SerializedName("events")
 	private List<JsonEvent> events;
-	private transient Map<String, MethodInfo> methods = new HashMap<String, MethodInfo>();
+	/**
+	 * Parsed method descriptors 
+	 */
+	private transient JsonMethods methods;
-	public void parse()
+	/**
+	 * Attempts to parse the information in this object
+	 */
+	private void parse()
 	{
+		if (this.events == null || this.events.isEmpty())
+		{
+			throw new InvalidEventJsonException("No events were defined in the supplied JSON");
+		}
+		
 		try
 		{
+			// Parse the obfuscation table
 			this.obfuscation.parse();
-			if (this.descriptors != null)
-			{
-				for (JsonDescriptor descriptor : this.descriptors)
-				{
-					this.methods.put(descriptor.getKey(), descriptor.parse(this.obfuscation));
-				}
-			}
+			// Parse the descriptor list
+			this.methods = new JsonMethods(this.obfuscation, this.descriptors);
+			// Parse the events
 			for (JsonEvent event : this.events)
 			{
-				event.parse(this);
+				event.parse(this.methods);
 			}
 		}
 		catch (InvalidEventJsonException ex)
@@ -65,6 +87,30 @@ public class JsonEvents implements Serializable
 		}
 	}
+	/**
+	 * Parse a token name, returns the token name as a string if the token is valid, or null if the token is not valid
+	 * 
+	 * @param token
+	 * @return
+	 */
+	static String parseToken(String token)
+	{
+		token = token.replace(" ", "").trim();
+		
+		Matcher tokenPatternMatcher = JsonEvents.tokenPattern.matcher(token);
+		if (tokenPatternMatcher.matches())
+		{
+			return tokenPatternMatcher.group(1);
+		}
+		
+		return null;
+	}
+
+	/**
+	 * Called to register all events defined in this object into the specified transformer
+	 * 
+	 * @param transformer
+	 */
 	public void register(ModEventInjectionTransformer transformer)
 	{
 		for (JsonEvent event : this.events)
@@ -73,44 +119,33 @@ public class JsonEvents implements Serializable
 		}
 	}
-	public MethodInfo getMethod(String token)
+//	public String toJson()
+//	{
+//		return JsonEvents.gson.toJson(this);
+//	}
+
+	/**
+	 * Parse a new JsonEvents object from the supplied JSON string
+	 * 
+	 * @param json
+	 * @return
+	 * @throws InvalidEventJsonException if the JSON ins invalid
+	 */
+	public static JsonEvents parse(String json) throws InvalidEventJsonException
 	{
-		String key = JsonEvents.parseToken(token);
-		if (key == null)
+		try
 		{
-			throw new InvalidEventJsonException("\"" + token + "\" is not a valid token");
+			JsonEvents newJsonEvents = JsonEvents.gson.fromJson(json, JsonEvents.class);
+			newJsonEvents.parse();
+			return newJsonEvents;
 		}
-
-		MethodInfo method = this.methods.get(key);
-		if (method == null)
+		catch (InvalidEventJsonException ex)
 		{
-			throw new InvalidEventJsonException("Could not locate method with token " + token);
+			throw ex;
 		}
-		return method;
-	}
-
-	public String toJson()
-	{
-		return JsonEvents.gson.toJson(this);
-	}
-
-	public static JsonEvents parse(String json)
-	{
-		JsonEvents newJsonEvents = JsonEvents.gson.fromJson(json, JsonEvents.class);
-		newJsonEvents.parse();
-		return newJsonEvents;
-	}
-	
-	protected static String parseToken(String token)
-	{
-		token = token.replace(" ", "").trim();
-		
-		Matcher tokenPatternMatcher = JsonEvents.tokenPattern.matcher(token);
-		if (tokenPatternMatcher.matches())
+		catch (Throwable th)
 		{
-			return tokenPatternMatcher.group(1);
+			throw new InvalidEventJsonException("An error occurred whilst parsing the event definition: " + th.getClass().getSimpleName() + ": " + th.getMessage(), th);
 		}
-		
-		return null;
 	}
 }
@@ -8,30 +8,57 @@ import com.mumfrey.liteloader.transformers.event.InjectionPoint;
 import com.mumfrey.liteloader.transformers.event.MethodInfo;
 import com.mumfrey.liteloader.transformers.event.inject.BeforeInvoke;
 import com.mumfrey.liteloader.transformers.event.inject.BeforeReturn;
+import com.mumfrey.liteloader.transformers.event.inject.BeforeStringInvoke;
 import com.mumfrey.liteloader.transformers.event.inject.MethodHead;
+/**
+ * A JSON injection point definition
+ * 
+ * @author Adam Mummery-Smith
+ */
 public class JsonInjection implements Serializable
 {
 	private static final long serialVersionUID = 1L;
+	/**
+	 * Method to inject into
+	 */
 	@SerializedName("method")
 	private String methodName;
+	/**
+	 * Type of injection point
+	 */
 	@SerializedName("type")
 	private JsonInjectionType type;
+	/**
+	 * Shift type (optional)
+	 */
 	@SerializedName("shift")
 	private JsonInjectionShiftType shift;
+	/**
+	 * Target method to search for when using INVOKE and INVOKESTRING
+	 */
 	@SerializedName("target")
 	private String target;
+	/**
+	 * Ordinal to use when using INVOKE and INVOKESTRING
+	 */
 	@SerializedName("ordinal")
 	private int ordinal = -1;
+	/**
+	 * InjectionPoint class to use for CUSTOM
+	 */
 	@SerializedName("class")
 	private String className;
+	/**
+	 * Constructor arguments to pass wehn using CUSTOM
+	 */
 	@SerializedName("args")
 	private Object[] args;
@@ -49,24 +76,26 @@ public class JsonInjection implements Serializable
 		return this.injectionPoint;
 	}
-	public void parse(JsonEvents json)
+	public void parse(JsonMethods methods)
 	{
-		this.method = this.parseMethod(json);
-		this.injectionPoint = this.parseInjectionPoint(json);
+		this.method = this.parseMethod(methods);
+		this.injectionPoint = this.parseInjectionPoint(methods);
 	}
-	private MethodInfo parseMethod(JsonEvents json)
+	private MethodInfo parseMethod(JsonMethods methods)
 	{
-		return json.getMethod(this.methodName);
+		return methods.get(this.methodName);
 	}
-	public InjectionPoint parseInjectionPoint(JsonEvents json)
+	public InjectionPoint parseInjectionPoint(JsonMethods methods)
 	{
 		switch (this.type)
 		{
 			case INVOKE:
-				MethodInfo method = json.getMethod(this.getTarget());
-				return this.applyShift(new BeforeInvoke(method, this.ordinal));
+				return this.applyShift(new BeforeInvoke(methods.get(this.getTarget()), this.ordinal));
+				
+			case INVOKESTRING:
+				return this.applyShift(new BeforeStringInvoke(this.getArg(0).toString(), methods.get(this.getTarget()), this.ordinal));
 			case RETURN:
 				return this.applyShift(new BeforeReturn(this.ordinal));
@@ -95,6 +124,14 @@ public class JsonInjection implements Serializable
 		throw new InvalidEventJsonException("Could not parse injection type");
 	}
+	private Object getArg(int arg)
+	{
+		if (this.args == null || this.args.length >= this.args.length || arg < 0)
+			return "";
+		
+		return this.args[arg];
+	}
+
 	private String getTarget()
 	{
 		if (this.target != null && this.shift == null)
@@ -3,6 +3,8 @@ package com.mumfrey.liteloader.transformers.event.json;
 public enum JsonInjectionType
 {
 	INVOKE,
+	INVOKESTRING,
+	FIELD,
 	RETURN,
 	HEAD,
 	CUSTOM;
+package com.mumfrey.liteloader.transformers.event.json;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.mumfrey.liteloader.transformers.event.MethodInfo;
+
+/**
+ * A simple registry of MethodInfo objects parsed from the JSON, objects which consume the specified
+ * MethodInfo objects will be passed an instance of this object at parse time.
+ * 
+ * @author Adam Mummery-Smith
+ */
+public class JsonMethods
+{
+	/**
+	 * Serialised obfusctation entries
+	 */
+	private final JsonObfuscationTable obfuscation;
+
+	/**
+	 * Method descriptors
+	 */
+	private final List<JsonDescriptor> descriptors;
+	
+	/**
+	 * Method descriptors which have been parsed from the descriptors collection
+	 */
+	private Map<String, MethodInfo> methods = new HashMap<String, MethodInfo>();
+
+	/**
+	 * @param obfuscation
+	 * @param descriptors
+	 */
+	public JsonMethods(JsonObfuscationTable obfuscation, List<JsonDescriptor> descriptors)
+	{
+		this.obfuscation = obfuscation;
+		this.descriptors = descriptors;
+		
+		this.parse();
+	}
+
+	/**
+	 * 
+	 */
+	private void parse()
+	{
+		if (this.descriptors != null)
+		{
+			for (JsonDescriptor descriptor : this.descriptors)
+			{
+				this.methods.put(descriptor.getKey(), descriptor.parse(this.obfuscation));
+			}
+		}
+	}
+
+	/**
+	 * Fetches a method descriptor by token
+	 * 
+	 * @param token
+	 * @return
+	 */
+	public MethodInfo get(String token)
+	{
+		String key = JsonEvents.parseToken(token);
+		if (key == null)
+		{
+			throw new InvalidEventJsonException("\"" + token + "\" is not a valid token");
+		}
+
+		MethodInfo method = this.methods.get(key);
+		if (method == null)
+		{
+			throw new InvalidEventJsonException("Could not locate method with token " + token);
+		}
+		return method;
+	}
+}
 \ No newline at end of file
@@ -9,6 +9,12 @@ import com.google.gson.annotations.SerializedName;
 import com.mumfrey.liteloader.core.runtime.Obf;
 import com.mumfrey.liteloader.core.runtime.Packets;
+/**
+ * JSON-defined obfuscation table entries used like a registry by the other JSON components to look up obfuscation mappings
+ * for methods and fields.
+ *
+ * @author Adam Mummery-Smith
+ */
 public class JsonObfuscationTable implements Serializable
 {
 	private static final long serialVersionUID = 1L;
@@ -22,10 +28,14 @@ public class JsonObfuscationTable implements Serializable
 	@SerializedName("fields")
 	private List<JsonObf> jsonFields;
+	// Parsed values
 	private transient Map<String, Obf> classObfs = new HashMap<String, Obf>();
 	private transient Map<String, Obf> methodObfs = new HashMap<String, Obf>();
 	private transient Map<String, Obf> fieldObfs = new HashMap<String, Obf>();
+	/**
+	 * Parse the entries in each collection to actual Obf objects
+	 */
 	public void parse()
 	{
 		if (this.jsonClasses != null)
@@ -53,6 +63,9 @@ public class JsonObfuscationTable implements Serializable
 		}
 	}
+	/**
+	 * Look up a type (a class or primitive type) by token
+	 */
 	public Object parseType(String token)
 	{
 		token = token.replace(" ", "").trim();
@@ -76,16 +89,28 @@ public class JsonObfuscationTable implements Serializable
 		return this.parseClass(token);
 	}
+	/**
+	 * @param token
+	 * @return
+	 */
 	public Obf parseClass(String token)
 	{
 		return this.parseObf(token, this.classObfs);
 	}
+	/**
+	 * @param token
+	 * @return
+	 */
 	public Obf parseMethod(String token)
 	{
 		return this.parseObf(token, this.methodObfs);
 	}
+	/**
+	 * @param token
+	 * @return
+	 */
 	public Obf parseField(String token)
 	{
 		return this.parseObf(token, this.fieldObfs);
@@ -119,7 +144,7 @@ public class JsonObfuscationTable implements Serializable
 				return packet;
 			}
-			throw new InvalidEventJsonException("The token " + token + " could not be resolved");
+			throw new InvalidEventJsonException("The token " + token + " could not be resolved to a type");
 		}
 		return new JsonObf.Mapping(token, token, token);