rparsec 0.4 → 0.4.1

data/rparsec.rb

@@ -0,0 +1,3 @@
+%w{
+parsers operators keywords expressions
+}.each {|lib| require "rparsec/#{lib}"}

data/rparsec/context.rb

@@ -0,0 +1,66 @@
+
+
+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
+  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

data/rparsec/error.rb

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

data/rparsec/expressions.rb

@@ -0,0 +1,137 @@
+require 'rparsec/parser'
+
+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.
+  #
+  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)
+  #   tbl.infixl(char(?-) >> Minus)
+  #   tbl.prefix(char(?-) >> Neg)
+  # end
+  #
+  def self.new
+    this = allocate
+    this.reinit
+    if block_given?
+      yield this
+    end
+    this
+  end
+  private
+  #
+  # To define methods for registering operator. 
+  # This is typically used internally. 
+  #
+  def self.def_operator(*kinds)
+    kinds.each do |kind|
+      define_method(kind) do |op, precedence|
+        add(kind, op, precedence)
+      end
+    end
+  end
+  def_operator(*Associativities)
+  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
+  private
+  def self.array_to_dict arr
+    result = {}
+    arr.each_with_index do |key,i|
+      result [key] = i unless result.include? key
+    end
+    result
+  end
+  KindPrecedence = array_to_dict Associativities
+  public
+  #
+  # 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
+  private
+  def self.apply_operators(term, entries, delim)
+  # apply operators stored in [[precedence,associativity],[op...]] starting from beginning.
+    entries.inject(term) do |result, entry|
+      key, ops = *entry
+      null, 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 self.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 self.ignore_rest(parser, delim)
+    return parser if delim.nil?
+    parser << delim
+  end
+  def self.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

data/rparsec/functors.rb

@@ -0,0 +1,249 @@
+#
+# 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}
+  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
+  private_class_method
+  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.
+  # 
+  def curry(ary=arity)
+    Functors.curry(ary, &self)
+  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