grammar 0.5 → 0.8

data/test/test_demo.rb

@@ -0,0 +1,200 @@
+#!/bin/env ruby
+require 'rubygems'
+gem 'grammar', '0.8'
+require 'test/unit'
+require 'stringio'
+require 'grammar'
+require 'grammar/ruby'
+class GrammarDemo < ::Test::Unit::TestCase
+    include Grammar::Molecules
+    def engine
+        Grammar::Ruby
+    end
+    def compile(gram)
+        #engine.dump(gram).lined
+        engine.compile(gram)
+    end
+    def error
+        RuntimeError
+    end
+    def input(s)
+        StringIO.new(s).method(:getc)
+    end
+
+    def test_digit
+
+        digit = E(?0..?9)
+
+        parser = compile(digit)
+        
+        o = []
+        assert_equal([?1],     parser[o, input("1" )] && o)
+        assert_equal([?1, ?2], parser[o, input("23")] && o)
+        assert_raise(error) {  parser[o, input(""  )] }
+        assert_raise(error) {  parser[o, input("a" )] }
+    end
+
+
+
+
+
+
+
+
+
+
+
+    def test_digits
+
+        digits = E(?0..?9).repeat1
+
+        parser = compile(digits + EOF)
+        
+        assert_equal([?1],     parser[o=[], input("1" )] && o)
+        assert_equal([?2, ?3], parser[o=[], input("23")] && o)
+        assert_raise(error) {  parser[o=[], input("4a")] }
+        assert_equal([?4], o)
+        assert_raise(error) {  parser[o=[], input(""  )] }
+    end
+
+
+
+
+
+
+
+
+
+
+
+    def test_int
+
+        int = E(?0..?9).repeat1.group("") { |s| s.to_i }
+
+        parser = compile(int + EOF)
+        
+        assert_equal([1],  parser[o=[], input("1" )] && o)
+        assert_equal([23], parser[o=[], input("23")] && o)
+    end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    def test_prim
+
+        int = E(?0..?9).repeat1.group("") { |s| s.to_i }
+        expr = Grammar()
+        prim = int | E(?().discard + expr + E(?)).discard
+
+        parser = compile(Recurse(expr) { prim } + EOF)
+        
+        assert_equal([123],   parser[o=[], input("123"     )] && o)
+        assert_equal([123],   parser[o=[], input("(123)"   )] && o)
+        assert_equal([123],   parser[o=[], input("((123))" )] && o)
+        assert_raise(error) { parser[o=[], input("((123)"  )] }
+    end
+
+
+
+
+
+
+
+
+
+
+    def test_unary
+
+        int = E(?0..?9).repeat1.group("") { |s| s.to_i }
+        expr = Grammar()
+        prim = int | E(?().discard + expr + E(?)).discard
+        unary = E(?-).discard + prim + Always { |e|
+            e.output << -e.output.pop
+        } | prim
+
+        parser = compile(Recurse(expr) { unary } + EOF)
+        
+        assert_equal([123],  parser[o=[], input("123"   )] && o)
+        assert_equal([123],  parser[o=[], input("(123)" )] && o)
+        assert_equal([-123], parser[o=[], input("-123"  )] && o)
+        assert_equal([-123], parser[o=[], input("-(123)")] && o)
+    end
+
+
+
+
+
+
+
+    def test_prod
+
+        int = E(?0..?9).repeat1.group("") { |s| s.to_i }
+        expr = Grammar()
+        prim = int | E(?().discard + expr + E(?)).discard
+        unary = E(?-).discard + prim + Always { |e|
+            e.output << -e.output.pop
+        } | prim
+        prod = Recurse { |prod|
+            prod + E(?*).discard + unary + Always { |e|
+                e.output << (e.output.pop * e.output.pop)
+            } | unary
+        }
+
+        parser = compile(Recurse(expr) { prod } + EOF)
+        
+        assert_equal([123],  parser[o=[], input("123"  )] && o)
+        assert_equal([123],  parser[o=[], input("(123)")] && o)
+        assert_equal([-123], parser[o=[], input("-123" )] && o)
+        assert_equal([6],    parser[o=[], input("2*3"  )] && o)
+        assert_equal([-6],   parser[o=[], input("2*-3" )] && o)
+    end
+
+    def test_sum
+
+        int = E(?0..?9).repeat1.group("") { |s| s.to_i }
+        expr = Grammar()
+        prim = int | E(?().discard + expr + E(?)).discard
+        unary = E(?-).discard + prim + Always { |e|
+            e.output << -e.output.pop
+        } | prim
+        prod = Recurse { |prod|
+            prod + E(?*).discard + unary + Always { |e|
+                e.output << (e.output.pop * e.output.pop)
+            } | unary
+        }
+        sum = Recurse { |sum|
+            sum + (
+                E(?+).discard + prod + Always { |e|
+                    e.output << (e.output.pop + e.output.pop)
+                } |
+                E(?-).discard + prod + Always { |e|
+                    e.output << (-e.output.pop + e.output.pop)
+                }
+            ) | prod
+        }
+
+        parser = compile(Recurse(expr) { sum } + EOF)
+        
+        assert_equal([123],  parser[o=[], input("123"    )] && o)
+        assert_equal([123],  parser[o=[], input("(123)"  )] && o)
+        assert_equal([-123], parser[o=[], input("-123"   )] && o)
+        assert_equal([5],    parser[o=[], input("2+3"    )] && o)
+        assert_equal([-1],   parser[o=[], input("2-3"    )] && o)
+        assert_equal([-10],  parser[o=[], input("2-3*4"  )] && o)
+        assert_equal([14],   parser[o=[], input("2*(3+4)")] && o)
+        assert_equal([20],   parser[o=[], input("(2+3)*4")] && o)
+    end
+
+end
+
+

data/test/test_ruby.rb

@@ -0,0 +1,30 @@
+#!/bin/env ruby
+
+require 'test/unit'
+require 'stringio'
+
+require 'grammar'
+require 'grammar/ruby'
+
+$: << File.dirname(__FILE__)
+require 'atoms'
+require 'molecules'
+require 'basic'
+require 'advanced'
+require 'composite'
+
+class Grammar
+module Test
+class Ruby < ::Test::Unit::TestCase
+    include Atoms
+    include Basic
+    include Molecules
+    include Advanced
+    include Composite
+    def engine; Grammar::Ruby; end
+    def error; RuntimeError; end
+end
+end
+end
+
+

data/test/test_ruby0.rb

@@ -0,0 +1,30 @@
+#!/bin/env ruby
+
+require 'test/unit'
+require 'stringio'
+
+require 'grammar'
+require 'grammar/ruby0'
+
+$: << File.dirname(__FILE__)
+require 'atoms'
+require 'molecules'
+require 'basic'
+require 'advanced'
+require 'composite'
+
+class Grammar
+module Test
+class Ruby0 < ::Test::Unit::TestCase
+    include Atoms
+    include Molecules
+    include Basic
+    include Advanced
+    include Composite
+    def engine; Grammar::Ruby0; end
+    def error; Grammar::Ruby0::Error; end
+end
+end
+end
+
+

data/test/test_ruby2cext.rb

@@ -0,0 +1,30 @@
+#!/bin/env ruby
+
+require 'test/unit'
+require 'stringio'
+
+require 'grammar'
+require 'grammar/ruby2cext'
+
+$: << File.dirname(__FILE__)
+require 'atoms'
+require 'molecules'
+require 'basic'
+require 'advanced'
+require 'composite'
+
+class Grammar
+module Test
+class Ruby2CExt < ::Test::Unit::TestCase
+    include Atoms
+    include Basic
+    include Molecules
+    include Advanced
+    include Composite
+    def engine; Grammar::Ruby2CExt; end
+    def error; RuntimeError; end
+end
+end
+end
+
+

data/test/test_rubycall.rb

@@ -0,0 +1,30 @@
+#!/bin/env ruby
+
+require 'test/unit'
+require 'stringio'
+
+require 'grammar'
+require 'grammar/rubycall'
+
+$: << File.dirname(__FILE__)
+require 'atoms'
+require 'molecules'
+require 'basic'
+require 'advanced'
+require 'composite'
+
+class Grammar
+module Test
+class RubyCall < ::Test::Unit::TestCase
+    include Atoms
+    include Basic
+    include Molecules
+    include Advanced
+    include Composite
+    def engine; Grammar::RubyCall; end
+    def error; RuntimeError; end
+end
+end
+end
+
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.10
+rubygems_version: 0.9.4
 specification_version: 1
 name: grammar
 version: !ruby/object:Gem::Version 
-  version: "0.5"
-date: 2005-10-13
+  version: "0.8"
+date: 2008-09-05 00:00:00 -05:00
 summary: BNF-like grammar specified directly in ruby
 require_paths: 
-  - lib
+- lib
 email: Eric under Mahurin at yahoo dot com
 homepage: http://rubyforge.org/projects/grammar/
 rubyforge_project: grammar
@@ -18,37 +18,54 @@ bindir:
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
 authors: 
-  - Eric Mahurin
+- Eric Mahurin
 files: 
-  - lib/grammar.rb
-  - test/test_grammar.rb
-  - samples/fact.tcl
-  - samples/infix2postfix.rb
-  - samples/tcl.rb
-  - samples/test.infix
-  - samples/CVS
+- lib/grammar.rb
+- lib/grammar/ruby2cext.rb
+- lib/grammar/ruby0.rb
+- lib/grammar/ruby.rb
+- lib/grammar/rubycall.rb
+- lib/grammar/ruby/code.rb
+- test/molecules.rb
+- test/atoms.rb
+- test/test_ruby.rb
+- test/advanced.rb
+- test/test_ruby0.rb
+- test/test_rubycall.rb
+- test/composite.rb
+- test/test_ruby2cext.rb
+- test/test_demo.rb
+- test/basic.rb
+- benchmark/json.benchmark.rb
+- benchmark/json.grammar.rb
+- benchmark/json.grammar0_5.rb
+- benchmark/json.ll1.rb
+- benchmark/json.re.rb
+- benchmark/json.peggy.rb
 test_files: 
-  - test/test_grammar.rb
+- test/test_ruby.rb
+- test/test_ruby0.rb
+- test/test_rubycall.rb
+- test/test_ruby2cext.rb
+- test/test_demo.rb
 rdoc_options: []
+
 extra_rdoc_files: []
+
 executables: []
+
 extensions: []
+
 requirements: []
-dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: cursor
-    version_requirement: 
-    version_requirements: !ruby/object:Gem::Version::Requirement 
-      requirements: 
-        - 
-          - ">="
-          - !ruby/object:Gem::Version 
-            version: "0.9"
-      version: 
+
+dependencies: []
+

data/samples/fact.tcl

@@ -1,12 +0,0 @@
-proc factorial a {
-    set ret 1
-    # factorial(0) == 1
-    if $a {
-        set ret [product $a [factorial \
-            [subtract $a 1]]]
-    }
-    sum $ret
-}
-set x::y(1) 6
-concat "factorial(\"$x::y(1)\") = " [factorial $x::y(1)] "\n"
-

data/samples/infix2postfix.rb

@@ -1,114 +0,0 @@
-#!/bin/env ruby
-
-require 'rubygems'
-require 'cursor/io'
-require 'cursor/indexed'
-require 'grammar'
-require 'duck'
-require 'set'
-
-class Expression
-
-def self.lexer
-    space = Grammar::Element[Set[?\ ,?\t,?\n].
-        duck!(:==,:include?,:to_s,:inspect)]
-    spacing = space.discard.list1
-    
-    alpha = Grammar::Element[(Set[?_]+(?a..?z)+(?A..?Z)).
-        duck!(:==,:include?,:to_s,:inspect)]
-    alphanum = Grammar::Element[(Set[?_]+(?0..?9)+(?a..?z)+(?A..?Z)).
-        duck!(:==,:include?,:to_s,:inspect)]
-    identifier = (alpha+alphanum.list0).
-        filter(String) { |iden,buf| buf << iden.to_sym }
-    
-    int = Grammar::Element[(?0..?9).duck!(:==,:===)].list1
-    number =
-        (int.group(String) +
-        ((Grammar::Element[?.]+int).optional +
-          ((Grammar::Element[?e]|Grammar::Element[?E])+
-           (Grammar::Element[?+]|Grammar::Element[?-]).optional+int).optional).
-           group(String)).
-        filter(Array) { |num,buf|
-            buf << (num[1].empty? ? num.to_s.to_i : num.to_s.to_f)
-        }
-          
-    hex = Grammar::Element[(
-        Set[]+(?0..?9)+(?a..?f)+(?A..?F)
-    ).duck!(:==,:include?,:to_s,:inspect)]
-    octal = Grammar::Element[(?0..?7).duck!(:==,:===)]
-    backslashed = Grammar::Element[?\\].discard+(
-        Grammar::Element[?a].filter { "\a" } |
-        Grammar::Element[?b].filter { "\b" } |
-        Grammar::Element[?f].filter { "\f" } |
-        Grammar::Element[?n].filter { "\n" } |
-        Grammar::Element[?r].filter { "\r" } |
-        Grammar::Element[?t].filter { "\t" } |
-        Grammar::Element[?v].filter { "\v" } |
-        Grammar::Element[?x].discard+hex.list1.filter { |n|
-            eval(%Q("\\x#{n}"))
-        } |
-        octal.list1.filter { |n|
-            eval(%Q("\\#{n}"))
-        } |
-        Grammar::ANY
-    )
-    character =
-        backslashed |
-        Grammar::ANY
-    string = Grammar::Element[?\"].discard + 
-        character.list1(Grammar::Element[?\"].discard).group(String)
-    other = Grammar::ANY.filter(String) { |op,buf| buf << op.to_sym }
-
-    (
-        spacing |
-        identifier |
-        number |
-        string |
-        other
-    ).list0(Grammar::EOF)
-end
-
-def self.parser
-    integer = Grammar::Element[Integer.duck!(:==,:===)]
-    float = Grammar::Element[Float.duck!(:==,:===)]
-    string = Grammar::Element[String.duck!(:==,:===)]
-    identifier = Grammar::Element[lambda { |v|
-        Symbol===v && ( /\A[_a-zA-Z]/=~v.to_s )
-    }.duck!(:==)]
-    expression = Grammar.new { |expression|
-        primary =
-            integer |
-            float |
-            string |
-            identifier |
-            Grammar::Element[:"("].discard+expression+Grammar::Element[:")"].discard
-        product_op = Grammar::Element[:"*"]|Grammar::Element[:"/"]
-        product = primary.filter(Array) { |x,buf|
-            op = buf.pop
-            buf.concat(x)
-            buf << op if op
-            buf
-        }.list1(nil,product_op)
-        sum_op = Grammar::Element[:"+"]|Grammar::Element[:"-"]
-        sum = product.filter(Array) { |x,buf|
-            op = buf.pop
-            buf.concat(x)
-            buf << op if op
-            buf
-        }.list1(nil,sum_op)
-    }
-end
-
-end
-
-if __FILE__==$0
-    lexer = Expression.lexer
-    token_buffer = Cursor::Producer.new { |buffer|
-        lexer.scan($stdin.to_cursor,buffer)
-    }
-    parser = Expression.parser
-    result = parser.scan(token_buffer)
-    p result
-    result
-end
-