yaparc 0.0.1 → 0.0.3

data/README

@@ -12,5 +12,12 @@ This is a yet another simple combinator parser library in ruby.
 
 = Usage
 
+  require 'rubygems'
+  require_gem 'yaparc'
+
+  
+
 Please look at unit test files.
 
+
+

data/lib/parser.rb

@@ -2,7 +2,9 @@
 module Yaparc
   module Parsable
     include Yaparc
-
+    
+    attr_accessor :tree
+    
     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'}
@@ -13,8 +15,13 @@ module Yaparc
     end
 
 
-    def parse(input)
-      @parser.call(input)
+    def parse(input, &block)
+      tree = @parser.call(input)
+      if block_given?
+        @tree = yield tree 
+      else
+        @tree = tree
+      end
     end
 
     def eval
@@ -143,8 +150,7 @@ module Yaparc
       @parser = lambda do |input|
         result = ItemParser.new.parse(string)
         if result == []
-          SucceedParser.new(result).parse(input)
-          #            FailParser.new.parse(input)
+          SucceedParser.new(result).parse(input) # FailParser.new.parse(input)
         else
           SeqParser.new(
                         CharParser.new(result[0][0]),
@@ -158,6 +164,19 @@ module Yaparc
     end
   end
 
+  class RegexParser
+    include Parsable
+    def initialize(regex)
+      @parser = lambda do |input|
+        if match = Regexp.new(regex).match(input)
+          [[match[0],match.post_match]]
+        else
+          []
+        end
+      end
+    end
+  end
+
   class ManyParser
     include Parsable
     def initialize(predicate)
@@ -185,6 +204,15 @@ module Yaparc
     end
   end
 
+  class ZeroOneParser
+    include Parsable
+    def initialize(parser)
+      @parser = lambda do |input|
+        AltParser.new(parser, 
+                      SucceedParser.new([])).parse(input)
+      end
+    end
+  end
 
   class Ident
     include Parsable

data/lib/parser_cps.rb

@@ -0,0 +1,319 @@
+
+module Yaparc
+  module Parsable
+    include Yaparc
+    
+    attr_accessor :tree
+    
+    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_SPACE = lambda {|i| i == ' '}
+
+#     def self.included(mod)
+#       mod.extend ClassMethods
+#     end
+
+    def parse(input, cont, &block)
+      tree = @parser.call(input, cont)
+      if block_given?
+        @tree = yield tree
+      else
+        @tree = tree
+      end
+      cont.apply(input)
+    end
+  end # of Parsable
+
+  module Continuation
+    class Base
+      def apply(input)
+        @proc.call(input)
+      end
+#       def apply(arg, input = '')
+#         @proc.call(input,val)
+#       end
+    end
+
+    class StopCont < Base
+      def initialize
+#         @proc = lambda do |input|
+#           lambda{|input, val|
+#             [[val,input]]
+#           }
+#         end
+        @proc = lambda do |val, input|
+          [[val,input]]
+        end
+      end
+    end
+
+
+
+    class ItemHeadCont < Base
+      def initialize(input, cont)
+        @proc = lambda do |val, input|
+          [[val,input]]
+        end
+      end
+    end
+
+    class ItemTailCont < Base
+      def initialize(cont)
+        @proc = lambda do |val, input|
+          [[val,input]]
+        end
+      end
+    end
+  end # of Continuation
+
+  module Parser
+    class SucceedParser
+      include Parsable
+      def initialize(val)
+        @parser = lambda do |input, cont|
+          cont.apply(val)
+        end
+      end
+    end
+
+    class FailParser
+      include Parsable
+      def initialize
+        @parser = lambda do |input|
+          []
+        end
+      end
+    end
+
+    class ItemParser
+      include Parsable
+      def initialize(cont)
+        @parser = lambda do |input|
+          if input.nil? or input.empty?
+            FailParser.new(StopCont.new)
+          else
+#            head = input[0..0]
+#            tail = input[1..input.length]
+            ItemHeadCont.new(input,ItemTailCont.new(cont)).apply(input)
+          end
+        end
+      end
+    end
+
+    class SatisfyParser
+      include Parsable
+      def initialize(predicate)
+        @parser = lambda do |input|
+          item = ItemParser.new.parse(input)
+          if item == []
+            FailParser.new.parse(input)
+          else
+            if predicate.call(item[0][0])
+              SucceedParser.new(item[0][0]).parse(item[0][1])
+            else
+              FailParser.new.parse(input)
+            end
+          end
+        end
+      end
+    end
+
+    class SeqParser
+      include Parsable
+      def initialize(first, second, &block)
+        @parser = lambda do |input, cont|
+          SeqCont.new(first, second, cont).apply(input)
+        end
+      end # of initialize
+
+      class SeqCont < Continuation::Base
+        def initialize(first, second, cont)
+          @proc = lambda do |input|
+            first.parse(input, second.parse(input, cont))
+          end
+        end
+      end
+    end # of SeqParser
+
+
+
+    class AltParser
+      include Parsable
+      def initialize(left, right)
+        @parser = lambda do |input, cont|
+          AltCont.new(left, right, cont).apply(input)
+        end
+      end
+      class AltCont < Continuation::Base
+        def initialize(left, right, cont)
+          @proc = lambda do |input|
+            left.parse(input, cont) or right.parse(input, cont)
+          end
+        end
+      end
+    end # of AltParser
+
+    class CharParser
+      include Parsable
+      def initialize(char)
+        equal_char = lambda {|i| i == char}
+        @parser = lambda do |input|
+          SatisfyParser.new(equal_char).parse(input)
+        end
+      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)
+          else
+            SeqParser.new(
+                          CharParser.new(result[0][0]),
+                          StringParser.new(result[0][1]),
+                          SucceedParser.new(result[0][0] + result[0][1])
+                          ) do |char_result, string_result, succeed_result|
+              succeed_result
+            end.parse(input)
+          end
+        end
+      end
+    end
+
+    class RegexParser
+      include Parsable
+      def initialize(regex)
+        @parser = lambda do |input|
+          if match = Regexp.new(regex).match(input)
+            [[match[0],match.post_match]]
+          else
+            []
+          end
+        end
+      end
+    end
+
+    class ManyParser
+      include Parsable
+      def initialize(predicate)
+        @parser = lambda do |input|
+          AltParser.new(ManyOneParser.new(predicate), SucceedParser.new([])).parse(input)
+        end
+      end
+    end
+
+    class ManyOneParser
+      include Parsable
+      def initialize(predicate)
+        @parser = lambda do |input|
+          SeqParser.new(
+                        SatisfyParser.new(predicate),
+                        ManyParser.new(predicate)
+                        ) do |v, vs|
+            if vs == []
+              v
+            else
+              v + vs.to_s
+            end
+          end.parse(input)
+        end
+      end
+    end
+
+    class ZeroOneParser
+      include Parsable
+      def initialize(parser)
+        @parser = lambda do |input|
+          AltParser.new(parser, 
+                        SucceedParser.new([])).parse(input)
+        end
+      end
+    end
+
+    class Ident
+      include Parsable
+      def initialize
+        @parser = lambda do |input|
+          SeqParser.new(
+                        SatisfyParser.new(IS_LOWER),
+                        ManyParser.new(IS_ALPHANUM)
+                        ) do |v, vs|
+            if vs == []
+              v
+            else
+              v + vs.to_s
+            end
+          end.parse(input)
+        end
+      end
+    end
+
+    class Nat
+      include Parsable
+      def initialize
+        @parser = lambda do |input|
+          SeqParser.new(ManyOneParser.new(IS_DIGIT)) do |vs|
+            if vs == []
+              vs
+            else
+              vs.to_i
+            end
+          end.parse(input)
+        end
+      end
+    end
+
+    class Space
+      include Parsable
+      def initialize
+        @parser = lambda do |input|
+          SeqParser.new(ManyParser.new(IS_SPACE)) do |vs|
+            []
+          end.parse(input)
+        end
+      end
+    end
+
+    class Token
+      include Parsable
+      def initialize(parser)
+        @parser = lambda do |input|
+          SeqParser.new(Space.new, parser, Space.new) do |_, vs, _|
+            vs
+          end.parse(input)
+        end
+      end
+    end
+
+    class Identifier
+      include Parsable
+      def initialize
+        @parser = lambda do |input|
+          Token.new(Ident.new).parse(input)
+        end
+      end
+    end
+
+    class Natural
+      include Parsable
+      def initialize
+        @parser = lambda do |input|
+          Token.new(Nat.new).parse(input)
+        end
+      end
+    end
+
+    class Symbol
+      include Parsable
+      def initialize(literal)
+        @parser = lambda do |input|
+          Token.new(StringParser.new(literal)).parse(input)
+        end
+      end
+    end
+  end # of Parser
+end # Yaparc

data/lib/yaparc.rb

@@ -0,0 +1,299 @@
+
+module Yaparc
+  module Parsable
+    include Yaparc
+    
+    attr_accessor :tree
+    
+    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_SPACE = lambda {|i| i == ' '}
+
+    def self.included(mod)
+      mod.extend ClassMethods
+    end
+
+
+    def parse(input, &block)
+      tree = @parser.call(input)
+      if block_given?
+        @tree = yield tree 
+      else
+        @tree = tree
+      end
+    end
+
+    def eval
+      tree = parse(input)
+    end
+
+    def define_parser
+      raise
+    end
+
+    module ClassMethods
+      def included(mod)
+      end
+
+#       def self.initialize
+#         @parser = @@parser
+#       end
+
+      def define_parser(&block)
+        @@parser = lambda do |input|
+          parser = yield 
+          parser.parse(input)
+        end
+      end
+    end
+  end # of Parsable
+
+  class SucceedParser
+    include Parsable
+    def initialize(value)
+      @parser = lambda {|input| [[value, input]]}
+    end
+  end
+
+  class FailParser
+    include Parsable
+    def initialize
+      @parser = lambda {|input| []}
+    end
+  end
+
+  class ItemParser
+    include Parsable
+    def initialize
+      @parser = lambda do |input|
+        if input.nil? or input.empty?
+          []
+        else
+          [[input[0..0],input[1..input.length]]]
+        end
+      end
+    end
+  end
+
+  class SatisfyParser
+    include Parsable
+    def initialize(predicate)
+      @parser = lambda do |input|
+        item = ItemParser.new.parse(input)
+        if item == []
+          FailParser.new.parse(input)
+        else
+          if predicate.call(item[0][0])
+            SucceedParser.new(item[0][0]).parse(item[0][1])
+          else
+            FailParser.new.parse(input)
+          end
+        end
+      end
+    end
+  end
+
+  class SeqParser
+    include Parsable
+    def initialize(*parsers, &block)
+      @parser = lambda do |input|
+        args = []
+        remains = parsers.inject(input) do |accumulator, parser|
+          result = parser.parse(accumulator)
+          unless result == []
+            args << result[0][0]
+            result[0][1]
+          else
+            break []
+          end
+        end
+        unless remains == []
+          retval = yield(*args)
+          [[retval, remains]]
+        else
+          []
+        end
+      end
+    end # of initialize
+  end # of SeqParser
+
+  class AltParser
+    include Parsable
+    def initialize(*parsers)
+      @parser = lambda do |input|
+        parsers.inject([]) do |accum, parser|
+          result = parser.parse(input)
+          if result == []
+            result
+          else
+            break [result[0]]
+          end
+        end
+      end
+    end # of initialize
+  end
+
+  class CharParser
+    include Parsable
+    def initialize(char)
+      equal_char = lambda {|i| i == char}
+      @parser = lambda do |input|
+        SatisfyParser.new(equal_char).parse(input)
+      end
+    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)
+        else
+          SeqParser.new(
+                        CharParser.new(result[0][0]),
+                        StringParser.new(result[0][1]),
+                        SucceedParser.new(result[0][0] + result[0][1])
+                        ) do |char_result, string_result, succeed_result|
+            succeed_result
+          end.parse(input)
+        end
+      end
+    end
+  end
+
+  class RegexParser
+    include Parsable
+    def initialize(regex)
+      @parser = lambda do |input|
+        if match = Regexp.new(regex).match(input)
+          [[match[0],match.post_match]]
+        else
+          []
+        end
+      end
+    end
+  end
+
+  class ManyParser
+    include Parsable
+    def initialize(predicate)
+      @parser = lambda do |input|
+        AltParser.new(ManyOneParser.new(predicate), SucceedParser.new([])).parse(input)
+      end
+    end
+  end
+
+  class ManyOneParser
+    include Parsable
+    def initialize(predicate)
+      @parser = lambda do |input|
+        SeqParser.new(
+                      SatisfyParser.new(predicate),
+                      ManyParser.new(predicate)
+                      ) do |v, vs|
+          if vs == []
+            v
+          else
+            v + vs.to_s
+          end
+        end.parse(input)
+      end
+    end
+  end
+
+  class ZeroOneParser
+    include Parsable
+    def initialize(parser)
+      @parser = lambda do |input|
+        AltParser.new(parser, 
+                      SucceedParser.new([])).parse(input)
+      end
+    end
+  end
+
+  class Ident
+    include Parsable
+    def initialize
+      @parser = lambda do |input|
+        SeqParser.new(
+                      SatisfyParser.new(IS_LOWER),
+                      ManyParser.new(IS_ALPHANUM)
+                      ) do |v, vs|
+          if vs == []
+            v
+          else
+            v + vs.to_s
+          end
+        end.parse(input)
+      end
+    end
+  end
+
+  class Nat
+    include Parsable
+    def initialize
+      @parser = lambda do |input|
+        SeqParser.new(ManyOneParser.new(IS_DIGIT)) do |vs|
+          if vs == []
+            vs
+          else
+            vs.to_i
+          end
+        end.parse(input)
+      end
+    end
+  end
+
+  class Space
+    include Parsable
+    def initialize
+      @parser = lambda do |input|
+        SeqParser.new(ManyParser.new(IS_SPACE)) do |vs|
+          []
+        end.parse(input)
+      end
+    end
+  end
+
+  class Token
+    include Parsable
+    def initialize(parser)
+      @parser = lambda do |input|
+        SeqParser.new(Space.new, parser, Space.new) do |_, vs, _|
+          vs
+        end.parse(input)
+      end
+    end
+  end
+
+  class Identifier
+    include Parsable
+    def initialize
+      @parser = lambda do |input|
+        Token.new(Ident.new).parse(input)
+      end
+    end
+  end
+
+  class Natural
+    include Parsable
+    def initialize
+      @parser = lambda do |input|
+        Token.new(Nat.new).parse(input)
+      end
+    end
+  end
+
+  class Symbol
+    include Parsable
+    def initialize(literal)
+      @parser = lambda do |input|
+        Token.new(StringParser.new(literal)).parse(input)
+      end
+    end
+  end
+
+end

data/tests/test_parser.rb

@@ -16,6 +16,11 @@ class YaparcTest < Test::Unit::TestCase
   def test_succeed_parse
     parser = ::Yaparc::SucceedParser.new(1)
     assert_equal [[1, "abs"]], parser.parse("abs")
+    assert_equal [[1, "abs"]], parser.tree
+    result = parser.parse("abs") do |result|
+      result[0][0]
+    end
+    assert_equal 1, result
   end
 
   def test_fail_parse
@@ -116,6 +121,16 @@ class YaparcTest < Test::Unit::TestCase
     assert_equal [],  result
   end
 
+  def test_regex_parse
+    parser = RegexParser.new(/[a-z]/)
+    result = parser.parse("abcdef")
+    assert_equal [["a", "bcdef"]],  result
+
+    parser = RegexParser.new(/[0-9]+/)
+    result = parser.parse("1234ab")
+    assert_equal [["1234", "ab"]],  result
+  end
+
   def test_many_parse
     is_digit = lambda {|i| i > '0' and i < '9'}
 
@@ -127,6 +142,15 @@ 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
     result = parser.parse("abc def")

data/tests/test_parser_cps.rb

@@ -0,0 +1,38 @@
+require 'lib/parser_cps.rb'
+require 'test/unit'
+require 'pp'
+
+class YaparcTest < Test::Unit::TestCase
+  include ::Yaparc
+
+
+  def setup
+    @stop = Continuation::StopCont.new
+  end
+
+
+  def test_succeed_parse
+    parser = ::Yaparc::Parser::SucceedParser.new(1)
+    assert_equal [[1, "abs"]], parser.parse("abs", @stop)
+#     assert_equal [[1, "abs"]], parser.tree
+#     result = parser.parse("abs") do |result|
+#       result[0][0]
+#     end
+#     assert_equal 1, result
+  end
+
+#   def test_fail_parse
+#     parser = ::Yaparc::Parser::FailParser.new(@stop)
+#     result = parser.parse("abc")
+#     assert_equal [],  result
+#   end
+
+#   def test_item_parse
+#     parser = ::Yaparc::Parser::ItemParser.new(@stop)
+#     result = parser.parse("")
+#     assert_equal [],  result
+#     result = parser.parse("abc")
+#     assert_equal [["a", "bc"]],  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.1
-date: 2007-12-06 00:00:00 +09:00
+  version: 0.0.3
+date: 2007-12-14 00:00:00 +09:00
 summary: Yet Another Combinator Parser Library
 require_paths: 
 - lib
@@ -12,7 +12,7 @@ email: akimichi_tatsukawa@nifty.com
 homepage: http://rubyforge.org/projects/yaparc/
 rubyforge_project: 
 description: 
-autorequire: parser
+autorequire: yaparc
 default_executable: 
 bindir: bin
 has_rdoc: true
@@ -29,13 +29,17 @@ post_install_message:
 authors: 
 - Akimichi Tatsukawa
 files: 
-- tests/test_calc.rb
+- tests/test_parser_cps.rb
 - tests/test_parser.rb
+- tests/test_calc.rb
+- lib/parser_cps.rb
+- lib/yaparc.rb
 - lib/parser.rb
 - README
 test_files: 
-- tests/test_calc.rb
+- tests/test_parser_cps.rb
 - tests/test_parser.rb
+- tests/test_calc.rb
 rdoc_options: []
 
 extra_rdoc_files: