Merge branch 'develop' of github.com:MultiMC/MultiMC5 into develop

52 files changed, 1779 insertions, 1963 deletions

diff --git a/depends/classparser/include/classparser_config.h b/depends/classparser/include/classparser_config.h
index fe6a2ab9..a043824a 100644
--- a/depends/classparser/include/classparser_config.h
+++ b/depends/classparser/include/classparser_config.h
@@ -16,8 +16,7 @@
 #include <QtCore/QtGlobal>
 
 #ifdef CLASSPARSER_LIBRARY
-#  define CLASSPARSER_EXPORT Q_DECL_EXPORT
+#define CLASSPARSER_EXPORT Q_DECL_EXPORT
 #else
-#  define CLASSPARSER_EXPORT Q_DECL_IMPORT
+#define CLASSPARSER_EXPORT Q_DECL_IMPORT
 #endif
-
diff --git a/depends/classparser/include/javautils.h b/depends/classparser/include/javautils.h
index 63e5ec26..90042261 100644
--- a/depends/classparser/include/javautils.h
+++ b/depends/classparser/include/javautils.h
@@ -22,8 +22,8 @@
 
 namespace javautils
 {
-	/**
-	 * @brief Get the version from a minecraft.jar by parsing its class files. Expensive!
-	 */
-	QString GetMinecraftJarVersion(QString jar);
+/**
+ * @brief Get the version from a minecraft.jar by parsing its class files. Expensive!
+ */
+QString GetMinecraftJarVersion(QString jar);
 }
diff --git a/depends/classparser/src/annotations.cpp b/depends/classparser/src/annotations.cpp
index fc0c98fa..d1a7c046 100644
--- a/depends/classparser/src/annotations.cpp
+++ b/depends/classparser/src/annotations.cpp
@@ -4,80 +4,82 @@
 
 namespace java
 {
-	std::string annotation::toString()
+std::string annotation::toString()
+{
+	std::ostringstream ss;
+	ss << "Annotation type : " << type_index << " - " << pool[type_index].str_data << std::endl;
+	ss << "Contains " << name_val_pairs.size() << " pairs:" << std::endl;
+	for (unsigned i = 0; i < name_val_pairs.size(); i++)
 	{
-		std::ostringstream ss;
-		ss << "Annotation type : " << type_index << " - " << pool[type_index].str_data << std::endl;
-		ss << "Contains " << name_val_pairs.size() << " pairs:" << std::endl;
-		for(unsigned i = 0; i < name_val_pairs.size(); i++)
-		{
-			std::pair<uint16_t, element_value *> &val = name_val_pairs[i];
-			auto name_idx = val.first;
-			ss << pool[name_idx].str_data << "(" << name_idx << ")" << " = " << val.second->toString() << std::endl;
-		}
-		return ss.str();
+		std::pair<uint16_t, element_value *> &val = name_val_pairs[i];
+		auto name_idx = val.first;
+		ss << pool[name_idx].str_data << "(" << name_idx << ")"
+		   << " = " << val.second->toString() << std::endl;
 	}
+	return ss.str();
+}
+
+annotation *annotation::read(util::membuffer &input, constant_pool &pool)
+{
+	uint16_t type_index = 0;
+	input.read_be(type_index);
+	annotation *ann = new annotation(type_index, pool);
 
-	annotation * annotation::read (util::membuffer& input, constant_pool& pool)
+	uint16_t num_pairs = 0;
+	input.read_be(num_pairs);
+	while (num_pairs)
 	{
-		uint16_t type_index = 0;
-		input.read_be(type_index);
-		annotation * ann = new annotation(type_index,pool);
-		
-		uint16_t num_pairs = 0;
-		input.read_be(num_pairs);
-		while(num_pairs)
-		{
-			uint16_t name_idx = 0;
-			// read name index
-			input.read_be(name_idx);
-			auto elem = element_value::readElementValue(input,pool);
-			// read value
-			ann->add_pair(name_idx, elem);
-			num_pairs --;
-		}
-		return ann;
+		uint16_t name_idx = 0;
+		// read name index
+		input.read_be(name_idx);
+		auto elem = element_value::readElementValue(input, pool);
+		// read value
+		ann->add_pair(name_idx, elem);
+		num_pairs--;
 	}
-	
-	element_value* element_value::readElementValue ( util::membuffer& input, java::constant_pool& pool )
+	return ann;
+}
+
+element_value *element_value::readElementValue(util::membuffer &input,
+											   java::constant_pool &pool)
+{
+	element_value_type type = INVALID;
+	input.read(type);
+	uint16_t index = 0;
+	uint16_t index2 = 0;
+	std::vector<element_value *> vals;
+	switch (type)
 	{
-		element_value_type type = INVALID;
-		input.read(type);
-		uint16_t index = 0;
-		uint16_t index2 = 0;
-		std::vector <element_value *> vals;
-		switch (type)
+	case PRIMITIVE_BYTE:
+	case PRIMITIVE_CHAR:
+	case PRIMITIVE_DOUBLE:
+	case PRIMITIVE_FLOAT:
+	case PRIMITIVE_INT:
+	case PRIMITIVE_LONG:
+	case PRIMITIVE_SHORT:
+	case PRIMITIVE_BOOLEAN:
+	case STRING:
+		input.read_be(index);
+		return new element_value_simple(type, index, pool);
+	case ENUM_CONSTANT:
+		input.read_be(index);
+		input.read_be(index2);
+		return new element_value_enum(type, index, index2, pool);
+	case CLASS: // Class
+		input.read_be(index);
+		return new element_value_class(type, index, pool);
+	case ANNOTATION: // Annotation
+		// FIXME: runtime visibility info needs to be passed from parent
+		return new element_value_annotation(ANNOTATION, annotation::read(input, pool), pool);
+	case ARRAY: // Array
+		input.read_be(index);
+		for (int i = 0; i < index; i++)
 		{
-		case PRIMITIVE_BYTE:
-		case PRIMITIVE_CHAR:
-		case PRIMITIVE_DOUBLE:
-		case PRIMITIVE_FLOAT:
-		case PRIMITIVE_INT:
-		case PRIMITIVE_LONG:
-		case PRIMITIVE_SHORT:
-		case PRIMITIVE_BOOLEAN:
-		case STRING:
-			input.read_be(index);
-			return new element_value_simple(type, index, pool);
-		case ENUM_CONSTANT:
-			input.read_be(index);
-			input.read_be(index2);
-			return new element_value_enum(type, index, index2, pool);
-		case CLASS: // Class
-			input.read_be(index);
-			return new element_value_class(type, index, pool);
-		case ANNOTATION: // Annotation
-			// FIXME: runtime visibility info needs to be passed from parent
-			return new element_value_annotation(ANNOTATION, annotation::read(input, pool), pool);
-		case ARRAY: // Array
-			input.read_be(index);
-			for (int i = 0; i < index; i++)
-			{
-				vals.push_back(element_value::readElementValue(input, pool));
-			}
-			return new element_value_array(ARRAY, vals, pool);
-		default:
-			throw new java::classfile_exception();
+			vals.push_back(element_value::readElementValue(input, pool));
 		}
+		return new element_value_array(ARRAY, vals, pool);
+	default:
+		throw new java::classfile_exception();
 	}
+}
 }
\ No newline at end of file
diff --git a/depends/classparser/src/annotations.h b/depends/classparser/src/annotations.h
index b115dc0b..aa25d241 100644
--- a/depends/classparser/src/annotations.h
+++ b/depends/classparser/src/annotations.h
@@ -5,248 +5,273 @@
 
 namespace java
 {
-	enum element_value_type : uint8_t
-	{
-		INVALID = 0,
-		STRING = 's',
-		ENUM_CONSTANT = 'e',
-		CLASS = 'c',
-		ANNOTATION = '@',
-		ARRAY = '[', // one array dimension
-		PRIMITIVE_INT = 'I', // integer
-		PRIMITIVE_BYTE = 'B', // signed byte
-		PRIMITIVE_CHAR = 'C', // Unicode character code point in the Basic Multilingual Plane, encoded with UTF-16
-		PRIMITIVE_DOUBLE = 'D', // double-precision floating-point value
-		PRIMITIVE_FLOAT = 'F', // single-precision floating-point value
-		PRIMITIVE_LONG = 'J', // long integer
-		PRIMITIVE_SHORT = 'S', // signed short
-		PRIMITIVE_BOOLEAN = 'Z' // true or false
-	};
+enum element_value_type : uint8_t
+{
+	INVALID = 0,
+	STRING = 's',
+	ENUM_CONSTANT = 'e',
+	CLASS = 'c',
+	ANNOTATION = '@',
+	ARRAY = '[',			// one array dimension
+	PRIMITIVE_INT = 'I',	// integer
+	PRIMITIVE_BYTE = 'B',   // signed byte
+	PRIMITIVE_CHAR = 'C',   // Unicode character code point in the Basic Multilingual Plane,
+							// encoded with UTF-16
+	PRIMITIVE_DOUBLE = 'D', // double-precision floating-point value
+	PRIMITIVE_FLOAT = 'F',  // single-precision floating-point value
+	PRIMITIVE_LONG = 'J',   // long integer
+	PRIMITIVE_SHORT = 'S',  // signed short
+	PRIMITIVE_BOOLEAN = 'Z' // true or false
+};
+/**
+ * The element_value structure is a discriminated union representing the value of an
+ *element-value pair.
+ * It is used to represent element values in all attributes that describe annotations
+ * - RuntimeVisibleAnnotations
+ * - RuntimeInvisibleAnnotations
+ * - RuntimeVisibleParameterAnnotations
+ * - RuntimeInvisibleParameterAnnotations).
+ *
+ * The element_value structure has the following format:
+ */
+class element_value
+{
+protected:
+	element_value_type type;
+	constant_pool &pool;
+
+public:
+	element_value(element_value_type type, constant_pool &pool) : type(type), pool(pool) {};
+
+	element_value_type getElementValueType()
+	{
+		return type;
+	}
+
+	virtual std::string toString() = 0;
+
+	static element_value *readElementValue(util::membuffer &input, constant_pool &pool);
+};
+
+/**
+ * Each value of the annotations table represents a single runtime-visible annotation on a
+ * program element.
+ * The annotation structure has the following format:
+ */
+class annotation
+{
+public:
+	typedef std::vector<std::pair<uint16_t, element_value *>> value_list;
+
+protected:
 	/**
-	 * The element_value structure is a discriminated union representing the value of an element-value pair.
-	 * It is used to represent element values in all attributes that describe annotations
-	 * - RuntimeVisibleAnnotations
-	 * - RuntimeInvisibleAnnotations
-	 * - RuntimeVisibleParameterAnnotations
-	 * - RuntimeInvisibleParameterAnnotations).
+	 * The value of the type_index item must be a valid index into the constant_pool table.
+	 * The constant_pool entry at that index must be a CONSTANT_Utf8_info (§4.4.7) structure
+	 * representing a field descriptor representing the annotation type corresponding
+	 * to the annotation represented by this annotation structure.
+	 */
+	uint16_t type_index;
+	/**
+	 * map between element_name_index and value.
 	 *
-	 * The element_value structure has the following format:
+	 * The value of the element_name_index item must be a valid index into the constant_pool
+	 *table.
+	 * The constant_pool entry at that index must be a CONSTANT_Utf8_info (§4.4.7) structure
+	 *representing
+	 * a valid field descriptor (§4.3.2) that denotes the name of the annotation type element
+	 *represented
+	 * by this element_value_pairs entry.
 	 */
-	class element_value
-	{
-	protected:
-		element_value_type type;
-		constant_pool & pool;
-
-	public:
-		element_value(element_value_type type, constant_pool & pool): type(type), pool(pool) {};
+	value_list name_val_pairs;
+	/**
+	 * Reference to the parent constant pool
+	 */
+	constant_pool &pool;
 
-		element_value_type getElementValueType()
+public:
+	annotation(uint16_t type_index, constant_pool &pool)
+		: type_index(type_index), pool(pool) {};
+	~annotation()
+	{
+		for (unsigned i = 0; i < name_val_pairs.size(); i++)
 		{
-			return type;
+			delete name_val_pairs[i].second;
 		}
-		
-		virtual std::string toString() = 0;
+	}
+	void add_pair(uint16_t key, element_value *value)
+	{
+		name_val_pairs.push_back(std::make_pair(key, value));
+	}
+	;
+	value_list::const_iterator begin()
+	{
+		return name_val_pairs.cbegin();
+	}
+	value_list::const_iterator end()
+	{
+		return name_val_pairs.cend();
+	}
+	std::string toString();
+	static annotation *read(util::membuffer &input, constant_pool &pool);
+};
+typedef std::vector<annotation *> annotation_table;
+
+/// type for simple value annotation elements
+class element_value_simple : public element_value
+{
+protected:
+	/// index of the constant in the constant pool
+	uint16_t index;
 
-		static element_value * readElementValue(util::membuffer & input, constant_pool & pool);
-	};
-	
+public:
+	element_value_simple(element_value_type type, uint16_t index, constant_pool &pool)
+		: element_value(type, pool), index(index) {
+										 // TODO: verify consistency
+									 };
+	uint16_t getIndex()
+	{
+		return index;
+	}
+	virtual std::string toString()
+	{
+		return pool[index].toString();
+	}
+	;
+};
+/// The enum_const_value item is used if the tag item is 'e'.
+class element_value_enum : public element_value
+{
+protected:
 	/**
-	 * Each value of the annotations table represents a single runtime-visible annotation on a program element.
-	 * The annotation structure has the following format:
+	 * The value of the type_name_index item must be a valid index into the constant_pool table.
+	 * The constant_pool entry at that index must be a CONSTANT_Utf8_info (§4.4.7) structure
+	 * representing a valid field descriptor (§4.3.2) that denotes the internal form of the
+	 * binary
+	 * name (§4.2.1) of the type of the enum constant represented by this element_value
+	 * structure.
 	 */
-	class annotation
-	{
-	public:
-		typedef std::vector< std::pair<uint16_t, element_value * > > value_list;
-	protected:
-		/**
-		 * The value of the type_index item must be a valid index into the constant_pool table.
-		 * The constant_pool entry at that index must be a CONSTANT_Utf8_info (§4.4.7) structure
-		 * representing a field descriptor representing the annotation type corresponding
-		 * to the annotation represented by this annotation structure.
-		 */
-		uint16_t type_index;
-		/**
-		 * map between element_name_index and value.
-		 * 
-		 * The value of the element_name_index item must be a valid index into the constant_pool table.
-		 * The constant_pool entry at that index must be a CONSTANT_Utf8_info (§4.4.7) structure representing
-		 * a valid field descriptor (§4.3.2) that denotes the name of the annotation type element represented
-		 * by this element_value_pairs entry.
-		 */
-		value_list name_val_pairs;
-		/**
-		 * Reference to the parent constant pool
-		 */
-		constant_pool & pool;
-	public:
-		annotation(uint16_t type_index, constant_pool& pool):type_index(type_index), pool(pool) {};
-		~annotation()
-		{
-			for(unsigned i = 0 ; i < name_val_pairs.size(); i++)
-			{
-				delete name_val_pairs[i].second;
-			}
-		}
-		void add_pair(uint16_t key, element_value * value)
-		{
-			name_val_pairs.push_back(std::make_pair(key, value));
-		};
-		value_list::const_iterator begin()
-		{
-			return name_val_pairs.cbegin();
-		}
-		value_list::const_iterator end()
-		{
-			return name_val_pairs.cend();
-		}
-		std::string toString();
-		static annotation * read(util::membuffer & input, constant_pool & pool);
-	};
-	typedef std::vector<annotation *> annotation_table;
-	
-	
-	/// type for simple value annotation elements
-	class element_value_simple : public element_value
-	{
-	protected:
-		/// index of the constant in the constant pool
-		uint16_t index;
-	public:
-		element_value_simple(element_value_type type, uint16_t index , constant_pool& pool):
-		element_value(type, pool), index(index)
-		{
-			// TODO: verify consistency
-		};
-		uint16_t getIndex()
-		{
-			return index;
-		}
-		virtual std::string toString()
-		{
-			return pool[index].toString();
-		};
-	};
-	/// The enum_const_value item is used if the tag item is 'e'.
-	class element_value_enum : public element_value
-	{
-	protected:
-		/**
-		 * The value of the type_name_index item must be a valid index into the constant_pool table.
-		 * The constant_pool entry at that index must be a CONSTANT_Utf8_info (§4.4.7) structure
-		 * representing a valid field descriptor (§4.3.2) that denotes the internal form of the binary
-		 * name (§4.2.1) of the type of the enum constant represented by this element_value structure.
-		 */
-		uint16_t typeIndex;
-		/**
-		 * The value of the const_name_index item must be a valid index into the constant_pool table.
-		 * The constant_pool entry at that index must be a CONSTANT_Utf8_info (§4.4.7) structure
-		 * representing the simple name of the enum constant represented by this element_value structure.
-		 */
-		uint16_t valueIndex;
-	public:
-		element_value_enum(element_value_type type, uint16_t typeIndex, uint16_t valueIndex, constant_pool& pool):
-		element_value(type, pool), typeIndex(typeIndex), valueIndex(valueIndex)
-		{
-			// TODO: verify consistency
-		}
-		uint16_t getValueIndex()
-		{
-			return valueIndex;
-		}
-		uint16_t getTypeIndex()
-		{
-			return typeIndex;
-		}
-		virtual std::string toString()
-		{
-			return "enum value";
-		};
-	};
-	
-	class element_value_class : public element_value
-	{
-	protected:
-		/**
-		 * The class_info_index item must be a valid index into the constant_pool table.
-		 * The constant_pool entry at that index must be a CONSTANT_Utf8_info (§4.4.7) structure
-		 * representing the return descriptor (§4.3.3) of the type that is reified by the class
-		 * represented by this element_value structure.
-		 * 
-		 * For example, 'V' for Void.class, 'Ljava/lang/Object;' for Object, etc.
-		 * 
-		 * Or in plain english, you can store type information in annotations. Yay.
-		 */
-		uint16_t classIndex;
-	public:
-		element_value_class(element_value_type type, uint16_t classIndex, constant_pool& pool):
-		element_value(type, pool), classIndex(classIndex)
-		{
-			// TODO: verify consistency
-		}
-		uint16_t getIndex()
-		{
-			return classIndex;
-		}
-		virtual std::string toString()
-		{
-			return "class";
-		};
-	};
-	
-	/// nested annotations... yay
-	class element_value_annotation : public element_value
-	{
-	private:
-		annotation * nestedAnnotation;
-	public:
-		element_value_annotation(element_value_type type, annotation * nestedAnnotation, constant_pool& pool):
-		element_value(type, pool), nestedAnnotation(nestedAnnotation)
-		{};
-		~element_value_annotation()
-		{
-			if(nestedAnnotation)
-			{
-				delete nestedAnnotation;
-				nestedAnnotation = nullptr;
-			}
-		}
-		virtual std::string toString()
-		{
-			return "nested annotation";
-		};
-	};
-	
-	/// and arrays!
-	class element_value_array : public element_value
-	{
-	public:
-		typedef std::vector <element_value *> elem_vec;
-	protected:
-		elem_vec values;
-	public:
-		element_value_array ( element_value_type type, std::vector <element_value *>& values, constant_pool& pool ):
-		element_value(type, pool), values(values)
-		{};
-		~element_value_array ()
-		{
-			for(unsigned i = 0; i < values.size();i++)
-			{
-				delete values[i];
-			}
-		};
-		elem_vec::const_iterator begin()
+	uint16_t typeIndex;
+	/**
+	 * The value of the const_name_index item must be a valid index into the constant_pool
+	 * table.
+	 * The constant_pool entry at that index must be a CONSTANT_Utf8_info (§4.4.7) structure
+	 * representing the simple name of the enum constant represented by this element_value
+	 * structure.
+	 */
+	uint16_t valueIndex;
+
+public:
+	element_value_enum(element_value_type type, uint16_t typeIndex, uint16_t valueIndex,
+					   constant_pool &pool)
+		: element_value(type, pool), typeIndex(typeIndex), valueIndex(valueIndex)
+	{
+		// TODO: verify consistency
+	}
+	uint16_t getValueIndex()
+	{
+		return valueIndex;
+	}
+	uint16_t getTypeIndex()
+	{
+		return typeIndex;
+	}
+	virtual std::string toString()
+	{
+		return "enum value";
+	}
+	;
+};
+
+class element_value_class : public element_value
+{
+protected:
+	/**
+	 * The class_info_index item must be a valid index into the constant_pool table.
+	 * The constant_pool entry at that index must be a CONSTANT_Utf8_info (§4.4.7) structure
+	 * representing the return descriptor (§4.3.3) of the type that is reified by the class
+	 * represented by this element_value structure.
+	 *
+	 * For example, 'V' for Void.class, 'Ljava/lang/Object;' for Object, etc.
+	 *
+	 * Or in plain english, you can store type information in annotations. Yay.
+	 */
+	uint16_t classIndex;
+
+public:
+	element_value_class(element_value_type type, uint16_t classIndex, constant_pool &pool)
+		: element_value(type, pool), classIndex(classIndex)
+	{
+		// TODO: verify consistency
+	}
+	uint16_t getIndex()
+	{
+		return classIndex;
+	}
+	virtual std::string toString()
+	{
+		return "class";
+	}
+	;
+};
+
+/// nested annotations... yay
+class element_value_annotation : public element_value
+{
+private:
+	annotation *nestedAnnotation;
+
+public:
+	element_value_annotation(element_value_type type, annotation *nestedAnnotation,
+							 constant_pool &pool)
+		: element_value(type, pool), nestedAnnotation(nestedAnnotation) {};
+	~element_value_annotation()
+	{
+		if (nestedAnnotation)
 		{
-			return values.cbegin();
+			delete nestedAnnotation;
+			nestedAnnotation = nullptr;
 		}
-		elem_vec::const_iterator end()
+	}
+	virtual std::stri