kpeg 0.7

data/test/test_kpeg.rb

@@ -0,0 +1,416 @@
+require 'test/unit'
+require 'kpeg'
+require 'stringio'
+
+class TestKPeg < Test::Unit::TestCase
+  def assert_match(m, str)
+    assert_kind_of KPeg::MatchString, m
+    assert_equal str, m.string
+  end
+
+  def test_dot
+    gram = KPeg.grammar do |g|
+      g.root = g.dot
+    end
+
+    assert_match KPeg.match("q", gram), "q"
+  end
+
+  def test_str
+    gram = KPeg.grammar do |g|
+      g.root = g.str("hello")
+    end
+
+    assert_match KPeg.match("hello", gram), "hello"
+    assert_equal nil, KPeg.match("vador", gram)
+  end
+
+  def test_reg
+    gram = KPeg.grammar do |g|
+      g.root = g.reg(/[0-9]/)
+    end
+
+    assert_match KPeg.match("3", gram), "3"
+  end
+
+  def test_char_range
+    gram = KPeg.grammar do |g|
+      g.root = g.range('0', '9')
+    end
+
+    assert_match KPeg.match("3", gram), "3"
+  end
+
+  def test_any
+    gram = KPeg.grammar do |g|
+      g.root = g.any g.str("hello"), g.str("chicken")
+    end
+
+    assert_match KPeg.match("hello", gram), "hello"
+    assert_match KPeg.match("chicken", gram), "chicken"
+    assert_equal nil, KPeg.match("vador", gram)
+  end
+
+  def test_maybe
+    gram = KPeg.grammar do |g|
+      g.root = g.maybe g.str("hello")
+    end
+
+    m = KPeg.match "hello", gram
+    assert_kind_of KPeg::Match, m
+    assert_equal 1, m.matches.size
+    assert_match m.matches[0], "hello"
+
+    m = KPeg.match "surprise", gram
+    assert_kind_of KPeg::Match, m
+    assert_equal 0, m.matches.size
+  end
+
+  def test_many
+    gram = KPeg.grammar do |g|
+      g.root = g.many g.str("run")
+    end
+
+    m = KPeg.match "runrunrun", gram
+    assert_kind_of KPeg::Match, m
+    assert_equal 3, m.matches.size
+    m.matches.each do |sm|
+      assert_match sm, "run"
+    end
+
+    assert_equal nil, KPeg.match("vador", gram)
+  end
+
+  def test_kleene
+    gram = KPeg.grammar do |g|
+      g.root = g.kleene g.str("run")
+    end
+
+    m = KPeg.match "runrunrun", gram
+    assert_kind_of KPeg::Match, m
+    assert_equal 3, m.matches.size
+    m.matches.each do |sm|
+      assert_match sm, "run"
+    end
+
+    m = KPeg.match "chicken", gram
+    assert_kind_of KPeg::Match, m
+    assert_equal 0, m.matches.size
+  end
+
+  def test_multiple
+    gram = KPeg.grammar do |g|
+      g.root = g.multiple g.str("run"), 2, 4
+    end
+
+    m = KPeg.match "runrun", gram
+    assert_kind_of KPeg::Match, m
+    assert_equal 2, m.matches.size
+    m.matches.each do |sm|
+      assert_match sm, "run"
+    end
+
+    m = KPeg.match "runrunrun", gram
+    assert_kind_of KPeg::Match, m
+    assert_equal 3, m.matches.size
+    m.matches.each do |sm|
+      assert_match sm, "run"
+    end
+
+    m = KPeg.match "runrunrunrun", gram
+    assert_kind_of KPeg::Match, m
+    assert_equal 4, m.matches.size
+    m.matches.each do |sm|
+      assert_match sm, "run"
+    end
+
+    assert_equal nil, KPeg.match("run", gram) 
+    assert_equal nil, KPeg.match("runrunrunrunrun", gram) 
+    assert_equal nil, KPeg.match("vador", gram) 
+  end
+
+  def test_seq
+    gram = KPeg.grammar do |g|
+      g.root = g.seq g.str("hello"), g.str(", world")
+    end
+
+    m = KPeg.match "hello, world", gram
+    assert_kind_of KPeg::Match, m
+    assert_match m.matches[0], "hello"
+    assert_match m.matches[1], ", world"
+
+    assert_equal m.value, ["hello", ", world"]
+
+    assert_equal nil, KPeg.match("vador", gram)
+    assert_equal nil, KPeg.match("hello, vador", gram)
+  end
+
+  def test_andp
+    gram = KPeg.grammar do |g|
+      g.root = g.seq g.andp(g.str("h")), g.str("hello")
+    end
+
+    m = KPeg.match "hello", gram
+    assert_equal m.matches.size, 2
+    assert_match m.matches[0], ""
+    assert_match m.matches[1], "hello"
+  end
+
+  def test_notp
+    gram = KPeg.grammar do |g|
+      g.root = g.seq g.notp(g.str("g")), g.str("hello")
+    end
+
+    m = KPeg.match "hello", gram
+    assert_equal m.matches.size, 2
+    assert_match m.matches[0], ""
+    assert_match m.matches[1], "hello"
+  end
+
+  def test_ref
+    gram = KPeg.grammar do |g|
+      g.greeting = g.str("hello")
+      g.root = g.ref "greeting"
+    end
+
+    m = KPeg.match "hello", gram
+    assert_match m, "hello"
+  end
+
+  def test_invoke
+    gram = KPeg.grammar do |g|
+      g.greeting = g.str("hello")
+      g.root = g.invoke "greeting"
+    end
+
+    m = KPeg.match "hello", gram
+    assert_match m, "hello"
+  end
+
+  def test_foreign_ref
+    g1 = KPeg.grammar do |g|
+      g.greeting = "hello"
+    end
+
+    g2 = KPeg.grammar do |g|
+      g.root = g.ref("greeting", g1)
+    end
+
+    m = KPeg.match "hello", g2
+    assert_match m, "hello"
+  end
+
+  def test_foreign_ref_with_ref
+    g1 = KPeg.grammar do |g|
+      g.name = ", evan"
+      g.greeting = g.seq("hello", :name)
+    end
+
+    g2 = KPeg.grammar do |g|
+      g.root = g.ref("greeting", g1)
+    end
+
+    m = KPeg.match "hello, evan", g2
+    assert_match m.matches[0], "hello"
+    assert_match m.matches[1], ", evan"
+  end
+
+  def test_tag_with_name
+    gram = KPeg.grammar do |g|
+      g.root = g.seq(" ", g.t("hello", "greeting"))
+    end
+
+    m = KPeg.match " hello", gram
+
+    assert_equal 2, m.matches.size
+    tag = m.matches[1]
+    assert_kind_of KPeg::Tag, tag.op
+    assert_equal 1, tag.matches.size
+    assert_match tag.matches[0], "hello"
+
+    # show that tag influences the value of the sequence
+    assert_equal m.value, "hello"
+  end
+
+  def test_tag_without_name
+    gram = KPeg.grammar do |g|
+      g.root = g.seq(" ", g.t("hello"))
+    end
+
+    m = KPeg.match " hello", gram
+    assert_equal m.value, "hello"
+  end
+
+  def test_action
+    gram = KPeg.grammar do |g|
+      g.root = g.seq("hello", g.action("b + c"))
+    end
+
+    m = KPeg.match "hello", gram
+    assert_equal 2, m.matches.size
+    assert_match m.matches[0], "hello"
+
+    action = m.matches[1]
+    assert_equal action.op.action, "b + c"
+  end
+
+  def test_naming
+    gram = KPeg.grammar do |g|
+      g.greeting = g.str("hello")
+      g.root = g.greeting
+    end
+
+    m = KPeg.match "hello", gram
+    assert_match m, "hello"
+  end
+
+  def test_matching_curly
+    gram = KPeg.grammar do |g|
+      g.curly = g.seq("{", g.kleene(g.any(/[^{}]+/, :curly)), "}")
+      g.root = :curly
+    end
+
+    m = KPeg.match "{ hello }", gram
+    assert_match m.matches[0], "{"
+    assert_match m.matches[1].matches[0], " hello "
+    assert_match m.matches[2], "}"
+
+    parc = KPeg::Parser.new "{ foo { bar } }", gram
+    m = parc.parse
+    assert_equal "{ foo { bar } }", m.total_string
+
+    parc = KPeg::Parser.new "{ foo {\nbar }\n }", gram
+    m = parc.parse
+    assert_equal "{ foo {\nbar }\n }", m.total_string
+  end
+
+  def test_collect
+    gram = KPeg.grammar do |g|
+      g.root = g.collect(g.many(/[a-z]/))
+    end
+
+    m = KPeg.match "hellomatch", gram
+    assert_equal "hellomatch", m.value
+  end
+
+  def test_memoization
+    gram = KPeg.grammar do |g|
+      g.one = g.str("1")
+      g.two = g.str("2")
+
+      g.root = g.any(
+        [:one, "-", :two],
+        [:one, "+", :two]
+        )
+    end
+
+    parser = KPeg::Parser.new "1+2", gram
+    m = parser.parse
+
+    assert_equal 3, m.matches.size
+    assert_match m.matches[0], "1"
+    assert_match m.matches[1], "+"
+    assert_match m.matches[2], "2"
+
+    one = gram.find("one")
+    two = gram.find("two")
+
+    # We try 1 twice
+    assert_equal 2, parser.memoizations[one][0].uses
+
+    # but we only get as far as 2 once
+    assert_equal 1, parser.memoizations[two][2].uses
+  end
+
+  def test_left_recursion
+    gram = KPeg.grammar do |g|
+      g.num  = g.reg(/[0-9]/)
+      g.expr = g.any [:expr, "-", :num], :num
+
+      g.root = g.expr
+    end
+
+    parser = KPeg::Parser.new "1-2-3", gram
+
+    m = parser.parse
+    assert_equal 3, m.matches.size
+
+    left = m.matches[0]
+    assert_equal 3, left.matches.size
+    assert_match left.matches[0], "1"
+    assert_match left.matches[1], "-"
+    assert_match left.matches[2], "2"
+    assert_match m.matches[1], "-"
+    assert_match m.matches[2], "3"
+
+    parser = KPeg::Parser.new "hello", gram
+    m = parser.parse
+
+    assert_equal nil, m
+  end
+
+  def test_math_grammar
+    gram = KPeg.grammar do |g|
+      g.num = '0'..'9'
+      g.term = g.seq(:term, "+", :term) \
+             | g.seq(:term, "-", :term) \
+             | :fact
+
+      g.fact = g.seq(:fact, "*", :fact) \
+             | g.seq(:fact, "/", :fact) \
+             | :num
+
+      g.root = g.term
+    end
+
+    sub = KPeg.match "4*3-8/9", gram
+    mul = sub.matches[0]
+    div = sub.matches[2]
+
+    assert_match mul.matches[0], "4"
+    assert_match mul.matches[1], "*"
+    assert_match mul.matches[2], "3"
+
+    assert_match sub.matches[1], "-"
+
+    assert_match div.matches[0], "8"
+    assert_match div.matches[1], "/"
+    assert_match div.matches[2], "9"
+  end
+
+  def test_calc
+    vars = {}
+    gram = KPeg.grammar do |g|
+      g.spaces = /\s*/
+      g.var = 'a'..'z'
+      g.num = g.lit(/[0-9]+/) { |i| i.to_i }
+
+      g.pri = g.seq(:spaces, :var)   { |s,v| vars[v] } \
+            | g.seq(:spaces, :num)   { |s,n| n }       \
+            | g.seq('(', :expr, ')') { |_,e,_| e }
+
+      g.mul = g.seq(:mul, "*", :pri) { |x,_,y| x * y } \
+            | g.seq(:mul, "/", :pri) { |x,_,y| x / y } \
+            | :pri
+
+      g.add = g.seq(:add, "+", :mul) { |x,_,y| x + y } \
+            | g.seq(:add, "-", :mul) { |x,_,y| x - y } \
+            | :mul
+
+      g.expr = g.seq(:var, "=", :expr) { |v,_,e| vars[v] = e } \
+             | :add
+
+      g.root = g.seq(g.kleene(:expr), :spaces) { |e,_| e }
+    end
+
+    m = KPeg.match "3+4*5", gram
+    assert_equal 23, m.value
+
+    m = KPeg.match "x=2", gram
+    assert_equal 2, m.value
+
+    m = KPeg.match "x=x*7", gram
+    assert_equal 14, m.value
+  end
+
+end

data/test/test_kpeg_code_generator.rb

@@ -0,0 +1,1307 @@
+require 'test/unit'
+require 'kpeg'
+require 'kpeg/code_generator'
+require 'stringio'
+
+class TestKPegCodeGenerator < Test::Unit::TestCase
+  def test_dot
+    gram = KPeg.grammar do |g|
+      g.root = g.dot
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = .
+  def _root
+    _tmp = get_byte
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", ".")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    assert cg.parse("hello")
+  end
+
+  def test_str
+    gram = KPeg.grammar do |g|
+      g.root = g.str("hello")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = "hello"
+  def _root
+    _tmp = match_string("hello")
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "\\\"hello\\\"")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    assert cg.parse("hello")
+  end
+
+  def test_reg
+    gram = KPeg.grammar do |g|
+      g.root = g.reg(/[0-9]/)
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = /[0-9]/
+  def _root
+    _tmp = scan(/\\A(?-mix:[0-9])/)
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "/[0-9]/")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    assert cg.parse("9")
+    assert cg.parse("1")
+    assert !cg.parse("a")
+  end
+
+  def test_char_range
+    gram = KPeg.grammar do |g|
+      g.root = g.range("a", "z")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = [a-z]
+  def _root
+    _save = self.pos
+    _tmp = get_byte
+    if _tmp
+      unless _tmp >= 97 and _tmp <= 122
+        self.pos = _save
+        _tmp = nil
+      end
+    end
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "[a-z]")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    assert cg.parse("z")
+    assert cg.parse("a")
+    assert !cg.parse("0")
+  end
+
+  def test_char_range_in_seq
+    gram = KPeg.grammar do |g|
+      g.root = g.seq(g.range("a", "z"), "hello")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = [a-z] "hello"
+  def _root
+
+    _save = self.pos
+    while true # sequence
+    _save1 = self.pos
+    _tmp = get_byte
+    if _tmp
+      unless _tmp >= 97 and _tmp <= 122
+        self.pos = _save1
+        _tmp = nil
+      end
+    end
+    unless _tmp
+      self.pos = _save
+      break
+    end
+    _tmp = match_string("hello")
+    unless _tmp
+      self.pos = _save
+    end
+    break
+    end # end sequence
+
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "[a-z] \\\"hello\\\"")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    assert cg.parse("ahello")
+    assert cg.parse("zhello")
+    assert !cg.parse("0hello")
+    assert !cg.parse("ajello")
+  end
+
+  def test_any
+    gram = KPeg.grammar do |g|
+      g.root = g.any("hello", "world")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = ("hello" | "world")
+  def _root
+
+    _save = self.pos
+    while true # choice
+    _tmp = match_string("hello")
+    break if _tmp
+    self.pos = _save
+    _tmp = match_string("world")
+    break if _tmp
+    self.pos = _save
+    break
+    end # end choice
+
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "(\\\"hello\\\" | \\\"world\\\")")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    assert cg.parse("hello")
+    assert cg.parse("world")
+    assert !cg.parse("jello")
+  end
+
+  def test_any_resets_pos
+    gram = KPeg.grammar do |g|
+      g.root = g.any(g.seq("hello", "world"), "hello balloons")
+    end
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    code = cg.make("helloworld")
+    assert code.parse
+    assert_equal 10, code.pos
+
+    assert cg.parse("hello balloons")
+  end
+
+  def test_maybe
+    gram = KPeg.grammar do |g|
+      g.root = g.maybe("hello")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = "hello"?
+  def _root
+    _save = self.pos
+    _tmp = match_string("hello")
+    unless _tmp
+      _tmp = true
+      self.pos = _save
+    end
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "\\\"hello\\\"?")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    assert cg.parse("hello")
+    assert cg.parse("jello")
+  end
+
+  def test_maybe_resets_pos
+    gram = KPeg.grammar do |g|
+      g.root = g.maybe(g.seq("hello", "world"))
+    end
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert cg.parse("helloworld")
+
+    code = cg.make("hellojello")
+    assert code.parse
+    assert_equal 0, code.pos
+  end
+
+  def test_kleene
+    gram = KPeg.grammar do |g|
+      g.root = g.kleene("hello")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = "hello"*
+  def _root
+    while true
+    _tmp = match_string("hello")
+    break unless _tmp
+    end
+    _tmp = true
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "\\\"hello\\\"*")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    code = cg.make("hellohellohello")
+    assert code.parse
+    assert_equal 15, code.pos
+  end
+
+  def test_kleene_reset_pos
+    gram = KPeg.grammar do |g|
+      g.root = g.kleene(g.seq("hello", "world"))
+    end
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    code = cg.make("helloworldhelloworld")
+    assert code.parse
+    assert_equal 20, code.pos
+
+    code = cg.make("hellojello")
+    assert code.parse
+    assert_equal 0, code.pos
+  end
+
+  def test_many
+    gram = KPeg.grammar do |g|
+      g.root = g.many("hello")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = "hello"+
+  def _root
+    _save = self.pos
+    _tmp = match_string("hello")
+    if _tmp
+      while true
+        _tmp = match_string("hello")
+        break unless _tmp
+      end
+      _tmp = true
+    else
+      self.pos = _save
+    end
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "\\\"hello\\\"+")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    code = cg.make("hellohello")
+    assert code.parse
+    assert_equal 10, code.pos
+
+    code = cg.make("hello")
+    assert code.parse
+    assert_equal 5, code.pos
+
+    code = cg.make("")
+    assert !code.parse
+  end
+
+  def test_many_resets_pos
+    gram = KPeg.grammar do |g|
+      g.root = g.many(g.seq("hello", "world"))
+    end
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    code = cg.make("helloworldhelloworld")
+    assert code.parse
+    assert_equal 20, code.pos
+
+    code = cg.make("hellojello")
+    assert !code.parse
+    assert_equal 0, code.pos
+  end
+
+  def test_multiple
+    gram = KPeg.grammar do |g|
+      g.root = g.multiple("hello", 5, 9)
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = "hello"[5, 9]
+  def _root
+    _save = self.pos
+    _count = 0
+    while true
+      _tmp = match_string("hello")
+      if _tmp
+        _count += 1
+        break if _count == 9
+      else
+        break
+      end
+    end
+    if _count >= 5
+      _tmp = true
+    else
+      self.pos = _save
+      _tmp = nil
+    end
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "\\\"hello\\\"[5, 9]")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+  end
+
+  def test_seq
+    gram = KPeg.grammar do |g|
+      g.root = g.seq("hello", "world")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = "hello" "world"
+  def _root
+
+    _save = self.pos
+    while true # sequence
+    _tmp = match_string("hello")
+    unless _tmp
+      self.pos = _save
+      break
+    end
+    _tmp = match_string("world")
+    unless _tmp
+      self.pos = _save
+    end
+    break
+    end # end sequence
+
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "\\\"hello\\\" \\\"world\\\"")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+  end
+
+  def test_seq_resets_pos
+    gram = KPeg.grammar do |g|
+      g.root = g.seq("hello", "world")
+    end
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    code = cg.make("helloworld")
+    assert code.parse
+
+    code = cg.make("hellojello")
+    assert !code.parse
+    assert_equal 0, code.pos
+  end
+
+  def test_andp
+    gram = KPeg.grammar do |g|
+      g.root = g.andp("hello")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = &"hello"
+  def _root
+    _save = self.pos
+    _tmp = match_string("hello")
+    self.pos = _save
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "&\\\"hello\\\"")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    code = cg.make("hello")
+    assert code.parse
+    assert_equal 0, code.pos
+
+    code = cg.make("jello")
+    assert !code.parse
+    assert_equal 0, code.pos
+  end
+
+  def test_andp_for_action
+    gram = KPeg.grammar do |g|
+      g.root = g.andp(g.action(" !defined? @fail "))
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = &{ !defined? @fail }
+  def _root
+    _save = self.pos
+    _tmp = begin;  !defined? @fail ; end
+    self.pos = _save
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "&{ !defined? @fail }")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    code = cg.make("hello")
+    assert code.parse
+    assert_equal 0, code.pos
+
+    code = cg.make("jello")
+    code.instance_variable_set :@fail, true
+    assert !code.parse
+    assert_equal 0, code.pos
+  end
+
+  def test_notp
+    gram = KPeg.grammar do |g|
+      g.root = g.notp("hello")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = !"hello"
+  def _root
+    _save = self.pos
+    _tmp = match_string("hello")
+    _tmp = _tmp ? nil : true
+    self.pos = _save
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "!\\\"hello\\\"")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    code = cg.make("hello")
+    assert !code.parse
+    assert_equal 0, code.pos
+
+    code = cg.make("jello")
+    assert code.parse
+    assert_equal 0, code.pos
+  end
+
+  def test_notp_for_action
+    gram = KPeg.grammar do |g|
+      g.root = g.notp(g.action(" defined? @fail "))
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = !{ defined? @fail }
+  def _root
+    _save = self.pos
+    _tmp = begin;  defined? @fail ; end
+    _tmp = _tmp ? nil : true
+    self.pos = _save
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "!{ defined? @fail }")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    code = cg.make("hello")
+    assert code.parse
+    assert_equal 0, code.pos
+
+    code = cg.make("jello")
+    code.instance_variable_set :@fail, true
+    assert !code.parse
+    assert_equal 0, code.pos
+  end
+
+
+  def test_ref
+    gram = KPeg.grammar do |g|
+      g.greeting = "hello"
+      g.root = g.ref("greeting")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # greeting = "hello"
+  def _greeting
+    _tmp = match_string("hello")
+    set_failed_rule :_greeting unless _tmp
+    return _tmp
+  end
+
+  # root = greeting
+  def _root
+    _tmp = apply(:_greeting)
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_greeting] = rule_info("greeting", "\\\"hello\\\"")
+  Rules[:_root] = rule_info("root", "greeting")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    assert cg.parse("hello")
+  end
+
+  def test_invoke
+    gram = KPeg.grammar do |g|
+      g.greeting = "hello"
+      g.root = g.invoke("greeting")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # greeting = "hello"
+  def _greeting
+    _tmp = match_string("hello")
+    set_failed_rule :_greeting unless _tmp
+    return _tmp
+  end
+
+  # root = @greeting
+  def _root
+    _tmp = _greeting()
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_greeting] = rule_info("greeting", "\\\"hello\\\"")
+  Rules[:_root] = rule_info("root", "@greeting")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    assert cg.parse("hello")
+  end
+
+  def test_invoke_with_args
+    gram = KPeg.grammar do |g|
+      g.set("greeting", "hello", ["a", "b"])
+      g.root = g.invoke("greeting", "(1,2)")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # greeting = "hello"
+  def _greeting(a,b)
+    _tmp = match_string("hello")
+    set_failed_rule :_greeting unless _tmp
+    return _tmp
+  end
+
+  # root = greeting(1,2)
+  def _root
+    _tmp = _greeting(1,2)
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_greeting] = rule_info("greeting", "\\\"hello\\\"")
+  Rules[:_root] = rule_info("root", "greeting(1,2)")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    assert cg.parse("hello")
+  end
+
+  gram = <<-GRAM
+  greeting = "hello"
+  greeting2(a,b) = "hello"
+  GRAM
+
+  KPeg.compile gram, "TestParser", self
+
+  def test_foreign_invoke
+    gram = KPeg.grammar do |g|
+      g.add_foreign_grammar "blah", "TestKPegCodeGenerator::TestParser"
+      g.root = g.foreign_invoke("blah", "greeting")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+  def setup_foreign_grammar
+    @_grammar_blah = TestKPegCodeGenerator::TestParser.new(nil)
+  end
+
+  # root = %blah.greeting
+  def _root
+    _tmp = @_grammar_blah.external_invoke(self, :_greeting)
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "%blah.greeting")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    assert cg.parse("hello")
+  end
+
+  def test_foreign_invoke_with_args
+    gram = KPeg.grammar do |g|
+      g.add_foreign_grammar "blah", "TestKPegCodeGenerator::TestParser"
+      g.root = g.foreign_invoke("blah", "greeting2", "(1,2)")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+  def setup_foreign_grammar
+    @_grammar_blah = TestKPegCodeGenerator::TestParser.new(nil)
+  end
+
+  # root = %blah.greeting2(1,2)
+  def _root
+    _tmp = @_grammar_blah.external_invoke(self, :_greeting2, 1,2)
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "%blah.greeting2(1,2)")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    assert cg.parse("hello")
+  end
+
+  def test_tag
+    gram = KPeg.grammar do |g|
+      g.root = g.t g.str("hello"), "t"
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = "hello":t
+  def _root
+    _tmp = match_string("hello")
+    t = @result
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "\\\"hello\\\":t")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+  end
+
+  def test_noname_tag
+    gram = KPeg.grammar do |g|
+      g.root = g.t g.str("hello")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = "hello"
+  def _root
+    _tmp = match_string("hello")
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "\\\"hello\\\"")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+  end
+
+  def test_tag_maybe
+    gram = KPeg.grammar do |g|
+      g.hello = g.seq(g.collect("hello"), g.action("text"))
+      g.root = g.seq g.t(g.maybe(:hello), "lots"), g.action("lots")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # hello = < "hello" > {text}
+  def _hello
+
+    _save = self.pos
+    while true # sequence
+    _text_start = self.pos
+    _tmp = match_string("hello")
+    if _tmp
+      text = get_text(_text_start)
+    end
+    unless _tmp
+      self.pos = _save
+      break
+    end
+    @result = begin; text; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save
+    end
+    break
+    end # end sequence
+
+    set_failed_rule :_hello unless _tmp
+    return _tmp
+  end
+
+  # root = hello?:lots {lots}
+  def _root
+
+    _save = self.pos
+    while true # sequence
+    _save1 = self.pos
+    _tmp = apply(:_hello)
+    @result = nil unless _tmp
+    unless _tmp
+      _tmp = true
+      self.pos = _save1
+    end
+    lots = @result
+    unless _tmp
+      self.pos = _save
+      break
+    end
+    @result = begin; lots; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save
+    end
+    break
+    end # end sequence
+
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_hello] = rule_info("hello", "< \\\"hello\\\" > {text}")
+  Rules[:_root] = rule_info("root", "hello?:lots {lots}")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    code = cg.make("hello")
+    assert code.parse
+    assert_equal "hello", code.result
+
+    code = cg.make("")
+    assert code.parse
+    assert_equal nil, code.result
+  end
+
+
+  def test_tag_multiple
+    gram = KPeg.grammar do |g|
+      g.hello = g.seq(g.collect("hello"), g.action("text"))
+      g.root = g.seq g.t(g.kleene(:hello), "lots"), g.action("lots")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # hello = < "hello" > {text}
+  def _hello
+
+    _save = self.pos
+    while true # sequence
+    _text_start = self.pos
+    _tmp = match_string("hello")
+    if _tmp
+      text = get_text(_text_start)
+    end
+    unless _tmp
+      self.pos = _save
+      break
+    end
+    @result = begin; text; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save
+    end
+    break
+    end # end sequence
+
+    set_failed_rule :_hello unless _tmp
+    return _tmp
+  end
+
+  # root = hello*:lots {lots}
+  def _root
+
+    _save = self.pos
+    while true # sequence
+    _ary = []
+    while true
+    _tmp = apply(:_hello)
+    _ary << @result if _tmp
+    break unless _tmp
+    end
+    _tmp = true
+    @result = _ary
+    lots = @result
+    unless _tmp
+      self.pos = _save
+      break
+    end
+    @result = begin; lots; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save
+    end
+    break
+    end # end sequence
+
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_hello] = rule_info("hello", "< \\\"hello\\\" > {text}")
+  Rules[:_root] = rule_info("root", "hello*:lots {lots}")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    code = cg.make("hellohello")
+    assert code.parse
+    assert_equal ["hello", "hello"], code.result
+
+    code = cg.make("hello")
+    assert code.parse
+    assert_equal ["hello"], code.result
+
+    code = cg.make("")
+    assert code.parse
+    assert_equal [], code.result
+  end
+
+  def test_tag_many
+    gram = KPeg.grammar do |g|
+      g.hello = g.seq(g.collect("hello"), g.action("text"))
+      g.root = g.seq g.t(g.many(:hello), "lots"), g.action("lots")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # hello = < "hello" > {text}
+  def _hello
+
+    _save = self.pos
+    while true # sequence
+    _text_start = self.pos
+    _tmp = match_string("hello")
+    if _tmp
+      text = get_text(_text_start)
+    end
+    unless _tmp
+      self.pos = _save
+      break
+    end
+    @result = begin; text; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save
+    end
+    break
+    end # end sequence
+
+    set_failed_rule :_hello unless _tmp
+    return _tmp
+  end
+
+  # root = hello+:lots {lots}
+  def _root
+
+    _save = self.pos
+    while true # sequence
+    _save1 = self.pos
+    _ary = []
+    _tmp = apply(:_hello)
+    if _tmp
+      _ary << @result
+      while true
+        _tmp = apply(:_hello)
+        _ary << @result if _tmp
+        break unless _tmp
+      end
+      _tmp = true
+      @result = _ary
+    else
+      self.pos = _save1
+    end
+    lots = @result
+    unless _tmp
+      self.pos = _save
+      break
+    end
+    @result = begin; lots; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save
+    end
+    break
+    end # end sequence
+
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_hello] = rule_info("hello", "< \\\"hello\\\" > {text}")
+  Rules[:_root] = rule_info("root", "hello+:lots {lots}")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    code = cg.make("hellohello")
+    assert code.parse
+    assert_equal ["hello", "hello"], code.result
+
+    code = cg.make("hello")
+    assert code.parse
+    assert_equal ["hello"], code.result
+
+    code = cg.make("")
+    assert !code.parse
+  end
+
+  def test_action
+    gram = KPeg.grammar do |g|
+      g.root = g.action "3 + 4"
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = {3 + 4}
+  def _root
+    @result = begin; 3 + 4; end
+    _tmp = true
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "{3 + 4}")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    code = cg.make("")
+    assert code.parse
+    assert_equal 7, code.result
+  end
+
+  def test_collect
+    gram = KPeg.grammar do |g|
+      g.root = g.seq(g.collect("hello"), g.action(" text "))
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+  # root = < "hello" > { text }
+  def _root
+
+    _save = self.pos
+    while true # sequence
+    _text_start = self.pos
+    _tmp = match_string("hello")
+    if _tmp
+      text = get_text(_text_start)
+    end
+    unless _tmp
+      self.pos = _save
+      break
+    end
+    @result = begin;  text ; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save
+    end
+    break
+    end # end sequence
+
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "< \\\"hello\\\" > { text }")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    code = cg.make("hello")
+    assert code.parse
+    assert_equal "hello", code.result
+  end
+
+  def test_parse_error
+    gram = KPeg.grammar do |g|
+      g.world = "world"
+      g.root = g.seq("hello", :world)
+    end
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    code = cg.make("no")
+    assert !code.parse
+    assert_equal 0, code.failing_rule_offset
+
+    cg2 = KPeg::CodeGenerator.new "Test", gram
+
+    code = cg2.make("hellono")
+    assert !code.parse
+    assert_equal 5, code.failing_rule_offset
+  end
+
+  def test_setup_actions
+    gram = KPeg.grammar do |g|
+      g.root = g.dot
+      g.add_setup g.action(" attr_reader :foo ")
+    end
+
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
+
+ attr_reader :foo 
+
+
+  # root = .
+  def _root
+    _tmp = get_byte
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", ".")
+end
+    STR
+
+    cg = KPeg::CodeGenerator.new "Test", gram
+
+    assert_equal str, cg.output
+
+    assert cg.parse("hello")
+  end
+
+end