asmrb 0.0.2.6.1.8 → 0.0.2.6.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b206f0b382ffa2ab511a342452fa387fa77e542
-  data.tar.gz: 3161af6af87ac4264de6fb8d00172f0c7a3471dd
+  metadata.gz: 151915b197bea335937f0343c7ad77572ac73a6d
+  data.tar.gz: 1463da6367aba6932894de04415c1714fd012200
 SHA512:
-  metadata.gz: 522e99187befd8c7a1c336dc27bda590f1e6cd80a831815d6c83a309fbd475f7ff0c772be60b5450a7221753f68e1466be11624995b986eef816deb9fc4a9ec5
-  data.tar.gz: abb44dd72d582f5323132c9661f9a12d6b83cc1829dec40f9fc83b09a870d8904cff61fa810eaa8f643973524ec6448b64275de653c7bae09d2f933917d19124
+  metadata.gz: a38a19d27198ca21bdacb7a8aadb1e53437a9f1687802cacca44613877149051ac2bdd663eed9c2a71ff953dd24665512e3be45f78d861da3ab32ba877f484dd
+  data.tar.gz: 656d66a30c6bbd441ddc3250d2bb2fd37874a6acaaa2b7ef5f831e1c6d0e1609e78f5b58691f33dd30e86771c0a82331087e556cd39abe76f876a71cfffd2b02

data/lib/asmrb.rb

@@ -29,12 +29,14 @@ class Asmrb
   # debug:
   # => $rec_print.is_debug = true
   #
-  # calling:
+  # invoking:
   # => $rec_print.invoke [1,2,3]
-  #
+  # 
+  # calling:
+  # => rec_print [1,2,3]
   #
 
-  attr_reader :variables, :stack, :source, :name, :result, :params,:is_debug, :is_compiled
+  attr_reader :variables, :stack, :source, :name, :result, :params,:is_debug
   attr_writer :is_debug
 
   def initialize &block
@@ -42,6 +44,52 @@ class Asmrb
     assemble &block unless block.nil?
   end
 
+  def compiled?
+    !@source.nil?
+  end
+
+  def invoke *args
+    arguments args
+    execute is_debug
+  end
+
+  def to_ruby
+    # need parititioning first..
+    partition
+    unless @partitions.empty?
+      @source = Array.new
+      block_labels = @partitions.map &:first
+      @entry_point = @partitions.first.first 
+      @partitions.each.with_index do |partition, index|  
+      define_block partition, index, block_labels
+      end
+      @source = @source.join "\n"
+    end
+  end
+
+  def all_ops
+    OPS.map do |k,v|
+      ops_info k
+    end
+  end
+
+  def all_opcodes
+    puts "[OPCODES] check:".green
+    OPS.map do |k, v|
+      check = OPCODES.include?(k.to_sym) ? :implemented : :not_yet
+      report = ""
+      case check
+      when :implemented
+        report = "#{k} => #{check}".light_green
+      when :not_yet
+        report = "#{k} => #{check}".light_yellow
+      end
+      puts report
+    end
+    puts "-------------------------".green
+  end
+
+  private
   def new_scope
     @variables = {}
     @source = []
@@ -53,7 +101,58 @@ class Asmrb
     @pc = 0
     @result = nil
     @is_debug = false
-    @is_compiled = false
+    @compile_stack = Array.new
+  end
+
+  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
+    block << "def #{func} #{args}"
+    indent = " " * 2
+    
+    body.each do |statement|
+      # process statement here.
+      puts statement.to_s if @is_debug
+      if OPCODES.include? statement[0].to_sym
+        segment = self.instance_exec *statement[1], &OPCODES[statement[0].to_sym]
+        #binding.pry
+        block << (indent + segment.to_s) unless segment.nil?
+      else
+        puts "[define_block] Undefined OPCODE: #{statement[0]}\nAt: #{func}: #{statement}".red
+      end
+    end
+    
+    make_jump_on_next block, block_labels, index, body
+
+    finalize_block block
+  end
+
+  def make_jump_on_next block, block_labels, index, body
+    # leave pointer of next function here:
+    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.to_sym == :arg
+        args = "#{body.last.join(', ')}"
+        block << "  #{func} #{args}"
+      else
+        block << "  #{func}"
+      end
+    end
+  end
+
+  def finalize_block block
+    block << "end\n"
+    @source << block.join("\n")
+    
+    if @is_debug
+      puts @source.last.light_yellow 
+      puts "-------------------" 
+    end
   end
 
   def refvar val
@@ -72,7 +171,7 @@ class Asmrb
   OPS = {
     "los" => lambda { | args |
                 args = @variables[args] if @variables.include?(args) 
-                args.each {|arg| @stack.push arg}
+                args.reverse.each {|arg| @stack.push arg}
               },
 
     "lea" => lambda { | name |
@@ -91,7 +190,11 @@ class Asmrb
                 @stack.push @variables[lst].first
               },
 
-    "rdu" => lambda { | ops |
+    "map" => lambda { | ops |
+                eval "@stack.map(&:#{ops})"
+              },
+
+    "red" => lambda { | ops |
                 e = eval "@stack.reduce(:#{ops})"
                 @stack.clear
                 @stack.push e
@@ -147,29 +250,20 @@ class Asmrb
               },
 
     "jge" => lambda { |name|
-                req_args "jge", 1
-                @pc = @labels[name] if @stack.pop == :gt
+                req_args "jge", 2
+                @pc = @labels[name] if @stack.pop > @stack.pop
               },
 
     "jlt" => lambda { |name|
-                req_args "jlt", 1
-                @pc = @labels[name] if @stack.pop == :lt
+                req_args "jlt", 2
+                @pc = @labels[name] if @stack.pop < @stack.pop
               },
 
     "jeq" => lambda { |name|
-                req_args "jeq", 1
-                @pc = @labels[name] if @stack.pop == :eq
+                req_args "jeq", 2
+                @pc = @labels[name] if @stack.pop == @stack.pop
               },
 
-    "cmp" => lambda {
-                  a = @stack.pop
-                  b = @stack.pop
-                  @stack.push(
-                    a > b ? :gt
-                          : a == b ? :eq : :lt )
-              },
-
-
     "jmp" => lambda { |name|
                 @pc = @labels[name]
                 new_title "[#{name}]" if @is_debug
@@ -203,18 +297,6 @@ class Asmrb
                 #binding.pry if @is_debug
               },
 
-    "fnc"  => lambda {|name|
-                args = []
-                params = eval "$#{name}.params"
-                params.times do
-                  args << @stack.pop
-                end
-                eval "$#{name}.is_debug = true" if @is_debug
-                o = eval "$#{name}.invoke #{args.join(',')}"
-                @stack.push o if !o.nil?
-                #binding.pry
-              },
-
     "inv" => lambda { |obj, f|
                 args = Array.new
                 @stack.each { args << @stack.pop } if @stack.length > 0
@@ -298,7 +380,6 @@ class Asmrb
         puts "#{@pc}: #{instr[0]} #{instr[1].join " "}".light_green if debug
         # execute proc: arg ,  proc
         self.instance_exec *instr[1], &OPS[instr[0]]
-        #binding.pry if debug
         @pc += 1
       end
       #binding.pry
@@ -356,12 +437,6 @@ class Asmrb
     binding.pry if is_debug
   end
 
-  def all_ops
-    OPS.map do |k,v|
-      ops_info k
-    end
-  end
-
   def ops_info name
     parameters = Array.new
     OPS[name].parameters.each do |pair|
@@ -376,11 +451,6 @@ class Asmrb
     end
   end
 
-  def invoke(*args)
-    arguments args
-    execute is_debug
-  end
-
   def clear
     @pc = 0
     @variables = { }
@@ -393,15 +463,25 @@ class Asmrb
     eval "$#{@name}"
   end
 
+  def collect_label_arg label
+    if @program[label.last+1].first.to_sym == :arg
+      @labels_arg[label.first] = @program[label.last+1].last
+    end
+  end
+
   def partition
     puts "partitioning...".light_green if@is_debug
     if @labels.empty?
       @partitions = { @name => @program }
     else
       @partitions = Hash.new
+      @labels_arg = Hash.new
       @limitation = 0
       @jump_points = @labels.map &:last
-      @labels.each.with_index do |label, label_index|
+      @labels.each.with_index do |label, label_index| 
+        collect_label_arg label
+        # to save all args with a :blo ;)
+
         if label_index != @jump_points.length-1
           @limitation = @jump_points[label_index+1] 
         else
@@ -412,9 +492,8 @@ class Asmrb
         # binding.pry
         code_segment = @program[label.last+1..@limitation]
         code_segment.each.with_index do |statement, index|
-          #break if [:rec].include? statement.first.to_sym
-          #binding.pry
           partition << statement
+
           puts (read_internal statement, index).light_yellow if @is_debug
         end
         @partitions[label.first] = partition.dup
@@ -428,46 +507,183 @@ class Asmrb
     "  #{index}: #{instruction.first}" +
     " #{instruction.last.join(" ") unless instruction.last.empty?}"          
   end
+  
+  def patched_arg label
+    "#{label} #{@labels_arg[label].join(', ') if @labels_arg.include?(label)}"
+  end
+
+  def opcode_operator op
+    @compile_stack.push "#{@compile_stack.pop} #{op} #{@compile_stack.pop}" if @compile_stack.length > 1
+    nil
+  end
+
+  def cond_jump op, label
+    return "if #{@compile_stack.pop} #{op} #{@compile_stack.pop}\n    #{patched_arg label}\n  end" if @compile_stack.length > 1
+    nil            
+  end
+
+  def sole_cond_jump op, label
+    return "if #{@compile_stack.pop}#{op}\n    #{patched_arg label}\n end" unless @compile_stack.empty?
+    nil
+  end
+
+  OPCODES = {
+    :dbg => lambda {|_|},
+    :req => lambda {|_|},
+    
+    :map => lambda {|op| "#{@compile_stack}.map &:#{op}" },
+    :red => lambda {|op| "#{@compile_stack}.reduce :#{op}" },
+    
+    :pop => lambda { @compile_stack.pop },
+    :icr => lambda {|arg| @compile_stack << "#{arg} = #{arg} + 1" },
+    :dcr => lambda {|arg| @compile_stack << "#{arg} = #{arg} - 1" },
+
+    :mov => lambda {|src, dest| "#{dest} = #{src}" },
+    :dpl => lambda { @compile_stack << @compile_stack.last },
+    
+    :car => lambda {|arg| @compile_stack << "#{arg}.first" },
+    :cdr => lambda {|arg| @compile_stack << "#{arg}.drop(1)" },
+    :len => lambda {|arg| @compile_stack << "#{arg}.length" },
+    
+    :arg => lambda {|*args|
+            # ignore it
+            },
+    :los => lambda {|*args|
+              args.reverse.each{|arg| @compile_stack << arg}
+              nil
+            },
+    :psh => lambda {|arg|
+              arg = "\"#{arg}\"" if arg.class == String
+              @compile_stack << arg
+              nil
+            },
+    :lea => lambda {|var|
+              return "#{var} = #{@compile_stack.pop}" unless @compile_stack.empty?
+              nil
+            },
+    :add => lambda { opcode_operator "+" },
+    :sub => lambda { opcode_operator "-" },
+    :mul => lambda { opcode_operator "*" },
+    :div => lambda { opcode_operator "/" },
+    :cal => lambda {|func|
+              _method = method func
+              if _method && _method.parameters.length > 0
+                args = Array.new
+                _method.parameters.length.times do
+                  args.push @compile_stack.pop
+                end
+                return "#{func} #{args.join(', ')}"
+              else
+                return "#{func}"
+              end              
+            },
+    :jmp => lambda {|label| "#{patched_arg label}"},
+    :jz =>  lambda {|label| sole_cond_jump " == 0", label },
+    :jnz => lambda {|label| sole_cond_jump " != 0", label },
+    :jnl => lambda {|label| sole_cond_jump ".nil?", label },
+    :jeq => lambda {|label| cond_jump "==", label },
+    :jge => lambda {|label| cond_jump ">", label },
+    :jlt => lambda {|label| cond_jump "<", label },
+    :rec => lambda {
+              "#{@entry_point} #{@labels_arg.first.last.length.times.collect{@compile_stack.pop}.reverse.join(', ')}"
+            },
+    :ret => lambda {
+              "return #{@compile_stack.pop unless @compile_stack.empty?}"
+            },
+    :exi => lambda {
+              "exit"
+            },
+    :inv => lambda {|obj, f|
+              begin
+                if method(f).parameters.length == 0
+                  @compile_stack << "#{obj}.#{f}" 
+                else
+                  args = method(f).parameters.collect{@compile_stack.pop}
+                  @compile_stack << "#{obj}.#{f} #{args.join(', ')}"
+                end
+                nil
+              rescue Exception => e
+                puts "[OPCODES]<inv> currently is not stable in compiling ruby mode.".red
+              end
+            }
+  }
 end
 
-# x = Asmrb.new do
+# @x = Asmrb.new do
 #     fun :play
 #     arg :toy
 #     psh :toy
 #     cal :puts
     
 #     blo :after_print
-#     psh :times
+#     psh :@times
 #     jnl :init_timer
 
 #     blo :append
-#     inv :times, :to_s
+#     inv :@times, :to_s
 #     psh "X"
 #     add
 #     cal :puts
 
 #     blo :count
-#     psh :times
+#     psh :@times    
 #     psh 1
 #     add
-#     lea :times
-#     psh :times
+#     lea :@times
+#     psh :@times
 #     psh 10
-#     cmp
 #     jeq :final
 #     psh "__"
 #     rec
 
 #     blo :final
-#     psh :times
-#     ret
+#     psh "__"
+#     cal :puts
+#     inv :@times, :to_s
+#     psh "Final result = "
+#     add
+#     cal :puts
+#     exi
 
 #     blo :init_timer
 #     psh 0
-#     lea :times
+#     lea :@times
 #     jmp :append
 # end
 
-#x.is_debug = true
-#x.partition
-#x.invoke "I'm The Trung, here we go:"
+# @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.new do
+#   fun :factorial
+#   arg :acc, :n
+#   los :n, 1
+#   jlt :final
+  
+#   blo :cont
+#   arg :acc, :n
+#   los :n, :acc
+#   mul
+#   los :n, 1
+#   sub
+#   rec 
+
+#   blo :final
+#   arg :acc
+#   psh :acc
+#   cal :puts
+#   exi             # no return yet, because return doesn't mean anything inside a block. we can't escape.
+# end
+
+# @y.all_opcodes
+# test = @y.to_ruby
+#puts test
+#eval test
+#puts "Start test:"
+#y = factorial 1, 1000

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: asmrb
 version: !ruby/object:Gem::Version
-  version: 0.0.2.6.1.8
+  version: 0.0.2.6.1.9
 platform: ruby
 authors:
 - The Trung
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-12 00:00:00.000000000 Z
+date: 2015-05-14 00:00:00.000000000 Z
 dependencies: []
-description: create a assembly-like toy language in ruby DSL.
+description: create a assembly-like toy language in ruby DSL. It can then compile
+  into ruby code.
 email: deulamco@gmail.com
 executables: []
 extensions: []
@@ -40,6 +41,6 @@ rubyforge_project:
 rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: assembly-like DSL toy in ruby
+summary: assembly-like Toy language
 test_files: []
 has_rdoc: