rparsec 0.4.1 → 0.4.2

data/rparsec.rb

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

data/rparsec/context.rb

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

@@ -1,20 +1,23 @@
-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
+require 'rparsec/misc'
+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

data/rparsec/expressions.rb

@@ -1,137 +1,180 @@
-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
+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. 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
+  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