kpeg 0.7

data/lib/kpeg/string_escape.rb

@@ -0,0 +1,322 @@
+require 'kpeg/compiled_parser'
+
+class KPeg::StringEscape < KPeg::CompiledParser
+
+
+  attr_reader :text
+
+
+
+  # segment = (< /[\w ]+/ > { text } | "\\" { "\\\\" } | "\n" { "\\n" } | "\t" { "\\t" } | "\b" { "\\b" } | "\"" { "\\\"" } | < . > { text })
+  def _segment
+
+    _save = self.pos
+    while true # choice
+
+    _save1 = self.pos
+    while true # sequence
+    _text_start = self.pos
+    _tmp = scan(/\A(?-mix:[\w ]+)/)
+    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
+    @result = begin;  "\\\\" ; 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("\n")
+    unless _tmp
+      self.pos = _save3
+      break
+    end
+    @result = begin;  "\\n" ; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save3
+    end
+    break
+    end # end sequence
+
+    break if _tmp
+    self.pos = _save
+
+    _save4 = self.pos
+    while true # sequence
+    _tmp = match_string("\t")
+    unless _tmp
+      self.pos = _save4
+      break
+    end
+    @result = begin;  "\\t" ; 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("\b")
+    unless _tmp
+      self.pos = _save5
+      break
+    end
+    @result = begin;  "\\b" ; 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("\"")
+    unless _tmp
+      self.pos = _save6
+      break
+    end
+    @result = begin;  "\\\"" ; 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 = get_byte
+    if _tmp
+      text = get_text(_text_start)
+    end
+    unless _tmp
+      self.pos = _save7
+      break
+    end
+    @result = begin;  text ; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save7
+    end
+    break
+    end # end sequence
+
+    break if _tmp
+    self.pos = _save
+    break
+    end # end choice
+
+    set_failed_rule :_segment unless _tmp
+    return _tmp
+  end
+
+  # segments = (segment:s segments:r { "#{s}#{r}" } | segment)
+  def _segments
+
+    _save = self.pos
+    while true # choice
+
+    _save1 = self.pos
+    while true # sequence
+    _tmp = apply(:_segment)
+    s = @result
+    unless _tmp
+      self.pos = _save1
+      break
+    end
+    _tmp = apply(:_segments)
+    r = @result
+    unless _tmp
+      self.pos = _save1
+      break
+    end
+    @result = begin;  "#{s}#{r}" ; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save1
+    end
+    break
+    end # end sequence
+
+    break if _tmp
+    self.pos = _save
+    _tmp = apply(:_segment)
+    break if _tmp
+    self.pos = _save
+    break
+    end # end choice
+
+    set_failed_rule :_segments unless _tmp
+    return _tmp
+  end
+
+  # root = segments:s { @text = s }
+  def _root
+
+    _save = self.pos
+    while true # sequence
+    _tmp = apply(:_segments)
+    s = @result
+    unless _tmp
+      self.pos = _save
+      break
+    end
+    @result = begin;  @text = s ; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save
+    end
+    break
+    end # end sequence
+
+    set_failed_rule :_root unless _tmp
+    return _tmp
+  end
+
+  # embed_seg = ("#" { "\\#" } | segment)
+  def _embed_seg
+
+    _save = self.pos
+    while true # choice
+
+    _save1 = self.pos
+    while true # sequence
+    _tmp = match_string("#")
+    unless _tmp
+      self.pos = _save1
+      break
+    end
+    @result = begin;  "\\#" ; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save1
+    end
+    break
+    end # end sequence
+
+    break if _tmp
+    self.pos = _save
+    _tmp = apply(:_segment)
+    break if _tmp
+    self.pos = _save
+    break
+    end # end choice
+
+    set_failed_rule :_embed_seg unless _tmp
+    return _tmp
+  end
+
+  # embed_segs = (embed_seg:s embed_segs:r { "#{s}#{r}" } | embed_seg)
+  def _embed_segs
+
+    _save = self.pos
+    while true # choice
+
+    _save1 = self.pos
+    while true # sequence
+    _tmp = apply(:_embed_seg)
+    s = @result
+    unless _tmp
+      self.pos = _save1
+      break
+    end
+    _tmp = apply(:_embed_segs)
+    r = @result
+    unless _tmp
+      self.pos = _save1
+      break
+    end
+    @result = begin;  "#{s}#{r}" ; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save1
+    end
+    break
+    end # end sequence
+
+    break if _tmp
+    self.pos = _save
+    _tmp = apply(:_embed_seg)
+    break if _tmp
+    self.pos = _save
+    break
+    end # end choice
+
+    set_failed_rule :_embed_segs unless _tmp
+    return _tmp
+  end
+
+  # embed = embed_segs:s { @text = s }
+  def _embed
+
+    _save = self.pos
+    while true # sequence
+    _tmp = apply(:_embed_segs)
+    s = @result
+    unless _tmp
+      self.pos = _save
+      break
+    end
+    @result = begin;  @text = s ; end
+    _tmp = true
+    unless _tmp
+      self.pos = _save
+    end
+    break
+    end # end sequence
+
+    set_failed_rule :_embed unless _tmp
+    return _tmp
+  end
+
+  Rules = {}
+  Rules[:_segment] = rule_info("segment", "(< /[\\w ]+/ > { text } | \"\\\\\" { \"\\\\\\\\\" } | \"\\n\" { \"\\\\n\" } | \"\\t\" { \"\\\\t\" } | \"\\b\" { \"\\\\b\" } | \"\\\"\" { \"\\\\\\\"\" } | < . > { text })")
+  Rules[:_segments] = rule_info("segments", "(segment:s segments:r { \"\#{s}\#{r}\" } | segment)")
+  Rules[:_root] = rule_info("root", "segments:s { @text = s }")
+  Rules[:_embed_seg] = rule_info("embed_seg", "(\"\#\" { \"\\\\\#\" } | segment)")
+  Rules[:_embed_segs] = rule_info("embed_segs", "(embed_seg:s embed_segs:r { \"\#{s}\#{r}\" } | embed_seg)")
+  Rules[:_embed] = rule_info("embed", "embed_segs:s { @text = s }")
+end

data/lib/kpeg/version.rb

@@ -0,0 +1,3 @@
+module KPeg
+  VERSION = "0.7"
+end

data/test/test_file_parser_roundtrip.rb

@@ -0,0 +1,112 @@
+require 'kpeg'
+require 'kpeg/format_parser'
+require 'kpeg/grammar_renderer'
+require 'kpeg/code_generator'
+require 'stringio'
+require 'test/unit'
+
+class TestKPegRoundtrip < Test::Unit::TestCase
+  PATH = File.expand_path("../../lib/kpeg/format.kpeg", __FILE__)
+  def test_roundtrip
+    data = File.read(PATH)
+
+    pr = KPeg::FormatParser.new data
+    assert pr.parse, "Couldn't parse with builtin parser"
+
+    io = StringIO.new
+    gr = KPeg::GrammarRenderer.new(pr.g)
+    gr.render io
+
+    cg1 = KPeg::CodeGenerator.new("Test1", pr.g, false)
+    pr2 = cg1.make(io.string)
+    g2 = KPeg::Grammar.new
+    pr2.instance_variable_set(:@g, g2)
+
+    assert pr2.parse, "Couldn't parse with 2nd generation parser"
+
+    io2 = StringIO.new
+    gr2 = KPeg::GrammarRenderer.new(g2)
+    gr2.render io2
+
+    assert_equal io2.string, io.string
+
+    cg2 = KPeg::CodeGenerator.new("Test2", g2, false)
+    pr3 = cg2.make(io2.string)
+    g3 = KPeg::Grammar.new
+    pr3.instance_variable_set(:@g, g3)
+
+    assert pr3.parse, "Couldn't parse with 3rd generation parser"
+
+    io3 = StringIO.new
+    gr3 = KPeg::GrammarRenderer.new(g3)
+    gr3.render io3
+
+    assert_equal io3.string, io2.string
+
+    cg3 = KPeg::CodeGenerator.new("Test3", g3, false)
+    pr4 = cg3.make(io3.string)
+    g4 = KPeg::Grammar.new
+    pr4.instance_variable_set(:@g, g4)
+
+    assert pr4.parse, "Couldn't parse with 4th generation parser"
+
+    io4 = StringIO.new
+    gr4 = KPeg::GrammarRenderer.new(g4)
+    gr4.render io4
+
+    assert_equal io4.string, io3.string
+  end
+
+  def test_roundtrip_standalone
+    data = File.read(PATH)
+
+    pr = KPeg::FormatParser.new data
+    assert pr.parse, "Couldn't parse with builtin parser"
+
+    io = StringIO.new
+    gr = KPeg::GrammarRenderer.new(pr.g)
+    gr.render io
+
+    cg1 = KPeg::CodeGenerator.new("Test1", pr.g, false)
+    cg1.standalone = true
+    pr2 = cg1.make(io.string)
+    g2 = KPeg::Grammar.new
+    pr2.instance_variable_set(:@g, g2)
+
+    assert pr2.parse, "Couldn't parse with 2nd generation parser"
+
+    io2 = StringIO.new
+    gr2 = KPeg::GrammarRenderer.new(g2)
+    gr2.render io2
+
+    assert_equal io2.string, io.string
+
+    cg2 = KPeg::CodeGenerator.new("Test2", g2, false)
+    cg2.standalone = true
+    pr3 = cg2.make(io2.string)
+    g3 = KPeg::Grammar.new
+    pr3.instance_variable_set(:@g, g3)
+
+    assert pr3.parse, "Couldn't parse with 3rd generation parser"
+
+    io3 = StringIO.new
+    gr3 = KPeg::GrammarRenderer.new(g3)
+    gr3.render io3
+
+    assert_equal io3.string, io2.string
+
+    cg3 = KPeg::CodeGenerator.new("Test3", g3, false)
+    cg3.standalone = true
+    pr4 = cg3.make(io3.string)
+    g4 = KPeg::Grammar.new
+    pr4.instance_variable_set(:@g, g4)
+
+    assert pr4.parse, "Couldn't parse with 4th generation parser"
+
+    io4 = StringIO.new
+    gr4 = KPeg::GrammarRenderer.new(g4)
+    gr4.render io4
+
+    assert_equal io4.string, io3.string
+  end
+end

data/test/test_gen_calc.rb

@@ -0,0 +1,63 @@
+require 'test/unit'
+require 'kpeg'
+require 'kpeg/format_parser'
+require 'kpeg/code_generator'
+require 'stringio'
+
+class TestKPegCodeGenerator < Test::Unit::TestCase
+  GRAMMAR = <<-'STR'
+Stmt    = - Expr:e EOL                  { @answers << e }
+        | ( !EOL . )* EOL               { puts "error" }
+
+Expr    = ID:i ASSIGN Sum:s             { @vars[i] = s }
+        | Sum:s                         { s }
+
+Sum     = Product:l
+                ( PLUS  Product:r       { l += r }
+                | MINUS Product:r       { l -= r }
+                )*                      { l }
+
+Product = Value:l
+                ( TIMES  Value:r        { l *= r }
+                | DIVIDE Value:r        { l /= r }
+                )*                      { l }
+
+Value   = NUMBER:i                      { i }
+        | ID:i !ASSIGN                  { @vars[i] }
+        | OPEN Expr:i CLOSE             { i }
+
+NUMBER  = < [0-9]+ >    -               { text.to_i }
+ID      = < [a-z] >     -               { text }
+ASSIGN  = '='           -
+PLUS    = '+'           -
+MINUS   = '-'           -
+TIMES   = '*'           -
+DIVIDE  = '/'           -
+OPEN    = '('           -
+CLOSE   = ')'           -
+
+-       = (' ' | '\t')*
+EOL     = ('\n' | '\r\n' | '\r' | ';') -
+
+root    = Stmt+
+  STR
+
+  def test_parse
+    parc = KPeg::FormatParser.new(GRAMMAR)
+    assert parc.parse, "Unable to parse"
+
+    gram = parc.grammar
+
+    # gr = KPeg::GrammarRenderer.new(gram)
+    # puts
+    # gr.render(STDOUT)
+
+    cg = KPeg::CodeGenerator.new "TestCalc", gram
+
+    code = cg.make("i = 3+4; j = i*8; i + j * 2;")
+    code.instance_variable_set(:@vars, {})
+    code.instance_variable_set(:@answers, [])
+    assert_equal true, code.parse
+    assert_equal [7,56,119], code.instance_variable_get(:@answers)
+  end
+end