rparsec2 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5de30f07e3855c6c2168832879138e3341ce79a20272ddf2c92857f47414e1ea
+  data.tar.gz: 74c1ad503c94fe4a75a788d1384161b6f1b34a7e017a0740a0025d24f8a8518f
+SHA512:
+  metadata.gz: 26932d06bc2b3ec459ea0b3e22d091ebd1470d277bdac373b075821c97b82b4ab5936bdf4944150f21016cd9632f0a84d0428417f68446c31e33447734035e74
+  data.tar.gz: e776214089f74d14ce7f61d4fde624ca245127d7edf89ca87033fe96b2132ab25b74f4d36a8927a6c0c24145c0722b911334f7e1eb32f08064ed7e6b448fd33f

data/lib/rparsec/context.rb

@@ -0,0 +1,86 @@
+require 'strscan'
+
+module RParsec
+
+class ParseContext
+  attr_reader :error, :src, :index, :result
+  attr_writer :error, :index, :result
+  
+  def initialize(src, index=0, error=nil)
+    @src, @index, @error = src, index, error
+    @scanner = nil
+  end
+
+  def scanner
+    @scanner = StringScanner.new(src) if @scanner.nil?
+    @scanner.pos= @index
+    @scanner
+  end
+  
+  def prepare_error
+    @error.flatten! if @error.kind_of?(Array)
+  end
+  
+  def to_msg
+    return '' if @error.nil?
+    return @error.msg unless @error.kind_of?(Array) 
+    @error.map{|e|e.msg}.join(' or ')
+  end
+  
+  def error_input
+    return nil if @error.nil?
+    err = @error
+    err = err.last if err.kind_of? Array
+    err.input
+  end
+  
+  def reset_error
+    @error = nil
+  end
+  
+  def current
+    @src[@index]
+  end
+  
+  def eof
+    @index >= @src.length
+  end
+  
+  def available
+    @src.length - @index
+  end
+  
+  def peek i
+    @src[@index+i]
+  end
+  
+  def next
+    @index += 1
+  end
+  
+  def advance n
+    @index += n
+  end
+  
+  def retn(val)
+    @result = val
+    true
+  end
+  
+  def failure(msg=nil)
+    @error = Failure.new(@index, get_current_input, msg)
+    return false
+  end
+  
+  def expecting(expected=nil)
+    @error = Expected.new(@index, get_current_input, expected)
+    return false
+  end
+  
+  def get_current_input
+    return nil if eof
+    current
+  end
+end
+
+end # module

data/lib/rparsec/error.rb

@@ -0,0 +1,28 @@
+require 'rparsec/misc'
+
+module RParsec
+
+class ParserException < StandardError
+  extend DefHelper
+  def_readable :index
+end
+class Failure
+  def initialize(ind, input, message = nil)
+    @index, @input, @msg = ind, input, message
+  end
+
+  attr_reader :index, :input
+  attr_writer :index
+
+  def msg
+    return @msg.to_s
+  end
+
+  Precedence = 100
+end
+
+class Expected < Failure
+  Precedence = 100
+end
+
+end # module

data/lib/rparsec/expressions.rb

@@ -0,0 +1,186 @@
+require 'rparsec/parser'
+
+module RParsec
+
+Associativities = [:prefix, :postfix, :infixn, :infixr, :infixl]
+#
+# This class holds information about operator precedences
+# and associativities.
+# prefix, postfix, infixl, infixr, infixn can be called
+# to register operators.
+#
+class OperatorTable
+  #
+  # operators attribute is used internally. Do not access it.
+  #
+  attr_reader :operators
+
+  #
+  # Re-initialize the operator table. Internal use only.
+  #
+  def reinit
+    @operators = []
+  end
+
+  #
+  # To create an OperatorTable instance.
+  # If a block is given, it is invoked to do post-instantiation.
+  # For example:
+  #
+  # OperatorTable.new do |tbl|
+  #   tbl.infixl(char(?+) >> Plus, 10)
+  #   tbl.infixl(char(?-) >> Minus, 10)
+  #   tbl.infixl(char(?*) >> Mul, 20)
+  #   tbl.infixl(char(?/) >> Div, 20)
+  #   tbl.prefix(char(?-) >> Neg, 50)
+  # end
+  #
+  def self.new
+    this = allocate
+    this.reinit
+    if block_given?
+      yield this
+    end
+    this
+  end
+
+  #
+  # Defines a prefix operator that returns a unary Proc object with a precedence associated.
+  # Returns self.
+  #
+  def prefix(op, precedence)
+    add(:prefix, op, precedence)
+  end
+
+  #
+  # Defines a postfix operator that returns a unary Proc object with a precedence associated.
+  # Returns self.
+  #
+  def postfix(op, precedence)
+    add(:postfix, op, precedence)
+  end
+
+  #
+  # Defines a left associative infix operator that returns a binary Proc object with a precedence
+  # associated. Returns self.
+  #
+  def infixl(op, precedence)
+    add(:infixl, op, precedence)
+  end
+
+  #
+  # Defines a right associative infix operator that returns a binary Proc object with a precedence
+  # associated. Returns self.
+  #
+  def infixr(op, precedence)
+    add(:infixr, op, precedence)
+  end
+
+  #
+  # Defines a non-associative infix operator that returns a binary Proc object with a precedence
+  # associated. Returns self.
+  #
+  def infixn(op, precedence)
+    add(:infixn, op, precedence)
+  end
+
+  private
+
+  def add(*entry)
+    @operators << entry
+    self
+  end
+end
+
+#
+# This module helps build an expression parser
+# using an OperatorTable instance and a parser
+# that parses the term expression.
+#
+module Expressions
+  class << self
+    private
+
+    def array_to_dict arr
+      result = {}
+      arr.each_with_index do |key, i|
+        result[key] = i unless result.include? key
+      end
+      result
+    end
+  end
+
+  KindPrecedence = array_to_dict Associativities
+
+  #
+  # build an expression parser using the given term parser
+  # and operator table.
+  # When _delim_ is specified, patterns recognized by _delim_
+  # is automatically ignored.
+  #
+  def self.build(term, table, delim = nil)
+    # sort so that higher precedence first.
+    apply_operators(term, prepare_suites(table).sort, delim)
+  end
+
+  class << self
+    private
+
+    def apply_operators(term, entries, delim)
+      # apply operators stored in [[precedence,associativity],[op...]] starting from beginning.
+      entries.inject(term) do |result, entry|
+        key, ops = *entry
+        _, kind_index = *key
+        op = ops[0]
+        op = Parsers.sum(*ops) if ops.length > 1
+        apply_operator(result, op, Associativities[kind_index], delim)
+      end
+    end
+
+    def apply_operator(term, op, kind, delim)
+      term, op = ignore_rest(term, delim), ignore_rest(op, delim)
+      # we could use send here,
+      # but explicit case stmt is more straight forward and less coupled with names.
+      # performance might be another benefit,
+      # though it is not clear whether meta-code is indeed slower than regular ones at all.
+      case kind
+      when :prefix
+        term.prefix(op)
+      when :postfix
+        term.postfix(op)
+      when :infixl
+        term.infixl(op)
+      when :infixr
+        term.infixr(op)
+      when :infixn
+        term.infixn(op)
+      else
+        raise ArgumentError, "unknown associativity: #{kind}"
+      end
+    end
+
+    def ignore_rest(parser, delim)
+      return parser if delim.nil?
+      parser << delim
+    end
+
+    def prepare_suites(table)
+      # create a hash with [precedence, associativity] as key, and op as value.
+      suites = {}
+      table.operators.each do |entry|
+        kind, op, precedence = *entry
+        key = [-precedence, KindPrecedence[kind]]
+        suite = suites[key]
+        if suite.nil?
+          suite = [op]
+          suites[key] = suite
+        else
+          suite << op
+        end
+      end
+      suites
+    end
+  end
+end
+
+end # module

data/lib/rparsec/functors.rb

@@ -0,0 +1,282 @@
+module RParsec
+
+#
+# This module provides frequently used functors.
+#
+module Functors
+  Id = proc { |x| x }
+  Idn = proc { |*x| x }
+  Neg = proc { |x| -x }
+  Inc = proc { |x| x + 1 }
+  Succ = proc { |x| x.succ }
+  Dec = proc { |x| x - 1 }
+  Plus = proc { |x, y| x + y }
+  Minus = proc { |x, y| x - y }
+  Mul = proc { |x, y| x * y }
+  Div = proc { |x, y| x / y }
+  Mod = proc { |x, y| x % y }
+  Power = proc { |x, y| x**y }
+  Not = proc { |x, _y| !x }
+  And = proc { |x, y| x && y }
+  Or = proc { |x, y| x || y }
+  Xor = proc { |x, y| x ^ y }
+  BitAnd = proc { |x, y| x & y }
+  Union = proc { |x, y| x | y }
+  Match = proc { |x, y| x =~ y }
+  Eq = proc { |x, y| x == y }
+  Ne = proc { |x, y| x != y }
+  Lt = proc { |x, y| x < y }
+  Gt = proc { |x, y| x > y }
+  Le = proc { |x, y| x <= y }
+  Ge = proc { |x, y| x >= y }
+  Compare = proc { |x, y| x <=> y }
+  Call = proc { |x, y| x.call(y) }
+  Feed = proc { |x, y| y.call(x) }
+  Fst = proc { |x, _| x }
+  Snd = proc { |_, x| x }
+  At = proc { |x, y| x[y] }
+  To_a = proc { |x| x.to_a }
+  To_s = proc { |x| x.to_s }
+  To_i = proc { |x| x.to_i }
+  To_sym = proc { |x| x.to_sym }
+  To_f = proc { |x| x.to_f }
+
+  #
+  # Get a Proc, when called, always return the given value.
+  #
+  def const(v)
+    proc { |_| v }
+  end
+
+  #
+  # Get a Proc, when called, return the nth parameter.
+  #
+  def nth(n)
+    proc { |*args| args[n] }
+  end
+
+  #
+  # Create a Proc, which expects the two parameters
+  # in the reverse order of _block_.
+  #
+  def flip(&block)
+    proc { |x, y| block.call(y, x) }
+  end
+
+  #
+  # Create a Proc, when called, the parameter is
+  # first passed into _f2_, _f1_ is called in turn
+  # with the return value from _other_.
+  #
+  def compose(f1, f2)
+    proc { |*x| f1.call(f2.call(*x)) }
+  end
+
+  #
+  # Create a Proc that's curriable.
+  # When curried, parameters are passed in from left to right.
+  # i.e. curry(closure).call(a).call(b) is quivalent to closure.call(a,b) .
+  # _block_ is encapsulated under the hood to perform the actual
+  # job when currying is done.
+  # arity explicitly specifies the number of parameters to curry.
+  #
+  def curry(arity, &block)
+    fail "cannot curry for unknown arity" if arity < 0
+    Functors.make_curry(arity, &block)
+  end
+
+  #
+  # Create a Proc that's curriable.
+  # When curried, parameters are passed in from right to left.
+  # i.e. reverse_curry(closure).call(a).call(b) is quivalent to closure.call(b,a) .
+  # _block_ is encapsulated under the hood to perform the actual
+  # job when currying is done.
+  # arity explicitly specifies the number of parameters to curry.
+  #
+  def reverse_curry(arity, &block)
+    fail "cannot curry for unknown arity" if arity < 0
+    Functors.make_reverse_curry(arity, &block)
+  end
+
+  #
+  # Uncurry a curried closure.
+  #
+  def uncurry(&block)
+    return block unless block.arity == 1
+    proc do |*args|
+      result = block
+      args.each do |a|
+        result = result.call(a)
+      end
+      result
+    end
+  end
+
+  #
+  # Uncurry a reverse curried closure.
+  #
+  def reverse_uncurry(&block)
+    return block unless block.arity == 1
+    proc do |*args|
+      result = block
+      args.reverse_each do |a|
+        result = result.call(a)
+      end
+      result
+    end
+  end
+
+  #
+  # Create a Proc, when called,
+  # repeatedly call _block_ for _n_ times.
+  # The same arguments are passed to each invocation.
+  #
+  def repeat(n, &block)
+    proc do |*args|
+      result = nil
+      n.times { result = block.call(*args) }
+      result
+    end
+  end
+
+  #
+  # Create a Proc, when called,
+  # repeatedly call _block_ for _n_ times.
+  # At each iteration, return value from the previous iteration
+  # is used as parameter.
+  #
+  def power(n, &block)
+    return const(nil) if n <= 0
+    return block if n == 1
+    proc do |*args|
+      result = block.call(*args)
+      (n - 1).times { result = block.call(result) }
+      result
+    end
+  end
+
+  extend self
+
+  def self.make_curry(arity, &block)
+    return block if arity <= 1
+    proc do |x|
+      make_curry(arity - 1) do |*rest|
+        block.call(*rest.insert(0, x))
+      end
+    end
+  end
+
+  def self.make_reverse_curry(arity, &block)
+    return block if arity <= 1
+    proc do |x|
+      make_reverse_curry(arity - 1) do |*rest|
+        block.call(*rest << x)
+      end
+    end
+  end
+end
+
+#
+# This module provides instance methods that
+# manipulate closures in a functional style.
+# It is typically included in Proc and Method.
+#
+module FunctorMixin
+  #
+  # Create a Proc, which expects the two parameters
+  # in the reverse order of _self_.
+  #
+  def flip
+    Functors.flip(&self)
+  end
+
+  #
+  # Create a Proc, when called, the parameter is
+  # first passed into _other_, _self_ is called in turn
+  # with the return value from _other_.
+  #
+  def compose(other)
+    Functors.compose(self, other)
+  end
+
+  alias << compose
+
+  #
+  # a >> b is equivalent to b << a
+  #
+  def >>(other)
+    other << self
+  end
+
+  #
+  # Create a Proc that's curriable.
+  # When curried, parameters are passed in from left to right.
+  # i.e. closure.curry.call(a).call(b) is quivalent to closure.call(a,b) .
+  # _self_ is encapsulated under the hood to perform the actual
+  # job when currying is done.
+  # _ary_ explicitly specifies the number of parameters to curry.
+  #
+  # *IMPORTANT*
+  # Proc and Method have built-in curry.
+  # but the arity always return -1.
+  # So, curry.reverse_curry does not work as expected.
+  # You need to use the "using FunctorMixin"
+  # See the "functor_test.rb"
+  [Proc, Method].each do |klass|
+    refine klass do
+      def curry(ary = arity)
+        Functors.curry(ary, &self)
+      end
+    end
+  end
+
+  #
+  # Create a Proc that's curriable.
+  # When curried, parameters are passed in from right to left.
+  # i.e. closure.reverse_curry.call(a).call(b) is quivalent to closure.call(b,a) .
+  # _self_ is encapsulated under the hood to perform the actual
+  # job when currying is done.
+  # _ary_ explicitly specifies the number of parameters to curry.
+  #
+  def reverse_curry(ary = arity)
+    Functors.reverse_curry(ary, &self)
+  end
+
+  #
+  # Uncurry a curried closure.
+  #
+  def uncurry
+    Functors.uncurry(&self)
+  end
+
+  #
+  # Uncurry a reverse curried closure.
+  #
+  def reverse_uncurry
+    Functors.reverse_uncurry(&self)
+  end
+
+  #
+  # Create a Proc, when called,
+  # repeatedly call _self_ for _n_ times.
+  # The same arguments are passed to each invocation.
+  #
+  def repeat(n)
+    Functors.repeat(n, &self)
+  end
+  #
+
+  # Create a Proc, when called,
+  # repeatedly call _self_ for _n_ times.
+  # At each iteration, return value from the previous iteration
+  # is used as parameter.
+  #
+  def power(n)
+    Functors.power(n, &self)
+  end
+
+  alias ** power
+  alias * repeat
+end
+
+end # module

data/lib/rparsec/id_monad.rb

@@ -0,0 +1,17 @@
+module RParsec
+
+class IdMonad
+  def value v
+    v
+  end
+
+  def bind prev
+    yield prev
+  end
+
+  def mplus a, _b
+    a
+  end
+end
+
+end # module

data/lib/rparsec/keywords.rb

@@ -0,0 +1,114 @@
+require 'rparsec/parser'
+
+module RParsec
+
+#
+# This class helps building lexers and parsers for keywords.
+#
+class Keywords
+  extend Parsers
+
+  private_class_method :new
+
+  #
+  # The symbol used to identify a keyword token
+  #
+  attr_reader :keyword_symbol
+
+  #
+  # The lexer that parses all the keywords represented
+  #
+  attr_reader :lexer
+
+  #
+  # Do we lex case sensitively?
+  #
+  def case_sensitive?
+    @case_sensitive
+  end
+
+  #
+  # To create an instance that lexes the given keywords
+  # case sensitively.
+  # _default_lexer_ is used to lex a token first, the token text is then compared with
+  # the given keywords. If it matches any of the keyword, a keyword token is generated instead
+  # using _keyword_symbol_.
+  # The _block_ parameter, if present, is used to convert the token text to another object
+  # when the token is recognized during grammar parsing phase.
+  #
+  def self.case_sensitive(words, default_lexer = word.token(:word), keyword_symbol = :keyword, &block)
+    new(words, true, default_lexer, keyword_symbol, &block)
+  end
+
+  #
+  # To create an instance that lexes the given keywords
+  # case insensitively.
+  # _default_lexer_ is used to lex a token first, the token text is then compared with
+  # the given keywords. If it matches any of the keyword, a keyword token is generated instead
+  # using _keyword_symbol_.
+  # The _block_ parameter, if present, is used to convert the token text to another object
+  # when the token is recognized during parsing phase.
+  #
+  def self.case_insensitive(words, default_lexer = word.token(:word), keyword_symbol = :keyword, &block)
+    new(words, false, default_lexer, keyword_symbol, &block)
+  end
+
+  # scanner has to return a string
+  def initialize(words, case_sensitive, default_lexer, keyword_symbol, &block)
+    @default_lexer, @case_sensitive, @keyword_symbol = default_lexer, case_sensitive, keyword_symbol
+    # this guarantees that we have copy of the words array and all the word strings.
+    words = copy_words(words, case_sensitive)
+    @name_map = {}
+    @symbol_map = {}
+    word_map = {}
+    words.each do |w|
+      symbol = "#{keyword_symbol}:#{w}".to_sym
+      word_map[w] = symbol
+      parser = Parsers.token(symbol, &block)
+      @symbol_map["#{w}".to_sym] = parser
+      @name_map[w] = parser
+    end
+    @lexer = make_lexer(default_lexer, word_map)
+  end
+
+  #
+  # Get the parser that recognizes the token of the given keyword during the parsing phase.
+  #
+  def parser(key)
+    result = nil
+    if key.kind_of? String
+      name = canonical_name(key)
+      result = @name_map[name]
+    else
+      result = @symbol_map[key]
+    end
+    raise ArgumentError, "parser not found for #{key}" if result.nil?
+    result
+  end
+
+  alias [] parser
+
+  private
+
+  def make_lexer(default_lexer, word_map)
+    default_lexer.map do |tok|
+      text, ind = tok.text, tok.index
+      key = canonical_name(text)
+      my_symbol = word_map[key]
+      case when my_symbol.nil? then tok
+        else Token.new(my_symbol, text, ind) end
+    end
+  end
+
+  def canonical_name(name)
+    case when @case_sensitive then name else name.downcase end
+  end
+
+  def copy_words(words, case_sensitive)
+    words.map do |w|
+      case when case_sensitive then w.dup else w.downcase end
+    end
+  end
+end
+
+end # module