rattler 0.3.0 → 0.4.0

data/lib/rattler/back_end/optimizer/join_predicate_or_nested_match.rb

@@ -0,0 +1,36 @@
+#
+# = rattler/back_end/optimizer/join_predicate_or_nested_match.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # A predicate and an adjacent skip of a Regexp match in a Choice can be
+  # joined into a single skip of a Regexp match.
+  #
+  # @author Jason Arhart
+  #
+  class JoinPredicateOrNestedMatch < JoinPredicateOrBareMatch
+    include CompositeReducing
+
+    include Rattler::Parsers
+
+    protected
+
+    def reduce(*pair)
+      pair.find {|_| _.is_a? Skip }.with_child super
+    end
+
+    def prepare_pattern(parser)
+      super(parser.is_a?(Skip) ? parser.child : parser)
+    end
+
+    def eligible_match?(parser)
+      parser.is_a? Skip and super parser.child
+    end
+
+  end
+end

data/lib/rattler/back_end/optimizer/match_joining.rb

@@ -0,0 +1,60 @@
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  # @private
+  module MatchJoining #:nodoc:
+
+    include CompositeReducing
+
+    include Rattler::Parsers
+
+    protected
+
+    def _applies_to?(parser, context)
+      any_neighbors?(parser) {|_| eligible_child? _ }
+    end
+
+    def _apply(parser, context)
+      new_children = []
+      matches = []
+      for child in parser
+        if eligible_child? child
+          matches << child
+        else
+          join_matches(matches) {|match| new_children << match }
+          matches = []
+          new_children << child
+        end
+      end
+      join_matches(matches) {|match| new_children << match }
+      finish_reduce parser, new_children
+    end
+
+    def any_neighbors?(parser)
+      parser.each_cons(2).any? {|a| a.all? {|_| yield _ } }
+    end
+
+    def join_matches(matches)
+      unless matches.empty?
+        yield create_match(join_patterns(create_patterns(matches)))
+      end
+    end
+
+    def create_patterns(matches)
+      matches.map {|_| create_pattern _ }
+    end
+
+    def join_patterns(patterns)
+      patterns.join
+    end
+
+    def create_pattern(match)
+      match.re.source
+    end
+
+    def create_match(pattern)
+      Match[Regexp.new(pattern)]
+    end
+
+  end
+end

data/lib/rattler/back_end/optimizer/optimization.rb

@@ -0,0 +1,94 @@
+#
+# = rattler/back_end/optimizer/optimization.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+require 'singleton'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # An +Optimization+ represents a simple transformation of a parser model into
+  # an equivalent model that can result in more efficient parsing code.
+  # Subclasses override <tt>#_applies_to?</tt> and <tt>#_apply</tt> to define
+  # an optimization.
+  #
+  # @author Jason Arhart
+  #
+  class Optimization
+
+    class <<self
+      def instance
+        @instance ||= self.new
+      end
+
+      # @see Rattler::BackEnd::Optimizer::Optimization#>>
+      def >>(other)
+        instance >> (other.respond_to?(:instance) ? other.instance : other)
+      end
+
+      # @see Rattler::BackEnd::Optimizer::Optimization#match
+      def apply(*args)
+        instance.apply(*args)
+      end
+
+      # @see Rattler::BackEnd::Optimizer::Optimization#applies_to?
+      def applies_to?(*args)
+        instance.applies_to?(*args)
+      end
+    end
+
+    def initialize
+      @applies_to_cache = Hash.new {|h, k| h[k] = {} }
+    end
+
+    # Return a new optimzation that sequences this optimzation and +other+,
+    # i.e. the new optimzation applies this optimzation, then applies +other+
+    # to the result.
+    #
+    # @param [Rattler::BackEnd::Optimizer::Optimization] other the optimization
+    #   to apply after this one
+    #
+    # @return [Rattler::BackEnd::Optimizer::Optimization] a new optimzation
+    #   that sequences this optimzation and +other+
+    def >>(other)
+      OptimizationSequence.new(self, other)
+    end
+
+    # Apply the optimzation to +parser+ in +context+ if
+    # <tt>#applies_to?(parser, context)</tt> is +true+.
+    #
+    # @param [Rattler::Parsers::Parser] parser the parser to be optimized
+    # @param [Rattler::BackEnd::Optimizer::OptimizationContext] context
+    #
+    # @return [Rattler::Parsers::Parser] the optimized parser
+    def apply(parser, context)
+      applies_to?(parser, context) ? _apply(parser, context) : parser
+    end
+
+    # Return +true+ if this optimzation applies to +parser+ in +context+.
+    #
+    # @param [Rattler::Parsers::Parser] parser a parser model
+    # @param [Rattler::BackEnd::Optimizer::OptimizationContext] context
+    #
+    # @return [Boolean] +true+ if this optimzation applies to +parser+ in
+    #   +context+
+    def applies_to?(parser, context)
+      @applies_to_cache[context].fetch(parser) do
+        @applies_to_cache[context][parser] = _applies_to?(parser, context)
+      end
+    end
+
+    private
+
+    def optimize(parser, context)
+      optimizations.apply(parser, context)
+    end
+
+    def optimizations
+      ::Rattler::BackEnd::Optimizer.optimizations
+    end
+
+  end
+end

data/lib/rattler/back_end/optimizer/optimization_context.rb

@@ -0,0 +1,72 @@
+#
+# = rattler/back_end/optimizer/optimization_context.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler/back_end/optimizer'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # +OptimizationContext+ provides contextual information to optimzations.
+  #
+  # @author Jason Arhart
+  #
+  class OptimizationContext
+
+    @@cache = Hash.new {|h, attrs| h[attrs] = self.new(attrs) }
+
+    def self.[](attrs)
+      @@cache[attrs]
+    end
+
+    def initialize(attrs)
+      @attrs = attrs
+      @rules = @attrs[:rules]
+    end
+
+    attr_reader :type, :rules
+
+    def start_rule
+      rules && rules.start_rule
+    end
+
+    def analysis
+      rules && rules.analysis
+    end
+
+    def capturing?
+      @attrs[:type] == :capturing
+    end
+
+    def matching?
+      @attrs[:type] == :matching
+    end
+
+    def standalone?
+      start_rule && @attrs[:standalone]
+    end
+
+    def relavent?(rule)
+      (not standalone? and not rule.attrs[:inline]) or
+      analysis.referenced?(rule.name)
+    end
+
+    def with(new_attrs)
+      self.class[@attrs.merge new_attrs]
+    end
+
+    def method_missing(symbol, *args)
+      if args.empty? and @attrs.has_key? symbol
+        @attrs[symbol]
+      else
+        super
+      end
+    end
+
+    def respond_to?(symbol)
+      super or @attrs.has_key? symbol
+    end
+
+  end
+end

data/lib/rattler/back_end/optimizer/optimization_sequence.rb

@@ -0,0 +1,37 @@
+#
+# = rattler/back_end/optimizer/optimization.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # An +OptimizationSequence+ sequences a pair of optimzations so that applying
+  # the sequence applies the first optimization, then applies the second
+  # optimzation to the result.
+  #
+  # @author Jason Arhart
+  #
+  class OptimizationSequence < Optimization
+
+    def initialize(init, last)
+      super()
+      @init = init
+      @last = last
+    end
+
+    protected
+
+    def _applies_to?(parser, context)
+      @last.applies_to? parser, context or
+      @init.applies_to? parser, context
+    end
+
+    def _apply(parser, context)
+      @last.apply(@init.apply(parser, context), context)
+    end
+
+  end
+end

data/lib/rattler/back_end/optimizer/optimize_children.rb

@@ -0,0 +1,46 @@
+#
+# = rattler/back_end/optimizer/flatten_choice.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # Optimizes all of the children of a parser model in the appropriate context.
+  #
+  # @author Jason Arhart
+  #
+  class OptimizeChildren < Optimization
+
+    include Rattler::Parsers
+
+    protected
+
+    def _applies_to?(parser, context)
+      !parser.children.empty? and
+      (parser.any? do |_|
+        optimizations.applies_to? _, child_context(parser, context)
+      end)
+    end
+
+    def _apply(parser, context)
+      parser.with_children(parser.map do |_|
+        optimize _, child_context(parser, context)
+      end)
+    end
+
+    private
+
+    def child_context(parser, context)
+      case parser
+      when Assert, Disallow, Token, Skip
+        context.with :type => :matching
+      else
+        context
+      end
+    end
+
+  end
+end

data/lib/rattler/back_end/optimizer/reduce_repeat_match.rb

@@ -0,0 +1,44 @@
+#
+# = rattler/back_end/optimizer/reduce_repeat_match.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # A repeat of a Regexp match can be reduced to a single Regexp match.
+  #
+  # @author Jason Arhart
+  #
+  class ReduceRepeatMatch < Optimization
+
+    include Rattler::Parsers
+
+    protected
+
+    def _applies_to?(parser, context)
+      context.matching? and
+      case parser
+      when ZeroOrMore, OneOrMore, Optional
+        parser.child.is_a?(Match)
+      end
+    end
+
+    def _apply(parser, context)
+      Match[Regexp.new("(?>#{parser.child.re.source})#{suffix parser}")]
+    end
+
+    private
+
+    def suffix(parser)
+      case parser
+      when ZeroOrMore then '*'
+      when OneOrMore then '+'
+      when Optional then '?'
+      end
+    end
+
+  end
+end

data/lib/rattler/back_end/optimizer/remove_meaningless_wrapper.rb

@@ -0,0 +1,32 @@
+#
+# = rattler/back_end/optimizer/remove_meaningless_wrapper.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # Token, skip, and symantic action wrappers only have meaning in a capturing
+  # context.
+  #
+  # @author Jason Arhart
+  #
+  class RemoveMeaninglessWrapper < Optimization
+
+    include Rattler::Parsers
+
+    protected
+
+    def _applies_to?(parser, context)
+      context.matching? and
+      [Token, Skip, DispatchAction, DirectAction].any? {|_| parser.is_a? _ }
+    end
+
+    def _apply(parser, context)
+      parser.child
+    end
+
+  end
+end

data/lib/rattler/back_end/optimizer/simplify_redundant_repeat.rb

@@ -0,0 +1,43 @@
+#
+# = rattler/back_end/optimizer/simplify_redundant_repeat.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # A repeat of a repeat can be simplified to a simple repeat.
+  #
+  # @author Jason Arhart
+  #
+  class SimplifyRedundantRepeat < Optimization
+
+    include Rattler::Parsers
+
+    @@repeat_types = [ZeroOrMore, OneOrMore, Optional]
+
+    protected
+
+    def _applies_to?(parser, context)
+      context.matching? and
+      [parser, parser.child].all? {|_| repeat? _ }
+    end
+
+    def _apply(parser, context)
+      if @@repeat_types.any? {|_| parser.is_a?(_) and parser.child.is_a?(_) }
+        parser.child
+      else
+        ZeroOrMore[parser.child.child]
+      end
+    end
+
+    private
+
+    def repeat?(parser)
+      @@repeat_types.any? {|_| parser.is_a? _ }
+    end
+
+  end
+end