asmrb 0.0.2.6.2.1 → 0.0.2.6.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c1efa63d1755144b58eaf04c1080f10adcbe553d
-  data.tar.gz: 5c0d8d57c3a6381621cb5364092b9bed60a41b42
+  metadata.gz: d060fb46ed0c1da76426e94cc0f8a315cb5b5464
+  data.tar.gz: 2dd5ec988a198e5ef3b432dd1a1edc27d671f79e
 SHA512:
-  metadata.gz: 80a48ffe33a30e325e8c1b51fb0d27da0a0253c1cc16c682ac891026addc1eecd394cb87633aebb26034209c8eeb74469431698fceb428d4dbcd9141d6347071
-  data.tar.gz: 447314ecf0c95a76529dc7d6c8c58dfcd5cf4eb3d60c7e74fb79d27b6c8b4db897626885c5f8c05b0111198f6f5a0fa053349c8819365fb91816a0dadf80855a
+  metadata.gz: 6985a71aa49990685e5d6af7023ff03cac9439bea40ff1c2427921eac17880437a8d151926f21e68f1f7ddef65927ba383f2629446f077d898652aded36f8dd8
+  data.tar.gz: a4d2eaa1eb1b368b41577bd2ed192cf478a612dfb08f045006ce58d94c21c7e71e369bccaab0fc12aad71596ad58deac54c26be55fae4a630e9c38e47d1f6398

data/README.md

@@ -0,0 +1,143 @@
+asmrb
+=======
+
+I. Intro
+
+Asmrb is my intend over making a high-level assembly language.
+Which shorten your horizonal source, better flow and readability.
+
+And to solve my question about how recursion loop through assembly
+by just jumping from label to label. 
+
+Have fun !
+    
+Just a prototype, play around if you know Ruby. 
+Get the Gem: https://rubygems.org/gems/asmrb
+
+II. Install
+
+\* asmrb is at very early state of experiment,
+  so all required gems would be pretty light-weight
+  and just for debugging and colorful printing.
+
+    gem install asmrb
+
+III. Usage
+
+Let's create one as below:
+
+    a = Asmrb.new do
+      fun :rec_print    # define a function, also label to jump.
+      arg arr           # arguments
+      psh 0
+      len arr           # get length of arr as array
+      jge :print           # then jump to :print block
+      ret                  # else, jump to :exit block
+      blo :print        # start of :print
+      car arr           # get out first element of arr
+      cal :puts         # call ruby's puts
+      cdr arr           # get rest of arr Array to @stack
+      rec               # jump back to :rec_print ( or start of this _fntion )
+    end
+
+toggle the debug mode to see steps:
+
+    a.is_debug = true
+
+invoke it with right arugument type:
+
+    a.invoke [1, 2]
+
+convert it to ruby code:
+
+    a.to_ruby
+
+Asmrb can run "infinite recursion" without being overflow, 
+by storing value with its own stack. 
+
+    Look at "rake test" for more samples.
+
+\* Execute source file:
+
+To execute a source file like `demo.arb`:
+
+    asmrb demo.arb
+
+VI. Features
+
+* I actually created asmrb to see how it change the coding style
+while still remain all high-level ruby functions. There're early
+plans on making LLVM underhood to improve overall performance,
+or just compiling down to ruby for maximum compatiability and
+go on with all ruby implementations.
+
+\* currently implemented:
+
+    Note: to see all implemented operators, run:
+    Asmrb.new.all_ops
+
+\* operations:
+
+all ops follow the rule:
+
+    psh 2
+    psh 1
+    add     # push (1 + 2) to stack
+
+
+to remove top-most element off stack:
+
+    psh 1
+    pop    
+
+same to above, when pushed values:
+
+    sub     # 1 - 2
+    add     # 1 + 2
+    mul     # 1 * 2
+    div     # 1 / 2
+    icr a   #  a = a + 1
+    dcr a   #  a = a - 1
+    dpl     # duplicate top-most value on stack
+
+\* array:
+
+    car arr  # get first element of array
+    cdr arr  # get rest element of array
+    len arr  # get length of array
+    los arr  # load all array elements on stack
+    los :a   # load all elements in :a variable
+
+\* jump:
+
+    blo :name   # create a label/block
+    
+    jlt   :label  # jump if  a < b 
+    jge   :label  # jump if  a > b 
+    jeq   :label  # jump if  a = b 
+    jnz   :label  # jump if not zero
+    jmp   :label  # jump to certain labeled immediately
+    jnl   :label  # jump if nil
+
+\* function define:
+
+    fun :function  # define function name and also a label to jump.
+    arg a,b   # function parameters binded to a and b.
+    req 3     # function require 3 arguments.
+    rec       # to recursively call function again.
+    lea :a    # load top-most value to variable a     
+
+\* high-level:
+
+    mov 1, :a    # there is still this, but it will soon be removed.
+    
+    
+    red :+       # reduce current stack frame by :+ operator
+    map :o       # map as usual to current stack
+    cal :puts    # calling ruby function
+    
+    inv :a, :f   # invoke function "f" of object "a" with n "args"
+    
+    dbg          # debug by pry at local instruction
+    ret          # exit and return top-most stack value
+    exi          # force exit

data/bin/asmrb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+dir = File.expand_path(File.dirname(__FILE__))
+require dir + '/../lib/asmrb.rb'
+
+require 'oyster'
+spec = Oyster.spec do
+  name "asmrb -- Lisp to ruby transformation"#, v. #{Heist::VERSION}"
+  author 'The Trung <deulamco@mail.com>'
+  
+  synopsis <<-EOS
+    asmrb -i [OPTIONS]
+    asmrb FILE_NAME [OPTIONS]
+  EOS
+  
+  flag :interactive, :desc =>
+        'Start an interactive Scheme session'
+end
+
+
+begin
+  options = spec.parse
+  
+  if options[:interactive] or options[:unclaimed].empty?
+    puts "Not implemented yet"
+  else
+    Asmrb.new.eval_file File.expand_path(options[:unclaimed].first)
+  end
+
+rescue Oyster::HelpRendered
+end

data/lib/asmrb.rb

@@ -44,6 +44,24 @@ class Asmrb
     assemble &block unless block.nil?
   end
 
+  def eval_file path
+    source = File.read path
+    eval_source source
+  end
+
+  def eval_source source
+    new_scope
+    puts source.light_yellow
+    eval <<-CODE
+    assemble do
+      #{source}
+    end
+    CODE
+    compiled = to_ruby
+    puts compiled.magenta
+    eval compiled
+  end
+
   def compiled?
     !@ruby_source.nil?
   end
@@ -57,7 +75,6 @@ class Asmrb
     # need parititioning first..
     partition
     unless @partitions.empty?
-      @compile_stack = Array.new
       @ruby_source = Array.new
       block_labels = @partitions.map &:first
       @entry_point = @partitions.first.first 
@@ -74,7 +91,7 @@ class Asmrb
     end
   end
 
-  def implementation_status
+  def all_opcodes
     puts "[OPCODES] check:".green
     OPS.map do |k, v|
       check = OPCODES.include?(k.to_sym) ? :implemented : :not_yet
@@ -136,7 +153,6 @@ class Asmrb
   def define_block partition, index, block_labels
     func = partition.first
     body = partition.last
-    
     args = body.first.first.to_sym == :arg ? body.first.last.join(', ') : "" 
     
     block = Array.new
@@ -165,10 +181,8 @@ class Asmrb
     if index != block_labels.length-1 && ![:rec, :ret, :exi].include?(body.last[0].to_sym)
       func = block_labels[index+1] 
       body = @partitions[func].first
-
       #binding.pry
-
-      if body.first == :arg
+      if body.first.to_sym == :arg
         args = "#{body.last.join(', ')}"
         block << "  #{func} #{args}"
       else
@@ -181,7 +195,10 @@ class Asmrb
     block << "end\n"
     @ruby_source << block.join("\n")
     
-    puts "-------------------" if @is_debug
+    if @is_debug
+      puts @source.last.join(" ").light_yellow 
+      puts "-------------------" 
+    end
   end
 
   def refvar val
@@ -199,17 +216,9 @@ class Asmrb
 
   OPS = {
     :slp => lambda { |amount| sleep amount},
-    :los => lambda { | *args |
-                args = args.collect do |arg|
-                  if @variables.include? arg
-                    @variables[arg] 
-                  else
-                    arg
-                  end
-                end
-                args.reverse.each do |arg|
-                  @stack.push arg
-                end
+    :los => lambda { | args |
+                args = @variables[args] if @variables.include?(args) 
+                args.reverse.each {|arg| @stack.push arg}
               },
 
     :lea => lambda { | name |
@@ -258,51 +267,32 @@ class Asmrb
 
     :jnl => lambda { | name |
                 req_args "jnl", 1
-                if @stack.pop.nil?
-                  @pc = @labels[name] 
-                  new_title "[#{name}]" if @is_debug
-                end
+                @pc = @labels[name] if @stack.pop.nil?
               },
 
     :jz => lambda { | name |
                 req_args "jz", 1
-                if @stack.pop == 0
-                  @pc = @labels[name] 
-                  new_title "[#{name}]" if @is_debug
-                end
+                @pc = @labels[name] if @stack.pop == 0
               },
 
     :jnz => lambda { | name |
                 req_args "jnz", 1
-                if @stack.pop != 0
-                  @pc = @labels[name] 
-                  new_title "[#{name}]" if @is_debug
-                end
+                @pc = @labels[name] if @stack.pop != 0
               },
 
     :jge => lambda { |name|
                 req_args "jge", 2
-                if @stack.pop > @stack.pop
-                  @pc = @labels[name] 
-                  new_title "[#{name}]" if @is_debug
-                end
+                @pc = @labels[name] if @stack.pop > @stack.pop
               },
 
     :jlt => lambda { |name|
                 req_args "jlt", 2
-                if @stack.pop < @stack.pop
-                  @pc = @labels[name] 
-                  new_title "[#{name}]" if @is_debug
-                end
-
+                @pc = @labels[name] if @stack.pop < @stack.pop
               },
 
     :jeq => lambda { |name|
                 req_args "jeq", 2
-                if @stack.pop == @stack.pop
-                  @pc = @labels[name] 
-                  new_title "[#{name}]" if @is_debug
-                end
+                @pc = @labels[name] if @stack.pop == @stack.pop
               },
 
     :jmp => lambda { |name|
@@ -363,7 +353,6 @@ class Asmrb
               },
     :rec => lambda {
                 @pc = -1
-                new_title "[#{@name}]" if @is_debug
               },
 
     :ret => lambda {
@@ -416,19 +405,17 @@ class Asmrb
     puts "#{@stack} > #{@name}".yellow  if debug
     begin
       @pc = 0
-      @variables = Hash.new
       until @pc == @program.length
-        
+        # get instruction:
         instr = @program[@pc]
-
         puts "#{@pc}: #{instr[0]} #{instr[1].join " "}".light_green if debug
-        
+        # execute proc: arg ,  proc
         self.instance_exec *instr[1], &OPS[instr[0]]
-        
         @pc += 1
       end
+      #binding.pry
       @result = @stack.last
-      @stack.clear
+      clear
     rescue Exception => e
       debug e, instr
     end
@@ -436,6 +423,20 @@ class Asmrb
     @result
   end
 
+  def fast_execute *args
+    arguments args
+    @pc = 0
+    until @pc == @program.length
+      # execute proc:
+      self.instance_exec *@program[@pc].last,
+                         &OPS[@program[@pc].first]
+      @pc += 1
+    end
+    @result = @stack.last
+    clear
+    @result
+  end
+
   def new_title title
     puts "\n::#{title}"
   end
@@ -457,7 +458,6 @@ class Asmrb
     (scope_begin..scope_end).each do | i |
       instr = @program[i]
       color = i != @pc ?  :light_green : :magenta
-      binding.pry
       puts "#{i}: #{instr[0]} #{instr[1]}".colorize color
     end
     unless instr.nil?
@@ -483,6 +483,12 @@ class Asmrb
     end
   end
 
+  def clear
+    @pc = 0
+    @variables = { }
+    @stack = []
+  end
+
   def assemble &block
     extend_program &block
     eval "$#{@name} = self.clone"
@@ -535,16 +541,7 @@ class Asmrb
   end
   
   def patched_arg label
-    patched = ""
-    if @labels_arg.include? label
-      patched = "#{label}(#{@labels_arg[label].join(', ')})"
-    else
-      patched = "#{label}"
-    end
-    if !@partitions[label].nil? && @partitions[label].last.first == :ret
-      patched = "return " + patched
-    end
-    patched
+    "#{label} #{@labels_arg[label].join(', ') if @labels_arg.include?(label)}"
   end
 
   def opcode_operator op
@@ -567,7 +564,7 @@ class Asmrb
   end
 
   OPCODES = {
-    :slp => lambda {|amount| "sleep #{amount}"},
+    :sleep => lambda {|amount| "sleep #{amount}"},
     :dbg => lambda {"binding.pry"},
     :req => lambda {|_|},
     
@@ -649,39 +646,80 @@ class Asmrb
   }
 end
 
-def asmrb &block
-  Asmrb.new &block
-end
+# demo for testing
+# @x = Asmrb.new do
+#     fun :play
+#     arg :toy
+#     psh :toy
+#     cal :puts
+    
+#     blo :after_print
+#     psh :@times
+#     jnl :init_timer
+
+#     blo :append
+#     inv :@times, :to_s
+#     psh "X"
+#     add
+#     cal :puts
+
+#     blo :count
+#     psh :@times    
+#     psh 1
+#     add
+#     lea :@times
+#     psh :@times
+#     psh 10
+#     jeq :final
+#     psh "__"
+#     rec
+
+#     blo :final
+#     psh "__"
+#     cal :puts
+#     inv :@times, :to_s
+#     psh "Final result = "
+#     add
+#     cal :puts
+#     exi
+
+#     blo :init_timer
+#     psh 0
+#     lea :@times
+#     jmp :append
+# end
+
+# @x.is_debug = false
+# test = @x.to_ruby
+# puts test.light_green
+# eval test
+# play "I'm The Trung, here we go:"
 
 # # applying: argumented  block ( lambda )
 # # should be "inline block" technique also, 
 # # to improve performance and local variable sharing.
-# @y = asmrb do
+# @f = Asmrb.new do
 #   fun :factorial
 #   arg :acc, :n
-#   los :acc, :n
 #   los :n, 1
-#   jlt :result
+#   jlt :final
   
-#   blo :else_block
+#   blo :cont
 #   arg :acc, :n
-#   los :acc, :n
+#   los :n, :acc
 #   mul
 #   los :n, 1
 #   sub
-#   rec
-  
-#   blo :result
+#   rec 
+
+#   blo :final
 #   arg :acc
 #   psh :acc
-#   ret
+#   cal :puts
+#   exi             # no return yet, because return doesn't mean anything inside a block. we can't escape.
 # end
 
-# @y.is_debug = true
-# puts @y.invoke 1, 3
-# #@y.all_opcodes
-# test = @y.to_ruby
-# puts test
-# eval test
-# @y = factorial 1, 1000
-# puts "Start test: #{@y}"
+# source = @f.to_ruby
+# puts source
+# eval source
+# factorial 1, 3

data/lib/ast.rb

@@ -0,0 +1,3 @@
+module AST
+  # should include words that has interpretation and compilation.
+end

data/lib/llvm_sample.rb

@@ -0,0 +1,109 @@
+require 'llvm/core'
+require 'llvm/execution_engine'
+require 'llvm/transforms/scalar'
+require "benchmark"
+require 'asmrb'
+
+# run this with any argument to get a speed comparison between llvm and different ruby implementations
+
+# Start the "engine" before driving
+LLVM.init_jit
+
+# modules hold functions and variables
+mod = LLVM::Module.new("Factorial")
+
+mod.functions.add("fac", [LLVM::Int], LLVM::Int) do |fac, n|
+  n.name    = "n"
+  entry     = fac.basic_blocks.append("entry")
+  recur     = fac.basic_blocks.append("recur")
+  result    = fac.basic_blocks.append("result")
+  n_fac_n_1 = nil # predeclare within function's scope
+
+  entry.build do |b|
+    test = b.icmp(:eq, n, LLVM::Int(1), "test")
+    b.cond(test, result, recur)
+  end
+
+  recur.build do |b|
+    n_1       = b.sub(n, LLVM::Int(1), "n-1")
+    fac_n_1   = b.call(fac, n_1, "fac(n-1)")
+    n_fac_n_1 = b.mul(n, fac_n_1, "n*fac(n-1)")
+    b.br(result)
+  end
+
+  result.build do |b|
+    fac = b.phi(LLVM::Int,
+               { entry => LLVM::Int(1),
+                 recur => n_fac_n_1 },
+               "fac")
+    b.ret(fac)
+  end
+end
+
+mod.verify
+mod.dump
+
+engine = LLVM::JITCompiler.new(mod)
+
+def rec_factorial(n)
+  if n <= 1
+    1
+  else
+    n * rec_factorial(n - 1);
+  end
+end
+def iter_factorial(n)
+  nn = n
+  i = n - 1
+  while(i > 1) do
+    nn *= i
+    i -= 1
+  end
+  return nn;
+end
+def array_factorial(n)
+    (1..n).inject(:*)
+end
+
+
+Asm.new do
+  defn :factorial
+  arg  acc, n
+  push 1
+  push n
+  cmp
+  jge  :recursion
+  jmp  :exit
+
+  label :recursion
+  push acc
+  push n
+  mul
+  push 1
+  push n
+  sub
+  jmp  :factorial
+  label :exit
+  push acc
+end
+
+
+if( ARGV.length == 0 )
+  puts "Single run with 42 = "  + engine.run_function(mod.functions["fac"], 42).to_i.to_s
+  exit
+end
+puts "Times show factorial execution times in milliseconds.".light_green
+puts "Both for llvm and ruby iterative and recusive algorithms".light_green
+puts ["Num" , "llvm rec","recursive" ,"iterative","array iter", "asmrb"].collect{|u|u.ljust(11)}.join
+res = [ 1, 5 , 20 , 50 , 100 , 200 , 500 , 1000 , 2000 , 5000, 8710  ].each do |i|
+  res = [ ]
+  res << Benchmark.realtime {engine.run_function(mod.functions["fac"], i)}
+  res << Benchmark.realtime {rec_factorial(i)}
+  res << Benchmark.realtime {iter_factorial(i) }
+  res << Benchmark.realtime {array_factorial(i) }
+  res << Benchmark.realtime {$factorial.invoke(1,i)}
+  res = [i] + res.collect {|u| ((u*1000)).round(4) }
+  res = res.collect {|z| z.to_s.ljust(8)}
+  next if i < 10
+  puts res.join("   ")
+end

metadata

@@ -1,29 +1,80 @@
 --- !ruby/object:Gem::Specification
 name: asmrb
 version: !ruby/object:Gem::Version
-  version: 0.0.2.6.2.1
+  version: 0.0.2.6.2.2
 platform: ruby
 authors:
 - The Trung
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-14 00:00:00.000000000 Z
-dependencies: []
+date: 2015-05-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: oyster
+  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: colorize
+  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'
 description: create a assembly-like toy language in ruby DSL. It can then compile
-  into ruby code.
+  into ruby code. * note that I have stopped this gem development, since I saw no
+  potential to make it further. Have fun playing around with it!
 email: deulamco@gmail.com
-executables: []
+executables:
+- asmrb
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
 files:
+- README.md
+- bin/asmrb
 - lib/asmrb.rb
+- lib/ast.rb
+- lib/llvm_sample.rb
 homepage: http://github.com/thetrung/asmrb.git
 licenses:
 - MIT
 metadata: {}
 post_install_message: 
-rdoc_options: []
+rdoc_options:
+- "--main"
+- README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement