jvm_bytecode 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0a1b9757f79bb089650a53b65eda732b46460e3e
+  data.tar.gz: 4a4ebd63056edd36bcb5721621df9aac52a3c4ee
+SHA512:
+  metadata.gz: 133fc00f84dc509ad1acc5573dc5a897a592284ba152f4ccc8135c023bc6feabcabbab318d080611ee647c195fd1c064faf566ff74d51d2880900c2124210aa2
+  data.tar.gz: 9cfcfd3eb75bce7be9951b71af7c5fccafd05a7df6bbc5b0fcbfb5535a780c8a16fe3ecec83f1cb226139aa1b64b637983552797c388822cadbeb3aeca54cc31

data/.editorconfig

@@ -0,0 +1,4 @@
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_size = 2

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+vendor/
+.DS_Store

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Takanori.Murakami
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+Tool for generating and decoding JVM bytecode.
+
+Now, this gem supports only minimal part of class file specification.
+
+## Examples
+
+Generating
+
+```rb
+require 'jvm_bytecode'
+
+class_file = JvmBytecode::ClassFile.new do
+  constant_pool do
+    utf8 'Sample'
+    utf8 'java/lang/Object'
+
+    add_class 'Sample'
+
+    add_method_ref(
+      add_class('java/lang/Object'),
+      add_name_and_type('<init>', '()V')
+    )
+  end
+
+  access_flag :super
+
+  this_class 'Sample'
+  super_class 'java/lang/Object'
+
+  method_definition do
+    name 'add'
+    descriptor '(II)I'
+
+    code do
+      max_stack 2
+      max_locals 3
+
+      iload_1
+      iload_2
+      iadd
+      ireturn
+    end
+  end
+
+  method_definition do
+    name '<init>'
+    descriptor '()V'
+
+    code do
+      max_stack 1
+      max_locals 1
+
+      aload_0
+      invokespecial 8
+      _return
+    end
+  end
+end
+
+File.open('Sample.class', 'wb') do |f|
+  f.write(class_file.bytecode)
+end
+```
+
+Decoding
+
+```
+irb(main):012:0* require 'jvm_bytecode'
+=> true
+irb(main):013:0> require 'pp'
+=> true
+irb(main):014:0> pp JvmBytecode::ClassFile.decode(File.open('Sample.class', 'rb')).to_hash
+{:minor_version=>0,
+ :major_version=>52,
+ :constant_pool=>
+  [{:index=>1, :type=>"Utf8", :string=>"Sample"},
+   {:index=>2, :type=>"Utf8", :string=>"java/lang/Object"},
+   {:index=>3, :type=>"Class", :name_index=>1},
+   {:index=>4, :type=>"Class", :name_index=>2},
+   {:index=>5, :type=>"Utf8", :string=>"<init>"},
+   {:index=>6, :type=>"Utf8", :string=>"()V"},
+   {:index=>7, :type=>"NameAndType", :name_index=>5, :descriptor_index=>6},
+   {:index=>8, :type=>"MethodRef", :class_index=>4, :name_and_type_index=>7},
+   {:index=>9, :type=>"Utf8", :string=>"add"},
+   {:index=>10, :type=>"Utf8", :string=>"(II)I"},
+   {:index=>11, :type=>"Utf8", :string=>"Code"}],
+ :access_flag=>[:super],
+ :this_class=>3,
+ :super_class=>4,
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "jvm_bytecode"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/jvm_bytecode.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jvm_bytecode/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jvm_bytecode"
+  spec.version       = JvmBytecode::VERSION
+  spec.authors       = ["bonono"]
+  spec.email         = ["bonono.jp@gmail.com"]
+
+  spec.summary       = %q{Tool for generating and decoding JVM bytecode}
+  spec.description   = %q{Tool for generating and decoding JVM bytecode}
+  spec.homepage      = "https://github.com/bonono/ruby-jvm-bytecode"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.1'
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/jvm_bytecode.rb

@@ -0,0 +1,27 @@
+require 'jvm_bytecode/version'
+require 'jvm_bytecode/extensions'
+
+require 'jvm_bytecode/access_flag'
+
+require 'jvm_bytecode/errors/constant_error'
+require 'jvm_bytecode/errors/decode_error'
+require 'jvm_bytecode/errors/opcode_error'
+
+require 'jvm_bytecode/constants/constant'
+require 'jvm_bytecode/constants/ref'
+require 'jvm_bytecode/constants/class'
+require 'jvm_bytecode/constants/method_ref'
+require 'jvm_bytecode/constants/name_and_type'
+require 'jvm_bytecode/constants/utf8'
+
+require 'jvm_bytecode/instructions/instruction'
+require 'jvm_bytecode/instructions/instruction_set'
+
+require 'jvm_bytecode/attributes/attribute'
+require 'jvm_bytecode/attributes/code'
+require 'jvm_bytecode/attributes/source_file'
+
+require 'jvm_bytecode/field'
+require 'jvm_bytecode/method'
+require 'jvm_bytecode/constant_pool'
+require 'jvm_bytecode/class_file'

data/lib/jvm_bytecode/access_flag.rb

@@ -0,0 +1,20 @@
+module JvmBytecode
+  module AccessFlag
+    def all_access_flag
+      self.class::ACCESS_FLAGS
+    end
+
+    def access_flag(*flags)
+      @acc_flag = flags.map(&all_access_flag.method(:[])).reduce(0, &:|) if flags.any?
+      @acc_flag || 0
+    end
+
+    def set_access_flag(acc_flag)
+      @acc_flag = acc_flag
+    end
+
+    def readable_access_flag
+      all_access_flag.select { |k, v| (@acc_flag & v) > 0 }.keys
+    end
+  end
+end

data/lib/jvm_bytecode/attributes/attribute.rb

@@ -0,0 +1,50 @@
+module JvmBytecode
+  module Attributes
+    class Attribute
+      using Extensions
+
+      class << self
+        attr_reader :attr_name, :locations
+        
+        def define(name: nil, location:)
+          @attr_name = name || shortname.encode('UTF-8')
+          @locations = location
+
+          @@attributes ||= {}
+          @@attributes[@attr_name] = self
+        end
+
+        def fetch(attr_name)
+          @@attributes[attr_name] || raise(Errors::AttributeError, "#{attr_name} is not implemented")
+        end
+
+        def locatable_at(loc)
+          @@attributes.select { |_, v| v.locations.include?(loc) }
+        end
+
+        def decode_serial(cp, io)
+          n = io.read(2).unpack('S>').first
+          Array.new(n) do
+            name_index = io.read(2).unpack('S>').first
+            fetch(cp.constant(name_index).to_s).new(cp).tap { |a| a.decode(io) }
+          end
+        end
+      end
+
+      attr_reader :cp
+
+      def initialize(cp)
+        @cp = cp
+      end
+
+      def additional_bytecode
+        raise NotImplementedError, "#{self.class}##{__method__} is not implemented!"
+      end
+
+      def bytecode
+        bc = additional_bytecode
+        [cp.utf8(self.class.attr_name), bc.length].pack('S>I>') + bc
+      end
+    end
+  end
+end

data/lib/jvm_bytecode/attributes/code.rb

@@ -0,0 +1,60 @@
+module JvmBytecode
+  module Attributes
+    class Code < Attribute
+      define location: [:method]
+
+      Instructions::Instruction.all.each do |i|
+        define_method(i.mnemonic) do |*args|
+          @instructions.push(i.new(cp)).last.args = args
+        end
+      end
+
+      def initialize(cp)
+        super(cp)
+
+        @max_stack = 0
+        @max_locals = 0
+        @instructions = []
+      end
+
+      def max_stack(n)
+        @max_stack = n
+      end
+
+      def max_locals(n)
+        @max_locals = n
+      end
+
+      def additional_bytecode
+        code = @instructions.map(&:bytecode).join('')
+        [@max_stack, @max_locals, code.length].pack('S>2I>') + code + [0, 0].pack('S>2')
+      end
+
+      def decode(io)
+        io.read(4) # discard length
+
+        @max_stack, @max_locals, len = io.read(8).unpack('S>2I>')
+        
+        @instructions.clear
+        while len > 0
+          opcode = io.read(1).unpack('C').first
+          inst = Instructions::Instruction.fetch(opcode)
+          @instructions << inst.new(cp).tap { |i| i.decode(io) }
+
+          len -= inst.size
+        end
+
+        io.read(4) # discard exceptions and attributes
+      end
+
+      def to_hash
+        {
+          type: self.class.name.split('::').last,
+          max_stack: @max_stack,
+          max_local_variables: @max_locals,
+          instructions: @instructions.map(&:to_hash)
+        }
+      end
+    end
+  end
+end

data/lib/jvm_bytecode/attributes/source_file.rb

@@ -0,0 +1,24 @@
+module JvmBytecode
+  module Attributes
+    class SourceFile < Attribute
+      define location: [:class_file]
+
+      def filename(f)
+        @filename = cp.index_or_utf8(f)
+      end
+
+      def additional_bytecode
+        [@filename].pack('S>')
+      end
+
+      def decode(io)
+        io.read(4) # discard length
+        @filename = io.read(2).unpack('S>').first
+      end
+
+      def to_hash
+        {}
+      end
+    end
+  end
+end

data/lib/jvm_bytecode/class_file.rb

@@ -0,0 +1,117 @@
+module JvmBytecode
+  class ClassFile
+    using Extensions
+    include AccessFlag
+
+    MAGIC_NUMBER = [0xCA, 0xFE, 0xBA, 0xBE].pack('C4').freeze
+    ACCESS_FLAGS = {
+      public: 0x0001,
+      final: 0x0010,
+      super: 0x0020,
+      interface: 0x0200,
+      abstract: 0x0400,
+      synthetic: 0x1000,
+      anotation: 0x2000,
+      enum: 0x4000
+    }.freeze
+
+    def self.decode(io)
+      new.tap { |cf| cf.decode(io) }
+    end
+
+    def initialize(&block)
+      @cp = ConstantPool.new
+
+      @minor_ver = 0
+      @major_ver = 52
+
+      @this_class = nil
+      @super_class = nil
+
+      @interfaces = []
+      @fields = []
+      @methods = []
+      @attributes = []
+
+      self.instance_eval(&block) if block_given?
+    end
+
+    def constant_pool(&block)
+      @cp.tap { |cp| cp.instance_eval(&block) if block_given? }
+    end
+
+    def minor_version(v)
+      @minor_ver = v
+    end
+
+    def major_version(v)
+      @major_ver = v
+    end 
+
+    def this_class(name)
+      @this_class = @cp.class_index(name)
+    end
+
+    def super_class(name)
+      @super_class = @cp.class_index(name)
+    end
+
+    def new_method
+      Method.new(@cp)
+    end
+
+    def add_method(m)
+      @methods.push(m).last
+    end
+
+    def method_definition(&block)
+      add_method(new_method).tap { |m| m.instance_eval(&block) if block_given?}
+    end
+
+    def source_file(filename)
+      @attributes << Attributes::SourceFile.new(@cp).tap do |a|
+        a.filename(filename)
+      end
+    end
+
+    def bytecode
+      version    = [@minor_ver, @major_ver].pack('S>*')
+      classes    = [access_flag, @this_class, @super_class].pack('S>*')
+      interfaces = ([@interfaces.length] + @interfaces).pack("S>*")
+      fields     = @fields.join_bytecodes
+      methods    = @methods.join_bytecodes
+      attributes = @attributes.join_bytecodes
+
+      MAGIC_NUMBER + version + @cp.bytecode + classes + interfaces + fields + methods + attributes
+    end
+
+    def decode(io)
+      raise Errors::DecodeError, 'Not class file' if io.read(4) != MAGIC_NUMBER
+
+      @minor_ver, @major_ver = io.read(4).unpack('S>2')
+
+      @cp.decode(io)
+
+      acc_flag, @this_class, @super_class = io.read(6).unpack('S>3')
+      set_access_flag(acc_flag)
+
+      if_count = io.read(2).unpack('S>').first
+      @interfaces = io.read(if_count * 2).unpack("S>#{if_count}")
+
+      @fields = Field.decode_serial(@cp, io)
+      @methods = Method.decode_serial(@cp, io)
+    end
+
+    def to_hash
+      {
+        minor_version: @minor_ver,
+        major_version: @major_ver,
+        constant_pool: @cp.to_hash,
+        access_flag: readable_access_flag,
+        this_class: @this_class,
+        super_class: @super_class,
+        methods: @methods.map(&:to_hash)
+      }
+    end
+  end
+end

data/lib/jvm_bytecode/constant_pool.rb

@@ -0,0 +1,84 @@
+module JvmBytecode
+  class ConstantPool
+    using Extensions
+
+    def initialize
+      @constants = []
+    end
+
+    def constant(index)
+      @constants[index - 1]
+    end
+
+    def utf8(str)
+      index = nil
+      each_constants_of Constants::Utf8.tag do |utf8, i|
+        index = i if utf8.to_s == str
+      end
+
+      index || add(Constants::Utf8.new(str))
+    end
+
+    def add_class(name)
+      add(Constants::Class.new(index_or_utf8(name)))
+    end
+
+    def add_name_and_type(name, descriptor)
+      add(
+        Constants::NameAndType.new(index_or_utf8(name), index_or_utf8(descriptor))
+      )
+    end
+
+    def add_method_ref(class_index, name_and_type_index)
+      add(Constants::MethodRef.new(class_index, name_and_type_index))
+    end
+
+    def class_index(name)
+      name_index = utf8(name)
+      
+      index = nil
+      each_constants_of Constants::Class.tag do |klass, i|
+        index = i if klass.name_index == name_index
+      end
+
+      index || raise(Errors::ConstantError, "Class constant named \"#{name}\" doesn't exist")
+    end
+
+    def each_constants_of(tag)
+      @constants.each.with_index do |const, i|
+        yield const, i + 1 if const.class.tag == tag
+      end
+    end
+
+    def add(const)
+      @constants.push(const).length
+    end
+
+    def index_or_utf8(v)
+      v.is_a?(String) ? utf8(v) : v.to_i
+    end
+
+    def bytecode
+      @constants.join_bytecodes { @constants.length + 1 }
+    end
+
+    def decode(io)
+      entries = io.read(2).unpack('S>').first - 1
+
+      @constants.clear
+      entries.times do
+        tag = io.read(1).unpack('C').first
+        @constants << Constants::Constant.fetch(tag).decode(io)
+      end
+    end
+
+    def to_hash
+      @constants.map.with_index do |const, i|
+        { 
+          index: i + 1,
+          type: const.class.name.split('::').last.gsub('Constant', '')
+        }.merge(const.to_hash)
+      end
+    end
+  end
+end

data/lib/jvm_bytecode/constants/class.rb

@@ -0,0 +1,25 @@
+module JvmBytecode
+  module Constants
+    class Class < Constant
+      define 7
+
+      attr_reader :name_index
+
+      def self.decode(io)
+        new(io.read(2).unpack('S>').first)
+      end
+
+      def initialize(name_index)
+        @name_index = name_index
+      end
+
+      def additional_bytecode
+        [@name_index].pack('S>')
+      end
+
+      def to_hash
+        { name_index: @name_index }
+      end
+    end
+  end 
+end

data/lib/jvm_bytecode/constants/constant.rb

@@ -0,0 +1,28 @@
+module JvmBytecode
+  module Constants
+    class Constant
+      class << self
+        attr_reader :tag
+
+        def define(t)
+          @@constants ||= {}
+          @@constants[t] = self
+
+          @tag = t
+        end
+
+        def fetch(t)
+          @@constants[t] || raise(Errors::ConstantError, "Constant:#{t} is not implemented")
+        end
+      end
+
+      def bytecode
+        [self.class.tag].pack('C') + additional_bytecode
+      end
+
+      def additional_bytecode
+        ''
+      end
+    end
+  end 
+end

data/lib/jvm_bytecode/constants/method_ref.rb

@@ -0,0 +1,7 @@
+module JvmBytecode
+  module Constants
+    class MethodRef < Ref
+      define 10
+    end
+  end 
+end

data/lib/jvm_bytecode/constants/name_and_type.rb

@@ -0,0 +1,30 @@
+module JvmBytecode
+  module Constants
+    class NameAndType < Constant
+      define 12
+
+      attr_reader :name_index, :descriptor_index
+
+      def self.decode(io)
+        indexes = io.read(4).unpack('S>2')
+        new(*indexes)
+      end
+
+      def initialize(name_index, descriptor_index)
+        @name_index = name_index
+        @descriptor_index = descriptor_index
+      end
+
+      def additional_bytecode
+        [@name_index, @descriptor_index].pack('S>2')
+      end
+
+      def to_hash
+        {
+          name_index: @name_index,
+          descriptor_index: @descriptor_index
+        }
+      end
+    end
+  end 
+end

data/lib/jvm_bytecode/constants/ref.rb

@@ -0,0 +1,28 @@
+module JvmBytecode
+  module Constants
+    class Ref < Constant
+      attr_reader :class_index, :name_and_type_index
+
+      def self.decode(io)
+        indexes = io.read(4).unpack('S>2')
+        new(*indexes)
+      end
+
+      def initialize(class_index, name_and_type_index)
+        @class_index = class_index
+        @name_and_type_index = name_and_type_index
+      end
+
+      def additional_bytecode
+        [@class_index, @name_and_type_index].pack('S>2')
+      end
+
+      def to_hash
+        {
+          class_index: @class_index,
+          name_and_type_index: @name_and_type_index
+        }
+      end
+    end
+  end 
+end

data/lib/jvm_bytecode/constants/utf8.rb

@@ -0,0 +1,30 @@
+module JvmBytecode
+  module Constants
+    class Utf8 < Constant
+      define 1
+
+      def self.decode(io)
+        str = io.read(io.read(2).unpack('S>').first).force_encoding('UTF-8')
+        new(str)
+      end
+
+      def initialize(str)
+        raise "#{self.class} requires utf-8 string" unless str.encoding.to_s == 'UTF-8'
+        @str = str
+      end
+
+      def to_s
+        @str
+      end
+
+      def additional_bytecode
+        s = @str.dup.force_encoding('ASCII-8BIT')
+        [s.length].pack('S>') + s
+      end
+
+      def to_hash
+        { string: @str }
+      end
+    end
+  end 
+end

data/lib/jvm_bytecode/errors/attribute_error.rb

@@ -0,0 +1,6 @@
+module JvmBytecode
+  module Errors
+    class AttributeError < StandardError
+    end
+  end
+end

data/lib/jvm_bytecode/errors/constant_error.rb

@@ -0,0 +1,6 @@
+module JvmBytecode
+  module Errors
+    class ConstantError < StandardError
+    end
+  end
+end

data/lib/jvm_bytecode/errors/decode_error.rb

@@ -0,0 +1,6 @@
+module JvmBytecode
+  module Errors
+    class DecodeError < StandardError
+    end
+  end
+end

data/lib/jvm_bytecode/errors/opcode_error.rb

@@ -0,0 +1,6 @@
+module JvmBytecode
+  module Errors
+    class OpcodeError < StandardError
+    end
+  end
+end

data/lib/jvm_bytecode/extensions.rb

@@ -0,0 +1,15 @@
+module JvmBytecode
+  module Extensions
+    refine Array do
+      def join_bytecodes(template = 'S>')
+        [block_given? ? yield : length].pack('S>') + map(&:bytecode).join('')
+      end
+    end
+
+    refine Class do
+      def shortname
+        name.split('::').last
+      end
+    end
+  end
+end

data/lib/jvm_bytecode/field.rb

@@ -0,0 +1,55 @@
+module JvmBytecode
+  class Field
+    using Extensions
+    include AccessFlag
+
+    ACCESS_FLAGS = {
+      public: 0x0001,
+      private: 0x0002,
+      protected: 0x0004,
+      static: 0x0008,
+      final: 0x0010,
+      volatile: 0x0040,
+      transient: 0x0080,
+      synthetic: 0x1000,
+      enum: 0x4000
+    }.freeze 
+
+    def self.decode_serial(cp, io)
+      Array.new(io.read(2).unpack('S>').first) do 
+        new(cp).tap { |f| f.decode(io) }
+      end
+    end
+
+    def initialize(cp)
+      @cp = cp
+      @name = 0
+      @descriptor = 0
+      @attributes = []
+    end
+
+    def name(n)
+      @name = @cp.index_or_utf8(n)
+    end
+
+    def descriptor(d)
+      @descriptor = @cp.index_or_utf8(d)
+    end
+
+    def bytecode
+      [access_flag, @name, @descriptor].pack('S>3') +
+      @attributes.join_bytecodes
+    end
+
+    def decode(io)
+      acc_flag, @name, @descriptor = io.read(6).unpack('S>3')
+      set_access_flag(acc_flag)
+      
+      @attributes = Attributes::Attribute.decode_serial(@cp, io)
+    end
+
+    def to_hash
+      {}
+    end
+  end
+end

data/lib/jvm_bytecode/instructions/instruction.rb

@@ -0,0 +1,55 @@
+module JvmBytecode
+  module Instructions
+    class Instruction
+      using Extensions
+
+      class << self
+        attr_reader :opcode, :size, :mnemonic
+
+        def format(opcode:, size: 1, mnemonic: nil)
+          @@instructions ||= {}
+          @@instructions[opcode] = self
+
+          @opcode = opcode
+          @size = size
+          @mnemonic = mnemonic || shortname.downcase
+        end 
+
+        def all
+          @@instructions.values
+        end
+
+        def fetch(opcode)
+          @@instructions[opcode] || raise(Errors::OpcodeError, "#{sprintf('0x%02X', opcode)} is not implemented")
+        end
+      end
+
+      attr_reader :cp
+      attr_accessor :args
+
+      def initialize(cp)
+        @cp = cp
+        @args = nil
+      end
+
+      def bytecode
+        [self.class.opcode].pack('C') + additional_bytecode
+      end
+
+      def additional_bytecode
+        ''
+      end
+
+      def decode(io)
+
+      end
+
+      def to_hash
+        {
+          mnemonic: self.class.mnemonic,
+          opcode: self.class.opcode
+        }
+      end
+    end
+  end
+end

data/lib/jvm_bytecode/instructions/instruction_set.rb

@@ -0,0 +1,48 @@
+module JvmBytecode
+  module Instructions
+    4.times do |n|
+      # iload_(0|1|2|3)
+      Class.new(Instruction) do
+        format opcode: 0x1A + n, mnemonic: "iload_#{n}"
+      end
+
+      # aload_(0|1|2|3)
+      Class.new(Instruction) do
+        format opcode: 0x2A + n, mnemonic: "aload_#{n}"
+      end
+    end
+
+    class IAdd < Instruction
+      format opcode: 0x60
+    end 
+
+    class IReturn < Instruction
+      format opcode: 0xAC
+    end
+
+    class Return < Instruction
+      format opcode: 0xB1, mnemonic: '_return'
+
+      def to_hash
+        super.merge({ mnemonic: 'return' })
+      end
+    end
+
+    class InvokeSpecial < Instruction
+      format opcode: 0xB7, size: 3
+
+      def additional_bytecode
+        [args.first].pack('S>')
+      end
+
+      def decode(io)
+        super(io)
+        self.args = io.read(2).unpack('S>')
+      end
+
+      def to_hash
+        super.merge({ ref: args.first })
+      end
+    end
+  end
+end

data/lib/jvm_bytecode/method.rb

@@ -0,0 +1,69 @@
+module JvmBytecode
+  class Method
+    using Extensions
+    include AccessFlag
+
+    ACCESS_FLAGS = {
+      public: 0x0001,
+      private: 0x0002,
+      protected: 0x0004,
+      static: 0x0008,
+      final: 0x0010,
+      syncrhonized: 0x0020,
+      bridge: 0x0040,
+      varargs: 0x0080,
+      native: 0x0100,
+      abstract: 0x0400,
+      strict: 0x0800,
+      synthetic: 0x1000
+    }.freeze 
+
+    def self.decode_serial(cp, io)
+      Array.new(io.read(2).unpack('S>').first) do 
+        new(cp).tap { |m| m.decode(io) }
+      end
+    end
+
+    def initialize(cp)
+      @cp = cp
+      @name = 0
+      @descriptor = 0
+      @attributes = []
+    end
+
+    def name(n)
+      @name = @cp.index_or_utf8(n)
+    end
+
+    def descriptor(d)
+      @descriptor = @cp.index_or_utf8(d)
+    end
+
+    def code(&block)
+      @attributes
+        .push(Attributes::Code.new(@cp))
+        .last
+        .instance_eval(&block)
+    end
+
+    def bytecode
+      [access_flag, @name, @descriptor].pack('S>*') + @attributes.join_bytecodes
+    end
+
+    def decode(io)
+      acc_flag, @name, @descriptor = io.read(6).unpack('S>3')
+      set_access_flag(acc_flag)
+
+      @attributes = Attributes::Attribute.decode_serial(@cp, io)
+    end
+
+    def to_hash
+      {
+        name_index: @name,
+        descriptor_index: @descriptor,
+        access_flag: access_flag,
+        attributes: @attributes.map(&:to_hash)
+      }
+    end
+  end
+end

data/lib/jvm_bytecode/version.rb

@@ -0,0 +1,3 @@
+module JvmBytecode
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: jvm_bytecode
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- bonono
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Tool for generating and decoding JVM bytecode
+email:
+- bonono.jp@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- jvm_bytecode.gemspec
+- lib/jvm_bytecode.rb
+- lib/jvm_bytecode/access_flag.rb
+- lib/jvm_bytecode/attributes/attribute.rb
+- lib/jvm_bytecode/attributes/code.rb
+- lib/jvm_bytecode/attributes/source_file.rb
+- lib/jvm_bytecode/class_file.rb
+- lib/jvm_bytecode/constant_pool.rb
+- lib/jvm_bytecode/constants/class.rb
+- lib/jvm_bytecode/constants/constant.rb
+- lib/jvm_bytecode/constants/method_ref.rb
+- lib/jvm_bytecode/constants/name_and_type.rb
+- lib/jvm_bytecode/constants/ref.rb
+- lib/jvm_bytecode/constants/utf8.rb
+- lib/jvm_bytecode/errors/attribute_error.rb
+- lib/jvm_bytecode/errors/constant_error.rb
+- lib/jvm_bytecode/errors/decode_error.rb
+- lib/jvm_bytecode/errors/opcode_error.rb
+- lib/jvm_bytecode/extensions.rb
+- lib/jvm_bytecode/field.rb
+- lib/jvm_bytecode/instructions/instruction.rb
+- lib/jvm_bytecode/instructions/instruction_set.rb
+- lib/jvm_bytecode/method.rb
+- lib/jvm_bytecode/version.rb
+homepage: https://github.com/bonono/ruby-jvm-bytecode
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Tool for generating and decoding JVM bytecode
+test_files: []