akaza 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8f268d8e1d526b8e7d63dba375322624e27a5af9c281f91101aa60c3ba5efc6
-  data.tar.gz: 561b42e5bac690f8c983cb03f992558ee5a35d24c81da8025973ff1a11b332a1
+  metadata.gz: 7a887b99455c8e17fb594fe02a570c5ea0251c57b5d3e0a73030aeff7c7d5c35
+  data.tar.gz: 5f57819daa32f8560816bb36a45930acef8aeecb11d9bc1acf7f247d75c9484f
 SHA512:
-  metadata.gz: 250e590b52669d99cbd3bac3c942c38558f9fb270b60a273507d4695c249afdd238011013b364db491c9945c7b383446563533b18ee39ff71af1c26b5047d948
-  data.tar.gz: 2f6bac299e64ecaaa42a21d04de0c20393b9caab95cc1a01c5e9bdb3c486453f8fb53ea2aa68379758d3226c1a45299d8733c8dddfb15553c1bc0814dba3f246
+  metadata.gz: 4bbe86bad2ad3096bd1d6845bd6a88f831977022c7b31cf4bd0aa8b35f6f89e68907bb1cd813fd25b0f656e2c4e2be936d77a51efef554245ebae3ed05349584
+  data.tar.gz: f426f4188fdb40d9632042941c2633922df440bf9fea1f08338e2ebdc43b86bf6029bad3986e8cd2431df1bc1258e75d83bee6edb9d67459e1471ce591abe953

data/.gitignore

@@ -6,3 +6,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+/Gemfile.lock

data/README.md

@@ -66,8 +66,7 @@ class A
     Akaza::Body
     
 	
-	
-    
+		    
 		output.string.to_i	
 	
 end
@@ -112,8 +111,7 @@ This	code is never evaluated.
 So you can write any
 sentences as comments!  
 	
-	
-    
+		    
 			
 	
 end
@@ -123,7 +121,7 @@ a = A.new
 input = StringIO.new("20\n22\n")
 output = StringIO.new
 a.sum(input, output)
-p output.string
+p output.string # => "42"
 ```
 
 ## Development

data/akaza.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 2.1.a"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "minitest", ">= 5"
 end

data/lib/akaza.rb

@@ -3,6 +3,7 @@ require 'akaza/ast_ext'
 require 'akaza/annotation'
 require 'akaza/parser'
 require 'akaza/vm'
+require 'akaza/ruby2ws'
 
 module Akaza
   def self.eval(code, input: $stdin, output: $stdout)

data/lib/akaza/ast_ext.rb

@@ -5,10 +5,13 @@ module Akaza
         file_content(path)[first_index(path)..last_index(path)]
       end
 
-      def traverse(&block)
-        block.call self
-        children.each do |child|
-          child.traverse(&block) if child.is_a?(RubyVM::AbstractSyntaxTree::Node)
+      def traverse(&on_enter)
+        opt = {}
+        on_enter.call self, opt
+        unless opt[:skip_children]
+          children.each do |child|
+            child.traverse(&on_enter) if child.is_a?(RubyVM::AbstractSyntaxTree::Node)
+          end
         end
       end
 

data/lib/akaza/parser.rb

@@ -115,7 +115,7 @@ module Akaza
         [:io, :write_num]
       when [TAB, SPACE]
         [:io, :read_char]
-      when [TAB, NL]
+      when [TAB, TAB]
         [:io, :read_num]
       else
         raise "unreachable: #{c}"

data/lib/akaza/ruby2ws.rb

@@ -0,0 +1,320 @@
+module Akaza
+  # Convert Ruby like script to Whitespace.
+  # The syntax is a subset of Ruby,
+  # but it has different semantics with Ruby.
+  #
+  # # sample code
+  #   # output
+  #   put_as_number n
+  #   put_as_char ch
+  #   put_as_number 42
+  #   put_as_char 'a'
+  #
+  #   # input
+  #   num = get_as_number
+  #   char = get_as_char
+  #
+  #   # flow
+  #   def foo
+  #   end
+  #
+  #   exit
+  #
+  #   if x == 0
+  #   end
+  #
+  #   if x < 0
+  #   end
+  #
+  #   # heap
+  #   x = 10
+  #   push x
+  module Ruby2ws
+    using AstExt
+    SPACE = ' '
+    TAB = "\t"
+    NL = "\n"
+
+    class ParseError < StandardError; end
+
+    def self.ruby_to_ws(ruby_code)
+      Transpiler.new(ruby_code).transpile
+    end
+
+    class Transpiler
+      def initialize(ruby_code)
+        @ruby_code = ruby_code
+        @label_index = 0
+      end
+
+      def transpile
+        ast = RubyVM::AbstractSyntaxTree.parse(@ruby_code)
+        commands = ast_to_commands(ast, main: true)
+        commands_to_ws(commands)
+      end
+
+      private def ast_to_commands(ast, main:)
+        commands = []
+        methods = []
+        lvars = []
+
+        ast.traverse do |node, opt|
+          case node
+          in [:FCALL, :put_as_number, [:ARRAY, arg, nil]]
+            commands.concat(push_value(arg))
+            commands << [:io, :write_num]
+            opt[:skip_children] = true
+          in [:FCALL, :put_as_char, [:ARRAY, arg, nil]]
+            commands.concat(push_value(arg))
+            commands << [:io, :write_char]
+            opt[:skip_children] = true
+          in [:VCALL, :exit]
+            commands << [:flow, :exit]
+          in [:LASGN, var, arg]
+            var_addr = str_to_int(var, type: :variable)
+            commands << [:stack, :push, var_addr]
+            commands.concat(push_value(arg))
+            commands << [:heap, :save]
+            opt[:skip_children] = true
+            lvars << var_addr
+          in [:DEFN, name, [:SCOPE, lvar_table, [:ARGS, args_count ,*_], body]]
+            m = [
+              [:flow, :def, str_to_int(name, type: :method)],
+            ]
+            lvar_table[0...args_count].reverse.each do |args_name|
+              m << [:stack, :push, str_to_int(args_name, type: :variable)]
+              m << [:stack, :swap]
+              m << [:heap, :save]
+            end
+            m.concat(ast_to_commands(body, main: false))
+            m << [:flow, :end]
+
+            methods << m
+            opt[:skip_children] = true
+          in [:SCOPE, *_] | [:BLOCK, *_]
+            # skip
+          in [:VCALL, name]
+            with_storing_lvars(lvars, commands) do
+              commands << [:flow, :call, str_to_int(name, type: :method)]
+            end
+            opt[:skip_children] = true
+          in [:FCALL, name, [:ARRAY, *args, nil]]
+            with_storing_lvars(lvars, commands) do
+              args.each do |arg|
+                commands.concat(push_value(arg))
+              end
+              commands << [:flow, :call, str_to_int(name, type: :method)]
+            end
+            opt[:skip_children] = true
+          in [:IF, cond, if_body, else_body]
+            commands.concat(compile_if(cond, if_body, else_body))
+            opt[:skip_children] = true
+          in [:UNLESS, cond, else_body, if_body]
+            commands.concat(compile_if(cond, if_body, else_body))
+            opt[:skip_children] = true
+          in [:WHILE, cond, body]
+            commands.concat(compile_while(cond, body))
+            opt[:skip_children] = true
+          end
+        end
+
+        commands << [:flow, :exit] if main
+        commands.concat(*methods)
+        commands
+      end
+
+      private def commands_to_ws(commands)
+        buf = +""
+        commands.each do |command|
+          case command
+          in [:stack, :push, num]
+            buf << SPACE << SPACE << num_to_ws(num)
+          in [:stack, :swap]
+            buf << SPACE << NL << TAB
+          in [:heap, :save]
+            buf << TAB << TAB << SPACE
+          in [:heap, :load]
+            buf << TAB << TAB << TAB
+          in [:io, :write_char]
+            buf << TAB << NL << SPACE << SPACE
+          in [:io, :write_num]
+            buf << TAB << NL << SPACE << TAB
+          in [:io, :read_char]
+            buf << TAB << NL << TAB << SPACE
+          in [:io, :read_num]
+            buf << TAB << NL << TAB << TAB
+          in [:flow, :exit]
+            buf << NL << NL << NL
+          in [:flow, :call, num]
+            buf << NL << SPACE << TAB << num_to_ws(num)
+          in [:flow, :def, num]
+            buf << NL << SPACE << SPACE << num_to_ws(num)
+          in [:flow, :end]
+            buf << NL << TAB << NL
+          in [:flow, :jump_if_zero, label]
+            buf << NL << TAB << SPACE << num_to_ws(label)
+          in [:flow, :jump, label]
+            buf << NL << SPACE << NL << num_to_ws(label)
+          in [:flow, :jump_if_neg, label]
+            buf << NL << TAB << TAB << num_to_ws(label)
+          in [:calc, :add]
+            buf << TAB << SPACE << SPACE << SPACE
+          in [:calc, :sub]
+            buf << TAB << SPACE << SPACE << TAB
+          in [:calc, :multi]
+            buf << TAB << SPACE << SPACE << NL
+          in [:calc, :div]
+            buf << TAB << SPACE << TAB << SPACE
+          in [:calc, :mod]
+            buf << TAB << SPACE << TAB << TAB
+          end
+        end
+        buf
+      end
+
+      private def with_storing_lvars(lvars, commands, &block)
+        lvars.each do |var_addr|
+          # stack.push(addr); stack.push(val)
+          commands << [:stack, :push, var_addr]
+          commands << [:stack, :push, var_addr]
+          commands << [:heap, :load]
+          # Fill zero
+          commands << [:stack, :push, var_addr]
+          commands << [:stack, :push, 0]
+          commands << [:heap, :save]
+        end
+
+        block.call
+
+        lvars.size.times do
+          commands << [:heap, :save]
+        end
+      end
+
+      private def push_value(ast)
+        commands = []
+
+        case ast
+        in [:LIT, num]
+          commands << [:stack, :push, num]
+        in [:STR, str]
+          check_char!(str)
+          commands << [:stack, :push, str.ord]
+        in [:LVAR, name]
+          commands << [:stack, :push, str_to_int(name, type: :variable)]
+          commands << [:heap, :load]
+        in [:VCALL, :get_as_number]
+          tmp_var = str_to_int("__tmp", type: :variable)
+          commands << [:stack, :push, tmp_var]
+          commands << [:io, :read_num]
+          commands << [:stack, :push, tmp_var]
+          commands << [:heap, :load]
+        in [:VCALL, :get_as_char]
+          tmp_var = str_to_int("__tmp", type: :variable)
+          commands << [:stack, :push, tmp_var]
+          commands << [:io, :read_char]
+          commands << [:stack, :push, tmp_var]
+          commands << [:heap, :load]
+        in [:OPCALL, l, sym, [:ARRAY, r, nil]]
+          com = {'+': :add, '-': :sub, '*': :multi, '/': :div, '%': :mod}[sym]
+          raise ParserError, "Unknown symbol: #{sym}" unless com
+          commands.concat(push_value(l))
+          commands.concat(push_value(r))
+          commands << [:calc, com]
+        end
+
+        commands
+      end
+
+      private def compile_if(cond, if_body, else_body)
+        commands = []
+        else_label = str_to_int("else_#{next_label_index}", type: :condition)
+        end_label = str_to_int("end_#{next_label_index}", type: :condition)
+
+        body = -> (x, sym) do
+          commands.concat(push_value(x))
+          commands << [:flow, sym, else_label]
+          commands.concat(ast_to_commands(else_body, main: false)) if else_body
+          commands << [:flow, :jump, end_label]
+          commands << [:flow, :def, else_label]
+          commands.concat(ast_to_commands(if_body, main: false)) if if_body
+          commands << [:flow, :def, end_label]
+        end
+
+        case cond
+        in [:OPCALL, [:LIT, 0], :==, [:ARRAY, x, nil]]
+          body.(x, :jump_if_zero)
+        in [:OPCALL, x, :==, [:ARRAY, [:LIT, 0], nil]]
+          body.(x, :jump_if_zero)
+        in [:OPCALL, x, :<, [:ARRAY, [:LIT, 0], nil]]
+          body.(x, :jump_if_neg)
+        in [:OPCALL, [:LIT, 0], :<, [:ARRAY, x, nil]]
+          body.(x, :jump_if_neg)
+        end
+
+        commands
+      end
+
+      private def compile_while(cond, body)
+        commands = []
+        cond_label = str_to_int("cond_#{next_label_index}", type: :condition)
+        body_label = str_to_int("body_#{next_label_index}", type: :condition)
+        end_label = str_to_int("end_#{next_label_index}", type: :condition)
+
+        make_body = -> (x, sym) do
+          commands << [:flow, :def, cond_label]
+          commands.concat(push_value(x))
+          commands << [:flow, sym, body_label]
+          commands << [:flow, :jump, end_label]
+          commands << [:flow, :def, body_label]
+          commands.concat(ast_to_commands(body, main: false))
+          commands << [:flow, :jump, cond_label]
+          commands << [:flow, :def, end_label]
+        end
+
+        case cond
+        in [:OPCALL, [:LIT, 0], :==, [:ARRAY, x, nil]]
+          make_body.(x, :jump_if_zero)
+        in [:OPCALL, x, :==, [:ARRAY, [:LIT, 0], nil]]
+          make_body.(x, :jump_if_zero)
+        in [:OPCALL, x, :<, [:ARRAY, [:LIT, 0], nil]]
+          make_body.(x, :jump_if_neg)
+        in [:OPCALL, [:LIT, 0], :<, [:ARRAY, x, nil]]
+          make_body.(x, :jump_if_neg)
+        end
+
+        commands
+      end
+
+      private def check_char!(char)
+        raise ParserError, "String size must be 1, but it's #{char} (#{char.size})" if char.size != 1
+      end
+
+      private def str_to_int(str, type:)
+        prefix =
+          case type
+          when :variable  then 'v'
+          when :method    then 'f'
+          when :condition then 'c'
+          else
+            raise "Unknown type: #{type}"
+          end
+        "#{prefix}_#{str}".bytes.inject { |a, b| (a << 8) + b }
+      end
+
+      private def num_to_ws(num)
+        sign =
+          if num < 0
+            TAB
+          else
+            SPACE
+          end
+        sign + num.abs.to_s(2).gsub("1", TAB).gsub('0', SPACE) + NL
+      end
+
+      private def next_label_index
+        @label_index += 1
+      end
+    end
+  end
+end

data/lib/akaza/version.rb

@@ -1,3 +1,3 @@
 module Akaza
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/akaza/vm.rb

@@ -25,15 +25,25 @@ module Akaza
         in [:stack, :pop]
           @stack.pop
         in [:calc, :add]
-          @stack.push @stack.pop + @stack.pop
+          r = @stack.pop
+          l = @stack.pop
+          @stack.push l + r
         in [:calc, :sub]
-          @stack.push @stack.pop - @stack.pop
+          r = @stack.pop
+          l = @stack.pop
+          @stack.push l - r
         in [:calc, :multi]
-          @stack.push @stack.pop * @stack.pop
+          r = @stack.pop
+          l = @stack.pop
+          @stack.push l * r
         in [:calc, :div]
-          @stack.push @stack.pop / @stack.pop
+          r = @stack.pop
+          l = @stack.pop
+          @stack.push l / r
         in [:calc, :mod]
-          @stack.push @stack.pop % @stack.pop
+          r = @stack.pop
+          l = @stack.pop
+          @stack.push l % r
         in [:heap, :save]
           val = @stack.pop
           addr = @stack.pop
@@ -42,13 +52,13 @@ module Akaza
           addr = @stack.pop
           @stack.push @heap[addr]
         in [:flow, :def, label]
-          # does nothing
+          # skip
         in [:flow, :call, label]
-          raise "unknwon label:#{label}" unless @labels.key?(label)
+          raise "unknwon label:#{label.inspect}" unless @labels.key?(label)
           @call_stack.push @index
           @index = @labels[label]
         in [:flow, :jump, label]
-          raise "unknwon label:#{label}" unless @labels.key?(label)
+          raise "unknwon label:#{label.inspect}" unless @labels.key?(label)
           @index = @labels[label]
         in [:flow, :jump_if_zero, label]
           @index = @labels[label] if @stack.pop == 0
@@ -77,7 +87,7 @@ module Akaza
       @commands.each.with_index do |command, index|
         case command
         in [:flow, :def, label]
-          @labels[label] = index - 1
+          @labels[label] = index
         else
           # skip
         end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: akaza
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Masataka Pocke Kuwabara
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-28 00:00:00.000000000 Z
+date: 2019-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.a
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.a
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -61,7 +61,6 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - Gemfile
-- Gemfile.lock
 - README.md
 - Rakefile
 - akaza.gemspec
@@ -72,6 +71,7 @@ files:
 - lib/akaza/annotation.rb
 - lib/akaza/ast_ext.rb
 - lib/akaza/parser.rb
+- lib/akaza/ruby2ws.rb
 - lib/akaza/version.rb
 - lib/akaza/vm.rb
 homepage: https://github.com/pocke/akaza

data/Gemfile.lock

@@ -1,22 +0,0 @@
-PATH
-  remote: .
-  specs:
-    akaza (0.1.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    minitest (5.11.3)
-    rake (12.3.2)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  akaza!
-  bundler (~> 2.1.a)
-  minitest (>= 5)
-  rake (~> 12.0)
-
-BUNDLED WITH
-   2.1.0.pre.1