atomy 0.1.1 → 0.6.3

data/lib/code_loader.rb

@@ -1,137 +0,0 @@
-require("stringio")
-
-module Atomy
-  class CodeLoader
-    class << self
-      def reason
-        @reason ||= :run
-      end
-
-      def reason=(x)
-        @reason = x
-      end
-
-      def when_load
-        @when_load ||= []
-      end
-
-      def when_load=(x)
-        @when_load = x
-      end
-
-      def compiled?
-        @compiled ||= false
-      end
-
-      def compiled!(x = false)
-        @compiled = x
-      end
-
-      def documentation
-        @documentation ||= false
-      end
-
-      def documentation=(x)
-        @documentation = x
-      end
-
-      def compiled_name(fn)
-        Atomy::Compiler.compiled_name(fn)
-      end
-
-      def source_name(fn)
-        if fn.suffix? ".compiled.ayc"
-          fn[0..-(".compiled.ayc".size)]
-        elsif fn.suffix? ".ayc"
-          fn[0..-2]
-        end
-      end
-
-      def docs_name(fn)
-        CodeLoader.documentation + "/" + File.basename(fn, ".ay") + ".ddl"
-      end
-
-      def compile_if_needed(fn, debug = false, docs = false)
-        source = source_name(fn)
-        compiled = compiled_name(fn)
-
-        if !File.exists?(compiled) ||
-            File.stat(compiled).mtime < File.stat(fn).mtime ||
-            CodeLoader.documentation
-          if CodeLoader.documentation
-            Thread.current[:atomy_documentation] = docs = StringIO.new
-            docs << "\\style{Atomy}\n\n"
-            before = docs.size
-          end
-
-          CodeLoader.compiled! true
-          Compiler.compile fn, nil, debug
-
-          if CodeLoader.documentation && docs.size > before
-            File.open(docs_name(fn), "w") do |f|
-              f.write(Thread.current[:atomy_documentation].string)
-            end
-          end
-        end
-
-        compiled
-      end
-
-      def find_file(fn)
-        if fn.suffix?(".ay") || fn.suffix?(".rb")
-          fn
-        elsif File.exists?(fn + ".ay")
-          fn + ".ay"
-        elsif File.exists?(fn + ".rb")
-          fn + ".rb"
-        else
-          fn
-        end
-      end
-
-      def loadable?(fn)
-        return false unless File.exists? fn
-
-        stat = File.stat fn
-        stat.file? && stat.readable?
-      end
-
-      def search_path(fn)
-        $LOAD_PATH.each do |dir|
-          path = find_file("#{dir}/#{fn}")
-          return path if loadable? path
-        end
-
-        nil
-      end
-
-      def qualified_path?(path)
-        path[0] == ?/ or path.prefix?("./") or path.prefix?("../")
-      end
-
-      def load_file(fn, r = :run, debug = false)
-        if qualified_path?(fn)
-          file = find_file(fn)
-        else
-          file = search_path(fn)
-        end
-
-        raise("cannot find file to load for #{fn}") unless file
-
-        return require(file) unless file.suffix?(".ay")
-
-        CodeLoader.when_load = []
-        CodeLoader.reason = r
-        CodeLoader.compiled! false
-
-        cfn = compile_if_needed(file, debug)
-        cl = Rubinius::CodeLoader.new(cfn)
-        cm = cl.load_compiled_file(cfn, 0)
-        script = cm.create_script(false)
-        script.file_path = fn
-
-        MAIN.__send__ :__script__
-      end
-    end
-  end
-end

data/lib/compiler/compiler.rb

@@ -1,155 +0,0 @@
-module Atomy
-  class Compiler < Rubinius::Compiler
-    attr_accessor :expander
-
-    def self.compiled_name(file)
-      if file.suffix? ".ay"
-        file + "c"
-      else
-        file + ".compiled.ayc"
-      end
-    end
-
-    def self.compile(file, output = nil, debug = false)
-      compiler = new :atomy_file, :compiled_file
-
-      parser = compiler.parser
-      parser.root Atomy::AST::Script
-      parser.input file, 1
-
-      if debug
-        printer = compiler.packager.print
-        printer.bytecode = debug
-      end
-
-      writer = compiler.writer
-      writer.name = output ? output : compiled_name(file)
-
-      compiler.run
-    end
-
-    def self.compile_file(file, debug = false)
-      compiler = new :atomy_file, :compiled_method
-
-      parser = compiler.parser
-      parser.root Atomy::AST::Script
-      parser.input file, 1
-
-      printer = compiler.packager.print
-      printer.bytecode = debug
-
-      compiler.run
-    end
-
-    def self.compile_string(string, file = "(eval)", line = 1, debug = false)
-      compiler = new :atomy_string, :compiled_method
-
-      parser = compiler.parser
-      parser.root Rubinius::AST::Script
-      parser.input string, file, line
-
-      if debug
-        printer = compiler.packager.print
-        printer.bytecode = debug
-      end
-
-      compiler.run
-    end
-
-    def self.compile_eval(string, scope = nil, file = "(eval)", line = 1, debug = false)
-      compiler = new :atomy_string, :compiled_method
-
-      parser = compiler.parser
-      parser.root Rubinius::AST::EvalExpression
-      parser.input string, file, line
-
-      if debug
-        printer = compiler.packager.print
-        printer.bytecode = debug
-      end
-
-      compiler.generator.variable_scope = scope
-
-      compiler.run
-    end
-
-    def self.compile_node(node, scope = nil, file = "(eval)", line = 1, debug = false)
-      compiler = new :atomy_bytecode, :compiled_method
-
-      eval = Rubinius::AST::EvalExpression.new(AST::Tree.new([node]))
-      eval.file = file
-
-      if debug
-        printer = compiler.packager.print
-        printer.bytecode = debug
-      end
-
-      compiler.generator.input eval
-      compiler.generator.variable_scope = scope
-
-      compiler.run
-    end
-
-    def self.evaluate_node(node, instance = nil, bnd = nil, file = "(eval)", line = 1)
-      if bnd.nil?
-        bnd = Binding.setup(
-          Rubinius::VariableScope.of_sender,
-          Rubinius::CompiledMethod.of_sender,
-          Rubinius::StaticScope.of_sender
-        )
-      end
-
-      cm = compile_node(node, bnd.variables, file, line)
-      cm.scope = bnd.static_scope.dup
-      cm.name = :__atomy_eval__
-
-      script = Rubinius::CompiledMethod::Script.new(cm, file, true)
-      script.eval_binding = bnd
-
-      cm.scope.script = script
-
-      be = Rubinius::BlockEnvironment.new
-      be.under_context(bnd.variables, cm)
-
-      if bnd.from_proc?
-        be.proc_environment = bnd.proc_environment
-      end
-
-      if instance
-        be.call_on_instance instance
-      else
-        be.call
-      end
-    end
-
-    def self.evaluate(string, bnd = nil, file = "(eval)", line = 1, debug = false)
-      if bnd.nil?
-        bnd = Binding.setup(
-          Rubinius::VariableScope.of_sender,
-          Rubinius::CompiledMethod.of_sender,
-          Rubinius::StaticScope.of_sender
-        )
-      end
-
-      cm = compile_eval(string, bnd.variables, file, line, debug)
-      cm.scope = bnd.static_scope.dup
-      cm.name = :__eval__
-
-      script = Rubinius::CompiledMethod::Script.new(cm, file, true)
-      script.eval_binding = bnd
-      script.eval_source = string
-
-      cm.scope.script = script
-
-      be = Rubinius::BlockEnvironment.new
-      be.under_context(bnd.variables, cm)
-
-      if bnd.from_proc?
-        be.proc_environment = bnd.proc_environment
-      end
-
-      be.from_eval!
-      be.call
-    end
-  end
-end

data/lib/compiler/stages.rb

@@ -1,81 +0,0 @@
-module Atomy
-  class Compiler
-    class Generator < Rubinius::Compiler::Stage
-      stage :atomy_bytecode
-      next_stage Rubinius::Compiler::Encoder
-
-      attr_accessor :variable_scope
-
-      def initialize(compiler, last)
-        super
-        @variable_scope = nil
-        compiler.generator = self
-      end
-
-      def run
-        @output = Rubinius::Generator.new
-        @input.variable_scope = @variable_scope
-        @input.bytecode @output
-        @output.close
-        run_next
-      end
-
-      def input(root)
-        @input = root
-      end
-    end
-
-    class Parser < Rubinius::Compiler::Stage
-      stage :atomy_parser
-      next_stage Generator
-
-      def initialize(compiler, last)
-        super
-        compiler.parser = self
-      end
-
-      def root(root)
-        @root = root
-      end
-
-      def print
-        @print = true
-      end
-
-      def input(code, file = "(eval)", line = 1)
-        @input = code
-        @file = file
-        @line = line
-      end
-
-      def run
-        @output = @root.new parse
-        @output.file = @file
-        run_next
-      end
-    end
-
-    class FileParser < Parser
-      stage :atomy_file
-      next_stage Generator
-
-      def input(file, line = 1)
-        @file = file
-        @line = line
-      end
-
-      def parse
-        Atomy::Parser.parse_file(@file)
-      end
-    end
-
-    class StringParser < Parser
-      stage :atomy_string
-      next_stage Generator
-
-      def parse
-        Atomy::Parser.parse_string(@input)
-      end
-    end
-  end
-end

data/lib/formatter.kpeg.rb

@@ -1,1394 +0,0 @@
-class Atomy::Format::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 :failing_rule_offset
-    attr_accessor :result, :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
-          other.result = @result
-        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
-
-    #
-
-
-    require File.expand_path("../atomy.kpeg.rb", __FILE__)
-    include Atomy::Format
-
-    def create(x, *as)
-      as << []
-      x.send(:new, 1, *as)
-    end
-
-
-  def setup_foreign_grammar
-    @_grammar_atomy = Atomy::Parser.new(nil)
-  end
-
-  # line = { current_line }
-  def _line
-    @result = begin;  current_line ; end
-    _tmp = true
-    set_failed_rule :_line unless _tmp
-    return _tmp
-  end
-
-  # text = (< /[^\\%#{Regexp.quote(e)}]+/ > { text } | "\\" < /[%\(\)\{\}\[\]]/ > { text } | "\\" %atomy.escape:e { e })
-  def _text(e)
-
-    _save = self.pos
-    while true # choice
-
-      _save1 = self.pos
-      while true # sequence
-        _text_start = self.pos
-        _tmp = scan(/\A(?-mix:[^\\%#{Regexp.quote(e)}]+)/)
-        if _tmp
-          text = get_text(_text_start)
-        end
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        @result = begin;  text ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save1
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save2 = self.pos
-      while true # sequence
-        _tmp = match_string("\\")
-        unless _tmp
-          self.pos = _save2
-          break
-        end
-        _text_start = self.pos
-        _tmp = scan(/\A(?-mix:[%\(\)\{\}\[\]])/)
-        if _tmp
-          text = get_text(_text_start)
-        end
-        unless _tmp
-          self.pos = _save2
-          break
-        end
-        @result = begin;  text ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save2
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save3 = self.pos
-      while true # sequence
-        _tmp = match_string("\\")
-        unless _tmp
-          self.pos = _save3
-          break
-        end
-        _tmp = @_grammar_atomy.external_invoke(self, :_escape)
-        e = @result
-        unless _tmp
-          self.pos = _save3
-          break
-        end
-        @result = begin;  e ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save3
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-      break
-    end # end choice
-
-    set_failed_rule :_text unless _tmp
-    return _tmp
-  end
-
-  # nested = text(e)+:c { Chunk.new(0, [], c.join) }
-  def _nested(e)
-
-    _save = self.pos
-    while true # sequence
-      _save1 = self.pos
-      _ary = []
-      _tmp = _text(e)
-      if _tmp
-        _ary << @result
-        while true
-          _tmp = _text(e)
-          _ary << @result if _tmp
-          break unless _tmp
-        end
-        _tmp = true
-        @result = _ary
-      else
-        self.pos = _save1
-      end
-      c = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      @result = begin;  Chunk.new(0, [], c.join) ; end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-      end
-      break
-    end # end sequence
-
-    set_failed_rule :_nested unless _tmp
-    return _tmp
-  end
-
-  # chunk = nested("")
-  def _chunk
-    _tmp = _nested("")
-    set_failed_rule :_chunk unless _tmp
-    return _tmp
-  end
-
-  # flagged = "%" flag*:fs segment:s { s.flags = fs; s }
-  def _flagged
-
-    _save = self.pos
-    while true # sequence
-      _tmp = match_string("%")
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      _ary = []
-      while true
-        _tmp = apply(:_flag)
-        _ary << @result if _tmp
-        break unless _tmp
-      end
-      _tmp = true
-      @result = _ary
-      fs = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      _tmp = apply(:_segment)
-      s = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      @result = begin;  s.flags = fs; s ; end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-      end
-      break
-    end # end sequence
-
-    set_failed_rule :_flagged unless _tmp
-    return _tmp
-  end
-
-  # flag = ("#" { Number.new(0, nil) } | "0" &("." /\d/ | /\d/) { ZeroPad.new(0) } | "." < /\d+/ > { Precision.new(0, text.to_i) } | < /\d+/ > { Number.new(0, text.to_i) } | < /[\.\+\*=<>,\?]/ > { Symbol.new(0, text) })
-  def _flag
-
-    _save = self.pos
-    while true # choice
-
-      _save1 = self.pos
-      while true # sequence
-        _tmp = match_string("#")
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        @result = begin;  Number.new(0, nil) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save1
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save2 = self.pos
-      while true # sequence
-        _tmp = match_string("0")
-        unless _tmp
-          self.pos = _save2
-          break
-        end
-        _save3 = self.pos
-
-        _save4 = self.pos
-        while true # choice
-
-          _save5 = self.pos
-          while true # sequence
-            _tmp = match_string(".")
-            unless _tmp
-              self.pos = _save5
-              break
-            end
-            _tmp = scan(/\A(?-mix:\d)/)
-            unless _tmp
-              self.pos = _save5
-            end
-            break
-          end # end sequence
-
-          break if _tmp
-          self.pos = _save4
-          _tmp = scan(/\A(?-mix:\d)/)
-          break if _tmp
-          self.pos = _save4
-          break
-        end # end choice
-
-        self.pos = _save3
-        unless _tmp
-          self.pos = _save2
-          break
-        end
-        @result = begin;  ZeroPad.new(0) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save2
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save6 = self.pos
-      while true # sequence
-        _tmp = match_string(".")
-        unless _tmp
-          self.pos = _save6
-          break
-        end
-        _text_start = self.pos
-        _tmp = scan(/\A(?-mix:\d+)/)
-        if _tmp
-          text = get_text(_text_start)
-        end
-        unless _tmp
-          self.pos = _save6
-          break
-        end
-        @result = begin;  Precision.new(0, text.to_i) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save6
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save7 = self.pos
-      while true # sequence
-        _text_start = self.pos
-        _tmp = scan(/\A(?-mix:\d+)/)
-        if _tmp
-          text = get_text(_text_start)
-        end
-        unless _tmp
-          self.pos = _save7
-          break
-        end
-        @result = begin;  Number.new(0, text.to_i) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save7
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save8 = self.pos
-      while true # sequence
-        _text_start = self.pos
-        _tmp = scan(/\A(?-mix:[\.\+\*=<>,\?])/)
-        if _tmp
-          text = get_text(_text_start)
-        end
-        unless _tmp
-          self.pos = _save8
-          break
-        end
-        @result = begin;  Symbol.new(0, text) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save8
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-      break
-    end # end choice
-
-    set_failed_rule :_flag unless _tmp
-    return _tmp
-  end
-
-  # segment = ("p" "(" sub(")"):s ")" ("(" sub(")"):p ")")? { Pluralize.new(0, s, [], p) } | "l" "(" sub(")"):c ")" { create(Lowercase, c) } | "c" "(" sub(")"):c ")" { create(Capitalize, c) } | "u" "(" sub(")"):c ")" { create(Uppercase, c) } | "j" ("(" sub(")"):c ")" { c })+:cs { create(Justify, cs) } | "{" sub("}"):c "}" { create(Iterate, c) } | ("[" sub("]"):c "]" { c })+:bs ("(" sub(")"):d ")" { d })? { Conditional.new(0, Array(bs), [], d) } | "_" { create(Skip) } | "^" { create(Break) } | "%" { create(Indirection) } | "s" { create(String) } | "d" { create(Decimal) } | "x" { create(Hex) } | "o" { create(Octal) } | "b" { create(Binary) } | "r" { create(Radix) } | "f" { create(Float) } | "e" { create(Exponent) } | "g" { create(General) } | "c" { create(Character) } | "v" { create(Any) })
-  def _segment
-
-    _save = self.pos
-    while true # choice
-
-      _save1 = self.pos
-      while true # sequence
-        _tmp = match_string("p")
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        _tmp = match_string("(")
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        _tmp = _sub(")")
-        s = @result
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        _tmp = match_string(")")
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        _save2 = self.pos
-
-        _save3 = self.pos
-        while true # sequence
-          _tmp = match_string("(")
-          unless _tmp
-            self.pos = _save3
-            break
-          end
-          _tmp = _sub(")")
-          p = @result
-          unless _tmp
-            self.pos = _save3
-            break
-          end
-          _tmp = match_string(")")
-          unless _tmp
-            self.pos = _save3
-          end
-          break
-        end # end sequence
-
-        unless _tmp
-          _tmp = true
-          self.pos = _save2
-        end
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        @result = begin;  Pluralize.new(0, s, [], p) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save1
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save4 = self.pos
-      while true # sequence
-        _tmp = match_string("l")
-        unless _tmp
-          self.pos = _save4
-          break
-        end
-        _tmp = match_string("(")
-        unless _tmp
-          self.pos = _save4
-          break
-        end
-        _tmp = _sub(")")
-        c = @result
-        unless _tmp
-          self.pos = _save4
-          break
-        end
-        _tmp = match_string(")")
-        unless _tmp
-          self.pos = _save4
-          break
-        end
-        @result = begin;  create(Lowercase, c) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save4
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save5 = self.pos
-      while true # sequence
-        _tmp = match_string("c")
-        unless _tmp
-          self.pos = _save5
-          break
-        end
-        _tmp = match_string("(")
-        unless _tmp
-          self.pos = _save5
-          break
-        end
-        _tmp = _sub(")")
-        c = @result
-        unless _tmp
-          self.pos = _save5
-          break
-        end
-        _tmp = match_string(")")
-        unless _tmp
-          self.pos = _save5
-          break
-        end
-        @result = begin;  create(Capitalize, c) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save5
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save6 = self.pos
-      while true # sequence
-        _tmp = match_string("u")
-        unless _tmp
-          self.pos = _save6
-          break
-        end
-        _tmp = match_string("(")
-        unless _tmp
-          self.pos = _save6
-          break
-        end
-        _tmp = _sub(")")
-        c = @result
-        unless _tmp
-          self.pos = _save6
-          break
-        end
-        _tmp = match_string(")")
-        unless _tmp
-          self.pos = _save6
-          break
-        end
-        @result = begin;  create(Uppercase, c) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save6
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save7 = self.pos
-      while true # sequence
-        _tmp = match_string("j")
-        unless _tmp
-          self.pos = _save7
-          break
-        end
-        _save8 = self.pos
-        _ary = []
-
-        _save9 = self.pos
-        while true # sequence
-          _tmp = match_string("(")
-          unless _tmp
-            self.pos = _save9
-            break
-          end
-          _tmp = _sub(")")
-          c = @result
-          unless _tmp
-            self.pos = _save9
-            break
-          end
-          _tmp = match_string(")")
-          unless _tmp
-            self.pos = _save9
-            break
-          end
-          @result = begin;  c ; end
-          _tmp = true
-          unless _tmp
-            self.pos = _save9
-          end
-          break
-        end # end sequence
-
-        if _tmp
-          _ary << @result
-          while true
-
-            _save10 = self.pos
-            while true # sequence
-              _tmp = match_string("(")
-              unless _tmp
-                self.pos = _save10
-                break
-              end
-              _tmp = _sub(")")
-              c = @result
-              unless _tmp
-                self.pos = _save10
-                break
-              end
-              _tmp = match_string(")")
-              unless _tmp
-                self.pos = _save10
-                break
-              end
-              @result = begin;  c ; end
-              _tmp = true
-              unless _tmp
-                self.pos = _save10
-              end
-              break
-            end # end sequence
-
-            _ary << @result if _tmp
-            break unless _tmp
-          end
-          _tmp = true
-          @result = _ary
-        else
-          self.pos = _save8
-        end
-        cs = @result
-        unless _tmp
-          self.pos = _save7
-          break
-        end
-        @result = begin;  create(Justify, cs) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save7
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save11 = self.pos
-      while true # sequence
-        _tmp = match_string("{")
-        unless _tmp
-          self.pos = _save11
-          break
-        end
-        _tmp = _sub("}")
-        c = @result
-        unless _tmp
-          self.pos = _save11
-          break
-        end
-        _tmp = match_string("}")
-        unless _tmp
-          self.pos = _save11
-          break
-        end
-        @result = begin;  create(Iterate, c) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save11
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save12 = self.pos
-      while true # sequence
-        _save13 = self.pos
-        _ary = []
-
-        _save14 = self.pos
-        while true # sequence
-          _tmp = match_string("[")
-          unless _tmp
-            self.pos = _save14
-            break
-          end
-          _tmp = _sub("]")
-          c = @result
-          unless _tmp
-            self.pos = _save14
-            break
-          end
-          _tmp = match_string("]")
-          unless _tmp
-            self.pos = _save14
-            break
-          end
-          @result = begin;  c ; end
-          _tmp = true
-          unless _tmp
-            self.pos = _save14
-          end
-          break
-        end # end sequence
-
-        if _tmp
-          _ary << @result
-          while true
-
-            _save15 = self.pos
-            while true # sequence
-              _tmp = match_string("[")
-              unless _tmp
-                self.pos = _save15
-                break
-              end
-              _tmp = _sub("]")
-              c = @result
-              unless _tmp
-                self.pos = _save15
-                break
-              end
-              _tmp = match_string("]")
-              unless _tmp
-                self.pos = _save15
-                break
-              end
-              @result = begin;  c ; end
-              _tmp = true
-              unless _tmp
-                self.pos = _save15
-              end
-              break
-            end # end sequence
-
-            _ary << @result if _tmp
-            break unless _tmp
-          end
-          _tmp = true
-          @result = _ary
-        else
-          self.pos = _save13
-        end
-        bs = @result
-        unless _tmp
-          self.pos = _save12
-          break
-        end
-        _save16 = self.pos
-
-        _save17 = self.pos
-        while true # sequence
-          _tmp = match_string("(")
-          unless _tmp
-            self.pos = _save17
-            break
-          end
-          _tmp = _sub(")")
-          d = @result
-          unless _tmp
-            self.pos = _save17
-            break
-          end
-          _tmp = match_string(")")
-          unless _tmp
-            self.pos = _save17
-            break
-          end
-          @result = begin;  d ; end
-          _tmp = true
-          unless _tmp
-            self.pos = _save17
-          end
-          break
-        end # end sequence
-
-        unless _tmp
-          _tmp = true
-          self.pos = _save16
-        end
-        unless _tmp
-          self.pos = _save12
-          break
-        end
-        @result = begin;  Conditional.new(0, Array(bs), [], d) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save12
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save18 = self.pos
-      while true # sequence
-        _tmp = match_string("_")
-        unless _tmp
-          self.pos = _save18
-          break
-        end
-        @result = begin;  create(Skip) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save18
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save19 = self.pos
-      while true # sequence
-        _tmp = match_string("^")
-        unless _tmp
-          self.pos = _save19
-          break
-        end
-        @result = begin;  create(Break) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save19
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save20 = self.pos
-      while true # sequence
-        _tmp = match_string("%")
-        unless _tmp
-          self.pos = _save20
-          break
-        end
-        @result = begin;  create(Indirection) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save20
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save21 = self.pos
-      while true # sequence
-        _tmp = match_string("s")
-        unless _tmp
-          self.pos = _save21
-          break
-        end
-        @result = begin;  create(String) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save21
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save22 = self.pos
-      while true # sequence
-        _tmp = match_string("d")
-        unless _tmp
-          self.pos = _save22
-          break
-        end
-        @result = begin;  create(Decimal) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save22
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save23 = self.pos
-      while true # sequence
-        _tmp = match_string("x")
-        unless _tmp
-          self.pos = _save23
-          break
-        end
-        @result = begin;  create(Hex) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save23
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save24 = self.pos
-      while true # sequence
-        _tmp = match_string("o")
-        unless _tmp
-          self.pos = _save24
-          break
-        end
-        @result = begin;  create(Octal) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save24
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save25 = self.pos
-      while true # sequence
-        _tmp = match_string("b")
-        unless _tmp
-          self.pos = _save25
-          break
-        end
-        @result = begin;  create(Binary) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save25
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save26 = self.pos
-      while true # sequence
-        _tmp = match_string("r")
-        unless _tmp
-          self.pos = _save26
-          break
-        end
-        @result = begin;  create(Radix) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save26
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save27 = self.pos
-      while true # sequence
-        _tmp = match_string("f")
-        unless _tmp
-          self.pos = _save27
-          break
-        end
-        @result = begin;  create(Float) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save27
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save28 = self.pos
-      while true # sequence
-        _tmp = match_string("e")
-        unless _tmp
-          self.pos = _save28
-          break
-        end
-        @result = begin;  create(Exponent) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save28
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save29 = self.pos
-      while true # sequence
-        _tmp = match_string("g")
-        unless _tmp
-          self.pos = _save29
-          break
-        end
-        @result = begin;  create(General) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save29
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save30 = self.pos
-      while true # sequence
-        _tmp = match_string("c")
-        unless _tmp
-          self.pos = _save30
-          break
-        end
-        @result = begin;  create(Character) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save30
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-
-      _save31 = self.pos
-      while true # sequence
-        _tmp = match_string("v")
-        unless _tmp
-          self.pos = _save31
-          break
-        end
-        @result = begin;  create(Any) ; end
-        _tmp = true
-        unless _tmp
-          self.pos = _save31
-        end
-        break
-      end # end sequence
-
-      break if _tmp
-      self.pos = _save
-      break
-    end # end choice
-
-    set_failed_rule :_segment unless _tmp
-    return _tmp
-  end
-
-  # sub = (flagged | nested(e))*:as { Array(as) } { Formatter.new(0, Array(as)) }
-  def _sub(e)
-
-    _save = self.pos
-    while true # sequence
-      _ary = []
-      while true
-
-        _save2 = self.pos
-        while true # choice
-          _tmp = apply(:_flagged)
-          break if _tmp
-          self.pos = _save2
-          _tmp = _nested(e)
-          break if _tmp
-          self.pos = _save2
-          break
-        end # end choice
-
-        _ary << @result if _tmp
-        break unless _tmp
-      end
-      _tmp = true
-      @result = _ary
-      as = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      @result = begin;  Array(as) ; end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      @result = begin;  Formatter.new(0, Array(as)) ; end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-      end
-      break
-    end # end sequence
-
-    set_failed_rule :_sub unless _tmp
-    return _tmp
-  end
-
-  # root = sub("")
-  def _root
-    _tmp = _sub("")
-    set_failed_rule :_root unless _tmp
-    return _tmp
-  end
-
-  Rules = {}
-  Rules[:_line] = rule_info("line", "{ current_line }")
-  Rules[:_text] = rule_info("text", "(< /[^\\\\%\#{Regexp.quote(e)}]+/ > { text } | \"\\\\\" < /[%\\(\\)\\{\\}\\[\\]]/ > { text } | \"\\\\\" %atomy.escape:e { e })")
-  Rules[:_nested] = rule_info("nested", "text(e)+:c { Chunk.new(0, [], c.join) }")
-  Rules[:_chunk] = rule_info("chunk", "nested(\"\")")
-  Rules[:_flagged] = rule_info("flagged", "\"%\" flag*:fs segment:s { s.flags = fs; s }")
-  Rules[:_flag] = rule_info("flag", "(\"\#\" { Number.new(0, nil) } | \"0\" &(\".\" /\\d/ | /\\d/) { ZeroPad.new(0) } | \".\" < /\\d+/ > { Precision.new(0, text.to_i) } | < /\\d+/ > { Number.new(0, text.to_i) } | < /[\\.\\+\\*=<>,\\?]/ > { Symbol.new(0, text) })")
-  Rules[:_segment] = rule_info("segment", "(\"p\" \"(\" sub(\")\"):s \")\" (\"(\" sub(\")\"):p \")\")? { Pluralize.new(0, s, [], p) } | \"l\" \"(\" sub(\")\"):c \")\" { create(Lowercase, c) } | \"c\" \"(\" sub(\")\"):c \")\" { create(Capitalize, c) } | \"u\" \"(\" sub(\")\"):c \")\" { create(Uppercase, c) } | \"j\" (\"(\" sub(\")\"):c \")\" { c })+:cs { create(Justify, cs) } | \"{\" sub(\"}\"):c \"}\" { create(Iterate, c) } | (\"[\" sub(\"]\"):c \"]\" { c })+:bs (\"(\" sub(\")\"):d \")\" { d })? { Conditional.new(0, Array(bs), [], d) } | \"_\" { create(Skip) } | \"^\" { create(Break) } | \"%\" { create(Indirection) } | \"s\" { create(String) } | \"d\" { create(Decimal) } | \"x\" { create(Hex) } | \"o\" { create(Octal) } | \"b\" { create(Binary) } | \"r\" { create(Radix) } | \"f\" { create(Float) } | \"e\" { create(Exponent) } | \"g\" { create(General) } | \"c\" { create(Character) } | \"v\" { create(Any) })")
-  Rules[:_sub] = rule_info("sub", "(flagged | nested(e))*:as { Array(as) } { Formatter.new(0, Array(as)) }")
-  Rules[:_root] = rule_info("root", "sub(\"\")")
-end