kpeg 0.8.0 → 0.8.1

data/lib/kpeg/format_parser.rb

@@ -334,6 +334,48 @@ class KPeg::FormatParser
     return _tmp
   end
 
+  # eof_comment = "#" (!eof .)*
+  def _eof_comment
+
+    _save = self.pos
+    while true # sequence
+    _tmp = match_string("#")
+    unless _tmp
+      self.pos = _save
+      break
+    end
+    while true
+
+    _save2 = self.pos
+    while true # sequence
+    _save3 = self.pos
+    _tmp = apply(:_eof)
+    _tmp = _tmp ? nil : true
+    self.pos = _save3
+    unless _tmp
+      self.pos = _save2
+      break
+    end
+    _tmp = get_byte
+    unless _tmp
+      self.pos = _save2
+    end
+    break
+    end # end sequence
+
+    break unless _tmp
+    end
+    _tmp = true
+    unless _tmp
+      self.pos = _save
+    end
+    break
+    end # end sequence
+
+    set_failed_rule :_eof_comment unless _tmp
+    return _tmp
+  end
+
   # comment = "#" (!eol .)* eol
   def _comment
 
@@ -424,6 +466,13 @@ class KPeg::FormatParser
     return _tmp
   end
 
+  # kleene = "*"
+  def _kleene
+    _tmp = match_string("*")
+    set_failed_rule :_kleene unless _tmp
+    return _tmp
+  end
+
   # var = < ("-" | /[a-zA-Z][\-_a-zA-Z0-9]*/) > { text }
   def _var
 
@@ -1073,13 +1122,50 @@ class KPeg::FormatParser
     return _tmp
   end
 
-  # range_elem = < /([1-9][0-9]*)|\*/ > { text }
+  # range_num = < /[1-9][0-9]*/ > { text }
+  def _range_num
+
+    _save = self.pos
+    while true # sequence
+    _text_start = self.pos
+    _tmp = scan(/\A(?-mix:[1-9][0-9]*)/)
+    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 :_range_num unless _tmp
+    return _tmp
+  end
+
+  # range_elem = < (range_num | kleene) > { text }
   def _range_elem
 
     _save = self.pos
     while true # sequence
     _text_start = self.pos
-    _tmp = scan(/\A(?-mix:([1-9][0-9]*)|\*)/)
+
+    _save1 = self.pos
+    while true # choice
+    _tmp = apply(:_range_num)
+    break if _tmp
+    self.pos = _save1
+    _tmp = apply(:_kleene)
+    break if _tmp
+    self.pos = _save1
+    break
+    end # end choice
+
     if _tmp
       text = get_text(_text_start)
     end
@@ -1099,66 +1185,113 @@ class KPeg::FormatParser
     return _tmp
   end
 
-  # mult_range = "[" - range_elem:l - "," - range_elem:r - "]" { [l == "*" ? nil : l.to_i, r == "*" ? nil : r.to_i] }
+  # mult_range = ("[" - range_elem:l - "," - range_elem:r - "]" { [l == "*" ? nil : l.to_i, r == "*" ? nil : r.to_i] } | "[" - range_num:e - "]" { [e.to_i, e.to_i] })
   def _mult_range
 
     _save = self.pos
+    while true # choice
+
+    _save1 = self.pos
     while true # sequence
     _tmp = match_string("[")
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
       break
     end
     _tmp = apply(:__hyphen_)
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
       break
     end
     _tmp = apply(:_range_elem)
     l = @result
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
       break
     end
     _tmp = apply(:__hyphen_)
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
       break
     end
     _tmp = match_string(",")
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
       break
     end
     _tmp = apply(:__hyphen_)
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
       break
     end
     _tmp = apply(:_range_elem)
     r = @result
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
       break
     end
     _tmp = apply(:__hyphen_)
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
       break
     end
     _tmp = match_string("]")
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
       break
     end
     @result = begin;  [l == "*" ? nil : l.to_i, r == "*" ? nil : r.to_i] ; end
     _tmp = true
     unless _tmp
-      self.pos = _save
+      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
+    _tmp = apply(:__hyphen_)
+    unless _tmp
+      self.pos = _save2
+      break
+    end
+    _tmp = apply(:_range_num)
+    e = @result
+    unless _tmp
+      self.pos = _save2
+      break
+    end
+    _tmp = apply(:__hyphen_)
+    unless _tmp
+      self.pos = _save2
+      break
+    end
+    _tmp = match_string("]")
+    unless _tmp
+      self.pos = _save2
+      break
+    end
+    @result = begin;  [e.to_i, e.to_i] ; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save2
     end
     break
     end # end sequence
 
+    break if _tmp
+    self.pos = _save
+    break
+    end # end choice
+
     set_failed_rule :_mult_range unless _tmp
     return _tmp
   end
@@ -2427,7 +2560,7 @@ class KPeg::FormatParser
     return _tmp
   end
 
-  # root = statements - "\n"? eof
+  # root = statements - eof_comment? eof
   def _root
 
     _save = self.pos
@@ -2443,7 +2576,7 @@ class KPeg::FormatParser
       break
     end
     _save1 = self.pos
-    _tmp = match_string("\n")
+    _tmp = apply(:_eof_comment)
     unless _tmp
       _tmp = true
       self.pos = _save1
@@ -2608,50 +2741,89 @@ class KPeg::FormatParser
     return _tmp
   end
 
-  # ast_root = ast_constant:c "(" ast_words:w ")" { [c, w] }
+  # ast_root = (ast_constant:c "(" ast_words:w ")" { [c, w] } | ast_constant:c "()"? { [c, []] })
   def _ast_root
 
     _save = self.pos
+    while true # choice
+
+    _save1 = self.pos
     while true # sequence
     _tmp = apply(:_ast_constant)
     c = @result
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
       break
     end
     _tmp = match_string("(")
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
       break
     end
     _tmp = apply(:_ast_words)
     w = @result
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
       break
     end
     _tmp = match_string(")")
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
       break
     end
     @result = begin;  [c, w] ; end
     _tmp = true
     unless _tmp
-      self.pos = _save
+      self.pos = _save1
+    end
+    break
+    end # end sequence
+
+    break if _tmp
+    self.pos = _save
+
+    _save2 = self.pos
+    while true # sequence
+    _tmp = apply(:_ast_constant)
+    c = @result
+    unless _tmp
+      self.pos = _save2
+      break
+    end
+    _save3 = self.pos
+    _tmp = match_string("()")
+    unless _tmp
+      _tmp = true
+      self.pos = _save3
+    end
+    unless _tmp
+      self.pos = _save2
+      break
+    end
+    @result = begin;  [c, []] ; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save2
     end
     break
     end # end sequence
 
+    break if _tmp
+    self.pos = _save
+    break
+    end # end choice
+
     set_failed_rule :_ast_root unless _tmp
     return _tmp
   end
 
   Rules = {}
   Rules[:_eol] = rule_info("eol", "\"\\n\"")
+  Rules[:_eof_comment] = rule_info("eof_comment", "\"\#\" (!eof .)*")
   Rules[:_comment] = rule_info("comment", "\"\#\" (!eol .)* eol")
   Rules[:_space] = rule_info("space", "(\" \" | \"\\t\" | eol)")
   Rules[:__hyphen_] = rule_info("-", "(space | comment)*")
+  Rules[:_kleene] = rule_info("kleene", "\"*\"")
   Rules[:_var] = rule_info("var", "< (\"-\" | /[a-zA-Z][\\-_a-zA-Z0-9]*/) > { text }")
   Rules[:_method] = rule_info("method", "< /[a-zA-Z_][a-zA-Z0-9_]*/ > { text }")
   Rules[:_dbl_escapes] = rule_info("dbl_escapes", "(\"\\\\\\\"\" { '\"' } | \"\\\\n\" { \"\\n\" } | \"\\\\t\" { \"\\t\" } | \"\\\\b\" { \"\\b\" } | \"\\\\\\\\\" { \"\\\\\" })")
@@ -2668,8 +2840,9 @@ class KPeg::FormatParser
   Rules[:_regexp] = rule_info("regexp", "\"/\" not_slash:body \"/\" regexp_opts:opts { @g.reg body, opts }")
   Rules[:_char] = rule_info("char", "< /[a-zA-Z0-9]/ > { text }")
   Rules[:_char_range] = rule_info("char_range", "\"[\" char:l \"-\" char:r \"]\" { @g.range(l,r) }")
-  Rules[:_range_elem] = rule_info("range_elem", "< /([1-9][0-9]*)|\\*/ > { text }")
-  Rules[:_mult_range] = rule_info("mult_range", "\"[\" - range_elem:l - \",\" - range_elem:r - \"]\" { [l == \"*\" ? nil : l.to_i, r == \"*\" ? nil : r.to_i] }")
+  Rules[:_range_num] = rule_info("range_num", "< /[1-9][0-9]*/ > { text }")
+  Rules[:_range_elem] = rule_info("range_elem", "< (range_num | kleene) > { text }")
+  Rules[:_mult_range] = rule_info("mult_range", "(\"[\" - range_elem:l - \",\" - range_elem:r - \"]\" { [l == \"*\" ? nil : l.to_i, r == \"*\" ? nil : r.to_i] } | \"[\" - range_num:e - \"]\" { [e.to_i, e.to_i] })")
   Rules[:_curly_block] = rule_info("curly_block", "curly")
   Rules[:_curly] = rule_info("curly", "\"{\" < (/[^{}]+/ | curly)* > \"}\" { @g.action(text) }")
   Rules[:_nested_paren] = rule_info("nested_paren", "\"(\" (/[^()]+/ | nested_paren)* \")\"")
@@ -2682,10 +2855,10 @@ class KPeg::FormatParser
   Rules[:_statement] = rule_info("statement", "(- var:v \"(\" args:a \")\" - \"=\" - expression:o { @g.set(v, o, a) } | - var:v - \"=\" - expression:o { @g.set(v, o) } | - \"%\" var:name - \"=\" - < /[::A-Za-z0-9_]+/ > { @g.add_foreign_grammar(name, text) } | - \"%%\" - curly:act { @g.add_setup act } | - \"%%\" - var:name - \"=\" - < (!\"\\n\" .)+ > { @g.set_variable(name, text) })")
   Rules[:_statements] = rule_info("statements", "statement (- statements)?")
   Rules[:_eof] = rule_info("eof", "!.")
-  Rules[:_root] = rule_info("root", "statements - \"\\n\"? eof")
+  Rules[:_root] = rule_info("root", "statements - eof_comment? eof")
   Rules[:_ast_constant] = rule_info("ast_constant", "< /[A-Z][A-Za-z0-9_]*/ > { text }")
   Rules[:_ast_word] = rule_info("ast_word", "< /[A-Za-z_][A-Za-z0-9_]*/ > { text }")
   Rules[:_ast_sp] = rule_info("ast_sp", "(\" \" | \"\\t\")*")
   Rules[:_ast_words] = rule_info("ast_words", "(ast_words:r ast_sp \",\" ast_sp ast_word:w { r + [w] } | ast_word:w { [w] })")
-  Rules[:_ast_root] = rule_info("ast_root", "ast_constant:c \"(\" ast_words:w \")\" { [c, w] }")
+  Rules[:_ast_root] = rule_info("ast_root", "(ast_constant:c \"(\" ast_words:w \")\" { [c, w] } | ast_constant:c \"()\"? { [c, []] })")
 end

data/lib/kpeg/grammar.rb

@@ -111,8 +111,15 @@ module KPeg
         if opts
           opts.split("").each do |o|
             case o
-            when "n", "N", "e", "E", "s", "S", "u", "U"
-              lang = o
+            when "n", "N", "e", "E", "s", "S"
+              lang = o.downcase
+            when "u", "U"
+              if RUBY_VERSION > "1.8.7"
+                # Ruby 1.9 defaults to UTF-8 for string matching
+                lang = ""
+              else
+                lang = "u"
+              end
             when "m"
               flags |= Regexp::MULTILINE
             when "x"
@@ -785,7 +792,17 @@ module KPeg
     def invoke(name, args=nil)
       InvokeRule.new name.to_s, args
     end
-
+    
+    # Invoke a rule defined on a foreign grammar
+    # == Parameters:
+    # gram::
+    #   The name of the grammar that the rule will be reference from 
+    # name::
+    #   The name of the rule that will be invoked
+    # args::
+    #   Any arguements that should be passed to the rule
+    # == Returns:
+    #   A new ForeignInvokeRule
     def foreign_invoke(gram, name, args=nil)
       ForeignInvokeRule.new gram, name.to_s, args
     end

data/lib/kpeg/version.rb

@@ -1,3 +1,3 @@
 module KPeg
-  VERSION = "0.8.0"
+  VERSION = "0.8.1"
 end

data/test/test_kpeg_code_generator.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require 'test/unit'
 require 'kpeg'
 require 'kpeg/code_generator'
@@ -97,7 +98,25 @@ end
     gram = KPeg.grammar do |g|
       g.root = g.reg(/./u)
     end
+    
+    if RUBY_VERSION > "1.8.7"
+    str = <<-STR
+require 'kpeg/compiled_parser'
+
+class Test < KPeg::CompiledParser
 
+  # root = /./
+  def _root
+    _tmp = scan(/\\A(?-mix:.)/)
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_root] = rule_info("root", "/./")
+end
+    STR
+    else
     str = <<-STR
 require 'kpeg/compiled_parser'
 
@@ -114,7 +133,7 @@ class Test < KPeg::CompiledParser
   Rules[:_root] = rule_info("root", "/./u")
 end
     STR
-
+    end
     cg = KPeg::CodeGenerator.new "Test", gram
 
     assert_equal str, cg.output
@@ -176,23 +195,23 @@ class Test < KPeg::CompiledParser
 
     _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
+      _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
-    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
@@ -229,13 +248,13 @@ class Test < KPeg::CompiledParser
 
     _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
+      _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
@@ -332,8 +351,8 @@ class Test < KPeg::CompiledParser
   # root = "hello"*
   def _root
     while true
-    _tmp = match_string("hello")
-    break unless _tmp
+      _tmp = match_string("hello")
+      break unless _tmp
     end
     _tmp = true
     set_failed_rule :_root unless _tmp
@@ -492,16 +511,16 @@ class Test < KPeg::CompiledParser
 
     _save = self.pos
     while true # sequence
-    _tmp = match_string("hello")
-    unless _tmp
-      self.pos = _save
+      _tmp = match_string("hello")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = match_string("world")
+      unless _tmp
+        self.pos = _save
+      end
       break
-    end
-    _tmp = match_string("world")
-    unless _tmp
-      self.pos = _save
-    end
-    break
     end # end sequence
 
     set_failed_rule :_root unless _tmp
@@ -821,10 +840,6 @@ class Test < KPeg::CompiledParser
     @_grammar_blah = TestKPegCodeGenerator::TestParser.new(nil)
   end
 
-  def invoke_blah(*args)
-    @_grammar_blah.external_invoke(self, :_root, *args)
-  end
-
   # root = %blah.greeting
   def _root
     _tmp = @_grammar_blah.external_invoke(self, :_greeting)
@@ -858,10 +873,6 @@ class Test < KPeg::CompiledParser
     @_grammar_blah = TestKPegCodeGenerator::TestParser.new(nil)
   end
 
-  def invoke_blah(*args)
-    @_grammar_blah.external_invoke(self, :_root, *args)
-  end
-
   # root = %blah.greeting2(1,2)
   def _root
     _tmp = @_grammar_blah.external_invoke(self, :_greeting2, 1,2)
@@ -952,21 +963,21 @@ class Test < KPeg::CompiledParser
 
     _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
+      _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
-    @result = begin; text; end
-    _tmp = true
-    unless _tmp
-      self.pos = _save
-    end
-    break
     end # end sequence
 
     set_failed_rule :_hello unless _tmp
@@ -978,24 +989,24 @@ class Test < KPeg::CompiledParser
 
     _save = self.pos
     while true # sequence
-    _save1 = self.pos
-    _tmp = apply(:_hello)
-    @result = nil unless _tmp
-    unless _tmp
+      _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
-      self.pos = _save1
-    end
-    lots = @result
-    unless _tmp
-      self.pos = _save
+      unless _tmp
+        self.pos = _save
+      end
       break
-    end
-    @result = begin; lots; end
-    _tmp = true
-    unless _tmp
-      self.pos = _save
-    end
-    break
     end # end sequence
 
     set_failed_rule :_root unless _tmp
@@ -1038,21 +1049,21 @@ class Test < KPeg::CompiledParser
 
     _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
+      _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
-    @result = begin; text; end
-    _tmp = true
-    unless _tmp
-      self.pos = _save
-    end
-    break
     end # end sequence
 
     set_failed_rule :_hello unless _tmp
@@ -1064,25 +1075,25 @@ class Test < KPeg::CompiledParser
 
     _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
+      _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
-    @result = begin; lots; end
-    _tmp = true
-    unless _tmp
-      self.pos = _save
-    end
-    break
     end # end sequence
 
     set_failed_rule :_root unless _tmp
@@ -1128,21 +1139,21 @@ class Test < KPeg::CompiledParser
 
     _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
+      _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
-    @result = begin; text; end
-    _tmp = true
-    unless _tmp
-      self.pos = _save
-    end
-    break
     end # end sequence
 
     set_failed_rule :_hello unless _tmp
@@ -1154,32 +1165,32 @@ class Test < KPeg::CompiledParser
 
     _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
+      _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
-      @result = _ary
-    else
-      self.pos = _save1
-    end
-    lots = @result
-    unless _tmp
-      self.pos = _save
+      unless _tmp
+        self.pos = _save
+      end
       break
-    end
-    @result = begin; lots; end
-    _tmp = true
-    unless _tmp
-      self.pos = _save
-    end
-    break
     end # end sequence
 
     set_failed_rule :_root unless _tmp
@@ -1255,21 +1266,21 @@ class Test < KPeg::CompiledParser
 
     _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
+      _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
-    @result = begin;  text ; end
-    _tmp = true
-    unless _tmp
-      self.pos = _save
-    end
-    break
     end # end sequence
 
     set_failed_rule :_root unless _tmp
@@ -1346,6 +1357,8 @@ end
     gram = KPeg.grammar do |g|
       g.root = g.dot
       g.set_variable "bracket", "ast BracketOperator(receiver, argument)"
+      g.set_variable "simple", "ast Simple()"
+      g.set_variable "simple2", "ast Simple2"
     end
 
     str = <<-STR
@@ -1363,10 +1376,24 @@ class Test < KPeg::CompiledParser
       attr_reader :receiver
       attr_reader :argument
     end
+    class Simple < Node
+      def initialize()
+      end
+    end
+    class Simple2 < Node
+      def initialize()
+      end
+    end
   end
   def bracket(receiver, argument)
     AST::BracketOperator.new(receiver, argument)
   end
+  def simple()
+    AST::Simple.new()
+  end
+  def simple2()
+    AST::Simple2.new()
+  end
 
   # root = .
   def _root