rattler 0.3.0 → 0.4.0

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

@@ -0,0 +1,17 @@
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  # @private
+  module Flattening #:nodoc:
+
+    def _applies_to?(parser, context)
+      parser.any? {|_| eligible_child? _ }
+    end
+
+    def _apply(parser, context)
+      children = parser.map {|_| eligible_child?(_) ? _.to_a : [_] }.reduce(:+)
+      parser.class.new(children, parser.attrs)
+    end
+
+  end
+end

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

@@ -0,0 +1,46 @@
+#
+# = rattler/back_end/optimizer/inline_regular_rules.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # References to regular parse rules can be inlined without affecting how they
+  # parse, assuming the referenced rule does not change. This optimization is
+  # only applied if the referenced rule is explicitly marked for inlining or
+  # the :standalone option is used.
+  #
+  # @author Jason Arhart
+  #
+  class InlineRegularRules < Optimization
+
+    include Rattler::Parsers
+
+    protected
+
+    def _applies_to?(parser, context)
+      parser.is_a? Apply and
+      inlineable? parser.rule_name, context
+    end
+
+    def _apply(parser, context)
+      optimize context.rules[parser.rule_name].expr, context
+    end
+
+    private
+
+    def inlineable?(rule_name, context)
+      inline_allowed? rule_name, context and
+      context.analysis.regular? rule_name
+    end
+
+    def inline_allowed?(rule_name, context)
+      context.standalone? or
+      context.rules[rule_name].attrs[:inline]
+    end
+
+  end
+end

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

@@ -0,0 +1,71 @@
+#
+# = rattler/back_end/optimizer/join_match_capturing_sequence.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # Sequences of Regexp matches can be joined into a single Regexp match using
+  # capturing groups if necessary.
+  #
+  # @author Jason Arhart
+  #
+  class JoinMatchCapturingSequence < Optimization
+    include MatchJoining
+
+    include Rattler::Parsers
+    include Rattler::BackEnd::ParserGenerator
+
+    protected
+
+    def _applies_to?(parser, context)
+      context.capturing? and
+      parser.is_a?(Sequence) and
+      any_neighbors?(parser) {|_| eligible_child? _ }
+    end
+
+    def eligible_child?(child)
+      child.is_a? Match or
+      (child.is_a? GroupMatch and child.num_groups == 1) or
+      (child.is_a? Skip and child.child.is_a? Match)
+    end
+
+    def create_patterns(parsers)
+      num_groups = 0
+      patterns = parsers.map do |parser|
+        case parser
+
+        when Match
+          num_groups += 1
+          "(#{parser.re.source})"
+
+        when GroupMatch
+          num_groups += parser.num_groups
+          "(?>#{parser.re.source})"
+
+        when Skip
+          "(?>#{parser.child.re.source})"
+
+        end
+      end
+      return {:patterns => patterns, :num_groups => num_groups }
+    end
+
+    def join_patterns(info)
+      return info.merge(:pattern => info[:patterns].join)
+    end
+
+    def create_match(info)
+      match = super(info[:pattern])
+      if info[:num_groups] > 0
+        GroupMatch[match, {:num_groups => info[:num_groups]}]
+      else
+        Skip[match]
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,37 @@
+#
+# = rattler/back_end/optimizer/join_match_choice.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # A choice of Regexp matches can be joined into a single Regexp match without
+  # affecting how it parses.
+  #
+  # @author Jason Arhart
+  #
+  class JoinMatchChoice < Optimization
+    include MatchJoining
+
+    include Rattler::Parsers
+
+    protected
+
+    def _applies_to?(parser, context)
+      parser.is_a?(Choice) and
+      super
+    end
+
+    def join_patterns(patterns)
+      patterns.join '|'
+    end
+
+    def eligible_child?(child)
+      child.is_a? Match
+    end
+
+  end
+end

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

@@ -0,0 +1,38 @@
+#
+# = rattler/back_end/optimizer/join_match_matching_sequence.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # Sequences of Regexp matches can be joined into a single Regexp without
+  # affecting how they match.
+  #
+  # @author Jason Arhart
+  #
+  class JoinMatchMatchingSequence < Optimization
+    include MatchJoining
+
+    include Rattler::Parsers
+
+    protected
+
+    def _applies_to?(parser, context)
+      context.matching? and
+      parser.is_a?(Sequence) and
+      any_neighbors?(parser) {|_| eligible_child? _ }
+    end
+
+    def eligible_child?(child)
+      child.is_a? Match
+    end
+
+    def create_pattern(match)
+      "(?>#{match.re.source})"
+    end
+
+  end
+end

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

@@ -0,0 +1,17 @@
+#
+# = rattler/back_end/optimizer/join_match_sequence.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler/back_end/optimizer'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # Sequences of Regexp matches can be joined into a single Regexp match using
+  # capturing groups if necessary.
+  #
+  # @author Jason Arhart
+  #
+  JoinMatchSequence = JoinMatchMatchingSequence >> JoinMatchCapturingSequence
+end

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

@@ -0,0 +1,68 @@
+#
+# = rattler/back_end/optimizer/join_predicate_bare_match.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # A predicate and an adjacent Regexp match in a Sequence can be joined into a
+  # single Regexp match.
+  #
+  # @author Jason Arhart
+  #
+  class JoinPredicateBareMatch < Optimization
+    include CompositeReducing
+
+    include Rattler::Parsers
+
+    protected
+
+    def _applies_to?(parser, context)
+      parser.is_a?(Sequence) and
+      parser.children.each_cons(2).any? {|a, b| eligible_pair? a, b }
+    end
+
+    def _apply(parser, context)
+      a = []
+      parser.each {|_| a << (eligible_pair?(a.last, _) ? reduce(a.pop, _) : _)}
+      finish_reduce parser, a
+    end
+
+    def reduce(*pair)
+      Match[Regexp.new(pair.map {|_| prepare_pattern _ }.join)]
+    end
+
+    def prepare_pattern(child)
+      case child
+      when Match        then "(?>#{child.re.source})"
+      when Assert       then "(?=#{child.child.re.source})"
+      when Disallow     then "(?!#{child.child.re.source})"
+      when Eof          then "\\z"
+      end
+    end
+
+    def eligible_pair?(a, b)
+      (eligible_match? a and eligible_predicate? b) or
+      (eligible_predicate? a and eligible_match? b)
+    end
+
+    def eligible_match?(parser)
+      parser.is_a? Match
+    end
+
+    def eligible_predicate?(parser)
+      case parser
+      when Eof
+        true
+      when Assert, Disallow
+        parser.child.is_a? Match
+      else
+        false
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,17 @@
+#
+# = rattler/back_end/optimizer/join_predicate_match.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler/back_end/optimizer'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # A predicate and an adjacent Regexp match in a Sequence can be joined into a
+  # single Regexp match.
+  #
+  # @author Jason Arhart
+  #
+  JoinPredicateMatch = JoinPredicateBareMatch >> JoinPredicateNestedMatch
+end

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

@@ -0,0 +1,37 @@
+#
+# = rattler/back_end/optimizer/join_predicate_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 Sequence can be
+  # joined into a single skip of a Regexp match.
+  #
+  # @author Jason Arhart
+  #
+  class JoinPredicateNestedMatch < JoinPredicateBareMatch
+    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/join_predicate_or_bare_match.rb

@@ -0,0 +1,68 @@
+#
+# = rattler/back_end/optimizer/join_predicate_or_bare_match.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # A predicate and an adjacent Regexp match in a Choice can be joined into a
+  # single Regexp match.
+  #
+  # @author Jason Arhart
+  #
+  class JoinPredicateOrBareMatch < Optimization
+    include CompositeReducing
+
+    include Rattler::Parsers
+
+    protected
+
+    def _applies_to?(parser, context)
+      parser.is_a?(Choice) and
+      parser.children.each_cons(2).any? {|a, b| eligible_pair? a, b }
+    end
+
+    def _apply(parser, context)
+      a = []
+      parser.each {|_| a << (eligible_pair?(a.last, _) ? reduce(a.pop, _) : _)}
+      finish_reduce parser, a
+    end
+
+    def reduce(*pair)
+      Match[Regexp.new(pair.map {|_| prepare_pattern _ }.join '|' )]
+    end
+
+    def prepare_pattern(child)
+      case child
+      when Match        then child.re.source
+      when Assert       then "(?=#{child.child.re.source})"
+      when Disallow     then "(?!#{child.child.re.source})"
+      when Eof          then "\\z"
+      end
+    end
+
+    def eligible_pair?(a, b)
+      (eligible_match? a and eligible_predicate? b) or
+      (eligible_predicate? a and eligible_match? b)
+    end
+
+    def eligible_match?(parser)
+      parser.is_a? Match
+    end
+
+    def eligible_predicate?(parser)
+      case parser
+      when Eof
+        true
+      when Assert, Disallow
+        parser.child.is_a? Match
+      else
+        false
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,17 @@
+#
+# = rattler/back_end/optimizer/join_predicate_or_match.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler/back_end/optimizer'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # A predicate and an adjacent Regexp match in a Choice can be joined into a
+  # single Regexp match.
+  #
+  # @author Jason Arhart
+  #
+  JoinPredicateOrMatch = JoinPredicateOrBareMatch >> JoinPredicateOrNestedMatch
+end