yaparc 0.1.5 → 0.1.6

data/README

@@ -138,17 +138,7 @@ The ManyOneParser requires at least one successfull application of parser.
 
 == Define your own parser
 
-
-There are two ways to construct parser. One is to inherit from Yaparc::ParserBase class.
-
-  class StringMatch < Yaparc::ParserBase
-
-    def initialize(literal)
-      @parser = Yaparc::Token.new(Yaparc::StringParser.new(literal))
-    end
-  end
-
-The other is to inherit from Yaparc::AbstractParser class.
+In order to construct parsers, you make parser class to be inherited from Yaparc::AbstractParser class.
 
   class Identifier < Yaparc::AbstractParser
     def initialize

data/lib/yaparc.rb

@@ -39,12 +39,10 @@ module Yaparc
         result = result.parse(input)
       else
         if block_given?
-          #        @tree = yield result.value
           result.value = yield result.value
           @tree = result
         else
           @tree = result.value
-          #          @tree = result.parse(input)
         end
         result
       end
@@ -59,11 +57,11 @@ module Yaparc
       def included(mod)
       end
 
-      def define_parser(&block)
-        @@cparser = lambda do
-          yield
-        end
-      end
+#       def define_parser(&block)
+#         @@cparser = lambda do
+#           yield
+#         end
+#       end
     end
   end # of Module Parsable
 
@@ -104,6 +102,33 @@ module Yaparc
     end
   end
 
+  class ZeroOneParser
+    include Parsable
+    def initialize(parser, identity = [])
+      @parser = lambda do |input|
+        case result = parser.parse(input)
+        when Result::Fail
+          SucceedParser.new(identity)
+        when Result::Error
+          Result::Error.new(:value => result.value, :input => result.input)
+        when Result::OK
+          result
+        else
+          raise
+        end
+
+#        AltParser.new(parser, SucceedParser.new(identity))
+#         case result = AltParser.new(parser, SucceedParser.new(identity)).parse(input)
+#         if input.nil? or input.empty?
+#           Result::Fail.new(:input => input)
+#         else
+#           Result::OK.new(:value => input[0..0],:input => input[1..input.length])
+#         end
+
+      end
+    end
+  end
+
   class SatisfyParser
     include Parsable
     def initialize(predicate)
@@ -197,7 +222,8 @@ module Yaparc
         initial_result = Result::OK.new(:input => input)
         final_result = Result::Fail.new(:input => input)
         parsers.each do |parser|
-          case result = parser.parse(initial_result.input)
+#          case result = parser.parse(initial_result.input)
+          case result = parser.parse(input)
           when Result::Fail
             next
           when Result::Error
@@ -256,32 +282,60 @@ module Yaparc
 
   class RegexParser
     include Parsable
-
-    def initialize(regex)
+    
+    def initialize(regex, &block)
+      @regex = regex
       @parser = lambda do |input|
         if match = Regexp.new(regex).match(input)
-          Result::OK.new(:value => match[0], :input => match.post_match)
+          if block_given?
+            SucceedParser.new(yield(*match.to_a[1..match.to_a.length])).parse(match.post_match)
+          else
+            Result::OK.new(:value => match[0], :input => match.post_match)
+          end
         else
           Result::Fail.new(:input => input)
         end
       end
     end
+
+    def parse_with_parameter(input)
+      if match = Regexp.new(@regex).match(input)
+        if block_given?
+          yield match.to_a[1..match.to_a.length]
+        else
+          Result::OK.new(:value => match, :input => match.post_match)
+        end
+      else
+        Result::Fail.new(:input => input)
+      end
+    end
   end
+#   class RegexParser
+#     include Parsable
+
+#     def initialize(regex)
+#       @parser = lambda do |input|
+#         if match = Regexp.new(regex).match(input)
+#           Result::OK.new(:value => match[0], :input => match.post_match)
+#         else
+#           Result::Fail.new(:input => input)
+#         end
+#       end
+#     end
+#   end
 
   # permits zero or more applications of parser.
   class ManyParser
     include Parsable
-#    def initialize(parser, identity = "")
     def initialize(parser, identity = [])
       @parser = lambda do |input|
-#        AltParser.new(ManyOneParser.new(parser, identity), SucceedParser.new(identity)).parse(input)
         AltParser.new(ManyOneParser.new(parser, identity), SucceedParser.new(identity))
       end
     end
 
-    def parse(input)
-      @parser.call(input).parse(input)
-    end
+#     def parse(input)
+#       @parser.call(input).parse(input)
+#     end
   end
 
   # requires at least one successfull application of parser.
@@ -303,107 +357,91 @@ module Yaparc
     end
   end
 
-  class ParserBase
-    include Parsable
-
-    def parse(input)
-      @parser.parse(input)
-    end
-  end
 
-  class CharParser < ParserBase
 
-    def initialize(char)
-      equal_char = lambda {|i| i == char}
-      @parser = SatisfyParser.new(equal_char)
-    end
-  end
-
-  class ZeroOneParser < ParserBase
-    def initialize(parser)
-      @parser = AltParser.new(parser, SucceedParser.new([])) # Is it OK?
-    end
-  end
 
-  class Ident < ParserBase
-    def initialize
-      @parser = SeqParser.new(
-                              SatisfyParser.new(IS_LOWER),
-                              ManyParser.new(SatisfyParser.new(IS_ALPHANUM),"")
-                              ) do |head, tail|
-        head + tail
-      end
-    end
-  end
-
-  class Nat < ParserBase
-    def initialize
-      @parser = SeqParser.new(ManyOneParser.new(SatisfyParser.new(IS_DIGIT),"")) do |vs|
-        if vs == ""
-          vs
-        else
-          vs.to_i
-        end
-      end
-    end
-  end
-
-
-  class Space < ParserBase
+  class SpaceParser
+    include Parsable
     def initialize
-      @parser = SeqParser.new(ManyParser.new(SatisfyParser.new(IS_SPACE),"")) do |vs|
-        SucceedParser.new([])
+      @parser = lambda do |input|
+        SeqParser.new(ManyParser.new(SatisfyParser.new(IS_SPACE),""))
       end
     end
   end
 
-  class WhiteSpace < ParserBase
+  class WhiteSpaceParser
+    include Parsable
     def initialize
-      @parser = SeqParser.new(ManyParser.new(SatisfyParser.new(IS_WHITESPACE),"")) do |vs|
-        SucceedParser.new([])
+      @parser = lambda do |input|
+        SeqParser.new(ManyParser.new(SatisfyParser.new(IS_WHITESPACE),''))
       end
     end
   end
 
-  class Token < ParserBase
+  class TokenizeParser
+    include Parsable
     attr_accessor :prefix, :postfix
 
-    def initialize(parser, prefix = WhiteSpace.new, postfix = WhiteSpace.new)
-      @prefix, @postfix  = prefix, postfix
-      @parser = SeqParser.new(@prefix, parser, @postfix) do |_, vs, _|
-        vs
+    def initialize(parser, args = { }, &block)
+      @parser = lambda do |input|
+        @prefix = args[:prefix] ? args[:prefix] : WhiteSpaceParser.new 
+        @postfix = args[:postfix] ? args[:postfix] : WhiteSpaceParser.new
+        if block_given?
+          yield self
+          SeqParser.new(@prefix, parser, @postfix) do |_, vs, _|
+            vs
+          end
+        else
+          SeqParser.new(@prefix, parser, @postfix) do |_, vs, _|
+            vs
+          end
+        end
       end
     end
   end
 
-  class Tokenize < ParserBase
-    attr_accessor :prefix, :postfix
+#   class Tokenize < ParserBase
+#     attr_accessor :prefix, :postfix
 
-    def initialize(parser, &block)
-      @prefix, @postfix = WhiteSpace.new,WhiteSpace.new
-      yield self
-      @parser = SeqParser.new(@prefix, parser, @postfix) do |_, vs, _|
-        vs
+#     def initialize(parser, &block)
+#       @prefix, @postfix = WhiteSpace.new,WhiteSpace.new
+#       yield self
+#       @parser = SeqParser.new(@prefix, parser, @postfix) do |_, vs, _|
+#         vs
+#       end
+#     end
+#   end
+
+  class LiteralParser
+    include Parsable
+    def initialize(literal)
+      @parser =  lambda do |input|
+        TokenizeParser.new(StringParser.new(literal))
       end
     end
   end
 
   # Refer to http://www.cs.nott.ac.uk/~gmh/monparsing.pdf, p.23
+
   class Identifier
-    include Parsable
+    include Yaparc::Parsable
+    @@identifier_regex = ::Yaparc::RegexParser.new(/\A[a-zA-Z_]+[a-zA-Z0-9_]*/)
+
     def initialize(*keywords)
       if keywords == []
         @parser = lambda do |input|
-          Token.new(Ident.new)
+          TokenizeParser.new(@@identifier_regex)
+#          Yaparc::Token.new(@@identifier_regex)
         end
       else
         @parser = lambda do |input|
-          keyword_parsers = keywords.map {|keyword| StringParser.new(keyword)}
-          case result = AltParser.new(*keyword_parsers).parse(input)
-          when Result::OK
-            FailParser.new
+          keyword_parsers = keywords.map {|keyword| Yaparc::StringParser.new(keyword)}
+          case result = Yaparc::AltParser.new(*keyword_parsers).parse(input)
+          when Yaparc::Result::OK
+            Yaparc::FailParser.new
           else # Result::Fail or Result::Error
-            Token.new(Ident.new)
+            TokenizeParser.new(@@identifier_regex)
+#            Yaparc::Token.new(@@identifier_regex)
           end
         end
       end
@@ -414,22 +452,148 @@ module Yaparc
     end
   end
 
+#   class ParserBase
+#     include Parsable
+
+#     def parse(input)
+#       @parser.parse(input)
+#     end
+#   end
+
+  class CharParser
+    include Parsable
+
+    def initialize(char)
+      equal_char = lambda {|i| i == char}
+      @parser =  lambda do |input|
+        SatisfyParser.new(equal_char)
+      end
+    end
+  end
+#   class CharParser < ParserBase
+
+#     def initialize(char)
+#       equal_char = lambda {|i| i == char}
+#       @parser = SatisfyParser.new(equal_char)
+#     end
+#   end
 
-  class Natural < ParserBase
+#   class ZeroOneParser < ParserBase
+#     def initialize(parser, identity = [])
+#       @parser = AltParser.new(parser, SucceedParser.new(identity)) # Is it OK?
+#     end
+#   end
 
+  class Ident
+    include Parsable
+    def initialize
+      @parser = lambda do |input|
+        SeqParser.new(
+                      SatisfyParser.new(IS_LOWER),
+                      ManyParser.new(SatisfyParser.new(IS_ALPHANUM),"")
+                      ) do |head, tail|
+          head + tail
+        end
+      end
+    end
+  end
+#   class Ident < ParserBase
+#     def initialize
+#       @parser = SeqParser.new(
+#                               SatisfyParser.new(IS_LOWER),
+#                               ManyParser.new(SatisfyParser.new(IS_ALPHANUM),"")
+#                               ) do |head, tail|
+#         head + tail
+#       end
+#     end
+#   end
+
+  class Nat
+    include Parsable
     def initialize
-      @parser = Token.new(Nat.new)
+      @parser = lambda do |input|
+        SeqParser.new(ManyOneParser.new(SatisfyParser.new(IS_DIGIT),"")) do |vs|
+          if vs == ""
+            vs
+          else
+            vs.to_i
+          end
+        end
+      end
+    end
+  end
+
+#   class Nat < ParserBase
+#     def initialize
+#       @parser = SeqParser.new(ManyOneParser.new(SatisfyParser.new(IS_DIGIT),"")) do |vs|
+#         if vs == ""
+#           vs
+#         else
+#           vs.to_i
+#         end
+#       end
+#     end
+#   end
+
+#   class Space < ParserBase
+#     def initialize
+#       @parser = SeqParser.new(ManyParser.new(SatisfyParser.new(IS_SPACE),"")) do |vs|
+#         SucceedParser.new([])
+#       end
+#     end
+#   end
+
+#   class WhiteSpace < ParserBase
+#     def initialize
+#       @parser = SeqParser.new(ManyParser.new(SatisfyParser.new(IS_WHITESPACE),"")) do |vs|
+#         SucceedParser.new([])
+#       end
+#     end
+#   end
+
+#   class Token < ParserBase
+#     attr_accessor :prefix, :postfix
+
+#     def initialize(parser, prefix = WhiteSpace.new, postfix = WhiteSpace.new)
+#       @prefix, @postfix  = prefix, postfix
+#       @parser = SeqParser.new(@prefix, parser, @postfix) do |_, vs, _|
+#         vs
+#       end
+#     end
+#   end
+
+  class Natural
+    include Parsable
+    def initialize(args = {})
+      @parser = lambda do |input|
+        TokenizeParser.new(Nat.new, args)
+      end
     end
   end
+#   class Natural < ParserBase
 
+#     def initialize
+#       @parser = Token.new(Nat.new)
+#     end
+#   end
 
-  class Symbol < ParserBase
 
-    def initialize(literal)
-      @parser = Token.new(StringParser.new(literal))
+  class Symbol
+    include Parsable
+    def initialize(literal, args = {})
+      @parser = lambda do |input|
+        LiteralParser.new(literal)
+      end
     end
   end
 
+#   class Symbol < ParserBase
+
+#     def initialize(literal)
+#       @parser = Token.new(StringParser.new(literal))
+#     end
+#   end
+
   class AbstractParser
     include Parsable