Move all the things (YES. Move them.)

Also, implemented some basic modlist logic, to be wired up.

1 files changed, 252 insertions, 0 deletions

diff --git a/depends/classparser/src/annotations.h b/depends/classparser/src/annotations.h
new file mode 100644
index 00000000..b115dc0b
--- /dev/null
+++ b/depends/classparser/src/annotations.h
@@ -0,0 +1,252 @@
+#pragma once
+#include "classfile.h"
+#include <map>
+#include <vector>
+
+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
+	};
+	/**
+	 * 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 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()
+		{
+			return values.cbegin();
+		}
+		elem_vec::const_iterator end()
+		{
+			return values.cend();
+		}
+		virtual std::string toString()
+		{
+			return "array";
+		};
+	};
+}
\ No newline at end of file