rsec 0.3.2

data/bench/bench.rb

@@ -0,0 +1,60 @@
+# Compare performance between rsec and treetop
+# NOTE simple parser doesn't require much backtracking, so treetop's caching is sure to fail.
+#      Next step is to compare really complex parsers.
+
+# string to be parsed
+s = '(3+24/5)/10-3*4+((82321+12-3)-3*4+(82321+12-3))/5'
+
+# rsec
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+$:.unshift "#{File.dirname(__FILE__)}/../ext"
+require "#{File.dirname(__FILE__)}/../examples/arithmetic"
+
+# treetop
+require "treetop"
+require "#{File.dirname(__FILE__)}/little.rb"
+
+require "benchmark"
+
+def measure &proc
+  puts proc[]
+  200.times &proc
+  puts((Benchmark.measure{
+    1000.times &proc
+  }), '')
+end
+
+# ------------------------------------------------------------------------------
+
+puts ''
+puts Benchmark::CAPTION
+puts ''
+
+print 'rsec result:', "\t"
+p = arithmetic()
+measure{ p.parse! s }
+
+print 'treetop result:', "\t"
+t = ArithmeticParser.new
+measure{ t.parse(s).value }
+
+puts 'treetop without calculation'
+t = ArithmeticParser.new
+measure{ t.parse s }
+
+PARSEC_ARITH_SO = "#{File.dirname(__FILE__)}/parsec/Arithmetic.so"
+if File.exist?(PARSEC_ARITH_SO)
+  require 'dl/import'
+  require 'dl/types'
+  module Arithmetic
+    extend DL::Importer
+    dlload PARSEC_ARITH_SO
+    extern "long calculate(char *)", :stdcall
+    extern "long donothing(char *)", :stdcall
+  end
+  print 'Haskell Parsec result:', "\t"
+  measure{ Arithmetic.calculate s }
+else
+  puts 'Haskell Parsec benchmark requires ghc installation. cd bench/parsec and run make.sh(unix) or make.bat(windows)'
+end
+

data/bench/little.rb

@@ -0,0 +1,328 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module Arithmetic
+  include Treetop::Runtime
+
+  def root
+    @root || :expr
+  end
+
+  module Expr0
+    def op
+      elements[0]
+    end
+
+    def right
+      elements[1]
+    end
+  end
+
+  module Expr1
+    def left
+      elements[0]
+    end
+
+    def right_opt
+      elements[1]
+    end
+  end
+
+  module Expr2
+    def value
+      right_opt.elements.inject(left.value) {|acc, plus_and_right|
+        acc.send \
+		    plus_and_right.op.text_value,
+          plus_and_right.right.value
+      }
+    end
+  end
+
+  def _nt_expr
+    start_index = index
+    if node_cache[:expr].has_key?(index)
+      cached = node_cache[:expr][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_term
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3, s3 = index, []
+        if has_terminal?('\G[\\+\\-]', true, index)
+          r4 = true
+          @index += 1
+        else
+          r4 = nil
+        end
+        s3 << r4
+        if r4
+          r5 = _nt_term
+          s3 << r5
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(Expr0)
+        else
+          @index = i3
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Expr1)
+      r0.extend(Expr2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:expr][start_index] = r0
+
+    r0
+  end
+
+  module Term0
+    def op
+      elements[0]
+    end
+
+    def right
+      elements[1]
+    end
+  end
+
+  module Term1
+    def left
+      elements[0]
+    end
+
+    def right_opt
+      elements[1]
+    end
+  end
+
+  module Term2
+    def value
+      right_opt.elements.inject(left.value) {|acc, mul_and_right|
+        acc.send \
+		    mul_and_right.op.text_value,
+          mul_and_right.right.value
+      }
+    end
+  end
+
+  def _nt_term
+    start_index = index
+    if node_cache[:term].has_key?(index)
+      cached = node_cache[:term][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_factor
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3, s3 = index, []
+        if has_terminal?('\G[\\*\\/]', true, index)
+          r4 = true
+          @index += 1
+        else
+          r4 = nil
+        end
+        s3 << r4
+        if r4
+          r5 = _nt_factor
+          s3 << r5
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(Term0)
+        else
+          @index = i3
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Term1)
+      r0.extend(Term2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:term][start_index] = r0
+
+    r0
+  end
+
+  module Factor0
+    def expr
+      elements[1]
+    end
+
+  end
+
+  module Factor1
+    def value
+      expr.value
+    end
+  end
+
+  def _nt_factor
+    start_index = index
+    if node_cache[:factor].has_key?(index)
+      cached = node_cache[:factor][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    if has_terminal?('(', false, index)
+      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('(')
+      r2 = nil
+    end
+    s1 << r2
+    if r2
+      r3 = _nt_expr
+      s1 << r3
+      if r3
+        if has_terminal?(')', false, index)
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure(')')
+          r4 = nil
+        end
+        s1 << r4
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(Factor0)
+      r1.extend(Factor1)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r0 = r1
+    else
+      r5 = _nt_number
+      if r5
+        r0 = r5
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:factor][start_index] = r0
+
+    r0
+  end
+
+  module Number0
+  end
+
+  module Number1
+    def value
+      text_value.to_f
+    end
+  end
+
+  def _nt_number
+    start_index = index
+    if node_cache[:number].has_key?(index)
+      cached = node_cache[:number][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if has_terminal?('\G[1-9]', true, index)
+      r1 = true
+      @index += 1
+    else
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        if has_terminal?('\G[0-9]', true, index)
+          r3 = true
+          @index += 1
+        else
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Number0)
+      r0.extend(Number1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:number][start_index] = r0
+
+    r0
+  end
+
+end
+
+class ArithmeticParser < Treetop::Runtime::CompiledParser
+  include Arithmetic
+end
+
+

data/bench/profile.rb

@@ -0,0 +1,14 @@
+# string to be parsed
+s = '(3+24/5)/10-3*4+((82321+12-3)-3*4+(82321+12-3))/5'
+
+# rsec
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+$:.unshift "#{File.dirname(__FILE__)}/../ext"
+require "#{File.dirname(__FILE__)}/../examples/arithmetic"
+
+p = arithmetic
+
+require "profile"
+1000.times{
+  p.parse s
+}

data/examples/arithmetic.rb

@@ -0,0 +1,28 @@
+# arithmetic parser
+
+require "rsec"
+
+include Rsec::Helpers
+
+def arithmetic
+  calculate = proc do |(p, *ps)|
+    ps.each_slice(2).inject(p) do |left, (op, right)|
+      left.send op, right
+    end
+  end
+
+  num    = prim(:double).fail 'number'
+  paren  = '('.r >> lazy{expr} << ')'
+  factor = num | paren
+  term   = factor.join(one_of_('*/%').fail 'operator').map &calculate
+  expr   = term.join(one_of_('+-').fail 'operator').map &calculate
+  expr.eof
+end
+
+if __FILE__ == $PROGRAM_NAME
+  print '1+ 2*4 = '
+  p arithmetic.parse! '1+ 2*4' #=> 9
+  print '1+ 2*/4 = '
+  p arithmetic.parse! '1+ 2*/4' #=> syntax error
+end
+

data/examples/bnf.rb

@@ -0,0 +1,31 @@
+# BNF grammar parser
+# http://en.wikipedia.org/wiki/Backus-Naur_form
+
+require "rsec"
+
+include Rsec::Helpers
+
+def bnf
+  nbsp      = /[\ \t]*/.r
+  spacee    = /\s*/.r # include \n
+  literal   = /".*?"|'.*?'/.r
+  rule_name = /\<.*?\>/
+  term      = literal | rule_name
+  list      = term.join(nbsp).even
+  expr      = list.join seq(nbsp, '|', nbsp)[1]
+  rule      = seq_ rule_name, '::=', expr
+  spacee.join(rule).eof
+end
+
+require "pp"
+pp bnf.parse! DATA.read
+
+__END__
+<syntax>     ::= <rule> | <rule> <syntax>
+<rule>       ::= <opt-whitespace> "<" <rule-name> ">" <opt-whitespace> "::=" <opt-whitespace> <expression> <line-end>
+<opt-whitespace> ::= " " <opt-whitespace> | ""
+<expression> ::= <list> | <list> "|" <expression>
+<line-end>   ::= <opt-whitespace> <EOL> | <line-end> <line-end>
+<list>       ::= <term> | <term> <opt-whitespace> <list>
+<term>       ::= <literal> | "<" <rule-name> ">"
+<literal>    ::= '"' <text> '"' | "'" <text> "'"