677 lines
23 KiB
Java
677 lines
23 KiB
Java
/*
|
|
* Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
package org.openjdk.asmtools.jasm;
|
|
|
|
import java.io.IOException;
|
|
import java.io.PrintWriter;
|
|
import java.util.HashMap;
|
|
|
|
/**
|
|
*
|
|
* Tables
|
|
*
|
|
* The classes in Tables are following a Singleton Pattern. These classes are Enums, and
|
|
* they are contained in private hash maps (lookup tables and reverse lookup tables).
|
|
* These hash maps all have public accessors, which clients use to look-up enums.
|
|
*
|
|
* Tokens in this table carry no external state, and are typically treated as constants.
|
|
* They do not need to be reset.
|
|
*
|
|
*/
|
|
public class Tables {
|
|
|
|
public static final int JAVA_MAGIC = 0xCAFEBABE;
|
|
/**
|
|
* Lookup-tables for various types.
|
|
*/
|
|
private static HashMap<String, AttrTag> NameToAttrTag = new HashMap<>(9);
|
|
private static HashMap<Integer, AttrTag> AttrTags = new HashMap<>(9);
|
|
|
|
private static HashMap<String, SubTag> NameToSubTag = new HashMap<>(9);
|
|
private static HashMap<Integer, SubTag> SubTags = new HashMap<>(9);
|
|
|
|
private static HashMap<String, BasicType> NameToBasicType = new HashMap<>(10);
|
|
private static HashMap<Integer, BasicType> BasicTypes = new HashMap<>(10);
|
|
|
|
private static HashMap<String, AnnotElemType> NameToAnnotElemType = new HashMap<>(10);
|
|
private static HashMap<Character, AnnotElemType> AnnotElemTypes = new HashMap<>(10);
|
|
|
|
private static HashMap<String, StackMapType> KeyToStackMapType = new HashMap<>(10);
|
|
private static HashMap<String, StackMapType> NameToStackMapType = new HashMap<>(10);
|
|
private static HashMap<Integer, StackMapType> StackMapTypes = new HashMap<>(10);
|
|
|
|
private static HashMap<String, StackMapFrameType> NameToStackMapFrameType = new HashMap<>(10);
|
|
private static HashMap<Integer, StackMapFrameType> StackMapFrameTypes = new HashMap<>(10);
|
|
|
|
private static HashMap<String, ConstType> NameToConstantType = new HashMap<>(ConstType.maxTag);
|
|
private static HashMap<Integer, ConstType> ConstantTypes = new HashMap<>(ConstType.maxTag);
|
|
|
|
static {
|
|
// register all of the tokens
|
|
for (ConstType ct : ConstType.values()) {
|
|
registerConstantType(ct);
|
|
}
|
|
|
|
/* Type codes for SubTags */
|
|
for (AttrTag at : AttrTag.values()) {
|
|
registerAttrtag(at);
|
|
}
|
|
|
|
/* Type codes for SubTags */
|
|
for (SubTag st : SubTag.values()) {
|
|
registerSubtag(st);
|
|
}
|
|
|
|
/* Type codes for BasicTypes */
|
|
for (BasicType bt : BasicType.values()) {
|
|
registerBasicType(bt);
|
|
}
|
|
|
|
/* Type codes for BasicTypes */
|
|
for (AnnotElemType aet : AnnotElemType.values()) {
|
|
registerAnnotElemType(aet);
|
|
}
|
|
|
|
/* Type codes for StackMapTypes */
|
|
for (StackMapType smt : StackMapType.values()) {
|
|
registerStackMapType(smt);
|
|
}
|
|
|
|
/* Type codes for StackMapFrame attribute */
|
|
for (StackMapFrameType smft : StackMapFrameType.values()) {
|
|
registerStackMapFrameType(smft);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* ConstType
|
|
*
|
|
* A (typed) tag (constant) representing the type of Constant in the Constant Pool.
|
|
*/
|
|
static public enum ConstType {
|
|
CONSTANT_ZERO (-3, "CONSTANT_ZERO", ""),
|
|
CONSTANT_UTF8 (1, "CONSTANT_UTF8", "Asciz"),
|
|
CONSTANT_UNICODE (2, "CONSTANT_UNICODE", ""),
|
|
CONSTANT_INTEGER (3, "CONSTANT_INTEGER", "int"),
|
|
CONSTANT_FLOAT (4, "CONSTANT_FLOAT", "float"),
|
|
CONSTANT_LONG (5, "CONSTANT_LONG", "long"),
|
|
CONSTANT_DOUBLE (6, "CONSTANT_DOUBLE", "double"),
|
|
CONSTANT_CLASS (7, "CONSTANT_CLASS", "class"),
|
|
CONSTANT_STRING (8, "CONSTANT_STRING", "String"),
|
|
CONSTANT_FIELD (9, "CONSTANT_FIELD", "Field"),
|
|
CONSTANT_METHOD (10, "CONSTANT_METHOD", "Method"),
|
|
CONSTANT_INTERFACEMETHOD (11, "CONSTANT_INTERFACEMETHOD", "InterfaceMethod"),
|
|
CONSTANT_NAMEANDTYPE (12, "CONSTANT_NAMEANDTYPE", "NameAndType"),
|
|
// Constant 13 reserved
|
|
// Constant 14 reserved
|
|
CONSTANT_METHODHANDLE (15, "CONSTANT_METHODHANDLE", "MethodHandle"),
|
|
CONSTANT_METHODTYPE (16, "CONSTANT_METHODTYPE", "MethodType"),
|
|
// Constant 17 reserved
|
|
CONSTANT_INVOKEDYNAMIC (18, "CONSTANT_INVOKEDYNAMIC", "InvokeDynamic"),
|
|
CONSTANT_MODULE (19, "CONSTANT_MODULE", "Module"),
|
|
CONSTANT_PACKAGE (20, "CONSTANT_PACKAGE", "Package");
|
|
|
|
static final public int maxTag = 20;
|
|
|
|
private final int value;
|
|
private final String parseKey;
|
|
private final String printval;
|
|
|
|
ConstType(int val, String print, String parse) {
|
|
value = val;
|
|
parseKey = parse;
|
|
printval = print;
|
|
}
|
|
|
|
public int value() {
|
|
return value;
|
|
}
|
|
|
|
public String parseKey() {
|
|
return parseKey;
|
|
}
|
|
|
|
public String printval() {
|
|
return printval;
|
|
}
|
|
|
|
public void print(PrintWriter out) {
|
|
out.print(parseKey);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "<" + printval + "> [" + Integer.toString(value) + "]";
|
|
}
|
|
};
|
|
|
|
static public ConstType tag(int i) {
|
|
return ConstantTypes.get(i);
|
|
}
|
|
|
|
static public ConstType tag(String parsekey) {
|
|
return NameToConstantType.get(parsekey);
|
|
}
|
|
|
|
private static void registerConstantType(ConstType tt) {
|
|
NameToConstantType.put(tt.parseKey, tt);
|
|
ConstantTypes.put(tt.value, tt);
|
|
}
|
|
|
|
/*-------------------------------------------------------- */
|
|
/**
|
|
* Attribute descriptor enums
|
|
*/
|
|
static public enum AttrTag {
|
|
|
|
// Constant for ME Spec (StackMap does not appear in SE VM Spec)
|
|
ATT_Unrecognized (0, "ATT_Unrecognized", ""),
|
|
ATT_StackMap (1, "ATT_StackMap", "StackMap"),
|
|
// Numbers corespond to VM spec (chapter 4.7.X)
|
|
ATT_ConstantValue (2, "ATT_ConstantValue", "ConstantValue"),
|
|
ATT_Code (3, "ATT_Code", "Code"),
|
|
ATT_StackMapTable (4, "ATT_StackMapTable", "StackMapTable"),
|
|
ATT_Exceptions (5, "ATT_Exceptions", "Exceptions"),
|
|
ATT_InnerClasses (6, "ATT_InnerClasses", "InnerClasses"),
|
|
ATT_EnclosingMethod (7, "ATT_EnclosingMethod", "EnclosingMethod"),
|
|
ATT_Synthetic (8, "ATT_Synthetic", "Synthetic"),
|
|
ATT_Signature (9, "ATT_Signature", "Signature"),
|
|
ATT_SourceFile (10, "ATT_SourceFile", "SourceFile"),
|
|
ATT_SourceDebugExtension (11, "ATT_SourceDebugExtension", "SourceDebugExtension"),
|
|
ATT_LineNumberTable (12, "ATT_LineNumberTable", "LineNumberTable"),
|
|
ATT_LocalVariableTable (13, "ATT_LocalVariableTable", "LocalVariableTable"),
|
|
ATT_LocalVariableTypeTable (14, "ATT_LocalVariableTypeTable", "LocalVariableTypeTable"),
|
|
ATT_Deprecated (15, "ATT_Deprecated", "Deprecated"),
|
|
ATT_RuntimeVisibleAnnotations (16, "ATT_RuntimeVisibleAnnotations", "RuntimeVisibleAnnotations"),
|
|
ATT_RuntimeInvisibleAnnotations (17, "ATT_RuntimeInvisibleAnnotations", "RuntimeInvisibleAnnotations"),
|
|
ATT_RuntimeVisibleParameterAnnotations (18, "ATT_RuntimeVisibleParameterAnnotations", "RuntimeVisibleParameterAnnotations"),
|
|
ATT_RuntimeInvisibleParameterAnnotations (19, "ATT_RuntimeInvisibleParameterAnnotations", "RuntimeInvisibleParameterAnnotations"),
|
|
ATT_AnnotationDefault (20, "ATT_AnnotationDefault", "AnnotationDefault"),
|
|
ATT_BootstrapMethods (21, "ATT_BootstrapMethods", "BootstrapMethods"),
|
|
ATT_RuntimeVisibleTypeAnnotations (22, "ATT_RuntimeVisibleTypeAnnotations", "RuntimeVisibleTypeAnnotations"),
|
|
ATT_RuntimeInvisibleTypeAnnotations (23, "ATT_RuntimeInvisibleTypeAnnotations", "RuntimeInvisibleTypeAnnotations"),
|
|
ATT_MethodParameters (24, "ATT_MethodParameters", "MethodParameters"),
|
|
ATT_Module (25, "ATT_Module", "Module"),
|
|
ATT_Version (26, "ATT_Version", "Version"),
|
|
ATT_TargetPlatform (27, "ATT_TargetPlatform", "TargetPlatform"),
|
|
ATT_MainClass (28, "ATT_MainClass", "MainClass"),
|
|
ATT_ModulePackages (29, "ATT_ModulePackages", "ModulePackages"),
|
|
ATT_ModuleMainClass (30, "ATT_ModuleMainClass", "ModuleMainClass"),
|
|
ATT_ModuleTarget (31, "ATT_ModuleTarget", "ModuleTarget");
|
|
|
|
private final Integer value;
|
|
private final String printval;
|
|
private final String parsekey;
|
|
|
|
AttrTag(Integer val, String print, String parse) {
|
|
value = val;
|
|
printval = print;
|
|
parsekey = parse;
|
|
}
|
|
|
|
public String printval() {
|
|
return printval;
|
|
}
|
|
|
|
public String parsekey() {
|
|
return parsekey;
|
|
}
|
|
}
|
|
|
|
private static void registerAttrtag(AttrTag tg) {
|
|
NameToAttrTag.put(tg.parsekey, tg);
|
|
AttrTags.put(tg.value, tg);
|
|
}
|
|
|
|
public static AttrTag attrtag(int val) {
|
|
AttrTag tg = AttrTags.get(val);
|
|
if (tg == null) {
|
|
tg = AttrTag.ATT_Unrecognized;
|
|
}
|
|
return tg;
|
|
}
|
|
|
|
public static AttrTag attrtag(String idValue) {
|
|
AttrTag tg = NameToAttrTag.get(idValue);
|
|
if (tg == null) {
|
|
tg = AttrTag.ATT_Unrecognized;
|
|
}
|
|
return tg;
|
|
}
|
|
|
|
public static String attrtagName(int subtag) {
|
|
AttrTag tg = AttrTags.get(subtag);
|
|
return tg.parsekey;
|
|
}
|
|
|
|
public static int attrtagValue(String idValue) {
|
|
AttrTag tg = attrtag(idValue);
|
|
return tg.value;
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------- */
|
|
/**
|
|
* SubTag enums
|
|
*/
|
|
static public enum SubTag {
|
|
REF_GETFIELD (1, "REF_getField"),
|
|
REF_GETSTATIC (2, "REF_getStatic"),
|
|
REF_PUTFIELD (3, "REF_putField"),
|
|
REF_PUTSTATIC (4, "REF_putStatic"),
|
|
REF_INVOKEVIRTUAL (5, "REF_invokeVirtual"),
|
|
REF_INVOKESTATIC (6, "REF_invokeStatic"),
|
|
REF_INVOKESPECIAL (7, "REF_invokeSpecial"),
|
|
REF_NEWINVOKESPECIAL (8, "REF_newInvokeSpecial"),
|
|
REF_INVOKEINTERFACE (9, "REF_invokeInterface");
|
|
|
|
private final Integer value;
|
|
private final String printval;
|
|
|
|
SubTag(Integer val, String print) {
|
|
value = val;
|
|
printval = print;
|
|
}
|
|
|
|
public String printval() {
|
|
return printval;
|
|
}
|
|
|
|
public Integer value() {
|
|
return value;
|
|
}
|
|
}
|
|
|
|
private static void registerSubtag(SubTag tg) {
|
|
NameToSubTag.put(tg.printval, tg);
|
|
SubTags.put(tg.value, tg);
|
|
}
|
|
|
|
public static SubTag subtag(String subtag) {
|
|
return NameToSubTag.get(subtag);
|
|
}
|
|
|
|
public static SubTag subtag(int subtag) {
|
|
return SubTags.get(subtag);
|
|
}
|
|
|
|
public static String subtagName(int subtag) {
|
|
String retval = null;
|
|
SubTag tg = SubTags.get(subtag);
|
|
if (tg != null) {
|
|
retval = tg.printval;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
public static int subtagValue(String idValue) {
|
|
int retval = 0;
|
|
SubTag tg = NameToSubTag.get(idValue);
|
|
if (tg != null) {
|
|
retval = tg.value;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
/*-------------------------------------------------------- */
|
|
/**
|
|
* BasicType enums
|
|
*/
|
|
static public enum BasicType {
|
|
T_INT (0x0000000a, "int"),
|
|
T_LONG (0x0000000b, "long"),
|
|
T_FLOAT (0x00000006, "float"),
|
|
T_DOUBLE (0x00000007, "double"),
|
|
T_CLASS (0x00000002, "class"),
|
|
T_BOOLEAN (0x00000004, "boolean"),
|
|
T_CHAR (0x00000005, "char"),
|
|
T_BYTE (0x00000008, "byte"),
|
|
T_SHORT (0x00000009, "short");
|
|
|
|
private final Integer value;
|
|
private final String printval;
|
|
|
|
BasicType(Integer val, String print) {
|
|
value = val;
|
|
printval = print;
|
|
}
|
|
|
|
public String printval() {
|
|
return printval;
|
|
}
|
|
}
|
|
|
|
private static void registerBasicType(BasicType typ) {
|
|
NameToBasicType.put(typ.printval, typ);
|
|
BasicTypes.put(typ.value, typ);
|
|
}
|
|
|
|
public static BasicType basictype(String idValue) {
|
|
return NameToBasicType.get(idValue);
|
|
}
|
|
|
|
public static BasicType basictype(int subtag) {
|
|
return BasicTypes.get(subtag);
|
|
}
|
|
|
|
public static String basictypeName(int subtag) {
|
|
String retval = null;
|
|
BasicType tg = BasicTypes.get(subtag);
|
|
if (tg != null) {
|
|
retval = tg.printval;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
public static int basictypeValue(String idValue) {
|
|
int retval = -1;
|
|
BasicType tg = NameToBasicType.get(idValue);
|
|
if (tg != null) {
|
|
retval = tg.value;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
/*-------------------------------------------------------- */
|
|
/**
|
|
* AnnotElemType enums
|
|
*/
|
|
static public enum AnnotElemType {
|
|
|
|
AE_BYTE ('B', "byte"),
|
|
AE_CHAR ('C', "char"),
|
|
AE_SHORT ('S', "short"),
|
|
AE_INT ('I', "int"),
|
|
AE_LONG ('J', "long"),
|
|
AE_FLOAT ('F', "float"),
|
|
AE_DOUBLE ('D', "double"),
|
|
AE_BOOLEAN ('Z', "boolean"),
|
|
AE_STRING ('s', "string"),
|
|
AE_ENUM ('e', "enum"),
|
|
AE_CLASS ('c', "class"),
|
|
AE_ANNOTATION ('@', "annotation"),
|
|
AE_ARRAY ('[', "array"),
|
|
AE_UNKNOWN ((char)0, "unknown");
|
|
|
|
private char value;
|
|
private final String printval;
|
|
|
|
AnnotElemType(char val, String print) {
|
|
value = val;
|
|
printval = print;
|
|
}
|
|
|
|
public char val() {
|
|
return value;
|
|
}
|
|
|
|
public String printval() {
|
|
return printval;
|
|
}
|
|
}
|
|
|
|
private static void registerAnnotElemType(AnnotElemType typ) {
|
|
NameToAnnotElemType.put(typ.printval, typ);
|
|
AnnotElemTypes.put(typ.value, typ);
|
|
}
|
|
|
|
public static AnnotElemType annotElemType(String idValue) {
|
|
return NameToAnnotElemType.get(idValue);
|
|
}
|
|
|
|
public static AnnotElemType annotElemType(char subtag) {
|
|
AnnotElemType type = AnnotElemTypes.get(subtag);
|
|
if ( type == null ) {
|
|
type = AnnotElemType.AE_UNKNOWN;
|
|
}
|
|
return type;
|
|
}
|
|
|
|
public static String annotElemTypeName(char subtag) {
|
|
String retval = null;
|
|
AnnotElemType tg = AnnotElemTypes.get(subtag);
|
|
if (tg != null) {
|
|
retval = tg.printval;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
public static char annotElemTypeVal(String idValue) {
|
|
char retval = 0;
|
|
AnnotElemType tg = NameToAnnotElemType.get(idValue);
|
|
if (tg != null) {
|
|
retval = tg.value;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------- */
|
|
/**
|
|
* MapTypes table. These constants are used in stackmap pseudo-instructions only.
|
|
*/
|
|
static public enum StackMapType {
|
|
/* Type codes for StackMap attribute */
|
|
ITEM_Bogus (0, "bogus", "B"), // an unknown or uninitialized value
|
|
ITEM_Integer (1, "int", "I"), // a 32-bit integer
|
|
ITEM_Float (2, "float", "F"), // not used
|
|
ITEM_Double (3, "double", "D"), // not used
|
|
ITEM_Long (4, "long", "L"), // a 64-bit integer
|
|
ITEM_Null (5, "null", "N"), // the type of null
|
|
ITEM_InitObject (6, "this", "IO"), // "this" in constructor
|
|
ITEM_Object (7, "CP", "O"), // followed by 2-byte index of class name
|
|
ITEM_NewObject (8, "at", "NO"), // followed by 2-byte ref to "new"
|
|
ITEM_UNKNOWN (null, "UNKNOWN", "UNKNOWN"); // placeholder for wrong types
|
|
|
|
private Integer value;
|
|
private final String printval;
|
|
private final String parsekey;
|
|
|
|
StackMapType(Integer val, String print, String parse) {
|
|
value = val;
|
|
printval = print;
|
|
parsekey = parse;
|
|
}
|
|
|
|
public String parsekey() {
|
|
return parsekey;
|
|
}
|
|
|
|
public String printval() {
|
|
return printval;
|
|
}
|
|
|
|
public Integer value() {
|
|
return value;
|
|
}
|
|
}
|
|
|
|
private static void registerStackMapType(StackMapType typ) {
|
|
KeyToStackMapType.put(typ.parsekey, typ);
|
|
NameToStackMapType.put(typ.printval, typ);
|
|
StackMapTypes.put(typ.value, typ);
|
|
}
|
|
|
|
public static StackMapType stackMapType(int subtag, PrintWriter out) {
|
|
StackMapType type = StackMapTypes.get(subtag);
|
|
if (type == null || type == StackMapType.ITEM_UNKNOWN) {
|
|
if (out != null)
|
|
out.println("// Unknown StackMap type " + subtag);
|
|
type = StackMapType.ITEM_UNKNOWN;
|
|
type.value = subtag;
|
|
}
|
|
return type;
|
|
}
|
|
|
|
public static StackMapType stackMapType(String subtag) {
|
|
return NameToStackMapType.get(subtag);
|
|
}
|
|
|
|
public static StackMapType stackMapTypeKey(String subtag) {
|
|
return KeyToStackMapType.get(subtag);
|
|
}
|
|
|
|
public static String stackMapTypeName(int subtag) {
|
|
String retval = null;
|
|
StackMapType tg = StackMapTypes.get(subtag);
|
|
if (tg != null) {
|
|
retval = tg.printval;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
public static int stackMapTypeValue(String idValue) {
|
|
int retval = 0;
|
|
StackMapType tg = NameToStackMapType.get(idValue);
|
|
if (tg != null) {
|
|
retval = tg.value;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------- */
|
|
/**
|
|
* StackMap-FrameType table. These constants are used in stackmap pseudo-instructions
|
|
* only.
|
|
*/
|
|
static public enum StackMapFrameType {
|
|
/* Type codes for StackMapFrame attribute */
|
|
SAME_FRAME (0, "same"),
|
|
SAME_LOCALS_1_STACK_ITEM_FRAME (64, "stack1"),
|
|
SAME_LOCALS_1_STACK_ITEM_EXTENDED_FRAME (247, "stack1_ex"),
|
|
CHOP_1_FRAME (250, "chop1"),
|
|
CHOP_2_FRAME (249, "chop2"),
|
|
CHOP_3_FRAME (248, "chop3"),
|
|
SAME_FRAME_EX (251, "same_ex"),
|
|
APPEND_FRAME (252, "append"),
|
|
FULL_FRAME (255, "full");
|
|
|
|
private final Integer value;
|
|
private final String parsekey;
|
|
|
|
StackMapFrameType(Integer val, String print) {
|
|
value = val;
|
|
parsekey = print;
|
|
}
|
|
|
|
public String parsekey() {
|
|
return parsekey;
|
|
}
|
|
|
|
public Integer value() {
|
|
return value;
|
|
}
|
|
}
|
|
|
|
private static void registerStackMapFrameType(StackMapFrameType typ) {
|
|
NameToStackMapFrameType.put(typ.parsekey, typ);
|
|
StackMapFrameTypes.put(typ.value, typ);
|
|
}
|
|
|
|
public static StackMapFrameType stackMapFrameTypeVal(int subtag) {
|
|
return StackMapFrameTypes.get(subtag);
|
|
}
|
|
|
|
public static String stackMapFrameTypeName(int subtag) {
|
|
String retval = null;
|
|
StackMapFrameType tg = StackMapFrameTypes.get(subtag);
|
|
if (tg != null) {
|
|
retval = tg.parsekey;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
public static StackMapFrameType stackMapFrameType(int subtag) {
|
|
StackMapFrameType frametype;
|
|
if (subtag < StackMapFrameType.SAME_LOCALS_1_STACK_ITEM_FRAME.value()) {
|
|
// type is same_frame;
|
|
frametype = StackMapFrameType.SAME_FRAME;
|
|
} else if (subtag >= StackMapFrameType.SAME_LOCALS_1_STACK_ITEM_FRAME.value()
|
|
&& subtag <= 127) {
|
|
// type is same_locals_1_stack_item_frame
|
|
frametype = StackMapFrameType.SAME_LOCALS_1_STACK_ITEM_FRAME;
|
|
|
|
} else if (subtag >= StackMapFrameType.APPEND_FRAME.value()
|
|
&& subtag < StackMapFrameType.FULL_FRAME.value()) {
|
|
// type is append_frame
|
|
frametype = StackMapFrameType.APPEND_FRAME;
|
|
} else {
|
|
frametype = StackMapFrameTypes.get(subtag);
|
|
}
|
|
return frametype;
|
|
}
|
|
|
|
public static int stackMapFrameTypeValue(String idValue) {
|
|
int retval = 0;
|
|
StackMapFrameType tg = NameToStackMapFrameType.get(idValue);
|
|
if (tg != null) {
|
|
retval = tg.value;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
/*-------------------------------------------------------- */
|
|
/**
|
|
* CF_Context enums
|
|
*/
|
|
static public enum CF_Context {
|
|
|
|
CTX_CLASS (0, "class"),
|
|
CTX_FIELD (1, "field"),
|
|
CTX_METHOD (2, "method"),
|
|
CTX_INNERCLASS (3, "inner-class"),
|
|
CTX_MODULE (4, "module") ;
|
|
|
|
private final int value;
|
|
private final String printval;
|
|
|
|
CF_Context(int val, String print) {
|
|
value = val;
|
|
printval = print;
|
|
}
|
|
|
|
public int val() {
|
|
return value;
|
|
}
|
|
|
|
public String printval() {
|
|
return printval;
|
|
}
|
|
}
|
|
|
|
private static void registerAnnotElemType(CF_Context ctx) {
|
|
// NameToAnnotElemType.put(typ.printval, typ);
|
|
// AnnotElemTypes.put(typ.value, typ);
|
|
}
|
|
/*
|
|
public static CF_Context annotElemType(String idValue) {
|
|
return NameToAnnotElemType.get(idValue);
|
|
}
|
|
public static CF_Context annotElemType(int subtag) {
|
|
return AnnotElemTypes.get(subtag);
|
|
}
|
|
*/
|
|
}
|