001 /* 002 * The JastAdd Extensible Java Compiler (http://jastadd.org) is covered 003 * by the modified BSD License. You should have received a copy of the 004 * modified BSD license with this compiler. 005 * 006 * Copyright (c) 2005-2008, Torbjorn Ekman 007 * All rights reserved. 008 */ 009 010 aspect BytecodeCONSTANT { 011 class CONSTANT_Class_Info extends CONSTANT_Info { 012 public int name_index; 013 014 public CONSTANT_Class_Info(BytecodeParser parser) { 015 super(parser); 016 name_index = p.u2(); 017 } 018 019 public String toString() { 020 return "ClassInfo: " + name(); 021 } 022 023 public String name() { 024 String name = ((CONSTANT_Utf8_Info) this.p.constantPool[name_index]).string(); 025 //name = name.replaceAll("\\/", "."); 026 name = name.replace('/', '.'); 027 return name; 028 } 029 030 public String simpleName() { 031 String name = name(); 032 //name = name.replace('$', '.'); 033 int pos = name.lastIndexOf('.'); 034 return name.substring(pos + 1, name.length()); 035 } 036 037 public String packageDecl() { 038 String name = name(); 039 //name = name.replace('$', '.'); 040 int pos = name.lastIndexOf('.'); 041 if(pos == -1) 042 return ""; 043 return name.substring(0, pos); 044 } 045 046 public Access access() { 047 String name = name(); 048 int pos = name.lastIndexOf('.'); 049 String typeName = name.substring(pos + 1, name.length()); 050 String packageName = pos == -1 ? "" : name.substring(0, pos); 051 if(typeName.indexOf('$') != -1) 052 return new BytecodeTypeAccess(packageName, typeName); 053 else 054 return new TypeAccess(packageName, typeName); 055 } 056 } 057 058 // refineable methods for literal building 059 public static Literal Literal.buildDoubleLiteral(double value) { 060 return new DoubleLiteral(Double.toString(value)); 061 } 062 063 public static Literal Literal.buildFloatLiteral(float value) { 064 return new FloatingPointLiteral(Double.toString(value)); 065 } 066 067 public static Literal Literal.buildIntegerLiteral(int value) { 068 return new IntegerLiteral("0x"+Integer.toHexString(value)); 069 } 070 071 public static Literal Literal.buildLongLiteral(long value) { 072 return new LongLiteral("0x"+Long.toHexString(value)); 073 } 074 075 public static Literal Literal.buildBooleanLiteral(boolean value) { 076 return new BooleanLiteral(value ? "true" : "false"); 077 } 078 079 public static Literal Literal.buildStringLiteral(String value) { 080 return new StringLiteral(value); 081 } 082 083 class CONSTANT_Double_Info extends CONSTANT_Info { 084 public double value; 085 086 public CONSTANT_Double_Info(BytecodeParser parser) { 087 super(parser); 088 value = this.p.readDouble(); 089 } 090 091 public String toString() { 092 return "DoubleInfo: " + Double.toString(value); 093 } 094 095 public Expr expr() { 096 return Literal.buildDoubleLiteral(value); 097 } 098 } 099 100 class CONSTANT_Fieldref_Info extends CONSTANT_Info { 101 public int class_index; 102 public int name_and_type_index; 103 104 public CONSTANT_Fieldref_Info(BytecodeParser parser) { 105 super(parser); 106 class_index = p.u2(); 107 name_and_type_index = p.u2(); 108 } 109 110 public String toString() { 111 return "FieldRefInfo: " + p.constantPool[class_index] + " " 112 + p.constantPool[name_and_type_index]; 113 } 114 } 115 116 class CONSTANT_Float_Info extends CONSTANT_Info { 117 public float value; 118 119 public CONSTANT_Float_Info(BytecodeParser parser) { 120 super(parser); 121 value = p.readFloat(); 122 } 123 124 public String toString() { 125 return "FloatInfo: " + Float.toString(value); 126 } 127 128 public Expr expr() { 129 return Literal.buildFloatLiteral(value); 130 } 131 } 132 133 class CONSTANT_Info { 134 protected BytecodeParser p; 135 public CONSTANT_Info(BytecodeParser parser) { 136 p = parser; 137 138 } 139 public Expr expr() { 140 throw new Error("CONSTANT_info.expr() should not be computed for " + getClass().getName()); 141 } 142 public Expr exprAsBoolean() { 143 return expr(); 144 } 145 } 146 147 class CONSTANT_Integer_Info extends CONSTANT_Info { 148 public int value; 149 150 public CONSTANT_Integer_Info(BytecodeParser parser) { 151 super(parser); 152 value = p.readInt(); 153 } 154 155 public String toString() { 156 return "IntegerInfo: " + Integer.toString(value); 157 } 158 159 public Expr expr() { 160 return Literal.buildIntegerLiteral(value); 161 } 162 public Expr exprAsBoolean() { 163 return Literal.buildBooleanLiteral(value == 0); 164 } 165 } 166 class CONSTANT_InterfaceMethodref_Info extends CONSTANT_Info { 167 public int class_index; 168 public int name_and_type_index; 169 170 public CONSTANT_InterfaceMethodref_Info(BytecodeParser parser) { 171 super(parser); 172 class_index = p.u2(); 173 name_and_type_index = p.u2(); 174 } 175 176 public String toString() { 177 return "InterfaceMethodRefInfo: " + p.constantPool[class_index] + " " 178 + p.constantPool[name_and_type_index]; 179 } 180 } 181 class CONSTANT_Long_Info extends CONSTANT_Info { 182 public long value; 183 184 public CONSTANT_Long_Info(BytecodeParser parser) { 185 super(parser); 186 value = p.readLong(); 187 } 188 189 public String toString() { 190 return "LongInfo: " + Long.toString(value); 191 } 192 193 public Expr expr() { 194 return Literal.buildLongLiteral(value); 195 } 196 } 197 class CONSTANT_Methodref_Info extends CONSTANT_Info { 198 public int class_index; 199 public int name_and_type_index; 200 201 public CONSTANT_Methodref_Info(BytecodeParser parser) { 202 super(parser); 203 class_index = p.u2(); 204 name_and_type_index = p.u2(); 205 } 206 207 public String toString() { 208 return "MethodRefInfo: " + class_index + " " + name_and_type_index; 209 } 210 } 211 212 class CONSTANT_NameAndType_Info extends CONSTANT_Info { 213 public int name_index; 214 public int descriptor_index; 215 216 public CONSTANT_NameAndType_Info(BytecodeParser parser) { 217 super(parser); 218 name_index = p.u2(); 219 descriptor_index = p.u2(); 220 } 221 222 public String toString() { 223 return "NameAndTypeInfo: " + name_index + " " + descriptor_index; 224 } 225 } 226 227 class CONSTANT_String_Info extends CONSTANT_Info { 228 public int string_index; 229 230 public CONSTANT_String_Info(BytecodeParser parser) { 231 super(parser); 232 string_index = p.u2(); 233 } 234 235 public Expr expr() { 236 CONSTANT_Utf8_Info i = (CONSTANT_Utf8_Info)p.constantPool[string_index]; 237 return Literal.buildStringLiteral(i.string); 238 } 239 240 public String toString() { 241 return "StringInfo: " + p.constantPool[string_index]; 242 } 243 } 244 245 class CONSTANT_Utf8_Info extends CONSTANT_Info { 246 public String string; 247 248 public CONSTANT_Utf8_Info(BytecodeParser parser) { 249 super(parser); 250 string = p.readUTF(); 251 } 252 253 public String toString() { 254 return "Utf8Info: " + string; 255 } 256 257 public Expr expr() { 258 return Literal.buildStringLiteral(string); 259 } 260 261 public String string() { 262 return string; 263 } 264 } 265 266 267 268 269 270 271 }