poetics 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.rbc
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "rake",   ">= 0.8.7"
+gem "kpeg",   "~> 0.8.2"
+gem "mspec",  "~> 1.5.17"

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Brian Ford. All rights reserved.
+
+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

@@ -0,0 +1,87 @@
+A native implementation of CoffeeScript [1] that runs on the Rubinius VM [2].
+
+Q. Whence comes the name Poetics?
+A. Poetics is a partial anagram of the word CoffeeScript. It is also a nod to
+   Jeremy Ashkenas, the author of CoffeeScript, and his interest in code as
+   literature.
+
+Q. Why a native implementation?
+A. CoffeeScript is an interesting language in its own right. Rather than
+   merely being a syntax layer on top of Javascript, and bound to expressing
+   its semantics in those of Javascript, it deserves its own implementation.
+   Many of the reasons to use CoffeeScript in Node.js would also apply to
+   using this native implementation.
+
+
+Installation
+
+First, install Rubinius:
+
+  1. Using RVM (http://rvm.beginrescueend.com).
+
+    rvm install rbx
+
+  2. Or directly (http://rubini.us/doc/en/what-is-rubinius/). 
+
+Second, install Poetics:
+
+    rbx -S gem install poetics
+
+
+Running Poetics
+
+Poetics provides a REPL for exploratory programming or runs CoffeeScript
+scripts.
+
+    rbx -S poetics -h
+
+The REPL presently just parses code and returns an S-Expression
+representation:
+
+    $ rbx -S poetics
+    > 42
+    [:number, 42.0, 1, 1]
+    > "hello, y'all"
+    [:string, "hello, y'all", 1, 1]
+    >
+
+
+Getting Help
+
+Poetics is a work in progress. If you encounter trouble, please file an issue
+at https://github.com/brixen/poetics/issues
+
+
+Contributing
+
+If you find Poetics interesting and would like to help out, fork the project
+on Github and submit a pull request.
+
+
+People
+
+Poetics was created by Brian Ford (brixen) to force him to really learn
+Javascript and CoffeeScript.
+
+<add your name here>
+
+
+License
+
+Poetics is MIT licensed. See the LICENSE file.
+
+
+Credits
+
+Jeremy has created an very interesting language in CoffeeScript. This
+implementation steals bits and pieces from other projects:
+
+Rubinius (https://github.com/evanphx/rubinius/)
+KPeg (https://github.com/evanphx/kpeg/)
+Atomy (https://github.com/vito/atomy/)
+Poison (https://github.com/brixen/poison/)
+Talon (https://github.com/evanphx/talon/)
+
+
+[1] CoffeeScript (http://jashkenas.github.com/coffee-script/)
+[2] Rubinius (http://rubini.us)

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => :spec
+
+base = File.expand_path '../lib/poetics/parser', __FILE__
+
+grammar = "#{base}/poetics.kpeg"
+parser  = "#{base}/parser.rb"
+
+file parser => grammar do
+  sh "rbx -S kpeg -f -s #{base}/poetics.kpeg -o #{base}/parser.rb"
+end
+
+desc "Convert the grammar description to a parser"
+task :parser => parser
+
+desc "Run the specs (default)"
+task :spec => :parser do
+  sh "mspec spec"
+end

data/bin/poetics

@@ -0,0 +1,140 @@
+#!/usr/bin/env rbx
+#
+# vim: filetype=ruby
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'readline'
+require 'poetics'
+
+class Poetics::Script
+  HISTORY = File.expand_path "~/.poetics_history"
+
+  attr_accessor :prompt
+
+  def initialize
+    @evals = []
+    @script = nil
+    @history = []
+  end
+
+  def options(argv=ARGV)
+    options = Rubinius::Options.new "Usage: poetics [options] [script]", 20
+
+    options.on "-", "Read and evaluate code from STDIN" do
+      @evals << STDIN.read
+    end
+
+    options.on "-c", "FILE", "Check the syntax of FILE" do |f|
+      begin
+        begin
+          Poetics::Parser.parse_file f
+        rescue => e
+          e.render
+          exit 1
+        end
+
+        puts "Syntax OK"
+        exit 0
+      end
+    end
+
+    options.on "-e", "CODE", "Execute CODE" do |e|
+      @evals << e
+    end
+
+    options.on "-v", "--version", "Display the version" do
+      puts Poetics::COMMAND_VERSION
+    end
+
+    options.on "-h", "--help", "Display this help" do
+      puts options
+      exit 0
+    end
+
+    options.doc ""
+
+    rest = options.parse(argv)
+    @script ||= rest.first
+  end
+
+  def evals
+    return if @evals.empty?
+
+    Poetics::CodeLoader.evaluate @evals.join("\n")
+  end
+
+  def script
+    return unless @script
+
+    if File.exists? @script
+      Poetics::CodeLoader.execute_file @script
+    else
+      STDERR.puts "Unable to find '#{@script}' to run"
+      exit 1
+    end
+  end
+
+  def load_history
+    return unless File.exists? HISTORY
+
+    File.open HISTORY, "r" do |f|
+      f.each { |l| Readline::HISTORY << l }
+    end
+  end
+
+  def save_history
+    File.open HISTORY, "w" do |f|
+      @history.last(100).map { |s| f.puts s }
+    end
+  end
+
+  def record_history(str)
+    @history << str
+  end
+
+  def start_prompt
+    @prompt = "> "
+  end
+
+  def continue_prompt
+    @prompt = ". "
+  end
+
+  def repl
+    return if @script
+    load_history
+    start_prompt
+
+    begin
+      snippet = ""
+      while str = Readline.readline(prompt)
+        break if str.nil? and snippet.empty?
+        next if str.empty?
+
+        snippet << str
+        begin
+          value = Poetics::CodeLoader.evaluate snippet
+          p value
+
+          record_history snippet
+          snippet = ""
+          start_prompt
+        rescue => e
+          STDERR.puts e
+        end
+      end
+    ensure
+      save_history
+    end
+  end
+
+  def main
+    options
+    evals
+    script
+    repl
+  end
+end
+
+Poetics::Script.new.main

data/lib/poetics.rb

@@ -0,0 +1,4 @@
+require 'poetics/version'
+require 'poetics/syntax'
+require 'poetics/parser'
+require 'poetics/library'

data/lib/poetics/library.rb

@@ -0,0 +1 @@
+require 'poetics/library/code_loader'

data/lib/poetics/library/code_loader.rb

@@ -0,0 +1,13 @@
+module Poetics
+  class CodeLoader
+    def self.evaluate(string)
+      # We're just parsing for now
+      Poetics::Parser.parse_to_sexp string
+    end
+
+    def self.execute_file(name)
+      value = Poetics::Parser.parse_to_sexp IO.read(name)
+      p value
+    end
+  end
+end

data/lib/poetics/parser.rb

@@ -0,0 +1,21 @@
+require 'poetics/parser/parser'
+
+class Poetics::Parser
+  include Poetics::Syntax
+
+  def self.parse_to_sexp(string)
+    parser = new string
+    unless parser.parse
+      parser.raise_error
+    end
+
+    parser.result.to_sexp
+  end
+
+  attr_reader :line, :column
+
+  def position(line, column)
+    @line = line
+    @column = column
+  end
+end

data/lib/poetics/parser/parser.rb

@@ -0,0 +1,875 @@
+class Poetics::Parser
+# STANDALONE START
+    def setup_parser(str, debug=false)
+      @string = str
+      @pos = 0
+      @memoizations = Hash.new { |h,k| h[k] = {} }
+      @result = nil
+      @failed_rule = nil
+      @failing_rule_offset = -1
+
+      setup_foreign_grammar
+    end
+
+    # This is distinct from setup_parser so that a standalone parser
+    # can redefine #initialize and still have access to the proper
+    # parser setup code.
+    #
+    def initialize(str, debug=false)
+      setup_parser(str, debug)
+    end
+
+    attr_reader :string
+    attr_reader :result, :failing_rule_offset
+    attr_accessor :pos
+
+    # STANDALONE START
+    def current_column(target=pos)
+      if c = string.rindex("\n", target-1)
+        return target - c - 1
+      end
+
+      target + 1
+    end
+
+    def current_line(target=pos)
+      cur_offset = 0
+      cur_line = 0
+
+      string.each_line do |line|
+        cur_line += 1
+        cur_offset += line.size
+        return cur_line if cur_offset >= target
+      end
+
+      -1
+    end
+
+    def lines
+      lines = []
+      string.each_line { |l| lines << l }
+      lines
+    end
+
+    #
+
+    def get_text(start)
+      @string[start..@pos-1]
+    end
+
+    def show_pos
+      width = 10
+      if @pos < width
+        "#{@pos} (\"#{@string[0,@pos]}\" @ \"#{@string[@pos,width]}\")"
+      else
+        "#{@pos} (\"... #{@string[@pos - width, width]}\" @ \"#{@string[@pos,width]}\")"
+      end
+    end
+
+    def failure_info
+      l = current_line @failing_rule_offset
+      c = current_column @failing_rule_offset
+
+      if @failed_rule.kind_of? Symbol
+        info = self.class::Rules[@failed_rule]
+        "line #{l}, column #{c}: failed rule '#{info.name}' = '#{info.rendered}'"
+      else
+        "line #{l}, column #{c}: failed rule '#{@failed_rule}'"
+      end
+    end
+
+    def failure_caret
+      l = current_line @failing_rule_offset
+      c = current_column @failing_rule_offset
+
+      line = lines[l-1]
+      "#{line}\n#{' ' * (c - 1)}^"
+    end
+
+    def failure_character
+      l = current_line @failing_rule_offset
+      c = current_column @failing_rule_offset
+      lines[l-1][c-1, 1]
+    end
+
+    def failure_oneline
+      l = current_line @failing_rule_offset
+      c = current_column @failing_rule_offset
+
+      char = lines[l-1][c-1, 1]
+
+      if @failed_rule.kind_of? Symbol
+        info = self.class::Rules[@failed_rule]
+        "@#{l}:#{c} failed rule '#{info.name}', got '#{char}'"
+      else
+        "@#{l}:#{c} failed rule '#{@failed_rule}', got '#{char}'"
+      end
+    end
+
+    class ParseError < RuntimeError
+    end
+
+    def raise_error
+      raise ParseError, failure_oneline
+    end
+
+    def show_error(io=STDOUT)
+      error_pos = @failing_rule_offset
+      line_no = current_line(error_pos)
+      col_no = current_column(error_pos)
+
+      io.puts "On line #{line_no}, column #{col_no}:"
+
+      if @failed_rule.kind_of? Symbol
+        info = self.class::Rules[@failed_rule]
+        io.puts "Failed to match '#{info.rendered}' (rule '#{info.name}')"
+      else
+        io.puts "Failed to match rule '#{@failed_rule}'"
+      end
+
+      io.puts "Got: #{string[error_pos,1].inspect}"
+      line = lines[line_no-1]
+      io.puts "=> #{line}"
+      io.print(" " * (col_no + 3))
+      io.puts "^"
+    end
+
+    def set_failed_rule(name)
+      if @pos > @failing_rule_offset
+        @failed_rule = name
+        @failing_rule_offset = @pos
+      end
+    end
+
+    attr_reader :failed_rule
+
+    def match_string(str)
+      len = str.size
+      if @string[pos,len] == str
+        @pos += len
+        return str
+      end
+
+      return nil
+    end
+
+    def scan(reg)
+      if m = reg.match(@string[@pos..-1])
+        width = m.end(0)
+        @pos += width
+        return true
+      end
+
+      return nil
+    end
+
+    if "".respond_to? :getbyte
+      def get_byte
+        if @pos >= @string.size
+          return nil
+        end
+
+        s = @string.getbyte @pos
+        @pos += 1
+        s
+      end
+    else
+      def get_byte
+        if @pos >= @string.size
+          return nil
+        end
+
+        s = @string[@pos]
+        @pos += 1
+        s
+      end
+    end
+
+    def parse(rule=nil)
+      if !rule
+        _root ? true : false
+      else
+        # This is not shared with code_generator.rb so this can be standalone
+        method = rule.gsub("-","_hyphen_")
+        __send__("_#{method}") ? true : false
+      end
+    end
+
+    class LeftRecursive
+      def initialize(detected=false)
+        @detected = detected
+      end
+
+      attr_accessor :detected
+    end
+
+    class MemoEntry
+      def initialize(ans, pos)
+        @ans = ans
+        @pos = pos
+        @uses = 1
+        @result = nil
+      end
+
+      attr_reader :ans, :pos, :uses, :result
+
+      def inc!
+        @uses += 1
+      end
+
+      def move!(ans, pos, result)
+        @ans = ans
+        @pos = pos
+        @result = result
+      end
+    end
+
+    def external_invoke(other, rule, *args)
+      old_pos = @pos
+      old_string = @string
+
+      @pos = other.pos
+      @string = other.string
+
+      begin
+        if val = __send__(rule, *args)
+          other.pos = @pos
+        else
+          other.set_failed_rule "#{self.class}##{rule}"
+        end
+        val
+      ensure
+        @pos = old_pos
+        @string = old_string
+      end
+    end
+
+    def apply(rule)
+      if m = @memoizations[rule][@pos]
+        m.inc!
+
+        prev = @pos
+        @pos = m.pos
+        if m.ans.kind_of? LeftRecursive
+          m.ans.detected = true
+          return nil
+        end
+
+        @result = m.result
+
+        return m.ans
+      else
+        lr = LeftRecursive.new(false)
+        m = MemoEntry.new(lr, @pos)
+        @memoizations[rule][@pos] = m
+        start_pos = @pos
+
+        ans = __send__ rule
+
+        m.move! ans, @pos, @result
+
+        # Don't bother trying to grow the left recursion
+        # if it's failing straight away (thus there is no seed)
+        if ans and lr.detected
+          return grow_lr(rule, start_pos, m)
+        else
+          return ans
+        end
+
+        return ans
+      end
+    end
+
+    def grow_lr(rule, start_pos, m)
+      while true
+        @pos = start_pos
+        @result = m.result
+
+        ans = __send__ rule
+        return nil unless ans
+
+        break if @pos <= m.pos
+
+        m.move! ans, @pos, @result
+      end
+
+      @result = m.result
+      @pos = m.pos
+      return m.ans
+    end
+
+    class RuleInfo
+      def initialize(name, rendered)
+        @name = name
+        @rendered = rendered
+      end
+
+      attr_reader :name, :rendered
+    end
+
+    def self.rule_info(name, rendered)
+      RuleInfo.new(name, rendered)
+    end
+
+    #
+  def setup_foreign_grammar; end
+
+  # root = - value? - end
+  def _root
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save1 = self.pos
+      _tmp = apply(:_value)
+      unless _tmp
+        _tmp = true
+        self.pos = _save1
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_end)
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  # end = !.
+  def _end
+    _save = self.pos
+    _tmp = get_byte
+    _tmp = _tmp ? nil : true
+    self.pos = _save
+    set_failed_rule :_end unless _tmp
+    return _tmp
+  end
+
+  # - = (" " | "\t" | "\n")*
+  def __hyphen_
+    while true
+
+      _save1 = self.pos
+      while true # choice
+        _tmp = match_string(" ")
+        break if _tmp
+        self.pos = _save1
+        _tmp = match_string("\t")
+        break if _tmp
+        self.pos = _save1
+        _tmp = match_string("\n")
+        break if _tmp
+        self.pos = _save1
+        break
+      end # end choice
+
+      break unless _tmp
+    end
+    _tmp = true
+    set_failed_rule :__hyphen_ unless _tmp
+    return _tmp
+  end
+
+  # value = (string | number | boolean)
+  def _value
+
+    _save = self.pos
+    while true # choice
+      _tmp = apply(:_string)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_number)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_boolean)
+      break if _tmp
+      self.pos = _save
+      break
+    end # end choice
+
+    set_failed_rule :_value unless _tmp
+    return _tmp
+  end
+
+  # boolean = position (true | false | null | undefined)
+  def _boolean
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_position)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+
+      _save1 = self.pos
+      while true # choice
+        _tmp = apply(:_true)
+        break if _tmp
+        self.pos = _save1
+        _tmp = apply(:_false)
+        break if _tmp
+        self.pos = _save1
+        _tmp = apply(:_null)
+        break if _tmp
+        self.pos = _save1
+        _tmp = apply(:_undefined)
+        break if _tmp
+        self.pos = _save1
+        break
+      end # end choice
+
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_boolean unless _tmp
+    return _tmp
+  end
+
+  # true = "true" {true_value}
+  def _true
+
+    _save = self.pos
+    while true # sequence
+      _tmp = match_string("true")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; true_value; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_true unless _tmp
+    return _tmp
+  end
+
+  # false = "false" {false_value}
+  def _false
+
+    _save = self.pos
+    while true # sequence
+      _tmp = match_string("false")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; false_value; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_false unless _tmp
+    return _tmp
+  end
+
+  # null = "null" {null_value}
+  def _null
+
+    _save = self.pos
+    while true # sequence
+      _tmp = match_string("null")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; null_value; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_null unless _tmp
+    return _tmp
+  end
+
+  # undefined = "undefined" {undefined_value}
+  def _undefined
+
+    _save = self.pos
+    while true # sequence
+      _tmp = match_string("undefined")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; undefined_value; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_undefined unless _tmp
+    return _tmp
+  end
+
+  # number = position (real | hex | int)
+  def _number
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_position)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+
+      _save1 = self.pos
+      while true # choice
+        _tmp = apply(:_real)
+        break if _tmp
+        self.pos = _save1
+        _tmp = apply(:_hex)
+        break if _tmp
+        self.pos = _save1
+        _tmp = apply(:_int)
+        break if _tmp
+        self.pos = _save1
+        break
+      end # end choice
+
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_number unless _tmp
+    return _tmp
+  end
+
+  # hexdigits = /[0-9A-Fa-f]/
+  def _hexdigits
+    _tmp = scan(/\A(?-mix:[0-9A-Fa-f])/)
+    set_failed_rule :_hexdigits unless _tmp
+    return _tmp
+  end
+
+  # hex = "0x" < hexdigits+ > {hexadecimal(text)}
+  def _hex
+
+    _save = self.pos
+    while true # sequence
+      _tmp = match_string("0x")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _text_start = self.pos
+      _save1 = self.pos
+      _tmp = apply(:_hexdigits)
+      if _tmp
+        while true
+          _tmp = apply(:_hexdigits)
+          break unless _tmp
+        end
+        _tmp = true
+      else
+        self.pos = _save1
+      end
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; hexadecimal(text); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_hex unless _tmp
+    return _tmp
+  end
+
+  # digits = ("0" | /[1-9]/ /[0-9]/*)
+  def _digits
+
+    _save = self.pos
+    while true # choice
+      _tmp = match_string("0")
+      break if _tmp
+      self.pos = _save
+
+      _save1 = self.pos
+      while true # sequence
+        _tmp = scan(/\A(?-mix:[1-9])/)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        while true
+          _tmp = scan(/\A(?-mix:[0-9])/)
+          break unless _tmp
+        end
+        _tmp = true
+        unless _tmp
+          self.pos = _save1
+        end
+        break
+      end # end sequence
+
+      break if _tmp
+      self.pos = _save
+      break
+    end # end choice
+
+    set_failed_rule :_digits unless _tmp
+    return _tmp
+  end
+
+  # int = < digits > {number(text)}
+  def _int
+
+    _save = self.pos
+    while true # sequence
+      _text_start = self.pos
+      _tmp = apply(:_digits)
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; number(text); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_int unless _tmp
+    return _tmp
+  end
+
+  # real = < digits "." digits ("e" /[-+]/? /[0-9]/+)? > {number(text)}
+  def _real
+
+    _save = self.pos
+    while true # sequence
+      _text_start = self.pos
+
+      _save1 = self.pos
+      while true # sequence
+        _tmp = apply(:_digits)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = match_string(".")
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_digits)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _save2 = self.pos
+
+        _save3 = self.pos
+        while true # sequence
+          _tmp = match_string("e")
+          unless _tmp
+            self.pos = _save3
+            break
+          end
+          _save4 = self.pos
+          _tmp = scan(/\A(?-mix:[-+])/)
+          unless _tmp
+            _tmp = true
+            self.pos = _save4
+          end
+          unless _tmp
+            self.pos = _save3
+            break
+          end
+          _save5 = self.pos
+          _tmp = scan(/\A(?-mix:[0-9])/)
+          if _tmp
+            while true
+              _tmp = scan(/\A(?-mix:[0-9])/)
+              break unless _tmp
+            end
+            _tmp = true
+          else
+            self.pos = _save5
+          end
+          unless _tmp
+            self.pos = _save3
+          end
+          break
+        end # end sequence
+
+        unless _tmp
+          _tmp = true
+          self.pos = _save2
+        end
+        unless _tmp
+          self.pos = _save1
+        end
+        break
+      end # end sequence
+
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; number(text); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_real unless _tmp
+    return _tmp
+  end
+
+  # string = position "\"" < /[^\\"]*/ > "\"" {string_value(text)}
+  def _string
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_position)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = match_string("\"")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _text_start = self.pos
+      _tmp = scan(/\A(?-mix:[^\\"]*)/)
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = match_string("\"")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; string_value(text); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_string unless _tmp
+    return _tmp
+  end
+
+  # line = { current_line }
+  def _line
+    @result = begin;  current_line ; end
+    _tmp = true
+    set_failed_rule :_line unless _tmp
+    return _tmp
+  end
+
+  # column = { current_column }
+  def _column
+    @result = begin;  current_column ; end
+    _tmp = true
+    set_failed_rule :_column unless _tmp
+    return _tmp
+  end
+
+  # position = line:l column:c { position(l, c) }
+  def _position
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_line)
+      l = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_column)
+      c = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin;  position(l, c) ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_position unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "- value? - end")
+  Rules[:_end] = rule_info("end", "!.")
+  Rules[:__hyphen_] = rule_info("-", "(\" \" | \"\\t\" | \"\\n\")*")
+  Rules[:_value] = rule_info("value", "(string | number | boolean)")
+  Rules[:_boolean] = rule_info("boolean", "position (true | false | null | undefined)")
+  Rules[:_true] = rule_info("true", "\"true\" {true_value}")
+  Rules[:_false] = rule_info("false", "\"false\" {false_value}")
+  Rules[:_null] = rule_info("null", "\"null\" {null_value}")
+  Rules[:_undefined] = rule_info("undefined", "\"undefined\" {undefined_value}")
+  Rules[:_number] = rule_info("number", "position (real | hex | int)")
+  Rules[:_hexdigits] = rule_info("hexdigits", "/[0-9A-Fa-f]/")
+  Rules[:_hex] = rule_info("hex", "\"0x\" < hexdigits+ > {hexadecimal(text)}")
+  Rules[:_digits] = rule_info("digits", "(\"0\" | /[1-9]/ /[0-9]/*)")
+  Rules[:_int] = rule_info("int", "< digits > {number(text)}")
+  Rules[:_real] = rule_info("real", "< digits \".\" digits (\"e\" /[-+]/? /[0-9]/+)? > {number(text)}")
+  Rules[:_string] = rule_info("string", "position \"\\\"\" < /[^\\\\\"]*/ > \"\\\"\" {string_value(text)}")
+  Rules[:_line] = rule_info("line", "{ current_line }")
+  Rules[:_column] = rule_info("column", "{ current_column }")
+  Rules[:_position] = rule_info("position", "line:l column:c { position(l, c) }")
+end