asmrb 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 792de4bbafddedb38b68b7d00165beafd20cb176
+  data.tar.gz: 8a7a97aead79fdd91dad623865cd0341a984bcb9
+SHA512:
+  metadata.gz: 3459ccc9f2b3610cbb3fa2b3fe1a4bfaa317f4c2f1276de722be47dbd2fa326d9dcf83fcf224196785df33f277974a66617d4710e1f83b7cb6ff72b124106cae
+  data.tar.gz: f2ddfc22f474096eca16109ad2da68a8341997dd018f94dc191f71e0c8f40e3a3acdf5b95f15e2d58e432de3d07efbdddc19f36cdac9ad036b7ebf5bb3e8a5b3

data/lib/asm.rb

@@ -0,0 +1,251 @@
+require 'colorize'
+require 'pry'
+
+class Asm
+  attr_reader :variables, :function, :stack, :name
+
+  def initialize
+    @@function = []
+    @variables = { }
+    @program = []
+    @labels = {}
+    @stack = []
+    @name = "undefined"
+  end
+
+  def new_var(dest)
+    eval("def #{dest}; #{@variables[dest]}; end")
+  end
+
+  def refvar(val)
+    val.is_a?(Symbol) ? @variables[val] : val
+  end
+
+  def req_args(func,amount)
+    raise Exception.new "[#{func}]: require #{amount} args to compare." if @stack.length < amount
+  end
+
+  OPS = {
+    "rdu" => lambda { | ops |
+                e = eval "@stack.reduce(&:#{ops})"
+                @stack.push e
+              },
+
+    "add" => lambda { | a , b |
+                @stack.push(refvar(a) + refvar(b))
+              },
+
+    "sub" => lambda { | a , b |
+                @stack.push(refvar(a) - refvar(b))
+              },
+
+    "mul" => lambda { | a , b |
+                @stack.push(refvar(a) * refvar(b))
+              },
+
+    "div" => lambda { | a , b |
+                @stack.push(refvar(a) / refvar(b))
+              },
+
+    "incr" => lambda { |dest, incval = 1|
+                @variables[dest] += incval
+              },
+
+    "decr" => lambda { |dest, decrval = 1|
+                @variables[dest] -= decrval
+              },
+
+    "mov" => lambda { | src , dest |
+                @variables[dest] =
+                  src.is_a?(Symbol) ?
+                      @variables[src] : src
+                #new_var dest
+              },
+
+    "jlt" => lambda { |less, more|
+                req_args "jlt", 2
+                @@pc = @labels[name] if @stack[@stack.length - 1] < @stack[@stack.length - 2]
+                @stack.drop 2
+              },
+
+    "jge" => lambda { |name|
+                req_args "jge", 1
+                x = @stack.pop
+                y = @stack.pop
+                @@pc = @labels[name] if x >= y
+              },
+
+    "lt" => lambda { |a, b|
+                req_args "lt", 2
+                @stack.push (a > b)
+              },
+
+
+    "jmp" => lambda { |name|
+                @@pc = @labels[name]
+              },
+
+    "pop"  => lambda {|val|
+                @variables[val] = @stack.pop
+                #new_var val
+              },
+
+    "push" => lambda {|src|
+                @stack.push(
+                  src.is_a?(Symbol) ? @variables[src] : src )
+              },
+
+    "arg" => lambda { |*args|
+                if @stack.length != args.length
+                  raise Exception.new "require: #{args}"
+                else
+                  args.reverse.each do | arg |
+                    @variables[arg] = @stack.pop
+                  end
+                end
+              },
+
+    "req"  => lambda {|amount|
+                raise Exception.new "require #{amount} #{ pluralize(amount, "argument") }." if @stack.length != amount
+              },
+
+    "dbg" => lambda {
+                puts @stack
+              },
+
+    "func"  => lambda {|&block|
+                @stack.push block
+              },
+
+    "call" => lambda {|fname|
+                _method = method(fname)
+                if _method.parameters.length > 0
+                  args = []
+                  _method.parameters.length.times do
+                    args.push @stack.pop
+                  end
+                  invoke = _method.call(args)
+                else
+                  invoke = _method.call
+                end
+                #binding.pry
+                @stack.push invoke if !invoke.nil?
+              },
+
+    "exit"  => lambda {
+                exit
+              }
+
+    #and so on
+  }
+
+  def create_label(lbl)
+    @labels[lbl] = @program.length-1
+  end
+
+  def method_missing(name, *args)
+
+    sname = name.to_s
+
+    if OPS.keys.include?(sname)
+      @program << [sname, args]
+
+      # TESTING FEATURE:
+    elsif @@function.include?(name)
+      @program << [sname, @@function[name].execute]
+
+    else
+
+      case sname
+
+      when "label"
+        create_label args.first
+
+      when "defn"
+        @name = args.first
+        create_label args.first
+
+      else
+        return name
+
+      end
+    end
+  end
+
+  def load_program(&block)
+    self.instance_exec(&block)
+  end
+
+  def execute(debug=false)
+    puts "function: #{@name}".white
+    begin
+      @@pc = 0
+      until(@@pc == @program.length)
+        # get instruction:
+        instr = @program[@@pc]
+        puts "#{instr}".light_green if debug
+        # execute proc:
+        self.instance_exec(*instr[1], &OPS[instr[0]])
+        #binding.pry if debug
+        @@pc += 1
+      end
+      @stack.last
+    rescue Exception => e
+      debug e, instr
+    end
+  end
+
+  def debug(e,instr)
+    # error scope:
+    debug_start = @@pc >= 1 ? @@pc - 1 : 0
+    debug_end = @@pc <= @program.length - 2 ?
+        @@pc + 2
+        : @program.length < 4 ? @program.length : @@pc + 4
+
+    # ranging...
+    (debug_start..debug_end).each do | i |
+      line = " #{i+1}: #{@program[i]}"
+      color = i != @@pc ? :light_green : :magenta
+      puts line.colorize color
+    end
+
+    puts "\nline #{@@pc+1}: #{ops_info(instr[0])}: #{e.message}".colorize(:magenta)
+    #puts e.backtrace
+
+    # test via pry:
+    binding.pry
+  end
+
+  def ops_info(name)
+    parameters = []
+    OPS[name].parameters.each {|pair| parameters << pair.last }
+    "#{name} [#{parameters.join(', ')}]"
+  end
+
+  def arguments(args=[])
+    args.each do | arg |
+     @stack << arg
+   end
+  end
+
+  def invoke(args=[],debug=false)
+    arguments args
+    execute debug
+  end
+
+  def clear
+    @variables = { }
+    @stack = []
+  end
+
+  def self.assemble (&block)
+    Asm.new.assemble &block
+  end
+
+  def assemble(&block)
+    load_program(&block)
+    self.dup
+  end
+end
+
+

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: asmrb
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- The Trung
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-31 00:00:00.000000000 Z
+dependencies: []
+description: Inteprete your assembly style code inside ruby.
+email: deulamco@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/asm.rb
+homepage: http://github.com/thetrung/asmrb.git
+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.4.5
+signing_key: 
+specification_version: 4
+summary: assembly-like DSL in ruby
+test_files: []
+has_rdoc: