yaparc 0.0.4 → 0.0.6

data/lib/yaparc.rb

@@ -13,7 +13,7 @@ module Yaparc
 
     IS_LOWER = lambda {|c| c >= 'a' and c <= 'z'}
     IS_ALPHANUM = lambda {|c| (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9')}
-    IS_DIGIT = lambda {|i| i > '0' and i < '9'}
+    IS_DIGIT = lambda {|i| i >= '0' and i <= '9'}
     IS_SPACE = lambda {|i| i == ' '}
 
     def self.included(mod)
@@ -24,7 +24,7 @@ module Yaparc
     def parse(input, &block)
       tree = @parser.call(input)
       if block_given?
-        @tree = yield tree 
+        @tree = yield tree
       else
         @tree = tree
       end
@@ -40,35 +40,38 @@ module Yaparc
       end
 
       def define_parser(&block)
-        @@parser = lambda do |input|
-          parser = yield
-          parser.parse(input)
+        @@cparser = lambda do
+          yield
         end
       end
 
-      def parser
-        @@parser
-      end
+#       def define_parser(&block)
+#         @@parser = lambda do |input|
+#           parser = yield
+#           parser.parse(input)
+#         end
+#       end
 
-      def parse(input, &block)
-        tree = @@parser.call(input)
+      def cparse(input, &block)
+        tree = @@cparser.call.parse(input)
         if block_given?
-          @@tree = yield tree 
+          yield tree
         else
-          @@tree = tree
+          tree
         end
       end
-#       def self.initialize
-#         @parser = @@parser
-#       end
+      module_function :cparse
 
     end
-  end # of Parsable
+  end # of Module Parsable
+
 
   class SucceedParser
     include Parsable
-    def initialize(value)
+    attr_reader :remaining
+    def initialize(value, remaining = nil)
       @parser = lambda {|input| [[value, input]]}
+      @remaining = remaining
     end
   end
 
@@ -100,18 +103,34 @@ module Yaparc
       @parser = lambda do |input|
         item = ItemParser.new.parse(input)
         if item == []
-          FailParser.new.parse(input)
+          FailParser.new
         else
-          if predicate.call(item[0][0])
-            SucceedParser.new(item[0][0]).parse(item[0][1])
-          else
-            FailParser.new.parse(input)
-          end
+          parser = if predicate.call(item[0][0])
+#                     input = item[0][1]
+                     SucceedParser.new(item[0][0], item[0][1])
+                   else
+                     FailParser.new
+                   end
+#          parser.parse(input)
         end
       end
     end
+
+    def parse(input)
+      parser = @parser.call(input)
+      case parser
+      when SucceedParser
+        parser.parse(parser.remaining)
+      when FailParser
+        parser.parse(input)
+      else
+        raise
+      end
+    end
+
   end
 
+
   class SeqParser
     include Parsable
     def initialize(*parsers, &block)
@@ -134,6 +153,7 @@ module Yaparc
         end
       end
     end # of initialize
+
   end # of SeqParser
 
   class AltParser
@@ -152,23 +172,45 @@ module Yaparc
     end # of initialize
   end
 
-  class CharParser
+
+  class ParserBase
+    include Parsable
+
+    def parse(input)
+      @parser.parse(input)
+    end
+  end
+
+  class AbstractParser
     include Parsable
+
+    def parse(input, &block)
+      tree = @parser.call.parse(input)
+      if block_given?
+        @tree = yield tree
+      else
+        @tree = tree
+      end
+
+    end
+  end
+
+  class CharParser < ParserBase
+
     def initialize(char)
       equal_char = lambda {|i| i == char}
-      @parser = lambda do |input|
-        SatisfyParser.new(equal_char).parse(input)
-      end
+      @parser = SatisfyParser.new(equal_char)
     end
   end
 
+
   class StringParser
     include Parsable
     def initialize(string)
       @parser = lambda do |input|
         result = ItemParser.new.parse(string)
         if result == []
-          SucceedParser.new(result).parse(input) # FailParser.new.parse(input)
+          SucceedParser.new(result)
         else
           SeqParser.new(
                         CharParser.new(result[0][0]),
@@ -176,14 +218,20 @@ module Yaparc
                         SucceedParser.new(result[0][0] + result[0][1])
                         ) do |char_result, string_result, succeed_result|
             succeed_result
-          end.parse(input)
+          end
         end
       end
     end
+
+    def parse(input)
+      @parser.call(input).parse(input)
+    end
   end
 
+
   class RegexParser
     include Parsable
+
     def initialize(regex)
       @parser = lambda do |input|
         if match = Regexp.new(regex).match(input)
@@ -195,6 +243,7 @@ module Yaparc
     end
   end
 
+  # permits zero or more applications of parser.
   class ManyParser
     include Parsable
     def initialize(parser)
@@ -202,14 +251,18 @@ module Yaparc
         AltParser.new(ManyOneParser.new(parser), SucceedParser.new([])).parse(input)
       end
     end
+
+    def parse(input)
+      @parser.call(input)
+    end
   end
 
+  # requires at least one successfull application of parser.
   class ManyOneParser
     include Parsable
     def initialize(parser)
       @parser = lambda do |input|
         SeqParser.new(
-#                      SatisfyParser.new(parser),
                       parser,
                       ManyParser.new(parser)
                       ) do |v, vs|
@@ -218,104 +271,95 @@ module Yaparc
           else
             v + vs.to_s
           end
-        end.parse(input)
+        end
       end
     end
+
+    def parse(input)
+      @parser.call(input).parse(input)
+    end
   end
 
-  class ZeroOneParser
-    include Parsable
+
+  class ZeroOneParser < ParserBase
+
     def initialize(parser)
-      @parser = lambda do |input|
-        AltParser.new(parser, 
-                      SucceedParser.new([])).parse(input)
-      end
+      @parser = AltParser.new(parser, SucceedParser.new([]))
     end
   end
 
-  class Ident
-    include Parsable
+
+  class Ident < ParserBase
+
     def initialize
-      @parser = lambda do |input|
-        SeqParser.new(
-                      SatisfyParser.new(IS_LOWER),
-#                      ManyParser.new(IS_ALPHANUM)
-                      ManyParser.new(SatisfyParser.new(IS_ALPHANUM))
-                      ) do |v, vs|
-          if vs == []
-            v
-          else
-            v + vs.to_s
-          end
-        end.parse(input)
+      @parser = SeqParser.new(
+                              SatisfyParser.new(IS_LOWER),
+                              ManyParser.new(SatisfyParser.new(IS_ALPHANUM))
+                              ) do |v, vs|
+        if vs == []
+          v
+        else
+          v + vs.to_s
+        end
       end
     end
   end
 
-  class Nat
-    include Parsable
+  class Nat < ParserBase
+
     def initialize
-      @parser = lambda do |input|
-#        SeqParser.new(ManyOneParser.new(IS_DIGIT)) do |vs|
-        SeqParser.new(ManyOneParser.new(SatisfyParser.new(IS_DIGIT))) do |vs|
-          if vs == []
-            vs
-          else
-            vs.to_i
-          end
-        end.parse(input)
+      @parser = SeqParser.new(ManyOneParser.new(SatisfyParser.new(IS_DIGIT))) do |vs|
+        if vs == []
+          vs
+        else
+          vs.to_i
+        end
       end
     end
   end
 
-  class Space
-    include Parsable
+
+  class Space < ParserBase
+
     def initialize
-      @parser = lambda do |input|
-#        SeqParser.new(ManyParser.new(IS_SPACE)) do |vs|
-        SeqParser.new(ManyParser.new(SatisfyParser.new(IS_SPACE))) do |vs|
-          []
-        end.parse(input)
+      @parser = SeqParser.new(ManyParser.new(SatisfyParser.new(IS_SPACE))) do |vs|
+        []
       end
     end
   end
 
-  class Token
-    include Parsable
+
+  class Token < ParserBase
+
     def initialize(parser)
-      @parser = lambda do |input|
-        SeqParser.new(Space.new, parser, Space.new) do |_, vs, _|
-          vs
-        end.parse(input)
+      @parser = SeqParser.new(Space.new, parser, Space.new) do |_, vs, _|
+        vs
       end
     end
   end
 
-  class Identifier
-    include Parsable
+
+  class Identifier < ParserBase
+
     def initialize
-      @parser = lambda do |input|
-        Token.new(Ident.new).parse(input)
-      end
+      @parser = Token.new(Ident.new)
     end
   end
 
-  class Natural
-    include Parsable
+
+  class Natural < ParserBase
+
     def initialize
-      @parser = lambda do |input|
-        Token.new(Nat.new).parse(input)
-      end
+      @parser = Token.new(Nat.new)
     end
   end
 
-  class Symbol
-    include Parsable
+
+  class Symbol < ParserBase
+
     def initialize(literal)
-      @parser = lambda do |input|
-        Token.new(StringParser.new(literal)).parse(input)
-      end
+      @parser = Token.new(StringParser.new(literal))
     end
   end
 
-end
+end # of Yaparc

data/tests/test_calc.rb

@@ -3,38 +3,55 @@ require 'test/unit'
 require 'pp'
 
 
+class Expr < Yaparc::AbstractParser
+#  include Yaparc::Parsable
 
-class Expr
-  include Yaparc::Parsable
-
-  define_parser do
-    AltParser.new(
-                  SeqParser.new(Term.new,
-                                Symbol.new('+'),
-                                Expr.new) do |term, _, expr|
-                    ['+', term,expr]
-                  end,
-                  Term.new
-                  )
-  end
+#   define_parser do
+#     Yaparc::AltParser.new(
+#                           Yaparc::SeqParser.new(Term.new,
+#                                                 Yaparc::Symbol.new('+'),
+#                                                 Expr.new) do |term, _, expr|
+#                             ['+', term,expr]
+#                           end,
+#                           Term.new
+#                           )
+#   end
 
   def initialize
-    @parser = lambda do |input|
-      AltParser.new(
-                    SeqParser.new(Term.new,
-                                  Symbol.new('+'),
-                                  Expr.new) do |term, _, expr|
-                      ['+', term,expr]
-                    end,
-                    Term.new
-                    ).parse(input)
+    @parser = lambda do
+      Yaparc::AltParser.new(
+                            Yaparc::SeqParser.new(Term.new,
+                                                  Yaparc::Symbol.new('+'),
+                                                  Expr.new) do |term, _, expr|
+                              ['+', term,expr]
+                            end,
+                            Term.new
+                            )
+#       SeqParser.new(Term.new,
+#                     AltParser.new(
+#                                   SeqParser.new(
+#                                                 Symbol.new('+'),
+#                                                 Expr.new) do |_, expr|
+#                                     expr
+#                                   end,
+#                                   SucceedParser.new([]))
+#                     ) do |term, expr|
+#         if expr == []
+#           term
+#         else
+#           ['+', term,expr]
+#         end
+#       end
     end
   end
 
-  def eval(input)
+#   def parse(input)
+#     @parser.call.parse(input)
+#   end
+
+  def evaluate(input)
     result = parse(input)
     tree = result[0][0]
-#    p tree
     eval_tree(tree)
   end
   
@@ -54,85 +71,154 @@ class Expr
     else
       tree
     end
-    
   end
 end
 
-class Term
-  include Yaparc::Parsable
+class Term < Yaparc::AbstractParser
+#  include Yaparc::Parsable
 
 #   define_parser do
-#     AltParser.new(
-#                   SeqParser.new(Factor.new,
-#                                 Symbol.new('*'),
-#                                 Term.new) do |factor, _, term|
-#                     ['*', factor,term]
-#                   end,
-#                   Factor.new
-#                   )
+#     Yaparc::AltParser.new(
+#                           Yaparc::SeqParser.new(Factor.new,
+#                                                 Yaparc::Symbol.new('*'),
+#                                                 Term.new) do |factor, _, term|
+#                             ['*', factor,term]
+#                           end,
+#                           Factor.new
+#                           )
 #   end
 
   def initialize
-    @parser = lambda do |input|
-      AltParser.new(
-                    SeqParser.new(Factor.new,
-                                  Symbol.new('*'),
-                                  Term.new) do |factor, _, term|
-                      ['*', factor,term]
-                    end,
-                    Factor.new
-                    ).parse(input)
+    @parser = lambda do
+      Yaparc::AltParser.new(
+                            Yaparc::SeqParser.new(Factor.new,
+                                                  Yaparc::Symbol.new('*'),
+                                                  Term.new) do |factor, _, term|
+                              ['*', factor,term]
+                            end,
+                            Factor.new
+                            )
+#       SeqParser.new(Factor.new,
+#                     AltParser.new(
+#                                   SeqParser.new(Symbol.new('*'),
+#                                                 Term.new) do |_, term|
+#                                     term
+#                                   end,
+#                                   SucceedParser.new([]))
+#                     ) do |factor, term|
+#         if term == []
+#           factor
+#         else
+#           ['*', factor,term]
+#         end
+#       end
     end
   end
+
+#   def parse(input)
+#     @parser.call.parse(input)
+#   end
 end
 
-class Factor
-  include Yaparc::Parsable
+class Factor < Yaparc::AbstractParser
+#  include Yaparc::Parsable
 
-#   define_parser do
-#     AltParser.new(
-#                   SeqParser.new(Symbol.new('('),
-#                                 Expr.new,
-#                                 Symbol.new(')')) do |_,expr, _|
-#                     expr
-#                   end,
-#                   Natural.new
-#                   )
-#   end
+  define_parser do
+    AltParser.new(
+                  Yaparc::SeqParser.new(
+                                        Yaparc::Symbol.new('('),
+                                        Expr.new,
+                                        Yaparc::Symbol.new(')')
+                                        ) do |_,expr, _|
+                    expr
+                  end,
+                  Natural.new
+                  )
+  end
 
   def initialize
-    @parser = lambda do |input|
+    @parser = lambda do
       AltParser.new(
-                    SeqParser.new(Symbol.new('('),
-                                  Expr.new,
-                                  Symbol.new(')')) do |_,expr, _|
+                    Yaparc::SeqParser.new(
+                                          Yaparc::Symbol.new('('),
+                                          Expr.new,
+                                          Yaparc::Symbol.new(')')
+                                          ) do |_,expr, _|
                       expr
                     end,
-                    Natural.new
-                    ).parse(input)
+                    Yaparc::Natural.new
+                    )
     end
   end
+
+#   def parse(input)
+#     @parser.call.parse(input)
+#   end
 end
 
+# class Comb  < Yaparc::ParserBase
+#   include Yaparc::Parsable
+
+#   def initialize
+#     @parser = lambda do
+#       AltParser.new(
+#                     SeqParser.new(Symbol.new('+'),
+#                                   Nat.new) do | _, nat|
+#                       nat
+#                     end,
+#                     Nat.new
+#                     )
+#     end
+#   end
+
+#   def parse(input)
+#     @parser.call.parse(input)
+#   end
+# end
+
 class YaparcCalcTest < Test::Unit::TestCase
   include ::Yaparc
 
   def setup
+    @expr = Expr.new
+    @factor = Factor.new
   end
 
   def test_expr
-    parser = Expr.new
-    result = parser.parse("1 + 2 ")
+    result = @expr.parse("1 + 2 ")
     assert_equal [[["+", 1, 2], ""]],  result
-    assert_equal 3, parser.eval("1 + 2 ")
-    assert_equal 9, parser.eval("(1 + 2) * 3 ")
+    assert_equal 3, @expr.evaluate("1 + 2 ")
+    assert_equal 9, @expr.evaluate("(1 + 2) * 3 ")
   end
 
-  def test_expr_define_parser
-    parser = Expr.new
-    result = Expr.parse("1 + 2 ")
-    assert_equal [[["+", 1, 2], ""]],  result
-    assert_equal 3, parser.eval("1 + 2 ")
-    assert_equal 9, parser.eval("(1 + 2) * 3 ")
+  def test_factor
+    result = @factor.parse("1")
+    assert_equal [[1, ""]],  result
+
+    result = @factor.parse("( 1 )")
+    assert_equal [[1, ""]],  result
+
+    result = @factor.parse("( 312 )")
+    assert_equal [[312, ""]],  result
   end
+
+#   def test_cexpr
+#     result = @expr.cparse("1 + 2 ")
+#     assert_equal [[["+", 1, 2], ""]],  result
+#   end
+
+#   def test_comb
+#      comb = Comb.new
+#      result = comb.parse("+123")
+#      assert_equal [[123, ""]],  result
+#   end
+
+
+#   def test_expr_define_parser
+#     parser = Expr.new
+#     result = Expr.parse("1 + 2 ")
+#     assert_equal [[["+", 1, 2], ""]],  result
+# #     assert_equal 3, parser.evaluate("1 + 2 ")
+# #     assert_equal 9, parser.evaluate("(1 + 2) * 3 ")
+#   end
 end

data/tests/test_parser.rb

@@ -37,6 +37,36 @@ class YaparcTest < Test::Unit::TestCase
     assert_equal [["a", "bc"]],  result
   end
 
+  def test_satisfy_parse
+    is_integer = lambda do |i|
+      begin
+        Integer(i)
+        true
+      rescue
+        false
+      end
+    end
+    parser = SatisfyParser.new(is_integer)
+    result = parser.parse("123")
+    assert_equal [["1", "23"]],  result
+
+    parser = SatisfyParser.new(is_integer)
+    result = parser.parse("abc")
+    assert_equal [],  result
+
+    is_char = lambda do |i|
+      begin
+        String(i)
+        true
+      rescue
+        false
+      end
+    end
+    parser = SatisfyParser.new(is_char)
+    result = parser.parse("abc")
+    assert_equal [["a", "bc"]],  result
+  end
+
   def test_seq_parse
     parser = SeqParser.new(ItemParser.new, ItemParser.new) do |item1, item2|
       [item1, item2]
@@ -71,35 +101,6 @@ class YaparcTest < Test::Unit::TestCase
     assert_equal [],  result
   end
 
-  def test_satisfy_parse
-    is_integer = lambda do |i|
-      begin
-        Integer(i)
-        true
-      rescue
-        false
-      end
-    end
-    parser = SatisfyParser.new(is_integer)
-    result = parser.parse("123")
-    assert_equal [["1", "23"]],  result
-
-    parser = SatisfyParser.new(is_integer)
-    result = parser.parse("abc")
-    assert_equal [],  result
-
-    is_char = lambda do |i|
-      begin
-        String(i)
-        true
-      rescue
-        false
-      end
-    end
-    parser = SatisfyParser.new(is_char)
-    result = parser.parse("abc")
-    assert_equal [["a", "bc"]],  result
-  end
 
   def test_char_parse
     parser = CharParser.new("a")
@@ -131,6 +132,15 @@ class YaparcTest < Test::Unit::TestCase
     assert_equal [["1234", "ab"]],  result
   end
 
+  def test_zero_one_parse
+    parser = ZeroOneParser.new(StringParser.new("abc"))
+    result = parser.parse("abc  ")
+    assert_equal [["abc", "  "]],  result
+    parser = ZeroOneParser.new(StringParser.new("abc"))
+    result = parser.parse("123")
+    assert_equal [[[], "123"]],  result
+  end
+
   def test_many_parse
 #    is_digit = lambda {|i| i > '0' and i < '9'}
     is_digit = SatisfyParser.new(lambda {|i| i > '0' and i < '9'})
@@ -142,14 +152,6 @@ class YaparcTest < Test::Unit::TestCase
     assert_equal [[[], "abcdef"]],  result
   end
 
-  def test_zero_one_parse
-    parser = ZeroOneParser.new(StringParser.new("abc"))
-    result = parser.parse("abc  ")
-    assert_equal [["abc", "  "]],  result
-    parser = ZeroOneParser.new(StringParser.new("abc"))
-    result = parser.parse("123")
-    assert_equal [[[], "123"]],  result
-  end
 
   def test_ident
     parser = Ident.new
@@ -201,5 +203,30 @@ class YaparcTest < Test::Unit::TestCase
     assert_equal [["%", ""]],  result
   end
 
+  def test_combination
+    parser = AltParser.new(
+                            SeqParser.new(Symbol.new('+'),
+                                          Natural.new) do | _, nat|
+                             nat
+                            end,
+                            Natural.new
+                            )
+    result = parser.parse("+123")
+    assert_equal [[123, ""]],  result
+    result = parser.parse(" 123 ")
+    assert_equal [[123, ""]],  result
+    parser = AltParser.new(
+                           SeqParser.new(
+                                         Symbol.new('('),
+                                         Natural.new,
+                                         Symbol.new(')')
+                                         ) do |_,expr, _|
+                             expr
+                           end,
+                           Natural.new
+                           )
+    result = parser.parse("( 123 )")
+    assert_equal [[123, ""]],  result
+  end
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.3
 specification_version: 1
 name: yaparc
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
-date: 2008-01-05 00:00:00 +09:00
+  version: 0.0.6
+date: 2008-01-07 00:00:00 +09:00
 summary: Yet Another Combinator Parser Library
 require_paths: 
 - lib