petooh 6.0.0

data/README.md

@@ -0,0 +1,50 @@
+### DESCRIPTION
+
+PETOOH interpreter written in [Ruby](http://ruby-lang.org) and [GPL](https://github.com/LavirtheWhiolet/self-bootstrap).
+
+### DEPENDS
+
+[Ruby](http://ruby-lang.org) 1.9.3 or higer.
+
+### BUILD
+
+First, you need to install:
+* [Rake](http://docs.seattlerb.org/rake/). Usually it comes with Ruby, but if it isn't then you may install it with the command `gem install rake`.
+* [GPL](https://github.com/LavirtheWhiolet/self-bootstrap). Just download ["peg2rb.rb"](https://github.com/LavirtheWhiolet/self-bootstrap/blob/master/peg2rb.rb) into this directory and you are ready.
+
+To (re-)build PETOOH interpreter as a standalone Ruby script you give the command:
+
+    rake petooh.rb
+
+To build a Ruby gem you give the command:
+    
+    rake gem
+    
+To build everything in this package you just give the command:
+    
+    rake
+
+To clean up your directory give the command:
+
+    rake clean
+
+### INSTALL
+
+Copy "petooh.rb" to some directory.
+
+Or install the corresponding Ruby gem by giving the command:
+
+    gem install petooh
+
+### USAGE
+
+To run:
+
+    ~$ ruby petooh.rb [options] file
+
+Or, if you have installed the interpreter as a Ruby gem:
+
+    ~$ petooh [options] file
+
+Options:
+* `-h` - Get some help.

data/bin/petooh

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+require 'petooh'
+
+# Parse args.
+case ARGV
+when [], ["-h"], ["--help"]
+  puts <<-HELP
+Usage: ruby #{File.basename(__FILE__)} file.koko
+  HELP
+  exit
+end
+file = ARGV[0]
+# Run!
+include PETOOH
+File.open(file) do |io|
+  program = parse(io)
+  run program
+end

data/gen/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012 Roman Nuritdinov
+
+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/gen/PETOOH.md

@@ -0,0 +1,49 @@
+PETOOH – a fundamentally new programming language
+==================================================
+
+Basics
+------
+
+<table>
+    <tr>
+        <td>Kudah</td>
+        <td>increment the data pointer (to point to the next cell to the right)</td>
+    </tr>
+    <tr>
+        <td>kudah</td>
+        <td>decrement the data pointer (to point to the next cell to the left)</td>
+    </tr>
+    <tr>
+        <td>Ko</td>
+        <td>increment (increase by one) the byte at the data pointer</td>
+    </tr>
+    <tr>
+        <td>kO</td>
+        <td>decrement (decrease by one) the byte at the data pointer</td>
+    </tr>
+    <tr>
+        <td>Kukarek</td>
+        <td>output the byte at the data pointer as an ASCII encoded character</td>
+    </tr>
+    <tr>
+        <td>Kud</td>
+        <td>if the byte at the data pointer is zero, then instead of moving the instruction pointer forward to the next command</td>
+    </tr>
+    <tr>
+        <td>kud</td>
+        <td>if the byte at the data pointer is nonzero, then instead of moving the instruction pointer forward to the next command</td>
+    </tr>
+</table>
+
+Code sample
+-----------
+
+    KoKoKoKoKoKoKoKoKoKo Kud-Kudah
+    KoKoKoKoKoKoKoKo kudah kO kud-Kudah Kukarek kudah
+    KoKoKo Kud-Kudah
+    kOkOkOkO kudah kO kud-Kudah Ko Kukarek kudah
+    KoKoKoKo Kud-Kudah KoKoKoKo kudah kO kud-Kudah kO Kukarek
+    kOkOkOkOkO Kukarek Kukarek kOkOkOkOkOkOkO
+    Kukarek
+
+[Try now!](http://ky6uk.github.io/PETOOH/)

data/gen/lib/petooh.rb

@@ -0,0 +1,375 @@
+# encoding: UTF-8
+
+# Generated from "lib/petooh.peg" on 2015-09-20 00:13:12 +0500
+
+module PETOOH
+
+  # 
+  # +program+ is an Array of PETOOH keywords (in the form of String-s).
+  #
+  # +debug+ - if true then PETOOH VM state is dumped on each execution step.
+  # 
+  def run(program, debug = false)
+    # Init virtual machine.
+    mem = [0] * 16
+    data_ptr = 0
+    pc = 0  # Index of current instruction in program.
+    # Run!
+    while pc < program.size
+      # Log (if needed).
+      if debug
+        STDERR.puts "MEM: #{mem.join(" ")}"
+        STDERR.puts "PC: #{pc} (#{program[pc]})"
+        STDERR.puts "DP: #{data_ptr} (#{mem[data_ptr]})"
+      end
+      # Analyze current program instruction.
+      case program[pc]
+      when "Kudah"
+        # 
+        data_ptr += 1
+        # Expand memory if needed.
+        if data_ptr >= mem.size
+          mem.concat([0] * 16)
+        end
+        # 
+        pc += 1
+      when "kudah"
+        # 
+        data_ptr -= 1
+        # Convert the machine's state from the form of
+        #   { data_ptr = -1, mem = { -1:x, 0:y, 1:z, … } }
+        # to the form of
+        #   { data_ptr = 0, mem = { 0:x, 1:y, 2:z, … } }
+        if data_ptr < 0
+          mem.unshift(0)
+          data_ptr = 0
+        end
+        # 
+        pc += 1
+      when "Ko"
+        mem[data_ptr] += 1
+        pc += 1
+      when "kO"
+        mem[data_ptr] -= 1
+        pc += 1
+      when "Kukarek"
+        print mem[data_ptr].chr
+        pc += 1
+      when "Kud"
+        if mem[data_ptr] == 0
+          # Increment PC until corresponding "kud" is encountered
+          # (taking nested "Kud"/"kud" into account).
+          nest_level = 1
+          pc += 1
+          while pc < program.size and nest_level > 0
+            case program[pc]
+            when "Kud"
+              nest_level += 1
+            when "kud"
+              nest_level -= 1
+            end
+            pc += 1
+          end
+        else
+          # Just skip the instruction.
+          pc += 1
+        end
+      when "kud"
+        if mem[data_ptr] != 0
+          # Decrement PC until corresponding "Kud" is encountered
+          # (taking nested "Kud"/"kud" into account).
+          nest_level = 1
+          pc -= 1
+          while pc > 0 and nest_level > 0
+            case program[pc]
+            when "Kud"
+              nest_level -= 1
+            when "kud"
+              nest_level += 1
+            end
+            pc -= 1
+          end
+          # Position PC right to the corresponding "Kud".
+          pc += 1
+        else
+          # Just skip the instruction.
+          pc += 1
+        end
+      end
+    end
+  end
+  
+  # 
+  # reads PETOOH program from +io+ and parses it into Array of PETOOH
+  # keywords (in the form of String-s).
+  # 
+  def parse(io)
+    yy_parse(io)
+  end
+  
+  private
+  
+  # Generated by Generator of Parsers of Lavir AKA self-bootstrap.
+  
+
+      
+      # 
+      # +input+ is IO. It must have working IO#pos, IO#pos= and
+      # IO#set_encoding() methods.
+      # 
+      # It may raise YY_SyntaxError.
+      # 
+      def yy_parse(input)
+        input.set_encoding("UTF-8", "UTF-8")
+        context = YY_ParsingContext.new(input)
+        yy_from_pcv(
+          yy_nonterm1(context) ||
+          # TODO: context.worst_error can not be nil here. Prove it.
+          raise(context.worst_error)
+        )
+      end
+
+      # TODO: Allow to pass String to the entry point.
+    
+      
+      # :nodoc:
+      ### converts value to parser-compatible value (which is always non-false and
+      ### non-nil).
+      def yy_to_pcv(value)
+        if value.nil? then :yy_nil
+        elsif value == false then :yy_false
+        else value
+        end
+      end
+      
+      # :nodoc:
+      ### converts value got by #yy_to_pcv() to actual value.
+      def yy_from_pcv(value)
+        if value == :yy_nil then nil
+        elsif value == :yy_false then false
+        else value
+        end
+      end
+      
+      # :nodoc:
+      class YY_ParsingContext
+        
+        # +input+ is IO.
+        def initialize(input)
+          @input = input
+          @worst_error = nil
+        end
+        
+        attr_reader :input
+        
+        # It is YY_SyntaxExpectationError or nil.
+        attr_accessor :worst_error
+        
+        # adds possible error to this YY_ParsingContext.
+        # 
+        # +error+ is YY_SyntaxExpectationError.
+        # 
+        def << error
+          # Update worst_error.
+          if worst_error.nil? or worst_error.pos < error.pos then
+            @worst_error = error
+          elsif worst_error.pos == error.pos then
+            @worst_error = @worst_error.or error
+          end
+          # 
+          return self
+        end
+        
+      end
+      
+      # :nodoc:
+      def yy_string(context, string)
+        # 
+        string_start_pos = context.input.pos
+        # Read string.
+        read_string = context.input.read(string.bytesize)
+        # Set the string's encoding; check if it fits the argument.
+        unless read_string and (read_string.force_encoding(Encoding::UTF_8)) == string then
+          # 
+          context << YY_SyntaxExpectationError.new(yy_displayed(string), string_start_pos)
+          # 
+          return nil
+        end
+        # 
+        return read_string
+      end
+      
+      # :nodoc:
+      def yy_end?(context)
+        #
+        if not context.input.eof?
+          context << YY_SyntaxExpectationError.new("the end", context.input.pos)
+          return nil
+        end
+        #
+        return true
+      end
+      
+      # :nodoc:
+      def yy_begin?(context)
+        #
+        if not(context.input.pos == 0)
+          context << YY_SyntaxExpectationError.new("the beginning", context.input.pos)
+          return nil
+        end
+        #
+        return true
+      end
+      
+      # :nodoc:
+      def yy_char(context)
+        # 
+        char_start_pos = context.input.pos
+        # Read a char.
+        c = context.input.getc
+        # 
+        unless c then
+          #
+          context << YY_SyntaxExpectationError.new("a character", char_start_pos)
+          #
+          return nil
+        end
+        #
+        return c
+      end
+      
+      # :nodoc:
+      def yy_char_range(context, from, to)
+        # 
+        char_start_pos = context.input.pos
+        # Read the char.
+        c = context.input.getc
+        # Check if it fits the range.
+        # NOTE: c has UTF-8 encoding.
+        unless c and (from <= c and c <= to) then
+          # 
+          context << YY_SyntaxExpectationError.new(%(#{yy_displayed from}...#{yy_displayed to}), char_start_pos)
+          # 
+          return nil
+        end
+        #
+        return c
+      end
+      
+      # :nodoc:
+      ### The form of +string+ suitable for displaying in messages.
+      def yy_displayed(string)
+        if string.length == 1 then
+          char = string[0]
+          char_code = char.ord
+          case char_code
+          when 0x00...0x20, 0x2028, 0x2029 then %(#{yy_unicode_s char_code})
+          when 0x20...0x80 then %("#{char}")
+          when 0x80...Float::INFINITY then %("#{char} (#{yy_unicode_s char_code})")
+          end
+        else
+          %("#{string}")
+        end
+      end
+      
+      # :nodoc:
+      ### "U+XXXX" string corresponding to +char_code+.
+      def yy_unicode_s(char_code)
+        "U+#{"%04X" % char_code}"
+      end
+      
+      class YY_SyntaxError < Exception
+        
+        def initialize(message, pos)
+          super(message)
+          @pos = pos
+        end
+        
+        attr_reader :pos
+        
+      end
+      
+      # :nodoc:
+      class YY_SyntaxExpectationError < YY_SyntaxError
+        
+        # 
+        # +expectations+ are String-s.
+        # 
+        def initialize(*expectations, pos)
+          super(nil, pos)
+          @expectations = expectations
+        end
+        
+        # 
+        # returns other YY_SyntaxExpectationError with #expectations combined.
+        # 
+        # +other+ is another YY_SyntaxExpectationError.
+        # 
+        # #pos of this YY_SyntaxExpectationError and +other+ must be equal.
+        # 
+        def or other
+          raise %(can not "or" #{YY_SyntaxExpectationError}s with different pos) unless self.pos == other.pos
+          YY_SyntaxExpectationError.new(*(self.expectations + other.expectations), pos)
+        end
+        
+        def message
+          expectations = self.expectations.uniq
+          (
+            if expectations.size == 1 then expectations.first
+            else [expectations[0...-1].join(", "), expectations[-1]].join(" or ")
+            end
+          ) + " is expected"
+        end
+        
+        protected
+        
+        # Private
+        attr_reader :expectations
+        
+      end
+    
+      # :nodoc:
+      def yy_nonterm1(yy_context)
+        val = nil
+        (begin
+       val = [] 
+      true
+    end and while true
+      yy_var8 = yy_context.input.pos
+      if not(begin; yy_var6 = yy_context.input.pos; begin
+      yy_var7 = yy_nonterm9(yy_context)
+      if yy_var7 then
+        val << yy_from_pcv(yy_var7)
+      end
+      yy_var7
+    end or (yy_context.input.pos = yy_var6; yy_nontermh(yy_context)); end) then
+        yy_context.input.pos = yy_var8
+        break true
+      end
+    end) and yy_to_pcv(val)
+      end
+    
+      # :nodoc:
+      def yy_nonterm9(yy_context)
+        val = nil
+        begin
+      val = ""
+      yy_varf = yy_context.input.pos
+      begin; yy_vare = yy_context.input.pos; yy_string(yy_context, "Kudah") or (yy_context.input.pos = yy_vare; yy_string(yy_context, "kudah")) or (yy_context.input.pos = yy_vare; yy_string(yy_context, "Ko")) or (yy_context.input.pos = yy_vare; yy_string(yy_context, "kO")) or (yy_context.input.pos = yy_vare; yy_string(yy_context, "Kukarek")) or (yy_context.input.pos = yy_vare; yy_string(yy_context, "Kud")) or (yy_context.input.pos = yy_vare; yy_string(yy_context, "kud")); end and begin
+        yy_varg = yy_context.input.pos
+        yy_context.input.pos = yy_varf
+        val << yy_context.input.read(yy_varg - yy_varf).force_encoding(Encoding::UTF_8)
+      end
+    end and yy_to_pcv(val)
+      end
+    
+      # :nodoc:
+      def yy_nontermh(yy_context)
+        val = nil
+        yy_char(yy_context) and yy_to_pcv(val)
+      end
+      
+  # End of generated code.
+
+end
+

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: petooh
+version: !ruby/object:Gem::Version
+  version: 6.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Roman Nuritdinov
+- Lavir the Whiolet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-19 00:00:00.000000000 Z
+dependencies: []
+description: ! 'Interpreter of PETOOH - the fundamentally new programming language.
+
+'
+email:
+- ky6uk.kun@gmail.com
+- Lavir.th.Whiolet@gmail.com
+executables:
+- petooh
+extensions: []
+extra_rdoc_files:
+- README.md
+- gen/PETOOH.md
+- gen/LICENSE
+files:
+- gen/lib/petooh.rb
+- README.md
+- gen/PETOOH.md
+- gen/LICENSE
+- bin/petooh
+homepage: http://ky6uk.github.io/PETOOH/
+licenses:
+- The MIT License (MIT)
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- gen/lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: PETOOH interpreter
+test_files: []
+has_rdoc: