rparsec2 1.1.0

data/lib/rparsec/locator.rb

@@ -0,0 +1,40 @@
+require 'rparsec/misc'
+
+module RParsec
+
+class CodeLocator
+  extend DefHelper
+
+  def_readable :code
+
+  LF = ?\n
+
+  def locate(ind)
+    return _locateEof if ind >= code.length
+    line, col = 1, 1
+    return line, col if ind <= 0
+    for i in (0...ind)
+      c = code[i]
+      if c == LF
+        line, col = line + 1, 1
+      else
+        col = col + 1
+      end
+    end
+    return line, col
+  end
+
+  def _locateEof
+    line, col = 1, 1
+    code.each_byte do |c|
+      if c == LF.ord
+        line, col = line + 1, 1
+      else
+        col = col + 1
+      end
+    end
+    return line, col
+  end
+end
+
+end # module

data/lib/rparsec/misc.rb

@@ -0,0 +1,106 @@
+module RParsec
+
+#
+# Helpers for defining ctor.
+#
+module DefHelper
+  def def_ctor(*vars)
+    define_method(:initialize) do |*params|
+      vars.each_with_index do |var, i|
+        instance_variable_set("@" + var.to_s, params[i])
+      end
+    end
+  end
+
+  def def_readable(*vars)
+    attr_reader(*vars)
+    def_ctor(*vars)
+  end
+
+  def def_mutable(*vars)
+    attr_accessor(*vars)
+    def_ctor(*vars)
+  end
+end
+
+#
+# To type check method parameters.
+#
+module TypeChecker
+  private
+
+  def nth n
+    th = case n when 0 then 'st' when 1 then 'nd' else 'th' end
+    "#{n + 1}#{th}"
+  end
+
+  public
+
+  def check_arg_type expected, obj, mtd, n = 0
+    unless obj.kind_of? expected
+      raise ArgumentError,
+        "#{obj.class} assigned to #{expected} for the #{nth n} argument of #{mtd}."
+    end
+  end
+
+  def check_arg_array_type elem_type, arg, mtd, n = 0
+    check_arg_type Array, arg, mtd, n
+    arg.each_with_index do |x, i|
+      unless x.kind_of? elem_type
+        raise ArgumentError,
+          "#{x.class} assigned to #{elem_type} for the #{nth i} element of the #{nth n} argument of #{mtd}."
+      end
+    end
+  end
+
+  def check_vararg_type expected, args, mtd, n = 0
+    (n...args.length).each do |i|
+      check_arg_type expected, args[i], mtd, i
+    end
+  end
+
+  extend self
+end
+
+#
+# To add declarative signature support.
+#
+module Signature
+  # Signatures = {}
+  def def_sig sym, *types
+    types.each_with_index do |t, i|
+      unless t.kind_of? Class
+        TypeChecker.check_arg_type Class, t, :def_sig, i unless t.kind_of? Array
+        TypeChecker.check_arg_type Class, t, :def_sig, i unless t.length <= 1
+        TypeChecker.check_arg_array_type Class, t, :def_sig, i
+      end
+    end
+    # Signatures[sym] = types
+    __intercept_method_to_check_param_types__(sym, types)
+  end
+
+  private
+
+  def __intercept_method_to_check_param_types__(sym, types)
+    mtd = instance_method(sym)
+    define_method(sym) do |*params, &block|
+      star_type, star_ind = nil, nil
+      types.each_with_index do |t, i|
+        t = star_type unless star_type.nil?
+        arg = params[i]
+        if t.kind_of? Class
+          TypeChecker.check_arg_type t, arg, sym, i
+        elsif t.empty?
+          TypeChecker.check_arg_type Array, arg, sym, i
+        else
+          star_type, star_ind = t[0], i
+          break
+        end
+      end
+      TypeChecker.check_vararg_type star_type, params, sym, star_ind unless star_ind.nil?
+      mtd.bind(self).call(*params, &block)
+    end
+  end
+end
+
+end # module

data/lib/rparsec/monad.rb

@@ -0,0 +1,63 @@
+module RParsec
+
+#
+# module for Monad
+#
+module Monad
+  attr_reader :this
+
+  #
+  # To initialize with a monad implementation and an object that obeys the monad law.
+  #
+  def initMonad(m, v)
+    raise ArgumentError, 'monad cannot be nil' if m.nil?
+    @monad = m;
+    @this = v;
+  end
+
+  #
+  # To create a value based on the monad impl.
+  #
+  def value v
+    @monad.value v
+  end
+
+  #
+  # Run the _bind_ operation on the encapsulated object following the monad law.
+  #
+  def bind(&binder)
+    @monad.bind(@this, &binder)
+  end
+
+  #
+  # Run the _seq_ operation on the encapsulated object following the monad law.
+  # If _seq_ is not defined by the monad impl, use _bind_ to implement.
+  #
+  def seq(other)
+    if @monad.respond_to? :seq
+      @monad.seq(other)
+    else
+      bind { |_x| other }
+    end
+  end
+
+  #
+  # Run the _map_ operation on the encapsulated object following the monad law.
+  # _bind_ is used to implement.
+  #
+  def map(&mapper)
+    bind do |v|
+      result = mapper.call v;
+      value(result);
+    end
+  end
+
+  #
+  # Run the _plus_ operation on the encapsulated object following the MonadPlus law.
+  #
+  def plus other
+    @monad.mplus(@this, other.this)
+  end
+end
+
+end # module

data/lib/rparsec/operators.rb

@@ -0,0 +1,106 @@
+require 'rparsec/parser'
+
+module RParsec
+
+#
+# This class helps building lexer and parser for operators.
+# The case that one operator (++ for example) contains another operator (+)
+# is automatically handled so client code don't have to worry about ambiguity.
+#
+class Operators
+  #
+  # To create an instance of Operators for the given operators.
+  # 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 initialize(ops, &block)
+    @lexers = {}
+    @parsers = {}
+    sorted = Operators.sort(ops)
+    lexers = sorted.map do |op|
+      symbol = op.to_sym
+      result = nil
+      if op.length == 1
+        result = Parsers.char(op)
+      else
+        result = Parsers.str(op)
+      end
+      result = result.token(symbol)
+      @lexers[symbol] = result
+      @parsers[symbol] = Parsers.token(symbol, &block)
+      result
+    end
+    @lexer = Parsers.sum(*lexers)
+  end
+
+  #
+  # Get the parser for the given operator.
+  #
+  def parser(op)
+    result = @parsers[op.to_sym]
+    raise ArgumentError, "parser not found for #{op}" if result.nil?
+    result
+  end
+
+  alias [] parser
+
+  #
+  # Get the lexer that lexes operators.
+  # If an operator is specified, the lexer for that operator is returned.
+  #
+  def lexer(op = nil)
+    return @lexer if op.nil?
+    @lexers[op.to_sym]
+  end
+
+  #
+  # Sort an array of operators so that contained operator appears after containers.
+  # When no containment exist between two operators, the shorter one takes precedence.
+  #
+  def self.sort(ops)
+    #sort the array by longer-string-first.
+    i = 0
+    ordered = ops.sort_by { |x| [x.length, i += 1] }.reverse
+    suites = []
+    # loop from the longer to shorter string
+    ordered.each do |s|
+      populate_suites(suites, s)
+    end
+    # suites are populated with bigger suite first
+    to_array suites
+  end
+
+  class << self
+    private
+
+    def populate_suites(suites, s)
+      # populate the suites so that bigger suite first
+      # this way we can use << operator for non-contained strings.
+
+      # we need to start from bigger suite. So loop in reverse order
+      for suite in suites
+        return if populate_suite(suite, s)
+      end
+      suites << [s]
+    end
+
+    def populate_suite(suite, s)
+      # loop from the tail of the suite
+      for i in (1..suite.length)
+        ind = suite.length - i
+        cur = suite[ind]
+        if cur.start_with?(s)
+          suite.insert(ind + 1, s) unless cur == s
+          return true
+        end
+      end
+      false
+    end
+
+    def to_array suites
+      suites.reverse!.flatten!
+    end
+  end
+end
+
+end # module