rparsec2 1.2.0 → 1.3.0

data/lib/rparsec/parsers.rb

@@ -1,6 +1,45 @@
 # frozen_string_literal: true
 
-require 'rparsec/parser'
+require 'rparsec/alt_parser'
+require 'rparsec/any_parser'
+require 'rparsec/are_parser'
+require 'rparsec/atom_parser'
+require 'rparsec/best_parser'
+require 'rparsec/bound_parser'
+require 'rparsec/boundn_parser'
+require 'rparsec/catch_parser'
+require 'rparsec/eof_parser'
+require 'rparsec/expect_parser'
+require 'rparsec/failure_parser'
+require 'rparsec/followed_parser'
+require 'rparsec/fragment_parser'
+require 'rparsec/get_index_parser'
+require 'rparsec/lazy_parser'
+require 'rparsec/many__parser'
+require 'rparsec/many_parser'
+require 'rparsec/map_current_parser'
+require 'rparsec/map_parser'
+require 'rparsec/mapn_current_parser'
+require 'rparsec/mapn_parser'
+require 'rparsec/nested_parser'
+require 'rparsec/one_parser'
+require 'rparsec/peek_parser'
+require 'rparsec/plus_parser'
+require 'rparsec/regexp_parser'
+require 'rparsec/repeat__parser'
+require 'rparsec/repeat_parser'
+require 'rparsec/satisfies_parser'
+require 'rparsec/sequence_parser'
+require 'rparsec/set_index_parser'
+require 'rparsec/some__parser'
+require 'rparsec/some_parser'
+require 'rparsec/string_case_insensitive_parser'
+require 'rparsec/throw_parser'
+require 'rparsec/token_parser'
+require 'rparsec/value_parser'
+require 'rparsec/watch_parser'
+require 'rparsec/watchn_parser'
+require 'rparsec/zero_parser'
 
 module RParsec
   #
@@ -87,9 +126,9 @@ module RParsec
     def char(c)
       if c.kind_of? Integer
         nm = c.chr
-        is(c, "'#{nm}' expected").setName(nm)
+        is(c, "'#{nm}' expected").tap { |p| p.name = nm }
       else
-        is(c[0], "'#{c}' expected").setName(c)
+        is(c[0], "'#{c}' expected").tap { |p| p.name = c }
       end
     end
 
@@ -99,9 +138,9 @@ module RParsec
     def not_char(c)
       if c.kind_of? Integer
         nm = c.chr
-        isnt(c, "'#{nm}' unexpected").setName("~#{nm}")
+        isnt(c, "'#{nm}' unexpected").tap { |p| p.name = "~#{nm}" }
       else
-        isnt(c[0], "'#{c}' unexpected").setName("~#{c}")
+        isnt(c[0], "'#{c}' unexpected").tap { |p| p.name = "~#{c}" }
       end
     end
 
@@ -109,7 +148,7 @@ module RParsec
     # A parser that succeeds when there's no input available.
     #
     def eof(expected = "EOF expected")
-      EofParser.new(expected).setName('EOF')
+      EofParser.new(expected).tap { |p| p.name = "EOF" }
     end
 
     #
@@ -134,7 +173,7 @@ module RParsec
     # A parser that matches the given string.
     #
     def string(str, msg = "\"#{str}\" expected")
-      are(str, msg).setName(str)
+      are(str, msg).tap { |p| p.name = str }
     end
 
     #
@@ -162,14 +201,14 @@ module RParsec
     # A parser that returns the current input index (starting from 0).
     #
     def get_index
-      GetIndexParser.new.setName('get_index')
+      GetIndexParser.new.tap { |p| p.name = 'get_index' }
     end
 
     #
     # A parser that moves the current input pointer to a certain index.
     #
     def set_index ind
-      SetIndexParser.new(ind).setName('set_index')
+      SetIndexParser.new(ind).tap { |p| p.name = "set_index" }
     end
 
     #
@@ -216,7 +255,8 @@ module RParsec
     # A parser that succeeds if the current input is within a certain range.
     #
     def range(from, to, msg = "#{as_char from}..#{as_char to} expected")
-      from, to = as_num(from), as_num(to)
+      from = as_num(from)
+      to = as_num(to)
       satisfies(msg) { |c| c <= to && c >= from }
     end
 
@@ -233,7 +273,7 @@ module RParsec
     # The matched string is consumed and returned as result.
     #
     def regexp(ptn, expected = "/#{ptn}/ expected")
-      RegexpParser.new(as_regexp(ptn), expected).setName(expected)
+      RegexpParser.new(as_regexp(ptn), expected).tap { |p| p.name = expected }
     end
 
     #
@@ -265,7 +305,7 @@ module RParsec
     # A parser that matches the given string, case insensitively.
     #
     def string_nocase(str, expected = "'#{str}' expected")
-      StringCaseInsensitiveParser.new(str, expected).setName(str)
+      StringCaseInsensitiveParser.new(str, expected).tap { |p| p.name = str }
     end
 
     #
@@ -428,620 +468,6 @@ module RParsec
     extend self
   end
 
-  class FailureParser < Parser # :nodoc:
-    init :msg
-    def _parse ctxt
-      return ctxt.failure(@msg)
-    end
-  end
-
-  class ValueParser < Parser # :nodoc:
-    init :value
-    def _parse ctxt
-      ctxt.retn @value
-    end
-  end
-
-  class LazyParser < Parser # :nodoc:
-    init :block
-    def _parse ctxt
-      @block.call._parse ctxt
-    end
-  end
-
-  class Failures # :nodoc:
-    def self.add_error(err, e)
-      return e if err.nil?
-      return err if e.nil?
-      cmp = compare_error(err, e)
-      return err if cmp > 0
-      return e if cmp < 0
-      err
-      # merge_error(err, e)
-    end
-
-    class << self
-      private
-
-      def get_first_element(err)
-        while err.kind_of?(Array)
-          err = err[0]
-        end
-        err
-      end
-
-      def compare_error(e1, e2)
-        e1, e2 = get_first_element(e1), get_first_element(e2)
-        return -1 if e1.index < e2.index
-        return 1 if e1.index > e2.index
-        0
-      end
-    end
-  end
-
-  ###############################################
-  #def merge_error(e1, e2)
-  #  return e1 << e2 if e1.kind_of?(Array)
-  #  [e1,e2]
-  #end
-  ###############################################
-  class ThrowParser < Parser # :nodoc:
-    init :symbol
-    def _parse _ctxt
-      throw @symbol
-    end
-  end
-
-  class CatchParser < Parser # :nodoc:
-    init :symbol, :parser
-    def _parse ctxt
-      interrupted = true
-      ok = false
-      catch @symbol do
-        ok = @parser._parse(ctxt)
-        interrupted = false
-      end
-      return ctxt.retn(@symbol) if interrupted
-      ok
-    end
-  end
-
-  class PeekParser < Parser # :nodoc:
-    init :parser
-    def _parse ctxt
-      ind = ctxt.index
-      return false unless @parser._parse ctxt
-      ctxt.index = ind
-      return true
-    end
-    def peek
-      self
-    end
-  end
-
-  class AtomParser < Parser # :nodoc:
-    init :parser
-    def _parse ctxt
-      ind = ctxt.index
-      return true if @parser._parse ctxt
-      ctxt.index = ind
-      return false
-    end
-    def atomize
-      self
-    end
-  end
-
-  class LookAheadSensitiveParser < Parser # :nodoc:
-    def initialize(la = 1)
-      super()
-      @lookahead = la
-    end
-    def visible(ctxt, n)
-      ctxt.index - n < @lookahead
-    end
-    def lookahead(n)
-      raise ArgumentError, "lookahead number #{n} should be positive" unless n > 0
-      return self if n == @lookahead
-      withLookahead(n)
-    end
-    def not(msg = "#{self} unexpected")
-      NotParser.new(self, msg, @lookahead)
-    end
-  end
-
-  class NotParser < LookAheadSensitiveParser # :nodoc:
-    def initialize(parser, msg, la = 1)
-      super(la)
-      @parser, @msg, @name = parser, msg, "~#{parser.name}"
-    end
-    def _parse ctxt
-      ind = ctxt.index
-      if @parser._parse ctxt
-        ctxt.index = ind
-        return ctxt.expecting(@msg)
-      end
-      return ctxt.retn(nil) if visible(ctxt, ind)
-      return false
-    end
-    def withLookahead(n)
-      NotParser.new(@parser, @msg, n)
-    end
-    def not()
-      @parser
-    end
-  end
-
-  class ExpectParser < Parser # :nodoc:
-    def initialize(parser, msg)
-      super()
-      @parser, @msg, @name = parser, msg, msg
-    end
-    def _parse ctxt
-      ind = ctxt.index
-      return true if @parser._parse ctxt
-      return false unless ind == ctxt.index
-      ctxt.expecting(@msg)
-    end
-  end
-
-  class PlusParser < LookAheadSensitiveParser # :nodoc:
-    def initialize(alts, la = 1)
-      super(la)
-      @alts = alts
-    end
-    def _parse ctxt
-      ind, result, err = ctxt.index, ctxt.result, ctxt.error
-      for p in @alts
-        ctxt.reset_error
-        ctxt.index, ctxt.result = ind, result
-        return true if p._parse(ctxt)
-        return false unless visible(ctxt, ind)
-        err = Failures.add_error(err, ctxt.error)
-      end
-      ctxt.error = err
-      return false
-    end
-    def withLookahead(n)
-      PlusParser.new(@alts, n)
-    end
-    def plus other
-      PlusParser.new(@alts.dup << other, @lookahead).setName(name)
-    end
-  end
-
-
-  class AltParser < LookAheadSensitiveParser # :nodoc:
-    def initialize(alts, la = 1)
-      super(la)
-      @alts, @lookahead = alts, la
-    end
-    def _parse ctxt
-      ind, result, err = ctxt.index, ctxt.result, ctxt.error
-      err_ind, err_pos = -1, -1
-      for p in @alts
-        ctxt.reset_error
-        ctxt.index, ctxt.result = ind, result
-        return true if p._parse(ctxt)
-        if ctxt.error.index > err_pos
-          err, err_ind, err_pos = ctxt.error, ctxt.index, ctxt.error.index
-        end
-      end
-      ctxt.index, ctxt.error = err_ind, err
-      return false
-    end
-    def withLookahead(n)
-      AltParser.new(@alts, n)
-    end
-    def | other
-      AltParser.new(@alts.dup << autobox_parser(other)).setName(name)
-    end
-  end
-
-
-  class BestParser < Parser # :nodoc:
-    init :alts, :longer
-    def _parse ctxt
-      best_result, best_ind = nil, -1
-      err_ind, err_pos = -1, -1
-      ind, result, err = ctxt.index, ctxt.result, ctxt.error
-      for p in @alts
-        ctxt.reset_error
-        ctxt.index, ctxt.result = ind, result
-        if p._parse(ctxt)
-          err, now_ind = nil, ctxt.index
-          if best_ind == -1 || (now_ind != best_ind && @longer == (now_ind > best_ind))
-            best_result, best_ind = ctxt.result, now_ind
-          end
-        elsif best_ind < 0 # no good match found yet.
-          if ctxt.error.index > err_pos
-            err_ind, err_pos = ctxt.index, ctxt.error.index
-          end
-          err = Failures.add_error(err, ctxt.error)
-        end
-      end
-      if best_ind >= 0
-        ctxt.index = best_ind
-        return ctxt.retn(best_result)
-      else
-        ctxt.error, ctxt.index = err, err_ind
-        return false
-      end
-    end
-  end
-
-  class BoundParser < Parser # :nodoc:
-    init :parser, :proc
-    def _parse ctxt
-      return false unless @parser._parse(ctxt)
-      @proc.call(ctxt.result)._parse ctxt
-    end
-  end
-
-  class BoundnParser < Parser # :nodoc:
-    init :parser, :proc
-    def _parse ctxt
-      return false unless @parser._parse(ctxt)
-      @proc.call(*ctxt.result)._parse ctxt
-    end
-  end
-
-  class MapParser < Parser # :nodoc:
-    init :parser, :proc
-    def _parse ctxt
-      return false unless @parser._parse(ctxt)
-      ctxt.result = @proc.call(ctxt.result)
-      true
-    end
-  end
-
-  class MapnParser < Parser # :nodoc:
-    init :parser, :proc
-    def _parse ctxt
-      return false unless @parser._parse(ctxt)
-      ctxt.result = @proc.call(*ctxt.result)
-      true
-    end
-  end
-
-  class SequenceParser < Parser # :nodoc:
-    init :parsers, :proc
-    def _parse ctxt
-      if @proc.nil?
-        for p in @parsers
-          return false unless p._parse(ctxt)
-        end
-      else
-        results = []
-        for p in @parsers
-          return false unless p._parse(ctxt)
-          results << ctxt.result
-        end
-        ctxt.retn(@proc.call(*results))
-      end
-      return true
-    end
-    def seq(other, &block)
-      SequenceParser.new(@parsers.dup << other, &block)
-    end
-  end
-
-  class FollowedParser < Parser # :nodoc:
-    init :p1, :p2
-    def _parse ctxt
-      return false unless @p1._parse ctxt
-      result = ctxt.result
-      return false unless @p2._parse ctxt
-      ctxt.retn(result)
-    end
-  end
-
-  class SatisfiesParser < Parser # :nodoc:
-    init :pred, :expected
-    def _parse ctxt
-      elem = nil
-      if ctxt.eof || !@pred.call(elem = ctxt.current)
-        return ctxt.expecting(@expected)
-      end
-      ctxt.next
-      ctxt.retn elem
-    end
-  end
-
-  class AnyParser < Parser # :nodoc:
-    def _parse ctxt
-      return ctxt.expecting if ctxt.eof
-      result = ctxt.current
-      ctxt.next
-      ctxt.retn result
-    end
-  end
-
-  class EofParser < Parser # :nodoc:
-    init :msg
-    def _parse ctxt
-      return true if ctxt.eof
-      return ctxt.expecting(@msg)
-    end
-  end
-
-  class RegexpParser < Parser # :nodoc:
-    init :ptn, :msg
-    def _parse ctxt
-      scanner = ctxt.scanner
-      result = scanner.check @ptn
-      if result.nil?
-        ctxt.expecting(@msg)
-      else
-        ctxt.advance(scanner.matched_size)
-        ctxt.retn(result)
-      end
-    end
-  end
-
-  class AreParser < Parser # :nodoc:
-    init :vals, :msg
-    def _parse ctxt
-      if @vals.length > ctxt.available
-        return ctxt.expecting(@msg)
-      end
-      cur = 0
-      for cur in (0...@vals.length)
-        if @vals[cur] != ctxt.peek(cur)
-          return ctxt.expecting(@msg)
-        end
-      end
-      ctxt.advance(@vals.length)
-      ctxt.retn @vals
-    end
-  end
-
-  class StringCaseInsensitiveParser < Parser # :nodoc:
-    init :str, :msg
-    def _downcase c
-      case when c.ord >= ?A.ord && c.ord <= ?Z.ord then (c.ord + (?a.ord - ?A.ord)).chr else c end
-    end
-    private :_downcase
-
-    def _parse ctxt
-      if @str.length > ctxt.available
-        return ctxt.expecting(@msg)
-      end
-      cur = 0
-      for cur in (0...@str.length)
-        if _downcase(@str[cur]) != _downcase(ctxt.peek(cur))
-          return ctxt.expecting(@msg)
-        end
-      end
-      result = ctxt.src[ctxt.index, @str.length]
-      ctxt.advance(@str.length)
-      ctxt.retn result
-    end
-  end
-
-  class FragmentParser < Parser # :nodoc:
-    init :parser
-    def _parse ctxt
-      ind = ctxt.index
-      return false unless @parser._parse ctxt
-      ctxt.retn(ctxt.src[ind, ctxt.index - ind])
-    end
-  end
-
-  class TokenParser < Parser # :nodoc:
-    init :symbol, :parser
-    def _parse ctxt
-      ind = ctxt.index
-      return false unless @parser._parse ctxt
-      raw = ctxt.result
-      raw = ctxt.src[ind, ctxt.index - ind] unless raw.kind_of? String
-      ctxt.retn(Token.new(@symbol, raw, ind))
-    end
-  end
-
-  class NestedParser < Parser # :nodoc:
-    init :parser1, :parser2
-    def _parse ctxt
-      ind = ctxt.index
-      return false unless @parser1._parse ctxt
-      _run_nested(ind, ctxt, ctxt.result, @parser2)
-    end
-    private
-    def _run_nested(start, ctxt, src, parser)
-      ctxt.error = nil
-      new_ctxt = nil
-      if src.kind_of? String
-        new_ctxt = ParseContext.new(src)
-        return true if _run_parser parser, ctxt, new_ctxt
-        ctxt.index = start + new_ctxt.index
-      elsif src.kind_of? Array
-        new_ctxt = ParseContext.new(src)
-        return true if _run_parser parser, ctxt, new_ctxt
-        ctxt.index = start + _get_index(new_ctxt) unless new_ctxt.eof
-      else
-        new_ctxt = ParseContext.new([src])
-        return true if _run_parser parser, ctxt, new_ctxt
-        ctxt.index = ind unless new_ctxt.eof
-      end
-      ctxt.error.index = ctxt.index
-      false
-    end
-    def _get_index ctxt
-      cur = ctxt.current
-      return cur.index if cur.respond_to? :index
-      ctxt.index
-    end
-    def _run_parser parser, old_ctxt, new_ctxt
-      if parser._parse new_ctxt
-        old_ctxt.result = new_ctxt.result
-        true
-      else
-        old_ctxt.error = new_ctxt.error
-        false
-      end
-    end
-  end
-
-  class WatchParser < Parser # :nodoc:
-    init :proc
-    def _parse ctxt
-      @proc.call(ctxt.result)
-      true
-    end
-  end
-
-  class WatchnParser < Parser # :nodoc:
-    init :proc
-    def _parse ctxt
-      @proc.call(*ctxt.result)
-      true
-    end
-  end
-
-  class MapCurrentParser < Parser # :nodoc:
-    init :proc
-    def _parse ctxt
-      ctxt.result = @proc.call(ctxt.result)
-      true
-    end
-  end
-
-  class MapnCurrentParser < Parser # :nodoc:
-    init :proc
-    def _parse ctxt
-      ctxt.result = @proc.call(*ctxt.result)
-      true
-    end
-  end
-
-  class Repeat_Parser < Parser # :nodoc:
-    init :parser, :times
-    def _parse ctxt
-      @times.times do
-        return false unless @parser._parse ctxt
-      end
-      return true
-    end
-  end
-
-  class RepeatParser < Parser # :nodoc:
-    init :parser, :times
-    def _parse ctxt
-      result = []
-      @times.times do
-        return false unless @parser._parse ctxt
-        result << ctxt.result
-      end
-      return ctxt.retn(result)
-    end
-  end
-
-  class Many_Parser < Parser # :nodoc:
-    init :parser, :least
-    def _parse ctxt
-      @least.times do
-        return false unless @parser._parse ctxt
-      end
-      while true
-        ind = ctxt.index
-        if @parser._parse ctxt
-          return true if ind == ctxt.index # infinite loop
-          next
-        end
-        return ind == ctxt.index
-      end
-    end
-  end
-
-  class ManyParser < Parser # :nodoc:
-    init :parser, :least
-    def _parse ctxt
-      result = []
-      @least.times do
-        return false unless @parser._parse ctxt
-        result << ctxt.result
-      end
-      while true
-        ind = ctxt.index
-        if @parser._parse ctxt
-          result << ctxt.result
-          return ctxt.retn(result) if ind == ctxt.index # infinite loop
-          next
-        end
-        if ind == ctxt.index
-          return ctxt.retn(result)
-        else
-          return false
-        end
-      end
-    end
-  end
-
-  class Some_Parser < Parser # :nodoc:
-    init :parser, :least, :max
-    def _parse ctxt
-      @least.times { return false unless @parser._parse ctxt }
-      (@least...@max).each do
-        ind = ctxt.index
-        if @parser._parse ctxt
-          return true if ind == ctxt.index # infinite loop
-          next
-        end
-        return ind == ctxt.index
-      end
-      return true
-    end
-  end
-
-  class SomeParser < Parser # :nodoc:
-    init :parser, :least, :max
-    def _parse ctxt
-      result = []
-      @least.times do
-        return false unless @parser._parse ctxt
-        result << ctxt.result
-      end
-      (@least...@max).each do
-        ind = ctxt.index
-        if @parser._parse ctxt
-          result << ctxt.result
-          return ctxt.retn(result) if ind == ctxt.index # infinite loop
-          next
-        end
-        if ind == ctxt.index
-          return ctxt.retn(result)
-        else
-          return false
-        end
-      end
-      return ctxt.retn(result)
-    end
-  end
-
-  class OneParser < Parser # :nodoc:
-    def _parse _ctxt
-      true
-    end
-  end
-
-  class ZeroParser < Parser # :nodoc:
-    def _parse ctxt
-      return ctxt.failure
-    end
-  end
-
-  class GetIndexParser < Parser # :nodoc:
-    def _parse ctxt
-      ctxt.retn(ctxt.index)
-    end
-  end
-  class SetIndexParser < Parser # :nodoc:
-    init :index
-    def _parse ctxt
-      ctxt.index = @index
-    end
-  end
-
   Nil = ValueParser.new(nil) # :nodoc:
 
 end # module