rparsec 0.4.1 → 0.4.2

data/rparsec/id_monad.rb

@@ -1,11 +1,13 @@
-class IdMonad
-  def value v
-    v
-  end
-  def bind prev
-    yield prev
-  end
-  def mplus a, b
-    a
-  end
-end
+class IdMonad
+  def value v
+    v
+  end
+  
+  def bind prev
+    yield prev
+  end
+  
+  def mplus a, b
+    a
+  end
+end

data/rparsec/keywords.rb

@@ -1,90 +1,102 @@
-require 'rparsec/parser'
-
-#
-# This class helps building lexers and parsers for keywords.
-# 
-class Keywords
-  extend Parsers
-  private_class_method :new
-  attr_reader :keyword_symbol, :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? : tok
-        else Token.new(my_symbol, text, ind) end
-    end
-  end
-  def canonical_name(name)
-    case when @case_sensitive: name else name.downcase end
-  end
-  def copy_words(words, case_sensitive)
-    words.map do |w|
-      case when case_sensitive: w.dup else w.downcase end
-    end
-  end
+require 'rparsec/parser'
+
+#
+# This class helps building lexers and parsers for keywords.
+# 
+class Keywords
+  extend Parsers
+  
+  private_class_method :new
+  
+  attr_reader :keyword_symbol, :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

data/rparsec/locator.rb

@@ -1,32 +1,36 @@
-require 'rparsec/misc'
-
-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
-        line, col = line+1, 1 
-      else
-        col = col+1
-      end
-    end
-    return line, col
-  end
-end
+require 'rparsec/misc'
+
+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
+        line, col = line+1, 1 
+      else
+        col = col+1
+      end
+    end
+    return line, col
+  end
+end

data/rparsec/misc.rb

@@ -1,102 +1,109 @@
-#
-# 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: 'st' when 1: '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)
-    helper = "_#{sym}_param_types_checked_helper".to_sym
-    define_method(helper) do |*params|
-      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)
-    end
-    module_eval """
-    def #{sym}(*params, &block)
-      #{helper}(*params).call(*params, &block)
-    end
-    """
-  end
-end
-
+#
+# 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)
+    helper = "_#{sym}_param_types_checked_helper".to_sym
+    define_method(helper) do |*params|
+      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)
+    end
+    module_eval """
+    def #{sym}(*params, &block)
+      #{helper}(*params).call(*params, &block)
+    end
+    """
+  end
+end
+