rasm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e53809f6f8b08b801973b09592bbbba0cdd0f0fd
+  data.tar.gz: 82cd8287f580bedb991aaa8625cdbacf7cdd9a74
+SHA512:
+  metadata.gz: 685d9619e126dbb4052ee0302cd9ea729fb2209cea2abbe413de6d7eefc3cd8064db1f6530e006bc5b4949efeb4c2014aabcf6eababdaa7456408ecad516b868
+  data.tar.gz: b112018494288f163b63e661e4fdded80a9d2799bed17253e6eb4c45d7925523a188ce0f3f25b8eb7bf655eb5ac458103b450f620007405b213386bad7a80169

data/.gitignore

@@ -0,0 +1,19 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+*.gem
+
+
+/lib/tmp

data/.rspec

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rasm.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 James Zhan
+
+MIT License
+
+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,31 @@
+# Rasm
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rasm'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rasm
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/jameszhan/rasm/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+

data/lib/rasm.rb

@@ -0,0 +1,11 @@
+require 'rasm/version'
+require 'rasm/core_ext'
+
+
+module Rasm
+  autoload :Ref, 'rasm/ref'
+
+  module Java
+    autoload :Bytecode, 'rasm/java/bytecode'
+  end
+end

data/lib/rasm/core_ext.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"].each do |path|
+  require path
+end

data/lib/rasm/core_ext/hash.rb

@@ -0,0 +1,16 @@
+class Hash
+
+  def ref(selector, options = {})
+    Rasm::Ref.new(self, selector, options)
+  end
+
+  def respond_to_missing?(method, *)
+    self.key?(method) || super
+  end
+
+  def method_missing(method, *args)
+    return self[method] if args.empty? && self.include?(method)
+    super
+  end
+
+end

data/lib/rasm/java/accessable.rb

@@ -0,0 +1,78 @@
+module Rasm
+  module Java
+
+    module Accessable
+      ACC_PUBLIC = 0x0001 # class, field, method
+      ACC_PRIVATE = 0x0002 # class, field, method
+      ACC_PROTECTED = 0x0004 # class, field, method
+      ACC_STATIC = 0x0008; # field, method
+      ACC_FINAL = 0x0010; # class, field, method
+      ACC_SUPER = 0x0020; # class
+      ACC_SYNCHRONIZED = 0x0020; # method
+      ACC_VOLATILE = 0x0040; # field
+      ACC_BRIDGE = 0x0040; # method
+      ACC_VARARGS = 0x0080; # method
+      ACC_TRANSIENT = 0x0080; # field
+      ACC_NATIVE = 0x0100; # method
+      ACC_INTERFACE = 0x0200; # class
+      ACC_ABSTRACT = 0x0400; # class, method
+      ACC_STRICT = 0x0800; # method
+      ACC_SYNTHETIC = 0x1000; # class, field, method
+      ACC_ANNOTATION = 0x2000; # class
+      ACC_ENUM = 0x4000; # class(?) field inner
+
+      ACC_DEPRECATED = 0x20000; # class, field, method
+
+
+      TYPES = {
+        Z: 'boolean',
+        B: 'byte',
+        C: 'char',
+        S: 'short',
+        I: 'int',
+        F: 'float',
+        J: 'long',
+        D: 'double',
+        L: lambda{|ref| "#{ref}"},
+        '['.to_sym => lambda{|type| "#{type}[]"}
+      }
+
+      TYPEPATTERN = /^([ZBCSIFJDL\[])([^;<]*(<[^>]+>)?);?$/
+
+      def typeof(decriptor)
+        if m = TYPEPATTERN.match(decriptor)
+          type = TYPES[m[1].to_sym]
+          if type.respond_to? :call
+            type.call(typeof(m[2]))
+          else
+            type
+          end
+        else
+          decriptor
+        end
+      end
+
+      def access_desc
+        access = access_flags & ~ ACC_SUPER
+        str = ''
+        str << 'public ' if ((access & ACC_PUBLIC) != 0)
+        str << 'private ' if ((access & ACC_PRIVATE) != 0)
+        str << 'protected ' if ((access & ACC_PROTECTED) != 0)
+        str << 'final ' if ((access & ACC_FINAL) != 0)
+        str << 'static ' if ((access & ACC_STATIC) != 0)
+        str << 'synchronized ' if ((access & ACC_SYNCHRONIZED) != 0)
+        str << 'volatile ' if ((access & ACC_VOLATILE) != 0)
+        str << 'transient ' if ((access & ACC_TRANSIENT) != 0)
+        str << 'abstract ' if ((access & ACC_ABSTRACT) != 0)
+        str << 'strictfp ' if ((access & ACC_STRICT) != 0)
+        str << 'synthetic ' if ((access & ACC_SYNTHETIC) != 0)
+        str << 'enum ' if ((access & ACC_ENUM) != 0)
+        str
+      end
+
+      attr_accessor :name, :access_flags
+
+    end
+
+  end
+end

data/lib/rasm/java/attributes.rb

@@ -0,0 +1,25 @@
+module Rasm
+  module Java
+    class Attribute
+      attr_reader :name
+      def initialize(cp, name, data)
+        @cp, @name, @data = cp, name, data
+      end
+
+      def value
+        @cp[@data.unpack('n')[0]].val
+      end
+
+      class << self
+        def of(cp, name, data)
+          case name
+            when 'Code'
+
+            else
+              Attribute.new(cp, name, data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rasm/java/bytecode.rb

@@ -0,0 +1,140 @@
+require 'rasm/java/constant_type'
+require 'rasm/java/structure'
+require 'rasm/java/accessable'
+require 'rasm/java/attributes'
+
+module Rasm
+  module Java
+    #
+    # ClassFile {
+    #     u4 magic;
+    #     u2 minor_version;
+    #     u2 major_version;
+    #     u2 constant_pool_count;
+    #     cp_info constant_pool[constant_pool_count-1];
+    #     u2 access_flags;
+    #     u2 this_class;
+    #     u2 super_class;
+    #     u2 interfaces_count;
+    #     u2 interfaces[interfaces_count];
+    #     u2 fields_count;
+    #     field_info fields[fields_count];
+    #     u2 methods_count;
+    #     method_info methods[methods_count];
+    #     u2 attributes_count;
+    #     attribute_info attributes[attributes_count];
+    # }
+    #
+    class Bytecode
+      include Accessable
+
+      attr_reader :version, :super_class, :interfaces, :fields, :methods, :attributes
+
+      def initialize(class_file)
+        open class_file, 'rb' do|io|
+          magic = io.read(4).unpack('N')[0]
+          if magic == 0xCAFEBABE
+            @version = io.read(4).unpack('nn').reverse.join('.')
+            pull_cp_info(io)
+            self.access_flags, this_class, super_class, interfaces_count = io.read(8).unpack('n*')
+            @interfaces = interfaces_count > 0 ? io.read(2 * interfaces_count).unpack('n*').map{|item| constant_pool[item].val} : []
+            self.name, @super_class = constant_pool[this_class].val, constant_pool[super_class].val
+
+            @fields = pull_list(io, FieldInfo)
+            @methods = pull_list(io, MethodInfo)
+            @attributes = pull_attributes(io)
+          else
+            raise "magic #{magic} is not valid java class file."
+          end
+        end
+      end
+
+      def to_s
+        access = access_flags
+        str = ''
+        if access & ACC_DEPRECATED != 0
+          str << "//DEPRECATED\n"
+        end
+        str << "// access flags 0x%x\n" % access
+        str << access_desc
+        if (access & ACC_ANNOTATION) != 0
+          str << '@interface '
+        elsif (access & ACC_INTERFACE) != 0
+          str << 'interface ';
+        elsif (access & ACC_ENUM) == 0
+          str << 'class '
+        end
+        str << name
+        str << " extends #{super_class} " if super_class && super_class != 'java/lang/Object'
+        str << " implements %s {\n" % interfaces.join(',') unless interfaces.empty?
+        fields.each do|f|
+          str << "#{f}\n"
+        end
+        str << "\n}"
+        str
+      end
+
+
+      def constant_pool
+        @constant_pool ||= {}
+      end
+
+      def cp_info
+        str = "cp_info (#{@constant_pool_count}) \n"
+        constant_pool.each do|i, e|
+          if e.is_a? Ref
+            str << "#%02d = %-16s %-20s %s\n" % [i, e.name, e, ("//#{e.val}" if e.is_a?(Ref))]
+          else
+            str << "#%02d = %-16s %-20s\n" % [i, e.name, e.val]
+          end
+
+        end
+        str
+      end
+
+      private
+        def pull_cp_info(io)
+          @constant_pool_count = io.read(2).unpack('n')[0]
+          i = 1
+          while i < @constant_pool_count
+            tag = io.read(1).unpack('C')[0]
+            constant_type = CONSTANT_TYPES[tag]
+            if constant_type
+              target = constant_type.value_at(io)
+              constant_pool[i] = target.respond_to?(:call) ? target.call(constant_pool) : target
+            end
+            i += 1 if tag == 5 || tag == 6
+            i += 1
+          end
+        end
+
+        def pull_list(io, type)
+          fields_count = io.read(2).unpack('n')[0]
+          items = []
+          if fields_count > 0
+            fields_count.times do
+              access_flags, name_index, descriptor_index = io.read(6).unpack('n*')
+              attributes = pull_attributes(io)
+              item = type.new(constant_pool[descriptor_index].val, attributes)
+              item.access_flags, item.name = access_flags, constant_pool[name_index].val
+              items << item
+            end
+          end
+          items
+        end
+
+        def pull_attributes(io)
+          attributes_count = io.read(2).unpack('n')[0]
+          attributes = []
+          attributes_count.times do
+            attribute_name_index, attribute_length = io.read(6).unpack('nN')
+            name = constant_pool[attribute_name_index].val
+            attributes << Attribute.of(constant_pool, name, io.read(attribute_length))
+          end
+          attributes
+        end
+    end
+
+
+  end
+end

data/lib/rasm/java/constant_type.rb

@@ -0,0 +1,65 @@
+module Rasm
+  module Java
+
+
+
+    ConstantType = Struct.new(:name, :tag, :rule) do
+
+      def value(val)
+        {tag: tag, name: name, val: val}
+      end
+
+      def value_at(io)
+        rule.call(io)
+      end
+
+      class << self
+        def val(name, tag, len, flag)
+          ConstantType.new(name, tag, val_lambda(name, tag, len, flag))
+        end
+
+        def ref(name, tag, len)
+          ConstantType.new(name, tag, ref_lambda(name, tag, len))
+        end
+
+        private
+          def val_lambda(name, tag, len, flag)
+            lambda do|io|
+              length = len.respond_to?(:call) ? len.call(io) : len
+              bytes = io.read(length)
+              val = flag.respond_to?(:call) ? flag.call(bytes) : bytes.unpack(flag)[0]
+              {val: val, name: name, tag: tag}
+            end
+          end
+
+          def ref_lambda(name, tag, len)
+            lambda do|io|
+              selector = len == 2 ? io.read(len).unpack('n')[0] : io.read(len).unpack('nn')
+              lambda{|cp| cp.ref(selector).bind(name: name, tag: tag)}
+            end
+          end
+      end
+
+    end
+
+
+    CONSTANT_TYPES = [
+      nil,
+      ConstantType.val(:Utf8, 1, lambda{|io| io.read(2).unpack('n')[0]}, 'a*'),
+      nil,
+      ConstantType.val(:Integer ,3, 4, 'N'),
+      ConstantType.val(:Float, 4, 4, 'g'),
+      ConstantType.val(:Long, 5, 8, lambda{|bytes| h, l = bytes.unpack('NN'); (h << 32) + l}),
+      ConstantType.val(:Double, 6, 8, 'G'),
+      ConstantType.ref(:Class, 7, 2),
+      ConstantType.ref(:String, 8, 2),
+      ConstantType.ref(:Fieldref, 9, 4),
+      ConstantType.ref(:Methodref, 10, 4),
+      ConstantType.ref(:InterfaceMethodref, 11, 4),
+      ConstantType.ref(:NameAndType, 12, 4)
+    ]
+
+
+
+  end
+end

data/lib/rasm/java/structure.rb

@@ -0,0 +1,38 @@
+require 'rasm/java/accessable'
+module Rasm
+  module Java
+
+    class FieldInfo
+      include Accessable
+      attr_reader :descriptor, :attributes
+      def initialize(descriptor, attributes)
+        @descriptor, @attributes = descriptor, attributes
+      end
+
+      def to_s
+        access = access_flags
+        str = ''
+        str << "\t// DEPRECATED\n" if access & ACC_DEPRECATED != 0
+        str << "\t// access flags 0x%x\n" % access
+        signature, constant_value = attribute_of('Signature'), attribute_of('ConstantValue')
+        if signature
+          str << "\t#{access_desc} #{typeof(signature.value)} #{name}"
+        else
+          str << "\t#{access_desc} #{typeof(descriptor)} #{name}"
+        end
+        str << " = #{constant_value.value}" if constant_value
+
+        str
+      end
+
+      def attribute_of(name)
+        attributes.detect{|attr| attr.name == name}
+      end
+
+    end
+
+    MethodInfo = Struct.new(:access_flags, :name, :descriptor, :attributes) do
+
+    end
+  end
+end

data/lib/rasm/ref.rb

@@ -0,0 +1,63 @@
+module Rasm
+
+  class Ref
+    attr_reader :scope, :selector, :options
+    def initialize(scope, selector, options = {})
+      @scope = scope
+      @selector = selector
+      @options = options
+    end
+
+    def bind(defs)
+      data.merge!(defs)
+      self
+    end
+
+    def [](key)
+      data[key]
+    end
+
+    def []=(key, value)
+      data[key] = value
+    end
+
+    def to_s
+      prefix = options[:prefix] || '#'
+      if selector.is_a? Array
+        split = options[:split] || ':'
+        selector.map{|item| "#{prefix}#{item}"}.join(split)
+      else
+        "#{prefix}#{selector}"
+      end
+    end
+
+    def val
+      split = options[:split] || ':'
+      if selector.respond_to? :map
+        selector.map{|item| find(scope, item) }.join(split)
+      else
+        find(scope, selector)
+      end
+    end
+
+    def respond_to_missing?(method, *)
+      data.include?(method) || super
+    end
+
+    def method_missing(method, *args)
+      return data[method] if args.empty? && data.include?(method)
+      super
+    end
+
+    private
+      def data
+         @data ||= {}
+      end
+
+      def find(scope, selector)
+        value = scope[selector]
+        value.respond_to?(:val) ? value.val : value
+      end
+  end
+
+end

data/lib/rasm/version.rb

@@ -0,0 +1,3 @@
+module Rasm
+  VERSION = '0.0.1'
+end

data/rasm.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rasm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rasm'
+  spec.version       = Rasm::VERSION
+  spec.authors       = ['James Zhan']
+  spec.email         = ['zhiqiangzhan@gmail.com']
+  spec.summary       = %q{A x86 assembler}
+  spec.description   = %q{A x86 assembler implemented by Ruby.}
+  spec.homepage      = 'https://github.com/jameszhan/rasm'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/spec/bytecode_spec.rb

@@ -0,0 +1,21 @@
+describe Rasm do
+
+  describe 'Bytecode' do
+    it 'it can analyze java class bytecode' do
+      root_dir = '/u/workdir/codes/rfsc/codegen/target/test-classes'
+      clazz = 'com.mulberry.athena.asm.DemoClass'
+
+
+      class_file = "#{root_dir}/#{clazz.gsub('.', '/')}.class"
+
+      bytecode = Rasm::Java::Bytecode.new class_file
+      puts bytecode.version
+      puts bytecode.cp_info
+      puts bytecode
+      puts bytecode.fields
+      puts bytecode.methods
+      puts bytecode.attributes
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,94 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rasm'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: rasm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- James Zhan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A x86 assembler implemented by Ruby.
+email:
+- zhiqiangzhan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rasm.rb
+- lib/rasm/core_ext.rb
+- lib/rasm/core_ext/hash.rb
+- lib/rasm/java/accessable.rb
+- lib/rasm/java/attributes.rb
+- lib/rasm/java/bytecode.rb
+- lib/rasm/java/constant_type.rb
+- lib/rasm/java/structure.rb
+- lib/rasm/ref.rb
+- lib/rasm/version.rb
+- rasm.gemspec
+- spec/bytecode_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jameszhan/rasm
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A x86 assembler
+test_files:
+- spec/bytecode_spec.rb
+- spec/spec_helper.rb