kaguya 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e73ebd3accde57e170c68259136fa3024de8c673
+  data.tar.gz: 29ce8f9a8441b5b7c433fe160b9426cd1d501b53
+SHA512:
+  metadata.gz: '0589b9960cb92fe547e3ed2cd48c81df78f87578e78657dc8aed9dcab1db2c33b0dff53d43826f4aab11bfaf271c272dec37dc719f7faef6d5d44b70068d6f5f'
+  data.tar.gz: 3d24c6dec0660cce7048edff1b934c5836e88db4ffed576f62a47729c4ee269c53666f593133a82ceff0b0b3109e6967d08203981b4c64c56e401d7580fa19be

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+before_install: gem install bundler -v 1.14.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kaguya.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 mozamimy (Moza USANE)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,132 @@
+# Kaguya
+
+Kaguya is an implementation of Brainf\*\*k by Ruby.
+
+This implementation consits of following elements,
+
+- Tiny parser
+- Tiny compiler
+- Tiny virtual stack machine
+
+## Installation
+
+```
+$ gem install kaguya
+```
+
+## Usage
+
+```
+$ kaguya helloworld.bf
+```
+
+An option `--debug` helps you to see AST and instruction sequence.
+
+```
+$ kaguya --debug helloworld.bf
+```
+
+## Technical components
+
+### Parser
+
+https://github.com/mozamimy/kaguya/blob/master/lib/kaguya/parser.rb
+
+The parser parses a BF script one charactor at a time. Errors can be raised by the parser if the script contains invalid corresponding of `[` and `]` or invalid charactors.
+
+Only the root node and `while` nodes have children.
+
+### Virtual machine
+
+https://github.com/mozamimy/kaguya/blob/master/lib/kaguya/vm.rb
+
+Kaguya VM has a two stacks (left\_stack, right\_stack) and has following 9 instructions,
+
+- `forward`: Forward stack, if right\_stack is empty then push 0 to left\_stack else move top of right\_stack to left\_stack.
+- `backward`: Backward stack, top data of left\_stack is poped and pushed to right\_stack.
+- `increment`: Increment top of left\_stack.
+- `decrement`: Decrement top of left\_stack.
+- `output`: Output top of left\_stack to standard I/O.
+- `input`: Input a value from standard I/O and push it to left\_stack.
+- `branch_ifzero N`: Jump to an instruction at `PC - N` if top of left\_stack is 0.
+- `branch_unlesszero N`: Jump to an instruction at `PC - N` unless top of left\_stack is 0.
+- `leave`: Exit
+
+### Compiler
+
+https://github.com/mozamimy/kaguya/blob/master/lib/kaguya/compiler.rb
+
+Kaguya compiler compiles an AST generated by the parser to an instruction sequence for Kaguya VM.
+
+### Example
+
+```
+[20:17:51]mozamimy@queen:kaguya (master) (-'x'-).oO(
+> cat example/useless.bf
+>>+[<>[+-]]
+[20:17:53]mozamimy@queen:kaguya (master) (-'x'-).oO(
+> be exe/kaguya --debug example/useless.bf
+=== AST ===
+#<Kaguya::AST::Node:0x007fd755a3f8c0
+ @children=
+  [#<Kaguya::AST::Node:0x007fd755a3f780
+    @children=[],
+    @parent=#<Kaguya::AST::Node:0x007fd755a3f8c0 ...>,
+    @type=:forward>,
+   #<Kaguya::AST::Node:0x007fd755a3f500
+    @children=[],
+    @parent=#<Kaguya::AST::Node:0x007fd755a3f8c0 ...>,
+    @type=:forward>,
+   #<Kaguya::AST::Node:0x007fd755a3f230
+    @children=[],
+    @parent=#<Kaguya::AST::Node:0x007fd755a3f8c0 ...>,
+    @type=:increment>,
+   #<Kaguya::AST::Node:0x007fd755a3f028
+    @children=
+     [#<Kaguya::AST::Node:0x007fd755a3edd0
+       @children=[],
+       @parent=#<Kaguya::AST::Node:0x007fd755a3f028 ...>,
+       @type=:backward>,
+      #<Kaguya::AST::Node:0x007fd755a3e7e0
+       @children=[],
+       @parent=#<Kaguya::AST::Node:0x007fd755a3f028 ...>,
+       @type=:forward>,
+      #<Kaguya::AST::Node:0x007fd755a3e5b0
+       @children=
+        [#<Kaguya::AST::Node:0x007fd755a3e3f8
+          @children=[],
+          @parent=#<Kaguya::AST::Node:0x007fd755a3e5b0 ...>,
+          @type=:increment>,
+         #<Kaguya::AST::Node:0x007fd755a3e1f0
+          @children=[],
+          @parent=#<Kaguya::AST::Node:0x007fd755a3e5b0 ...>,
+          @type=:decrement>],
+       @parent=#<Kaguya::AST::Node:0x007fd755a3f028 ...>,
+       @type=:while>],
+    @parent=#<Kaguya::AST::Node:0x007fd755a3f8c0 ...>,
+    @type=:while>],
+ @parent=nil,
+ @type=:root>
+=== ISEQ ===
+[[:forward, nil],
+ [:forward, nil],
+ [:increment, nil],
+ [:branch_ifzero, 8],
+ [:backward, nil],
+ [:forward, nil],
+ [:branch_ifzero, 4],
+ [:increment, nil],
+ [:decrement, nil],
+ [:branch_unlesszero, -2],
+ [:branch_unlesszero, -6],
+ [:leave, nil]]
+=== RUN ===
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/mozamimy/kaguya.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "kaguya"
+
+# 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/example/helloworkd.bf

@@ -0,0 +1,2 @@
++++++++++[>++++++++>+++++++++++>+++++<<<-]>.>++.+++++++..+++.>-.
+------------.<++++++++.--------.+++.------.--------.>+.

data/example/prime.bf

@@ -0,0 +1,5 @@
+>++++[<++++++++>-]>++++++++[<++++++>-]<++.<.>+.<.>++.<.>++.<.>>++[<--->-]
+<..<.>.++.<.>--.>++[<+++>-]<.<.>>++[<--->-]<.>++[<++++>-]<.<.>>++[<--->-]
+<-.+.<.>-.>+++[<++>-]<+.<.>>++[<--->-]<.--.<.>++.++++.<.>---.---.<.>++.-
+.<.>+.+++.<.>--.--.<.>++.++++.<.>---.-----.<.>+++++.+.<.>.>++[<--->-]<.<.
+>>++[<+++>-]<.----.<.>++++.++.<.>-.-----.<.>+++++.+.<.>.--.

data/example/useless.bf

@@ -0,0 +1 @@
+>>+[<>[+-]]

data/exe/kaguya

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'kaguya/cli'
+
+Kaguya::CLI.start(ARGV)

data/kaguya.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kaguya/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'kaguya'
+  spec.version       = Kaguya::VERSION
+  spec.authors       = ['mozamimy (Moza USANE)']
+  spec.email         = ['alice@mozami.me']
+
+  spec.summary       = %q{An implementation of brankf**k.}
+  spec.description   = %q{An implementation of brankf**k.}
+  spec.homepage      = 'https://github.com/mozamimy/kaguya'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/kaguya.rb

@@ -0,0 +1,8 @@
+require 'kaguya/version'
+require 'kaguya/cli'
+require 'kaguya/parser'
+require 'kaguya/compiler'
+require 'kaguya/vm'
+require 'kaguya/ast/node'
+
+module Kaguya; end

data/lib/kaguya/ast/node.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Kaguya
+  module AST
+    class Node
+      attr_reader :parent
+      attr_reader :children
+      attr_reader :type
+
+      # @param [Symbol] type
+      # @param [Node] parent
+      def initialize(type:, parent:)
+        @type = type
+        @parent = parent
+        @children = []
+
+        @parent.children << self if @parent
+      end
+
+      # @param [Compiler] compiler
+      # @return [Array]
+      def accept(compiler)
+        compiler.visit(self)
+      end
+
+      # @return [String]
+      def to_s
+        @type.to_s
+      end
+    end
+  end
+end

data/lib/kaguya/cli.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'kaguya'
+require 'optparse'
+require 'pp'
+
+module Kaguya
+  class CLI
+    def self.start(argv)
+      new(argv).run
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+      parser.parse!(@argv)
+    end
+
+    def run
+      source_file = File.open(@argv[0], 'r')
+      parser = Parser.new(source_file)
+      ast = parser.parse
+
+      if @debug
+        puts '=== AST ==='
+        pp ast
+      end
+
+      compiler = Compiler.new(ast)
+      iseq = compiler.compile
+
+      if @debug
+        puts '=== ISEQ ==='
+        pp iseq
+        puts '=== RUN ==='
+      end
+
+      vm = VM.new(iseq)
+      vm.run
+    end
+
+    private
+
+    def parser
+      @parser ||= OptionParser.new do |opts|
+        opts.banner = 'kaguya'
+        opts.version = Kaguya::VERSION
+        opts.on('-d', '--debug') { |d| @debug = d }
+      end
+    end
+  end
+end

data/lib/kaguya/compiler.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Kaguya
+  class Compiler
+    # @param [AST::Node] ast
+    def initialize(ast)
+      @ast = ast
+    end
+
+    # @return [Array]
+    def compile
+      iseq = @ast.accept(self)
+      iseq << [:leave, nil]
+      iseq
+    end
+
+    # @param [AST::Node] node
+    # @return [Array]
+    def visit(node)
+      iseq = []
+
+      case node.type
+      when :forward
+        iseq << [:forward, nil]
+      when :backward
+        iseq << [:backward, nil]
+      when :increment
+        iseq << [:increment, nil]
+      when :decrement
+        iseq << [:decrement, nil]
+      when :output
+        iseq << [:output, nil]
+      when :input
+        iseq << [:input, nil]
+      when :while
+        sub_iseq = []
+
+        node.children.each do |child|
+          sub_iseq.concat(child.accept(self))
+        end
+
+        iseq << [:branch_ifzero, sub_iseq.size + 2]
+        iseq.concat(sub_iseq)
+        iseq << [:branch_unlesszero, -sub_iseq.size]
+      when :root
+        node.children.each do |child|
+          iseq.concat(child.accept(self))
+        end
+      else
+        raise 'Invalid node!'
+      end
+
+      iseq
+    end
+  end
+end

data/lib/kaguya/parser.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Kaguya
+  class Parser
+    # @param [IO] input
+    def initialize(input)
+      @input = input
+    end
+
+    # @return [AST::Node]
+    def parse
+      root = AST::Node.new(type: :root, parent: nil)
+      current_node = root
+      context_level = 0
+
+      @input.each_char do |ch|
+        case ch
+        when '>'
+          AST::Node.new(type: :forward, parent: current_node)
+        when '<'
+          AST::Node.new(type: :backward, parent: current_node)
+        when '+'
+          AST::Node.new(type: :increment, parent: current_node)
+        when '-'
+          AST::Node.new(type: :decrement, parent: current_node)
+        when '.'
+          AST::Node.new(type: :output, parent: current_node)
+        when ','
+          AST::Node.new(type: :input, parent: current_node)
+        when '['
+          context_level += 1
+          current_node = AST::Node.new(type: :while, parent: current_node)
+        when ']'
+          context_level -= 1
+          current_node = current_node.parent
+        when ' ', "\n", "\r"
+          # read next charactor
+        else
+          raise "Invalid charactor `#{ch}`."
+        end
+      end
+
+      if context_level != 0
+        raise 'Invalid brace correspondence.'
+      end
+
+      root
+    end
+  end
+end

data/lib/kaguya/version.rb

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

data/lib/kaguya/vm.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'pp'
+
+module Kaguya
+  class VM
+    # @param [Array] iseq
+    def initialize(iseq)
+      @iseq = iseq
+      @pc = 0
+      @left_stack = [0]
+      @right_stack = []
+    end
+
+    def run
+      loop do
+        instruction = fetch(@pc)
+        execute(instruction)
+      end
+    end
+
+    private
+
+    # @param [Integer] pc
+    # @return [Integer]
+    def fetch(pc)
+      @iseq[pc]
+    end
+
+    # @param [Array] instruction
+    def execute(instruction)
+      case instruction[0]
+      when :forward
+        if @right_stack.size < 1
+          @left_stack.push(0)
+        else
+          @left_stack.push(@right_stack.pop)
+        end
+        @pc += 1
+      when :backward
+        @right_stack.push(@left_stack.pop)
+        @pc += 1
+      when :increment
+        @left_stack.push(@left_stack.pop + 1)
+        @pc += 1
+      when :decrement
+        @left_stack.push(@left_stack.pop - 1)
+        @pc += 1
+      when :output
+        value = @left_stack.pop
+        STDOUT.print(value.chr)
+        @left_stack.push(value)
+        @pc += 1
+      when :input
+        @left_stack.pop
+        @left_stack.push(STDIN.getc.ord)
+        @pc += 1
+      when :branch_ifzero
+        value = @left_stack.pop
+        @left_stack.push(value)
+        if value.zero?
+          @pc += instruction[1]
+        else
+          @pc += 1
+        end
+      when :branch_unlesszero
+        value = @left_stack.pop
+        @left_stack.push(value)
+        if !value.zero?
+          @pc += instruction[1]
+        else
+          @pc += 1
+        end
+      when :leave
+        exit 0
+      else
+        raise "Unknown instruction #{instruction[0]}"
+      end
+    rescue => e
+      pp @left_stack
+      pp @right_stack
+      raise(e)
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: kaguya
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- mozamimy (Moza USANE)
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: An implementation of brankf**k.
+email:
+- alice@mozami.me
+executables:
+- kaguya
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- example/helloworkd.bf
+- example/prime.bf
+- example/useless.bf
+- exe/kaguya
+- kaguya.gemspec
+- lib/kaguya.rb
+- lib/kaguya/ast/node.rb
+- lib/kaguya/cli.rb
+- lib/kaguya/compiler.rb
+- lib/kaguya/parser.rb
+- lib/kaguya/version.rb
+- lib/kaguya/vm.rb
+homepage: https://github.com/mozamimy/kaguya
+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.6.8
+signing_key: 
+specification_version: 4
+summary: An implementation of brankf**k.
+test_files: []