diff options
Diffstat (limited to 'java/annotations.h')
| -rw-r--r-- | java/annotations.h | 252 |
1 files changed, 0 insertions, 252 deletions
diff --git a/java/annotations.h b/java/annotations.h deleted file mode 100644 index b115dc0b..00000000 --- a/java/annotations.h +++ /dev/null @@ -1,252 +0,0 @@ -#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 |