Index: /lang/ruby/yabcel/lib/yabcel/access_flags.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/access_flags.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/access_flags.rb (revision 13478) @@ -0,0 +1,25 @@ +module Yabcel + class AccessFlags + PUBLIC = 0x0001 + PRIVATE = 0x0002 + PROTECTED = 0x0004 + STATIC = 0x0008 + FINAL = 0x0010 + SYNCHRONIZED = 0x0020 + VOLATILE = 0x0040 + BRIDGE = 0x0040 + TRANSIENT = 0x0080 + VARARGS = 0x0080 + NATIVE = 0x0100 + INTERFACE = 0x0200 + ABSTRACT = 0x0400 + STRICT = 0x0800 + SYNTHETIC = 0x1000 + ANNOTATION = 0x2000 + ENUM = 0x4000 + + NAMES = %w(public private protected static final synchronized volatile + transient native interface abstract strictfp synthetic + annotation enum) + end +end Index: /lang/ruby/yabcel/lib/yabcel/method.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/method.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/method.rb (revision 13478) @@ -0,0 +1,84 @@ +require 'yabcel/member' + +module Yabcel + class Method < Member + include Yabcel + def get_code() + ret = nil + @attributes.each { |attribute| + if attribute.instance_of?(Code) + ret = attribute + end + } + ret + end + def get_local_variable_table() + code = get_code() + if code == nil + return nil + end + ret = nil + code.attributes.each { |attribute| + if attribute.instance_of?(LocalVariableTable) + ret = attribute + break + end + } + ret + end + def to_s + signature = get_signature().bytes + vars = get_local_variable_table() + if (/^\(/ !~ signature) + raise ClassFormatError, "Invalid method signature: #{signature}" + end + buf = " " + access_to_s(@access_flags, false) + buf += " " if buf.length() > 2 + var_index = (@access_flags & AccessFlags::STATIC != 0) ? 0 : 1 + # + # ::= | V + # ::= + # ::= () + # ::= * + # + closed_parenthesis = signature.index(")") + arguments_signature = signature[1..closed_parenthesis-1] + return_signature = signature[closed_parenthesis+1..signature.length] + + return_type = signature_to_s(return_signature) + if return_type.length() != 1 + raise ClassFormatError, "Invalid return signature: #{return_signature}" + end + buf += "#{return_type[0]} " + buf += "#{get_name().bytes} (" + args = [] + arguments_type = signature_to_s(arguments_signature) + arguments_type.each { |argument| + arg_buf = "#{argument} " + if (vars != nil) + var = vars[var_index] + if (var != nil) + arg_buf += var.get_name().bytes + else + arg_buf += "arg#{var_index}" + end + else + arg_buf += "arg#{var_index}" + end + args.push(arg_buf) + if (argument == "long") || (argument == "double") + var_index += 2 + else + var_index += 1 + end + } + buf += args.join(", ") + buf += ")\n" + @attributes.each { |attribute| + buf += "#{attribute}" + } + buf += "\n" + buf + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/exceptions.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/exceptions.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/exceptions.rb (revision 13478) @@ -0,0 +1,26 @@ +require 'yabcel/attribute' + +module Yabcel + class ExceptionTable < Attribute + attr_accessor :exception_index_table + def initialize(name_index, length, constant_pool, exception_index_table) + super(name_index, length, constant_pool) + @exception_index_table = exception_index_table + end + def self.parse(name_index, length, constant_pool, file) + exception_index_table = [] + file.read_short().times { + exception_index_table.push(file.read_short()) + } + new(name_index, length, constant_pool, exception_index_table) + end + def to_s + buf = " Exceptions:\n" + @exception_index_table.each { |exception_index| + name_index = @constant_pool[exception_index].name_index + buf += " #{@constant_pool[name_index].bytes.gsub(/\//, '.')}\n" + } + buf + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/constant_pool.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/constant_pool.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/constant_pool.rb (revision 13478) @@ -0,0 +1,176 @@ +module Yabcel + + class ConstantUTF8 + attr_accessor :bytes + def initialize(bytes) + @bytes = bytes + end + def self.parse(file) + new(file.read(file.read_short())) + end + def to_s + sprintf("%-15s %s", "UTF8", @bytes) + end + end + + class ConstantInteger + attr_accessor :bytes + def initialize(bytes) + @bytes = bytes + end + def self.parse(file) + new(file.read_int()) + end + def to_s + sprintf("%-15s %s", "int", @bytes) + end + end + + class ConstantFloat + attr_accessor :bytes + def initialize(bytes) + @bytes = bytes + end + def self.parse(file) + new(file.read_float()) + end + def to_s + sprintf("%-15s %s", "float", @bytes) + end + end + + class ConstantLong + attr_accessor :bytes + def initialize(bytes) + @bytes = bytes + end + def self.parse(file) + new(file.read_long()) + end + def to_s + sprintf("%-15s %s", "long", @bytes) + end + end + + class ConstantDouble + attr_accessor :bytes + def initialize(bytes) + @bytes = bytes + end + def self.parse(file) + new(file.read_double()) + end + def to_s + sprintf("%-15s %s", "double", @bytes) + end + end + + class ConstantClass + attr_accessor :name_index + def initialize(name_index) + @name_index = name_index + end + def self.parse(file) + new(file.read_short()) + end + def to_s + sprintf("%-15s #%s", "Class", @name_index) + end + end + + class ConstantString + attr_accessor :string_index + def initialize(string_index) + @string_index = string_index + end + def self.parse(file) + new(file.read_short()) + end + def to_s + sprintf("%-15s #%s", "String", @string_index) + end + end + + class ConstantMember + attr_accessor :class_index, :name_and_type_Index + def initialize(class_index, name_and_type_index) + @class_index = class_index + @name_and_type_index = name_and_type_index + end + def self.parse(file) + new(file.read_short(), file.read_short()) + end + end + + class ConstantFieldRef < ConstantMember + def to_s + sprintf("%-15s #%-5s #%-5s", "Field", @class_index, @name_and_type_index) + end + end + class ConstantMethodRef < ConstantMember + def to_s + sprintf("%-15s #%-5s #%-5s", "Method", @class_index, @name_and_type_index) + end + end + class ConstantInterfaceMethodRef < ConstantMember + def to_s + sprintf("%-15s #%-5s #%-5s", "InterfaceMethod", @class_index, + @name_and_type_index) + end + end + + class ConstantNameAndType + attr_accessor :name_index, :signature_index + def initialize(name_index, signature_index) + @name_index = name_index + @signature_index = signature_index + end + def self.parse(file) + new(file.read_short(), file.read_short()) + end + def to_s + sprintf("%-15s #%-5s #%-5s", "NameAndType", @name_index, @signature_index) + end + end + + class ConstantPool + CONSTANTS = [nil, ConstantUTF8, + nil, ConstantInteger, + ConstantFloat, ConstantLong, + ConstantDouble, ConstantClass, + ConstantString, ConstantFieldRef, + ConstantMethodRef, ConstantInterfaceMethodRef, + ConstantNameAndType ] + def initialize(constants) + @constants = constants + end + def self.parse(file) + count = file.read_short() + constants= [] + constants.push(nil) + i = 1 + while i < count + byte = file.getc() + constant = CONSTANTS[byte]::parse(file) + constants.push(constant) + i += 1 + if ((CONSTANTS[byte] == ConstantLong) || + (CONSTANTS[byte] == ConstantDouble)) + constants.push(nil) + i += 1 + end + end + new(constants) + end + def [](index) + @constants[index] + end + def to_s + buf = " ConstantPool:\n" + @constants.each_with_index { |item, index| + buf += sprintf(" #%-5d = %s\n", index, item) if item + } + buf + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/field.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/field.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/field.rb (revision 13478) @@ -0,0 +1,19 @@ +require 'yabcel/member' + +module Yabcel + class Field < Member + include Yabcel + def to_s + buf = " " + buf += access_to_s(@access_flags, false) + buf += " " if @access_flags != 0 + buf += signature_to_s(get_signature().bytes)[0] + buf += " #{get_name().bytes};\n" + @attributes.each { |attribute| + buf += "#{attribute}" + } + buf += "\n" + buf + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/constant_value.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/constant_value.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/constant_value.rb (revision 13478) @@ -0,0 +1,17 @@ +require 'yabcel/attribute' + +module Yabcel + class ConstantValue < Attribute + attr_accessor :constant_value_index + def initialize(name_index, length, constant_pool, constant_value_index) + super(name_index, length, constant_pool) + @constant_value_index = constant_value_index + end + def self.parse(name_index, length, constant_pool, constant_value_index) + new(name_index, length, constant_pool, constant_value_index) + end + def to_s + " ConstantValue: ##{@constant_value_index}\n" + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/code_exception.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/code_exception.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/code_exception.rb (revision 13478) @@ -0,0 +1,17 @@ +require 'yabcel/attribute' + +module Yabcel + class CodeException + attr_accessor :start_pc, :end_pc, :handler_pc, :catch_type + def initialize(start_pc, end_pc, handler_pc, catch_type) + @start_pc = start_pc + @end_pc = end_pc + @handler_pc = handler_pc + @catch_type = catch_type + end + def self.parse(file) + new(file.read_short(), file.read_short(), file.read_short(), + file.read_short()) + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/opcodes.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/opcodes.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/opcodes.rb (revision 13478) @@ -0,0 +1,244 @@ +module Yabcel + class Opcodes + NOP = 0 + ACONST_NULL = 1 + ICONST_M1 = 2 + ICONST_0 = 3 + ICONST_1 = 4 + ICONST_2 = 5 + ICONST_3 = 6 + ICONST_4 = 7 + ICONST_5 = 8 + LCONST_0 = 9 + LCONST_1 = 10 + FCONST_0 = 11 + FCONST_1 = 12 + FCONST_2 = 13 + DCONST_0 = 14 + DCONST_1 = 15 + BIPUSH = 16 + SIPUSH = 17 + LDC = 18 + LDC_W = 19 + LDC2_W = 20 + ILOAD = 21 + LLOAD = 22 + FLOAD = 23 + DLOAD = 24 + ALOAD = 25 + ILOAD_0 = 26 + ILOAD_1 = 27 + ILOAD_2 = 28 + ILOAD_3 = 29 + LLOAD_0 = 30 + LLOAD_1 = 31 + LLOAD_2 = 32 + LLOAD_3 = 33 + FLOAD_0 = 34 + FLOAD_1 = 35 + FLOAD_2 = 36 + FLOAD_3 = 37 + DLOAD_0 = 38 + DLOAD_1 = 39 + DLOAD_2 = 40 + DLOAD_3 = 41 + ALOAD_0 = 42 + ALOAD_1 = 43 + ALOAD_2 = 44 + ALOAD_3 = 45 + IALOAD = 46 + LALOAD = 47 + FALOAD = 48 + DALOAD = 49 + AALOAD = 50 + BALOAD = 51 + CALOAD = 52 + SALOAD = 53 + ISTORE = 54 + LSTORE = 55 + FSTORE = 56 + DSTORE = 57 + ASTORE = 58 + ISTORE_0 = 59 + ISTORE_1 = 60 + ISTORE_2 = 61 + ISTORE_3 = 62 + LSTORE_0 = 63 + LSTORE_1 = 64 + LSTORE_2 = 65 + LSTORE_3 = 66 + FSTORE_0 = 67 + FSTORE_1 = 68 + FSTORE_2 = 69 + FSTORE_3 = 70 + DSTORE_0 = 71 + DSTORE_1 = 72 + DSTORE_2 = 73 + DSTORE_3 = 74 + ASTORE_0 = 75 + ASTORE_1 = 76 + ASTORE_2 = 77 + ASTORE_3 = 78 + IASTORE = 79 + LASTORE = 80 + FASTORE = 81 + DASTORE = 82 + AASTORE = 83 + BASTORE = 84 + CASTORE = 85 + SASTORE = 86 + POP = 87 + POP2 = 88 + DUP = 89 + DUP_X1 = 90 + DUP_X2 = 91 + DUP2 = 92 + DUP2_X1 = 93 + DUP2_X2 = 94 + SWAP = 95 + IADD = 96 + LADD = 97 + FADD = 98 + DADD = 99 + ISUB = 100 + LSUB = 101 + FSUB = 102 + DSUB = 103 + IMUL = 104 + LMUL = 105 + FMUL = 106 + DMUL = 107 + IDIV = 108 + LDIV = 109 + FDIV = 110 + DDIV = 111 + IREM = 112 + LREM = 113 + FREM = 114 + DREM = 115 + INEG = 116 + LNEG = 117 + FNEG = 118 + DNEG = 119 + ISHL = 120 + LSHL = 121 + ISHR = 122 + LSHR = 123 + IUSHR = 124 + LUSHR = 125 + IAND = 126 + LAND = 127 + IOR = 128 + LOR = 129 + IXOR = 130 + LXOR = 131 + IINC = 132 + I2L = 133 + I2F = 134 + I2D = 135 + L2I = 136 + L2F = 137 + L2D = 138 + F2I = 139 + F2L = 140 + F2D = 141 + D2I = 142 + D2L = 143 + D2F = 144 + I2B = 145 + I2C = 146 + I2S = 147 + LCMP = 148 + FCMPL = 149 + FCMPG = 150 + DCMPL = 151 + DCMPG = 152 + IFEQ = 153 + IFNE = 154 + IFLT = 155 + IFGE = 156 + IFGT = 157 + IFLE = 158 + IF_ICMPEQ = 159 + IF_ICMPNE = 160 + IF_ICMPLT = 161 + IF_ICMPGE = 162 + IF_ICMPGT = 163 + IF_ICMPLE = 164 + IF_ACMPEQ = 165 + IF_ACMPNE = 166 + GOTO = 167 + JSR = 168 + RET = 169 + TABLESWITCH = 170 + LOOKUPSWITCH = 171 + IRETURN = 172 + LRETURN = 173 + FRETURN = 174 + DRETURN = 175 + ARETURN = 176 + RETURN = 177 + GETSTATIC = 178 + PUTSTATIC = 179 + GETFIELD = 180 + PUTFIELD = 181 + INVOKEVIRTUAL = 182 + INVOKESPECIAL = 183 + INVOKESTATIC = 184 + INVOKEINTERFACE = 185 + NEW = 187 + NEWARRAY = 188 + ANEWARRAY = 189 + ARRAYLENGTH = 190 + ATHROW = 191 + CHECKCAST = 192 + INSTANCEOF = 193 + MONITORENTER = 194 + MONITOREXIT = 195 + WIDE = 196 + MULTIANEWARRAY = 197 + IFNULL = 198 + IFNONNULL = 199 + GOTO_W = 200 + JSR_W = 201 + + NAMES = %w(nop aconst_null + iconst_m1 iconst_0 iconst_1 iconst_2 iconst_3 iconst_4 iconst_5 + lconst_0 lconst_1 + fconst_0 fconst_1 fconst_2 + dconst_0 dconst_1 + bipush sipush ldc ldc_w ldc2_w + iload lload fload dload aload + iload_0 iload_1 iload_2 iload_3 + lload_0 lload_1 lload_2 lload_3 + fload_0 fload_1 fload_2 fload_3 + dload_0 dload_1 dload_2 dload_3 + aload_0 aload_1 aload_2 aload_3 + iaload laload faload daload aaload baload caload saload + istore lstore fstore dstore astore + istore_0 istore_1 istore_2 istore_3 + lstore_0 lstore_1 lstore_2 lstore_3 + fstore_0 fstore_1 fstore_2 fstore_3 + dstore_0 dstore_1 dstore_2 dstore_3 + astore_0 astore_1 astore_2 astore_3 + iastore lastore fastore dastore aastore bastore castore sastore + pop pop2 dup dup_x1 dup_x2 dup2 dup2_x1 dup2_x2 swap + iadd ladd fadd dadd isub lsub fsub dsub + imul lmul fmul dmul idiv ldiv fdiv ddiv + irem lrem frem drem ineg lneg fneg dneg + ishl lshl ishr lshr iushr lushr + iand land ior lor ixor lxor iinc + i2l i2f i2d l2i l2f l2d f2i f2l f2d d2i d2l d2f i2b i2c i2s + lcmp fcmpl fcmpg dcmpl dcmpg + ifeq ifne iflt ifge ifgt ifle + if_icmpeq if_icmpne if_icmplt if_icmpge if_icmpgt if_icmple + if_acmpeq if_acmpne + goto jsr ret tableswitch lookupswitch + ireturn lreturn freturn dreturn areturn return + getstatic putstatic getfield putfield + invokevirtual invokespecial invokestatic invokeinterface + ILLEGAL_OPCODE new newarray anewarray arraylength + athrow checkcast instanceof monitorenter monitorexit wide + multianewarray ifnull ifnonnull goto_w jsr_w) + end +end Index: /lang/ruby/yabcel/lib/yabcel/source_file.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/source_file.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/source_file.rb (revision 13478) @@ -0,0 +1,20 @@ +require 'yabcel/attribute' + +module Yabcel + class SourceFile < Attribute + attr_accessor :source_file_index + def initialize(name_index, length, constant_pool, source_file_index) + super(name_index, length, constant_pool) + @source_file_index = source_file_index + end + def self.parse(name_index, length, constant_pool, source_file_index) + new(name_index, length, constant_pool, source_file_index) + end + def get_source_file_name + @constant_pool[@source_file_index].bytes + end + def to_s + " SourceFile: ##{@source_file_index}\n" + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/line_number.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/line_number.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/line_number.rb (revision 13478) @@ -0,0 +1,39 @@ +require 'yabcel/attribute' + +module Yabcel + class LineNumberTable < Attribute + attr_accessor :line_number_table + def initialize(name_index, length, constant_pool, line_number_table) + super(name_index, length, constant_pool) + @line_number_table = line_number_table + end + def self.parse(name_index, length, constant_pool, file) + line_number_table = [] + file.read_short().times { + line_number_table.push(LineNumber::parse(file)) + } + new(name_index, length, constant_pool, line_number_table) + end + def to_s + buf = " LineNumberTable:\n" + buf += sprintf(" %-7s %s\n", "Line", "PC") + @line_number_table.each { |line_number| + buf += "#{line_number}" + } + buf + end + end + class LineNumber + attr_accessor :start_pc, :line_number + def initialize(start_pc, line_number) + @start_pc = start_pc + @line_number = line_number + end + def self.parse(file) + new(file.read_short(), file.read_short()) + end + def to_s + sprintf(" %-7s %s\n", @line_number, @start_pc) + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/local_variable.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/local_variable.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/local_variable.rb (revision 13478) @@ -0,0 +1,61 @@ +require 'yabcel/attribute' + +module Yabcel + class LocalVariableTable < Attribute + attr_accessor :local_variable_table + def initialize(name_index, length, constant_pool, local_variable_table) + super(name_index, length, constant_pool) + @local_variable_table = local_variable_table + end + def self.parse(name_index, length, constant_pool, file) + local_variable_table = [] + file.read_short().times { + local_variable_table.push(LocalVariable::parse(file, constant_pool)) + } + new(name_index, length, constant_pool, local_variable_table) + end + def [](index) + ret = nil + @local_variable_table.each { |local_variable| + if local_variable.index == index + ret = local_variable + end + } + ret + end + def to_s + buf = " LocalVariable:\n" + buf += sprintf(" %-7s %-7s %-7s %-7s %s\n", "Start", "Length", + "Slot", "Name", "Signature") + @local_variable_table.each { |local_variable| + buf += "#{local_variable}" + } + buf + end + end + + class LocalVariable + attr_accessor :start_pc, :length, :name_index, :signature_index, :index + attr_accessor :constant_pool + def initialize(start_pc, length, name_index, signature_index, index, + constant_pool) + @start_pc = start_pc + @length = length + @name_index = name_index + @signature_index = signature_index + @index = index + @constant_pool = constant_pool + end + def self.parse(file, constant_pool) + new(file.read_short(), file.read_short(), file.read_short(), + file.read_short(), file.read_short(), constant_pool) + end + def get_name() + @constant_pool[@name_index] + end + def to_s + sprintf(" %-7s %-7s %-7s %-7s #%s\n", @start_pc, @length, @index, + get_name().bytes, @signature_index) + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/deprecated.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/deprecated.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/deprecated.rb (revision 13478) @@ -0,0 +1,17 @@ +require 'yabcel/attribute' + +module Yabcel + class Deprecated < Attribute + attr_accessor :bytes + def initialize(name_index, length, constant_pool, bytes) + super(name_index, length, constant_pool) + @bytes = bytes + end + def self.parse(name_index, length, constant_pool, file) + new(name_index, length, constant_pool, file.read(length)) + end + def to_s + " Deprecated: true\n" + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/inner_class.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/inner_class.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/inner_class.rb (revision 13478) @@ -0,0 +1,44 @@ +require 'yabcel/attribute' + +module Yabcel + class InnerClasses < Attribute + attr_accessor :inner_classes + def initialize(name_index, length, constant_pool, inner_classes) + super(name_index, length, constant_pool) + @inner_classes = inner_classes + end + def self.parse(name_index, length, constant_pool, file) + inner_classes = [] + file.read_short().times { + inner_classes.push(InnerClass::parse(file)) + } + new(name_index, length, constant_pool, inner_classes) + end + def to_s + buf = " InnerClasses:\n" + @inner_classes.each { |inner_class| + buf += "#{inner_class}" + } + buf + end + end + + class InnerClass + attr_accessor :inner_class_index, :outer_class_index + attr_accessor :inner_name_index, :inner_access_flags + def initialize(inner_class_index, outer_class_index, + inner_name_index, inner_access_flags) + @inner_class_index = inner_class_index + @outer_class_index = outer_class_index + @inner_name_index = inner_name_index + @inner_access_flags = inner_access_flags + end + def self.parse(file) + new(file.read_short(), file.read_short(), file.read_short(), + file.read_short()) + end + def to_s + " ##{@inner_class_index}\n" + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/signature.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/signature.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/signature.rb (revision 13478) @@ -0,0 +1,17 @@ +require 'yabcel/attribute' + +module Yabcel + class Signature < Attribute + attr_accessor :signature_index + def initialize(name_index, length, constant_pool, signature_index) + super(name_index, length, constant_pool) + @signature_index = signature_index + end + def self.parse(name_index, length, constant_pool, file) + new(name_index, length, constant_pool, file.read_short()) + end + def to_s + " Signature: ##{@signature_index}\n" + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/utility.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/utility.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/utility.rb (revision 13478) @@ -0,0 +1,174 @@ + +class File + def read_char() + read(1).unpack("c")[0] + end + def read_uchar() + read(1).unpack("C")[0] + end + def read_short() + read(2).unpack("n")[0] + end + def read_uint() + read(4).unpack("N")[0] + end + def read_int() + read(4).reverse!().unpack("l")[0] + end + def read_float() + read(4).unpack("g")[0] + end + def read_long() + read(8).reverse!().unpack("q")[0] + end + def read_double() + read(8).unpack("G")[0] + end +end + +module Yabcel + class ClassFormatError < RuntimeError; end + class IllegalStateError < RuntimeError; end + + class ByteSequence < File + attr_accessor :bytes, :position + def initialize(bytes) + @bytes = bytes + @bytes.freeze() + @position = 0 + end + def read(length) + endpoint = @position + length + if (@bytes.length() <= endpoint) + length = @bytes.length() - @position + end + ret = @bytes[@position, length].pack("C*") + @position += length + ret + end + def length() + @bytes.length() + end + end + + def access_to_s(access_flags, for_class) + buf = [] + AccessFlags::NAMES.each_with_index { |item, index| + mask = 1 << index + if (access_flags & mask) != 0 + if for_class && ((mask == AccessFlags::SYNCHRONIZED) || + (mask == AccessFlags::INTERFACE)) + next + end + buf.push(item) + end + } + buf.join(" ") + end + + def signature_to_s(signature) + # ::= + # ::= || + # ::= B|C|D|F|I|J|S|Z + # ::= L; + # ::= [ + buf = [] + index = 0 + dim = 0 + while index < signature.length + case signature[index, 1].intern + when "B".intern + str = "byte" + if dim > 0 + str += "[]" * dim + dim = 0 + end + buf.push(str) + index += 1 + when "C".intern + str = "char" + if dim > 0 + str += "[]" * dim + dim = 0 + end + buf.push(str) + index += 1 + when "D".intern + str = "double" + if dim > 0 + str += "[]" * dim + dim = 0 + end + buf.push(str) + index += 1 + when "F".intern + str = "float" + if dim > 0 + str += "[]" * dim + dim = 0 + end + buf.push(str) + index += 1 + when "I".intern + str = "int" + if dim > 0 + str += "[]" * dim + dim = 0 + end + buf.push(str) + index += 1 + when "J".intern + str = "long" + if dim > 0 + str += "[]" * dim + dim = 0 + end + buf.push(str) + index += 1 + when "L".intern + endpoint = signature.index(";", index) + if endpoint == nil + raise ClassFormatError, "Invalid signature: #{signature}" + end + substr = signature[index+1..endpoint-1] + str = substr.gsub(/\//, ".") + if dim > 0 + str += "[]" * dim + dim = 0 + end + buf.push(str) + index += substr.length + 2 + when "S".intern + str = "short" + if dim > 0 + str += "[]" * dim + dim = 0 + end + buf.push(str) + index += 1 + when "Z".intern + str = "boolean" + if dim > 0 + str += "[]" * dim + dim = 0 + end + buf.push(str) + index += 1 + when "[".intern + while signature[index, 1] == "[" + dim += 1 + index += 1 + end + when "V".intern + if dim > 0 + raise ClassFormatError, "Invalid signature: #{signature}" + end + buf.push("void") + index += 1 + else + raise ClassFormatError, "Invalid signature: #{signature}" + end + end + buf + end +end Index: /lang/ruby/yabcel/lib/yabcel/attribute.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/attribute.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/attribute.rb (revision 13478) @@ -0,0 +1,55 @@ +module Yabcel + class Attribute + attr_accessor :name_index, :length, :constant_pool + def initialize(name_index, length, constant_pool) + @name_index = name_index + @length = length + @constant_pool = constant_pool + end + def self.parse(file, constant_pool) + name_index = file.read_short() + name = constant_pool[name_index].bytes + length = file.read_int() + case name + when "ConstantValue" + ConstantValue::parse(name_index, length, constant_pool, + file.read_short()) + when "SourceFile" + SourceFile::parse(name_index, length, constant_pool, + file.read_short()) + when "Code" + Code::parse(name_index, length, constant_pool, file) + when "Exceptions" + ExceptionTable::parse(name_index, length, constant_pool, file) + when "LineNumberTable" + LineNumberTable::parse(name_index, length, constant_pool, file) + when "LocalVariableTable" + LocalVariableTable::parse(name_index, length, constant_pool, file) + when "InnerClasses" + InnerClasses::parse(name_index, length, constant_pool, file) + when "Deprecated" + Deprecated::parse(name_index, length, constant_pool, file) + when "Signature" + Signature::parse(name_index, length, constant_pool, file) + else + Unknown::parse(name_index, length, constant_pool, file) + end + end + end + + class Unknown < Attribute + attr_accessor :bytes + def initialize(name_index, length, constant_pool, bytes) + super(name_index, length, constant_pool) + @bytes = bytes + end + def self.parse(name_index, length, constant_pool, file) + new(name_index, length, constant_pool, file.read(length)) + end + def to_s + buf = " #{@constant_pool[@name_index].bytes}: length=#{@length}\n" + buf += " [#{@bytes.unpack("C*").join(", ")}]\n" + buf + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/types.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/types.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/types.rb (revision 13478) @@ -0,0 +1,20 @@ +module Yabcel + class Types + BOOLEAN = 4 + CHAR = 5 + FLOAT = 6 + DOUBLE = 7 + BYTE = 8 + SHORT = 9 + INT = 10 + LONG = 11 + VOID = 12 + ARRAY = 13 + OBJECT = 14 + UNKNOWN = 15 + + NAMES = %w(ILLEGAL_TYPE ILLEGAL_TYPE ILLEGAL_TYPE ILLEGAL_TYPE + boolean char float double byte short int long + void array object unknown) + end +end Index: /lang/ruby/yabcel/lib/yabcel/java_class.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/java_class.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/java_class.rb (revision 13478) @@ -0,0 +1,104 @@ +module Yabcel + class JavaClass + include Yabcel + attr_accessor :class_name_index, :superclass_name_index, :file_name + attr_accessor :major, :minor, :access_flags, :constant_pool + attr_accessor :interfaces, :fields, :methods, :attributes + + def initialize(class_name_index, superclass_name_index, major, minor, + access_flags, constant_pool, interfaces, fields, methods, + attributes) + @class_name_index = class_name_index + @superclass_name_index = superclass_name_index + @major = major + @minor = minor + @access_flags = access_flags + @constant_pool = constant_pool + @interfaces = interfaces + @fields = fields + @methods = methods + @attributes = attributes + + class_name_index = @constant_pool[@class_name_index].name_index + @class_name= @constant_pool[class_name_index].bytes + @class_name.gsub!(/\//, ".") + + superclass_name_index = @constant_pool[@superclass_name_index].name_index + @superclass_name = @constant_pool[superclass_name_index].bytes + @superclass_name.gsub!(/\//, ".") + + @interface_names = [] + interfaces.each { |interface_index| + interface_name_index = @constant_pool[interface_index].name_index + interface_name = @constant_pool[interface_name_index].bytes + @interface_names.push(interface_name.gsub(/\//, ".")) + } + end + + def self.parse(file) + magic = file.read_uint() + if magic != 0xcafebabe + raise ClassFormatError, + "#{file} is not a Java .class file (bad magic: #{magic})" + end + minor = file.read_short() + major = file.read_short() + constant_pool = ConstantPool::parse(file) + access_flags = file.read_short() + if ((access_flags & AccessFlags::ABSTRACT) != 0) && + ((access_flags & AccessFlags::FINAL) != 0) + raise ClassFormatError, + "Class can't be both final and abstract" + end + class_name_index = file.read_short() + superclass_name_index = file.read_short() + interfaces = [] + file.read_short().times { + interfaces.push(file.read_short()) + } + fields = [] + file.read_short().times { + fields.push(Field::parse(file, constant_pool)) + } + methods = [] + file.read_short().times { + methods.push(Method::parse(file, constant_pool)) + } + attributes = [] + file.read_short().times { + attributes.push(Attribute::parse(file, constant_pool)) + } + new(class_name_index, superclass_name_index, major, minor, access_flags, + constant_pool, interfaces, fields, methods, attributes) + end + + def to_s + access = access_to_s(@access_flags, true) + buf = access != "" ? "#{access} " : "" + buf += ((@access_flags & AccessFlags::INTERFACE) != 0 ? + "interface" : "class") + " " + buf += @class_name + " extends " + buf += @superclass_name + if @interface_names.length != 0 + buf += " implements " + buf += @interface_names.join(", ") + end + buf += "\n" + buf += " minor version: #{@minor}\n" + buf += " major version: #{@major}\n" + @attributes.each { |attribute| + buf += "#{attribute}" + } + buf += "#{@constant_pool}{\n" + @fields.each { |field| + buf += "#{field}" + } + buf += "\n" if @fields.length() != 0 + @methods.each { |method| + buf += "#{method}" + } + buf += "\n" if @methods.length() != 0 + buf += "}\n" + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/member.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/member.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/member.rb (revision 13478) @@ -0,0 +1,33 @@ +module Yabcel + class Member + attr_accessor :access_flags + attr_accessor :name_index + attr_accessor :signature_index + attr_accessor :attributes + attr_accessor :constant_pool + def initialize(access_flags, name_index, signature_index, attributes, + constant_pool) + @access_flags = access_flags + @name_index = name_index + @signature_index = signature_index + @attributes = attributes + @constant_pool = constant_pool + end + def self.parse(file, constant_pool) + access_flags = file.read_short() + name_index = file.read_short() + signature_index = file.read_short() + attributes = [] + file.read_short().times { + attributes.push(Attribute::parse(file, constant_pool)) + } + new(access_flags, name_index, signature_index, attributes, constant_pool) + end + def get_signature() + @constant_pool[@signature_index] + end + def get_name() + @constant_pool[@name_index] + end + end +end Index: /lang/ruby/yabcel/lib/yabcel/code.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel/code.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel/code.rb (revision 13478) @@ -0,0 +1,416 @@ +require 'yabcel/attribute' + +module Yabcel + class Code < Attribute + include Yabcel + attr_accessor :max_stack, :max_locals, :code, :exception_table, :attributes + def initialize(name_index, length, constant_pool, max_stack, max_locals, + code, exception_table, attributes) + super(name_index, length, constant_pool) + @max_stack = max_stack + @max_locals = max_locals + @code = code + @exception_table = exception_table + @attributes = attributes + end + def self.parse(name_index, length, constant_pool, file) + max_stack = file.read_short() + max_locals = file.read_short() + code = file.read(file.read_uint()) + exception_table = [] + file.read_short().times { + exception_table.push(CodeException::parse(file)) + } + attributes = [] + file.read_short().times { + attributes.push(Attribute::parse(file, constant_pool)) + } + new(name_index, length, constant_pool, max_stack, max_locals, code, + exception_table, attributes) + end + def to_s + buf = " Code: max_stack = #{@max_stack}," + buf += " max_locals = #{@max_locals}," + buf += " code_length = #{@code.length}\n" + opcodes = ByteSequence::new(@code.unpack("C*")) + wide = false + default_offset = 0 + padding = 0 + buf += sprintf(" %-7s %-15s\n", "PC", "Opcode") + while opcodes.position < opcodes.length() + buf += sprintf(" %-8s", opcodes.position) + op = opcodes.read_uchar() + buf += sprintf("%-16s", Opcodes::NAMES[op]) + if (op == Opcodes::TABLESWITCH) || + (op == Opcodes::LOOKUPSWITCH) + remainder = opcodes.position % 4 + padding = (4 - remainder) % 4 + padding.times { + if (opcodes.read_uchar() != 0) + warn("Warning: Padding byte != 0 in #{Opcodes::NAMES[op]}") + end + } + default_offset = opcodes.read_int() + end + case op + when Opcodes::NOP + when Opcodes::ACONST_NULL + when Opcodes::ICONST_M1 + when Opcodes::ICONST_0 + when Opcodes::ICONST_1 + when Opcodes::ICONST_2 + when Opcodes::ICONST_3 + when Opcodes::ICONST_4 + when Opcodes::ICONST_5 + when Opcodes::LCONST_0 + when Opcodes::LCONST_1 + when Opcodes::FCONST_0 + when Opcodes::FCONST_1 + when Opcodes::FCONST_2 + when Opcodes::DCONST_0 + when Opcodes::DCONST_1 + when Opcodes::BIPUSH + buf += sprintf("%-7s", opcodes.read_uchar()) + when Opcodes::SIPUSH + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::LDC + buf += sprintf("#%-7s", opcodes.read_uchar()) + when Opcodes::LDC_W + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::LDC2_W + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::ILOAD + if (wide) + index = opcodes.read_short() + wide = false + else + index = opcodes.read_uchar() + end + buf += sprintf("#%-7s", index) + when Opcodes::LLOAD + if (wide) + index = opcodes.read_short() + wide = false + else + index = opcodes.read_uchar() + end + buf += sprintf("#%-7s", index) + when Opcodes::FLOAD + if (wide) + index = opcodes.read_short() + wide = false + else + index = opcodes.read_uchar() + end + buf += sprintf("#%-7s", index) + when Opcodes::DLOAD + if (wide) + index = opcodes.read_short() + wide = false + else + index = opcodes.read_uchar() + end + buf += sprintf("#%-7s", index) + when Opcodes::ALOAD + if (wide) + index = opcodes.read_short() + wide = false + else + index = opcodes.read_uchar() + end + buf += sprintf("#%-7s", index) + when Opcodes::ILOAD_0 + when Opcodes::ILOAD_1 + when Opcodes::ILOAD_2 + when Opcodes::ILOAD_3 + when Opcodes::LLOAD_0 + when Opcodes::LLOAD_1 + when Opcodes::LLOAD_2 + when Opcodes::LLOAD_3 + when Opcodes::FLOAD_0 + when Opcodes::FLOAD_1 + when Opcodes::FLOAD_2 + when Opcodes::FLOAD_3 + when Opcodes::DLOAD_0 + when Opcodes::DLOAD_1 + when Opcodes::DLOAD_2 + when Opcodes::DLOAD_3 + when Opcodes::ALOAD_0 + when Opcodes::ALOAD_1 + when Opcodes::ALOAD_2 + when Opcodes::ALOAD_3 + when Opcodes::IALOAD + when Opcodes::LALOAD + when Opcodes::FALOAD + when Opcodes::DALOAD + when Opcodes::AALOAD + when Opcodes::BALOAD + when Opcodes::CALOAD + when Opcodes::SALOAD + when Opcodes::ISTORE + if (wide) + index = opcodes.read_short() + wide = false + else + index = opcodes.read_uchar() + end + buf += sprintf("#%-7s", index) + when Opcodes::LSTORE + if (wide) + index = opcodes.read_short() + wide = false + else + index = opcodes.read_uchar() + end + buf += sprintf("#%-7s", index) + when Opcodes::FSTORE + if (wide) + index = opcodes.read_short() + wide = false + else + index = opcodes.read_uchar() + end + buf += sprintf("#%-7s", index) + when Opcodes::DSTORE + if (wide) + index = opcodes.read_short() + wide = false + else + index = opcodes.read_uchar() + end + buf += sprintf("#%-7s", index) + when Opcodes::ASTORE + if (wide) + index = opcodes.read_short() + wide = false + else + index = opcodes.read_uchar() + end + buf += sprintf("#%-7s", index) + when Opcodes::ISTORE_0 + when Opcodes::ISTORE_1 + when Opcodes::ISTORE_2 + when Opcodes::ISTORE_3 + when Opcodes::LSTORE_0 + when Opcodes::LSTORE_1 + when Opcodes::LSTORE_2 + when Opcodes::LSTORE_3 + when Opcodes::FSTORE_0 + when Opcodes::FSTORE_1 + when Opcodes::FSTORE_2 + when Opcodes::FSTORE_3 + when Opcodes::DSTORE_0 + when Opcodes::DSTORE_1 + when Opcodes::DSTORE_2 + when Opcodes::DSTORE_3 + when Opcodes::ASTORE_0 + when Opcodes::ASTORE_1 + when Opcodes::ASTORE_2 + when Opcodes::ASTORE_3 + when Opcodes::IASTORE + when Opcodes::LASTORE + when Opcodes::FASTORE + when Opcodes::DASTORE + when Opcodes::AASTORE + when Opcodes::BASTORE + when Opcodes::CASTORE + when Opcodes::SASTORE + when Opcodes::POP + when Opcodes::POP2 + when Opcodes::DUP + when Opcodes::DUP_X1 + when Opcodes::DUP_X2 + when Opcodes::DUP2 + when Opcodes::DUP2_X1 + when Opcodes::DUP2_X2 + when Opcodes::SWAP + when Opcodes::IADD + when Opcodes::LADD + when Opcodes::FADD + when Opcodes::DADD + when Opcodes::ISUB + when Opcodes::LSUB + when Opcodes::FSUB + when Opcodes::DSUB + when Opcodes::IMUL + when Opcodes::LMUL + when Opcodes::FMUL + when Opcodes::DMUL + when Opcodes::IDIV + when Opcodes::LDIV + when Opcodes::FDIV + when Opcodes::DDIV + when Opcodes::IREM + when Opcodes::LREM + when Opcodes::FREM + when Opcodes::DREM + when Opcodes::INEG + when Opcodes::LNEG + when Opcodes::FNEG + when Opcodes::DNEG + when Opcodes::ISHL + when Opcodes::LSHL + when Opcodes::ISHR + when Opcodes::LSHR + when Opcodes::IUSHR + when Opcodes::LUSHR + when Opcodes::IAND + when Opcodes::LAND + when Opcodes::IOR + when Opcodes::LOR + when Opcodes::IXOR + when Opcodes::LXOR + when Opcodes::IINC + if (wide) + index = opcodes.read_short() + constant = opcodes.read_short() + wide = false + else + index = opcodes.read_uchar() + constant = opcodes.read_char() + end + buf += sprintf("%%%-7s %s", index, constant) + when Opcodes::I2L + when Opcodes::I2F + when Opcodes::I2D + when Opcodes::L2I + when Opcodes::L2F + when Opcodes::L2D + when Opcodes::F2I + when Opcodes::F2L + when Opcodes::F2D + when Opcodes::D2I + when Opcodes::D2L + when Opcodes::D2F + when Opcodes::I2B + when Opcodes::I2C + when Opcodes::I2S + when Opcodes::LCMP + when Opcodes::FCMPL + when Opcodes::FCMPG + when Opcodes::DCMPL + when Opcodes::DCMPG + when Opcodes::IFEQ + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IFNE + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IFLT + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IFGE + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IFGT + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IFLE + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IF_ICMPEQ + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IF_ICMPNE + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IF_ICMPLT + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IF_ICMPGE + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IF_ICMPGT + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IF_ICMPLE + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IF_ACMPEQ + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IF_ACMPNE + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::GOTO + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::JSR + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::RET + if (wide) + index = opcodes.read_short() + wide = false + else + index = opcodes.read_uchar() + end + buf += sprintf("#%-7s", index) + when Opcodes::TABLESWITCH + lo = opcodes.read_int() + hi = opcodes.read_int() + offset = opcodes.position - 12 - padding - 1 + default_offset += offset + buf += "\n" + buf += sprintf(" %-7s %s\n", "Value", "Destination") + (lo..hi).each { |value| + buf += sprintf(" %-7s %s\n", value, + offset + opcodes.read_int()) + } + buf += sprintf(" %-7s %s", "default", default_offset) + when Opcodes::LOOKUPSWITCH + npairs = opcodes.read_int() + offset = opcodes.position - 8 - padding - 1 + default_offset += offset + buf += "\n" + buf += sprintf(" %-7s %s\n", "Value", "Destination") + npairs.times { + buf += sprintf(" %-7s %s\n", opcodes.read_int(), + offset + opcodes.read_int()) + } + buf += sprintf(" %-7s %s", "default", default_offset) + when Opcodes::IRETURN + when Opcodes::LRETURN + when Opcodes::FRETURN + when Opcodes::DRETURN + when Opcodes::ARETURN + when Opcodes::RETURN + when Opcodes::GETSTATIC + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::PUTSTATIC + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::GETFIELD + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::PUTFIELD + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::INVOKEVIRTUAL + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::INVOKESPECIAL + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::INVOKESTATIC + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::INVOKEINTERFACE + buf += sprintf("#%-7s %s", opcodes.read_short(), opcodes.read_uchar()) + opcodes.read_uchar() # reserved + when Opcodes::NEW + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::NEWARRAY + buf += sprintf("%-7s", Types::NAMES[opcodes.read_uchar()]) + when Opcodes::ANEWARRAY + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::ARRAYLENGTH + when Opcodes::ATHROW + when Opcodes::CHECKCAST + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::INSTANCEOF + buf += sprintf("#%-7s", opcodes.read_short()) + when Opcodes::MONITORENTER + when Opcodes::MONITOREXIT + when Opcodes::WIDE + wide = true + when Opcodes::MULTIANEWARRAY + buf += sprintf("#%-7s %s", opcodes.read_short(), opcodes.read_uchar()) + when Opcodes::IFNULL + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::IFNONNULL + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_short()) + when Opcodes::GOTO_W + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_int()) + when Opcodes::JSR_W + buf += sprintf("#%-7s", opcodes.position - 1 + opcodes.read_int()) + else + + end + buf += "\n" + end + @attributes.each { |attribute| + buf += "#{attribute}" + } + buf + end + end +end Index: /lang/ruby/yabcel/lib/yabcel.rb =================================================================== --- /lang/ruby/yabcel/lib/yabcel.rb (revision 13478) +++ /lang/ruby/yabcel/lib/yabcel.rb (revision 13478) @@ -0,0 +1,28 @@ +# +# yabcel.rb: Yet Another ByteCode Enginnering Library for Ruby +# + +require 'yabcel/utility' + +require 'yabcel/access_flags' +require 'yabcel/types' +require 'yabcel/opcodes' +require 'yabcel/constant_pool' + +require 'yabcel/member' +require 'yabcel/field' +require 'yabcel/method' + +require 'yabcel/attribute' +require 'yabcel/constant_value' +require 'yabcel/source_file' +require 'yabcel/line_number' +require 'yabcel/local_variable' +require 'yabcel/exceptions' +require 'yabcel/signature' +require 'yabcel/code' +require 'yabcel/code_exception' +require 'yabcel/deprecated' +require 'yabcel/inner_class' + +require 'yabcel/java_class' Index: /lang/ruby/yabcel/yabcel_driver.rb =================================================================== --- /lang/ruby/yabcel/yabcel_driver.rb (revision 13478) +++ /lang/ruby/yabcel/yabcel_driver.rb (revision 13478) @@ -0,0 +1,11 @@ +#!/usr/bin/env ruby +# +# % ruby -I lib yabcel_driver.rb *.class +# + +require 'yabcel' + +ARGV.each { |classfile| + puts Yabcel::JavaClass::parse(open(classfile)) +} +