binrip 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fdcf48f2dbbcf86fbaee2b8df4ae52e7e3d5d780c2355550c3067207b398b958
+  data.tar.gz: '096136cc21c5a841782054f55f7fcfe7d44687ff9af8346796752fe97664b2df'
+SHA512:
+  metadata.gz: bfc2e4aca21afb16774675b4967da77f8631aa91594098d1eb2c062b24a4549b8452ae222415fb3e1226abdcd6c6100a693dd24354498df22d58845e6c8f6ad4
+  data.tar.gz: b115be023cfa59e5c171b9ba1f0c01a8ca13171b2163baede955dd74a847e4476d44839a397b71ab313b31afd35de39882b82902785ace638b369d6e7e2ab10b

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in binrip.gemspec
+gemspec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'binrip'
+
+# 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(__FILE__)

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/binrip.gemspec

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'binrip/version'
+
+Gem::Specification.new do |spec|
+  unless spec.respond_to?(:metadata)
+    # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host',
+    # or delete this section to allow pushing this gem to any host.
+    raise <<-ERR
+      RubyGems 2.0 or newer is required to protect against public gem pushes.
+    ERR
+  end
+
+  spec.name          = 'binrip'
+  spec.version       = Binrip::VERSION
+  spec.authors       = ['David Siaw']
+  spec.email         = ['davidsiaw@gmail.com']
+
+  spec.summary       = 'Binary file format language'
+  spec.description   = 'Ripper of binary files'
+  spec.homepage      = 'https://github.com/davidsiaw/binrip'
+  spec.license       = 'MIT'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/davidsiaw/binrip'
+  spec.metadata['changelog_uri'] = 'https://github.com/davidsiaw/binrip'
+
+  spec.files = Dir['{data,exe,lib,bin}/**/*'] +
+               %w[Gemfile binrip.gemspec]
+  spec.test_files    = Dir['{spec,features}/**/*']
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'optimist'
+  spec.add_dependency 'sinatra', '~> 2.0.3'
+
+  spec.add_development_dependency 'bundler', '~> 1.9'
+  spec.add_development_dependency 'rspec'
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+end

data/lib/binrip.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'binrip/version'
+require 'yaml'

data/lib/binrip/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Binrip
+  VERSION = '0.1.0'
+end

data/spec/binrip_spec.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+# Main module
+module Binrip
+  class Device
+    def index(something)
+    end
+  end
+
+  class SetInstruction
+    def initialize(machine, params)
+      @machine = machine
+      @params = params
+    end
+
+    def run!
+      @machine.registers[dst_register_name] = src_value
+    end
+
+    def src_value
+      return @params[1] if @params[1].is_a? Integer
+
+      @machine.registers[src_register_name]
+    end
+
+    def src_register_name
+      name_of @params[1]
+    end
+
+    def dst_register_name
+      name_of @params[0]
+    end
+
+    def name_of(thing)
+      thing.to_s.sub(/^reg_/, '').to_sym
+    end
+  end
+
+  # interpreter
+  class Interpreter
+    attr_reader :error, :memory, :device, :rom, :registers
+
+    # a, b, c, d, e, f, g, h -> general purpose registers
+    # pc -> register with address of next operation
+    # mr -> register with address of memory being used
+    # err -> error register
+    # mem -> setting this register outputs to memory
+    #        reading this register inputs from memory
+    # dev -> setting this register outputs to device
+    #        reading this register inputs from device
+    REGISTER_NAMES = %i[a b c d e f g h pc mr err mem dev].freeze
+
+    def initialize(rom, device)
+      @rom = rom
+      @memory = {}
+      @stack = []
+      @halted = false
+      @device = device
+      @registers = REGISTER_NAMES.map { |x| [x, 0] }.to_h
+    end
+
+    def step!
+      return if halted? # no need to run if halted
+
+      execute!
+
+    rescue => e
+      @error = e
+      set_register(:err, 1)
+
+    ensure
+      increment(:pc)
+      @halted = true if register_value(:pc) >= @rom.length
+    end
+
+    def execute!
+      instruction = @rom[register_value(:pc)]
+      params = instruction.values[0]
+
+      case instruction.keys[0]
+      when 'set'
+        SetInstruction.new(self, params).run!
+      end
+    end
+
+    def register_value(register)
+      @registers[register]
+    end
+
+    def set_register(register, value)
+      @registers[register] = value
+    end
+
+    def increment(register)
+      @registers[register] += 1
+    end
+
+    def halted?
+      @halted
+    end
+  end
+
+  # linker
+  class Linker
+    def initialize(asm)
+      @asm = asm
+      p @asm
+    end
+
+    def positions
+      pos = {}
+      count = 0
+      @asm.each do |fname, fdef|
+        pos[fname] = count
+        count += fdef.length + 1
+      end
+      pos
+    end
+
+    def output
+      result = []
+      @asm.each do |fname, fdef|
+        fdef.each do |instr|
+          params = instr.values[0]
+          if instr.keys[0] == 'call'
+            result << { 'call' => [ positions[params[0]] ] }
+          else
+            result << instr
+          end
+        end
+        result << { 'return' => [] }
+      end
+      result
+    end
+  end
+
+  # compiler
+  class Compiler
+    def initialize(desc)
+      @desc = desc
+    end
+
+    def functions
+      result = {}
+      @desc['formats'].each do |name, info|
+        result["alloc_#{name}"] = [
+          { 'alloc' => [name, 'reg_a'] }
+        ]
+
+        init_instrs = []
+        read_instrs = []
+        write_instrs = []
+
+        info['fields'].each do |field_info|
+          read_func = "read_#{name}_#{field_info['name']}"
+          write_func = "write_#{name}_#{field_info['name']}"
+
+          result[read_func] = [            
+            { 'index' => ['reg_a', 'simple.number', 1] },
+            { 'read_bytes' => [1, 'reg_dev'] }
+          ]
+
+          result[write_func] = [            
+            { 'index' => ['reg_a', 'simple.number', 1] },
+            { 'write_bytes' => [1, 'reg_dev'] }
+          ]
+
+          init_instrs += [
+            { 'index' => ['reg_a', 'simple.number', 1] },
+            { 'set' => ['reg_dev', 0] }
+          ]
+
+          read_instrs << { 'call' => [read_func] }
+          write_instrs << { 'call' => [write_func] }
+        end
+
+        result["init_#{name}"] = init_instrs
+        result["read_#{name}"] = read_instrs
+        result["write_#{name}"] = write_instrs
+      end
+      result
+    end
+
+    def output
+      {
+        'functions' => functions
+      }
+    end
+  end
+end
+
+RSpec.describe Binrip do
+  it 'has a version number' do
+    expect(Binrip::VERSION).not_to be nil
+  end
+end
+
+RSpec.describe Binrip::Compiler do
+  it 'compiles a description to read and write' do
+
+    yaml = <<~YAML
+      formats:
+        simple:
+          fields:
+          - name: count
+            type: int8
+    YAML
+    compiler = Binrip::Compiler.new(YAML.load(yaml))
+    expect(compiler.output).to eq YAML.load(<<~YAML)
+      functions:
+        alloc_simple:
+        - alloc: [simple, reg_a]
+
+        init_simple:
+        - index: [reg_a, simple.number, 1]
+        - set: [reg_dev, 0]
+
+        read_simple:
+        - call: [read_simple_count]
+
+        read_simple_count:
+        - index: [reg_a, simple.number, 1]
+        - read_bytes: [1, reg_dev]
+
+        write_simple:
+        - call: [write_simple_count]
+        
+        write_simple_count:
+        - index: [reg_a, simple.number, 1]
+        - write_bytes: [1, reg_dev]
+    YAML
+  end
+end
+
+RSpec.describe Binrip::Linker do
+  it 'assembles compiler output to a string of instructions' do
+    compiler_output = YAML.load(<<~YAML)
+      ---
+      main:
+        - set: [reg_a, 2]
+        - call: [a_function]
+        - inc: [reg_a, 3]
+
+      a_function:
+        - inc: [reg_a, 1]
+    YAML
+
+    linker = Binrip::Linker.new(compiler_output)
+
+    expect(linker.output).to eq YAML.load(<<~YAML)
+      - set: [reg_a, 2]  # 0 main
+      - call: [4]        # 1 call a_function
+      - inc: [reg_a, 3]  # 2
+      - return: []       # 3
+      - inc: [reg_a, 1]  # 4 a_function
+      - return: []       # 5 ret
+    YAML
+  end
+end
+
+RSpec.describe Binrip::Interpreter do
+  it 'interprets a simple set of instructions' do
+    instructions = YAML.load(<<~YAML)
+      - set: [reg_a, 2]
+      - set: [reg_b, 3]
+      - set: [reg_c, 4]
+    YAML
+
+    d = Binrip::Device.new
+
+    machine = Binrip::Interpreter.new(instructions, d)
+
+    loop do
+      machine.step!
+      break if machine.halted?
+    end
+
+    expect(machine.error).to be_nil
+    expect(machine.register_value(:a)).to eq 2
+    expect(machine.register_value(:b)).to eq 3
+    expect(machine.register_value(:c)).to eq 4
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'binrip'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: binrip
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Siaw
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-05-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: optimist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !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: Ripper of binary files
+email:
+- davidsiaw@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- bin/console
+- bin/setup
+- binrip.gemspec
+- lib/binrip.rb
+- lib/binrip/version.rb
+- spec/binrip_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/davidsiaw/binrip
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/davidsiaw/binrip
+  source_code_uri: https://github.com/davidsiaw/binrip
+  changelog_uri: https://github.com/davidsiaw/binrip
+  allowed_push_host: https://rubygems.org
+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.7.8
+signing_key: 
+specification_version: 4
+summary: Binary file format language
+test_files:
+- spec/binrip_spec.rb
+- spec/spec_helper.rb