yaparc 0.0.7 → 0.0.8

data/lib/yaparc.rb

@@ -22,13 +22,22 @@ module Yaparc
 
 
     def parse(input, &block)
-      tree = @parser.call(input)
+      result = @parser.call(input)
       if block_given?
-        @tree = yield tree
+        @tree = yield result.value
       else
-        @tree = tree
+        @tree = result.value
       end
+      result
     end
+#     def parse(input, &block)
+#       result = @parser.call(input)
+#       if block_given?
+#         @tree = yield result
+#       else
+#         @tree = result
+#       end
+#     end
 
     def eval
       tree = parse(input)
@@ -52,61 +61,116 @@ module Yaparc
 #         end
 #       end
 
-      def cparse(input, &block)
-        tree = @@cparser.call.parse(input)
-        if block_given?
-          yield tree
-        else
-          tree
-        end
-      end
-      module_function :cparse
+#       def cparse(input, &block)
+#         tree = @@cparser.call.parse(input)
+#         if block_given?
+#           yield tree
+#         else
+#           tree
+#         end
+#       end
+#       module_function :cparse
 
     end
   end # of Module Parsable
 
+  class Result
+    attr_accessor :message, :input, :value
+    def initialize(options = {})
+      @message = options[:message] if options[:message]
+      @input = options[:input] if options[:input]
+      @value = options[:value] if options[:value]
+    end
+  end
+
+  class OK < Result
+  end
+
+  class Fail < Result
+  end
+
+  class Error < Result
+  end
 
   class SucceedParser
     include Parsable
     attr_reader :remaining
     def initialize(value, remaining = nil)
-      @parser = lambda {|input| [[value, input]]}
+      @parser = lambda do |input|
+#        [[value, input]]
+        OK.new(:value => value, :input => input)
+      end
       @remaining = remaining
     end
   end
+#   class SucceedParser
+#     include Parsable
+#     attr_reader :remaining
+#     def initialize(value, remaining = nil)
+#       @parser = lambda do |input|
+#         [[value, input]]
+#       end
+#       @remaining = remaining
+#     end
+#   end
 
   class FailParser
     include Parsable
     def initialize
-      @parser = lambda {|input| []}
+      @parser = lambda do |input|
+        Fail.new
+      end
     end
   end
 
+#   class FailParser
+#     include Parsable
+#     def initialize
+#       @parser = lambda do |input|
+#         []
+#       end
+#     end
+#   end
+
   class ItemParser
     include Parsable
     def initialize
       @parser = lambda do |input|
         if input.nil? or input.empty?
-          []
+          Fail.new
         else
-          [[input[0..0],input[1..input.length]]]
+#          [[input[0..0],input[1..input.length]]]
+          OK.new(:value => input[0..0],:input => input[1..input.length])
         end
       end
     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)
       assert_at(__FILE__,__LINE__){predicate.instance_of?(Proc)}
 
       @parser = lambda do |input|
-        item = ItemParser.new.parse(input)
-        if item == []
+        case result = ItemParser.new.parse(input)
+        when Fail
           FailParser.new
         else
-          parser = if predicate.call(item[0][0])
-                     SucceedParser.new(item[0][0], item[0][1])
+          parser = if predicate.call(result.value)
+                     SucceedParser.new(result.value, result.input)
                    else
                      FailParser.new
                    end
@@ -124,72 +188,173 @@ module Yaparc
         raise
       end
     end
-
   end
 
+#   class SatisfyParser
+#     include Parsable
+#     def initialize(predicate)
+#       assert_at(__FILE__,__LINE__){predicate.instance_of?(Proc)}
+
+#       @parser = lambda do |input|
+#         item = ItemParser.new.parse(input)
+#         if item == []
+#           FailParser.new
+#         else
+#           parser = if predicate.call(item[0][0])
+#                      SucceedParser.new(item[0][0], item[0][1])
+#                    else
+#                      FailParser.new
+#                    end
+#         end
+#       end
+#     end
+
+#     def parse(input)
+#       case parser = @parser.call(input)
+#       when SucceedParser
+#         parser.parse(parser.remaining)
+#       when FailParser
+#         parser.parse(input)
+#       else
+#         raise
+#       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)
-          if result == []
-            break []
+        initial_result = OK.new(:input => input)
+        final_result = parsers.inject(initial_result) do |subsequent, parser|
+          case result = parser.parse(subsequent.input)
+          when Fail
+            break Fail.new
           else
-            args << result[0][0]
-            result[0][1]
+            args << result.value
+            result
           end
         end
-        if remains == []
-          []
-        else
-          retval = if block_given?
+
+        case final_result
+        when Fail
+          Fail.new
+        when OK
+          final_value = if block_given?
                      yield(*args)
                    else
                      args.last
                    end
-          [[retval, remains]]
+          OK.new(:value => final_value, :input => final_result.input)
+        else
+          raise
         end
       end
     end # of initialize
-
   end # of SeqParser
 
+#   class SeqParser
+#     include Parsable
+#     def initialize(*parsers, &block)
+#       @parser = lambda do |input|
+#         args = []
+#         remains = parsers.inject(input) do |accumulator, parser|
+#           result = parser.parse(accumulator)
+#           if result == []
+#             break []
+#           else
+#             args << result[0][0]
+#             result[0][1]
+#           end
+#         end
+#         if remains == []
+#           []
+#         else
+#           retval = if block_given?
+#                      yield(*args)
+#                    else
+#                      args.last
+#                    end
+#           [[retval, remains]]
+#         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
+        initial_result = OK.new(:input => input)
+        final_result = Fail.new
+        parsers.each do |parser|
+          case result = parser.parse(initial_result.input)
+          when Fail
+            next
+          when OK
+            break final_result = result
           else
-            break [result[0]]
+            raise
           end
         end
+        final_result
       end
     end # of initialize
   end
 
+#   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 StringParser
+  class ApplyParser
     include Parsable
-    def initialize(string)
+    def initialize(parser, &block)
       @parser = lambda do |input|
-        result = ItemParser.new.parse(string)
+        args = nil
+        result = parser.parse(input)
         if result == []
-          SucceedParser.new(result)
+          FailParser.new.parse(input)
         else
+          SucceedParser.new(yield(result[0][0])).parse(result[0][1])
+        end
+      end
+    end # of initialize
+  end # of ApplyParser
+
+  class StringParser
+    include Parsable
+    def initialize(string)
+      @parser = lambda do |input|
+        case result = ItemParser.new.parse(string)
+        when Fail
+          SucceedParser.new(result) # Is it OK?
+        when OK
           SeqParser.new(
-                        CharParser.new(result[0][0]),
-                        StringParser.new(result[0][1]),
-                        SucceedParser.new(result[0][0] + result[0][1])
+                        CharParser.new(result.value),
+                        StringParser.new(result.input),
+                        SucceedParser.new(result.value + result.input)
                         ) do |char_result, string_result, succeed_result|
             succeed_result
           end
+        else
+          raise
         end
       end
     end
@@ -199,6 +364,30 @@ module Yaparc
     end
   end
 
+#   class StringParser
+#     include Parsable
+#     def initialize(string)
+#       @parser = lambda do |input|
+#         result = ItemParser.new.parse(string)
+#         if result == []
+#           SucceedParser.new(result)
+#         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
+#         end
+#       end
+#     end
+
+#     def parse(input)
+#       @parser.call(input).parse(input)
+#     end
+#   end
+
 
   class RegexParser
     include Parsable
@@ -206,20 +395,34 @@ module Yaparc
     def initialize(regex)
       @parser = lambda do |input|
         if match = Regexp.new(regex).match(input)
-          [[match[0],match.post_match]]
+          OK.new(:value => match[0], :input => match.post_match)
         else
-          []
+          Fail.new
         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
+
   # permits zero or more applications of parser.
   class ManyParser
     include Parsable
     def initialize(parser)
       @parser = lambda do |input|
-        AltParser.new(ManyOneParser.new(parser), SucceedParser.new([])).parse(input)
+        AltParser.new(ManyOneParser.new(parser), SucceedParser.new("")).parse(input)
       end
     end
 
@@ -228,6 +431,19 @@ module Yaparc
     end
   end
 
+#   class ManyParser
+#     include Parsable
+#     def initialize(parser)
+#       @parser = lambda do |input|
+#         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
@@ -236,12 +452,8 @@ module Yaparc
         SeqParser.new(
                       parser,
                       ManyParser.new(parser)
-                      ) do |v, vs|
-          if vs == []
-            v
-          else
-            v + vs.to_s
-          end
+                      ) do |head, tail|
+          head + tail
         end
       end
     end
@@ -251,6 +463,28 @@ module Yaparc
     end
   end
 
+#   class ManyOneParser
+#     include Parsable
+#     def initialize(parser)
+#       @parser = lambda do |input|
+#         SeqParser.new(
+#                       parser,
+#                       ManyParser.new(parser)
+#                       ) do |v, vs|
+#           if vs == []
+#             v
+#           else
+#             v + vs.to_s
+#           end
+#         end
+#       end
+#     end
+
+#     def parse(input)
+#       @parser.call(input).parse(input)
+#     end
+#   end
+
 
   class ParserBase
     include Parsable
@@ -268,34 +502,58 @@ module Yaparc
     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([]))
+      @parser = AltParser.new(parser, SucceedParser.new([])) # Is it OK?
     end
   end
 
+#   class ZeroOneParser < ParserBase
+#     def initialize(parser)
+#       @parser = AltParser.new(parser, SucceedParser.new([]))
+#     end
+#   end
+
 
   class Ident < ParserBase
     def initialize
       @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
+                              ) do |head, tail|
+        head + tail
       end
     end
   end
 
-  class Nat < ParserBase
+#   class Ident < ParserBase
+#     def initialize
+#       @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 < ParserBase
     def initialize
       @parser = SeqParser.new(ManyOneParser.new(SatisfyParser.new(IS_DIGIT))) do |vs|
-        if vs == []
+        if vs == ""
           vs
         else
           vs.to_i
@@ -304,9 +562,21 @@ module Yaparc
     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 Space < ParserBase
     def initialize
       @parser = SeqParser.new(ManyParser.new(SatisfyParser.new(IS_SPACE))) do |vs|
         []
@@ -314,22 +584,78 @@ module Yaparc
     end
   end
 
+#   class Space < ParserBase
+
+#     def initialize
+#       @parser = SeqParser.new(ManyParser.new(SatisfyParser.new(IS_SPACE))) do |vs|
+#         []
+#       end
+#     end
+#   end
+
   class Token < ParserBase
 
-    def initialize(parser)
-      @parser = SeqParser.new(Space.new, parser, Space.new) do |_, vs, _|
+    def initialize(parser, prefix = Space.new, postfix = Space.new)
+#      @parser = SeqParser.new(Space.new, parser, Space.new) do |_, vs, _|
+      @parser = SeqParser.new(prefix, parser, postfix) do |_, vs, _|
         vs
       end
     end
   end
 
-  class Identifier < ParserBase
+  # Refer to http://www.cs.nott.ac.uk/~gmh/monparsing.pdf, p.23
+  class Identifier
+    include Parsable
+    def initialize(*keywords)
+      if keywords == []
+        @parser = lambda do |input|
+          Token.new(Ident.new)
+        end
+      else
+        @parser = lambda do |input|
+          keyword_parsers = keywords.map {|keyword| StringParser.new(keyword)}
+          case result = AltParser.new(*keyword_parsers).parse(input)
+          when OK
+            FailParser.new
+          when Fail
+            Token.new(Ident.new)
+          else
+            raise
+          end
+        end
+      end
+    end
 
-    def initialize
-      @parser = Token.new(Ident.new)
+    def parse(input)
+      @parser.call(input).parse(input)
     end
   end
 
+#   class Identifier
+#     include Parsable
+#     def initialize(*keywords)
+#       if keywords == []
+#         @parser = lambda do |input|
+#           Token.new(Ident.new)
+#         end
+#       else
+#         @parser = lambda do |input|
+#           keyword_parsers = keywords.map {|keyword| StringParser.new(keyword)}
+#           result = AltParser.new(*keyword_parsers).parse(input)
+#           unless result == []
+#             FailParser.new
+#           else
+#             Token.new(Ident.new)
+#           end
+#         end
+#       end
+#     end
+
+#     def parse(input)
+#       @parser.call(input).parse(input)
+#     end
+#   end
+
   class Natural < ParserBase
 
     def initialize
@@ -337,6 +663,13 @@ module Yaparc
     end
   end
 
+#   class Natural < ParserBase
+
+#     def initialize
+#       @parser = Token.new(Nat.new)
+#     end
+#   end
+
   class Symbol < ParserBase
 
     def initialize(literal)