rparsec2 1.1.0 → 1.2.1

data/lib/rparsec/locator.rb

@@ -1,40 +1,42 @@
+# frozen_string_literal: true
+
 require 'rparsec/misc'
 
 module RParsec
 
-class CodeLocator
-  extend DefHelper
+  class CodeLocator # :nodoc:
+    extend DefHelper
 
-  def_readable :code
+    def_readable :code
 
-  LF = ?\n
+    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
+    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
-    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
+    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
-    return line, col
   end
-end
 
 end # module

data/lib/rparsec/misc.rb

@@ -1,106 +1,23 @@
-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
+# frozen_string_literal: true
 
-  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
+module RParsec
 
-#
-# 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
+  #
+  # Helpers for defining ctor.
+  #
+  module DefHelper # :nodoc:
+    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
-    # 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)
+    def def_readable(*vars)
+      attr_reader(*vars)
+      def_ctor(*vars)
     end
   end
-end
 
 end # module

data/lib/rparsec/monad.rb

@@ -1,63 +1,66 @@
-module RParsec
+# frozen_string_literal: true
 
-#
-# module for Monad
-#
-module Monad
-  attr_reader :this
+module RParsec
 
   #
-  # To initialize with a monad implementation and an object that obeys the monad law.
+  # module for Monad
   #
-  def initMonad(m, v)
-    raise ArgumentError, 'monad cannot be nil' if m.nil?
-    @monad = m;
-    @this = v;
-  end
+  module Monad
+    attr_reader :this
 
-  #
-  # To create a value based on the monad impl.
-  #
-  def value v
-    @monad.value v
-  end
+    #
+    # 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
 
-  #
-  # Run the _bind_ operation on the encapsulated object following the monad law.
-  #
-  def bind(&binder)
-    @monad.bind(@this, &binder)
-  end
+    #
+    # To create a value based on the monad impl.
+    #
+    def value v
+      @monad.value v
+    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 }
+    #
+    # Run the _bind_ operation on the encapsulated object following the monad law.
+    #
+    def bind(&binder)
+      @monad.bind(@this, &binder)
     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);
+    #
+    # 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
-  end
 
-  #
-  # Run the _plus_ operation on the encapsulated object following the MonadPlus law.
-  #
-  def plus other
-    @monad.mplus(@this, other.this)
+    #
+    # 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
 
-end # module
+end # module

data/lib/rparsec/operator_table.rb

@@ -0,0 +1,89 @@
+module RParsec
+  #
+  # This class holds information about operator precedences and
+  # associativities.  #prefix, #postfix, #infixl, #infixr, #infixn can
+  # be called to register operators.
+  #
+  class OperatorTable
+
+    #
+    # Operator attributes.
+    #
+    attr_reader :operators # :nodoc:
+
+    #
+    # Re-initialize the operator table.
+    #
+    def reinit # :nodoc:
+      @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
+end

data/lib/rparsec/operators.rb

@@ -1,106 +1,110 @@
+# frozen_string_literal: true
+
 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.
+  # This class helps building lexer and parser for operators.  The
+  # case that one operator (<tt>++</tt> for example) contains another
+  # operator (<tt>+</tt>) is automatically handled so client code
+  # don't have to worry about ambiguity.
   #
-  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)
+  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
-      result = result.token(symbol)
-      @lexers[symbol] = result
-      @parsers[symbol] = Parsers.token(symbol, &block)
-      result
+      @lexer = Parsers.sum(*lexers)
     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
+    #
+    # 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
+    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
+    #
+    # 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)
+    #
+    # 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
-    # suites are populated with bigger suite first
-    to_array suites
-  end
 
-  class << self
-    private
+    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.
+      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)
+        # 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
-      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
+      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
-      false
-    end
 
-    def to_array suites
-      suites.reverse!.flatten!
+      def to_array suites
+        suites.reverse!.flatten!
+      end
     end
   end
-end
 
 end # module