rattler 0.5.0 → 0.6.0

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

@@ -0,0 +1,83 @@
+require 'rattler/compiler/optimizer'
+
+module Rattler::Compiler::Optimizer
+
+  # +OptimizationContext+ provides contextual information to optimzations.
+  class OptimizationContext
+
+    # @private
+    @@cache = Hash.new {|h, attrs| h[attrs] = self.new(attrs) }
+
+    # @param [Hash] attrs attributes of an optimization context
+    # @return [OptimizationContext] an optimization context with the given
+    #   attributes
+    def self.[](attrs)
+      @@cache[attrs]
+    end
+
+    # @param [Hash] attrs attributes of an optimization context
+    def initialize(attrs)
+      @attrs = attrs
+      @rules = @attrs[:rules]
+    end
+
+    attr_reader :type, :rules
+
+    # @return [Symbol] the name of the start rule
+    def start_rule
+      rules && rules.start_rule
+    end
+
+    # @return [Rattler::Parsers::Analysis] an analysis of the parse rules
+    def analysis
+      rules && rules.analysis
+    end
+
+    # @return whether this is a capturing context
+    def capturing?
+      @attrs[:type] == :capturing
+    end
+
+    # @return whether this is a matching context
+    def matching?
+      @attrs[:type] == :matching
+    end
+
+    # @param [Symbol] rule_name the name of a rule in the context
+    # @return whether the rule can be inlined
+    def inlineable?(rule_name)
+      if rule = rules[rule_name]
+        rule.attrs[:inline] and
+        analysis.regular? rule_name
+      end
+    end
+
+    # @param [Rattler::Parsers::Rule] rule a rule in the context
+    # @return whether the rule is relavent to the optimized parser
+    def relavent?(rule)
+      !rule.attrs[:inline] or
+      analysis.referenced?(rule.name)
+    end
+
+    # @param [Hash] new_attrs additional attributes
+    # @return [OptimizationContext] a new context with +new_attrs+ added
+    def with(new_attrs)
+      self.class[@attrs.merge new_attrs]
+    end
+
+    # @private
+    def method_missing(symbol, *args) #:nodoc:
+      if args.empty? and @attrs.has_key? symbol
+        @attrs[symbol]
+      else
+        super
+      end
+    end
+
+    # @private
+    def respond_to?(symbol) #:nodoc:
+      super or @attrs.has_key? symbol
+    end
+
+  end
+end

data/lib/rattler/{back_end → compiler}/optimizer/optimization_sequence.rb

@@ -1,19 +1,11 @@
 #
-# = rattler/back_end/optimizer/optimization.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-require 'rattler'
+require 'rattler/compiler/optimizer'
+
+module Rattler::Compiler::Optimizer
 
-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)

data/lib/rattler/compiler/optimizer/optimizations.rb

@@ -0,0 +1,27 @@
+require 'rattler/compiler/optimizer'
+
+module Rattler::Compiler::Optimizer
+
+  # +Optimizations+ defines the sequence of optimizations to apply to optimize
+  # parsers
+  module Optimizations
+
+    # @return [Optimization] the sequence of optimizations to apply to optimize
+    #   parsers
+    def optimizations
+      @optimizations ||=
+        InlineRegularRules >>
+        OptimizeChildren >>
+        SimplifyRedundantRepeat >>
+        RemoveMeaninglessWrapper >>
+        SimplifyTokenMatch >>
+        FlattenSequence >>
+        FlattenChoice >>
+        ReduceRepeatMatch >>
+        JoinPredicateMatch >>
+        JoinPredicateOrMatch >>
+        JoinMatchSequence >>
+        JoinMatchChoice
+    end
+  end
+end

data/lib/rattler/{back_end → compiler}/optimizer/optimize_children.rb

@@ -1,19 +1,11 @@
-#
-# = rattler/back_end/optimizer/flatten_choice.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-require 'rattler'
-
-module Rattler::BackEnd::Optimizer
-  #
+require 'rattler/compiler/optimizer'
+
+module Rattler::Compiler::Optimizer
+
   # Optimizes all of the children of a parser model in the appropriate context.
-  #
-  # @author Jason Arhart
-  #
   class OptimizeChildren < Optimization
 
+    include Optimizations
     include Rattler::Parsers
 
     protected
@@ -27,7 +19,7 @@ module Rattler::BackEnd::Optimizer
 
     def _apply(parser, context)
       parser.with_children(parser.map do |_|
-        optimize _, child_context(parser, context)
+        optimizations.apply _, child_context(parser, context)
       end)
     end
 

data/lib/rattler/{back_end → compiler}/optimizer/reduce_repeat_match.rb

@@ -1,17 +1,8 @@
-#
-# = rattler/back_end/optimizer/reduce_repeat_match.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-require 'rattler'
-
-module Rattler::BackEnd::Optimizer
-  #
+require 'rattler/compiler/optimizer'
+
+module Rattler::Compiler::Optimizer
+
   # A repeat of a Regexp match can be reduced to a single Regexp match.
-  #
-  # @author Jason Arhart
-  #
   class ReduceRepeatMatch < Optimization
 
     include Rattler::Parsers

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

@@ -0,0 +1,22 @@
+require 'rattler/compiler/optimizer'
+
+module Rattler::Compiler::Optimizer
+
+  # Token and skip wrappers only have meaning in a capturing context.
+  class RemoveMeaninglessWrapper < Optimization
+
+    include Rattler::Parsers
+
+    protected
+
+    def _applies_to?(parser, context)
+      context.matching? and
+      [Token, Skip].any? {|_| parser.is_a? _ }
+    end
+
+    def _apply(parser, context)
+      parser.child
+    end
+
+  end
+end

data/lib/rattler/{back_end → compiler}/optimizer/simplify_redundant_repeat.rb

@@ -1,17 +1,8 @@
-#
-# = rattler/back_end/optimizer/simplify_redundant_repeat.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-require 'rattler'
-
-module Rattler::BackEnd::Optimizer
-  #
+require 'rattler/compiler/optimizer'
+
+module Rattler::Compiler::Optimizer
+
   # A repeat of a repeat can be simplified to a simple repeat.
-  #
-  # @author Jason Arhart
-  #
   class SimplifyRedundantRepeat < Optimization
 
     include Rattler::Parsers

data/lib/rattler/{back_end → compiler}/optimizer/simplify_token_match.rb

@@ -1,17 +1,8 @@
-#
-# = rattler/back_end/optimizer/simplify_token_match.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-require 'rattler'
-
-module Rattler::BackEnd::Optimizer
-  #
+require 'rattler/compiler/optimizer'
+
+module Rattler::Compiler::Optimizer
+
   # A token wrapping a terminal parser is redundant.
-  #
-  # @author Jason Arhart
-  #
   class SimplifyTokenMatch < Optimization
 
     include Rattler::Parsers

data/lib/rattler/compiler/parser_generator.rb

@@ -0,0 +1,108 @@
+require 'rattler/compiler'
+
+module Rattler::Compiler
+
+  # A +ParserGenerator+ generates ruby parsing code from parser models.
+  module ParserGenerator
+
+    autoload :GrammarGenerator, 'rattler/compiler/parser_generator/grammar_generator'
+    autoload :RuleSetGenerator, 'rattler/compiler/parser_generator/rule_set_generator'
+    autoload :RuleGenerator, 'rattler/compiler/parser_generator/rule_generator'
+    autoload :ExprGenerator, 'rattler/compiler/parser_generator/expr_generator'
+    autoload :GeneratorHelper, 'rattler/compiler/parser_generator/generator_helper'
+    autoload :NestedExprGenerator, 'rattler/compiler/parser_generator/expr_generator'
+    autoload :SubGenerating, 'rattler/compiler/parser_generator/sub_generating'
+    autoload :NestedSubGenerating, 'rattler/compiler/parser_generator/sub_generating'
+    autoload :TopLevelSubGenerating, 'rattler/compiler/parser_generator/sub_generating'
+    autoload :Nested, 'rattler/compiler/parser_generator/nested'
+    autoload :TopLevel, 'rattler/compiler/parser_generator/top_level'
+    autoload :MatchGenerator, 'rattler/compiler/parser_generator/match_generator'
+    autoload :ChoiceGenerator, 'rattler/compiler/parser_generator/choice_generator'
+    autoload :SequenceGenerator, 'rattler/compiler/parser_generator/sequence_generator'
+    autoload :RepeatGenerator, 'rattler/compiler/parser_generator/repeat_generator'
+    autoload :GeneralRepeatGenerator, 'rattler/compiler/parser_generator/general_repeat_generator'
+    autoload :ListGenerator, 'rattler/compiler/parser_generator/list_generator'
+    autoload :GeneralListGenerator, 'rattler/compiler/parser_generator/general_list_generator'
+    autoload :ApplyGenerator, 'rattler/compiler/parser_generator/apply_generator'
+    autoload :AssertGenerator, 'rattler/compiler/parser_generator/assert_generator'
+    autoload :DisallowGenerator, 'rattler/compiler/parser_generator/disallow_generator'
+    autoload :EofGenerator, 'rattler/compiler/parser_generator/eof_generator'
+    autoload :ESymbolGenerator, 'rattler/compiler/parser_generator/e_symbol_generator'
+    autoload :SemanticActionGenerator, 'rattler/compiler/parser_generator/semantic_action_generator'
+    autoload :NodeActionGenerator, 'rattler/compiler/parser_generator/node_action_generator'
+    autoload :AttributedSequenceGenerator, 'rattler/compiler/parser_generator/attributed_sequence_generator'
+    autoload :TokenGenerator, 'rattler/compiler/parser_generator/token_generator'
+    autoload :SkipGenerator, 'rattler/compiler/parser_generator/skip_generator'
+    autoload :SuperGenerator, 'rattler/compiler/parser_generator/super_generator'
+    autoload :LabelGenerator, 'rattler/compiler/parser_generator/label_generator'
+    autoload :BackReferenceGenerator, 'rattler/compiler/parser_generator/back_reference_generator'
+    autoload :FailGenerator, 'rattler/compiler/parser_generator/fail_generator'
+    autoload :DelegatingGenerator, 'rattler/compiler/parser_generator/delegating_generator'
+    autoload :SequenceGenerating, 'rattler/compiler/parser_generator/sequence_generating'
+    autoload :ZeroOrMoreGenerating, 'rattler/compiler/parser_generator/zero_or_more_generating'
+    autoload :OptionalGenerating, 'rattler/compiler/parser_generator/optional_generating'
+    autoload :OneOrMoreGenerating, 'rattler/compiler/parser_generator/one_or_more_generating'
+    autoload :List0Generating, 'rattler/compiler/parser_generator/list0_generating'
+    autoload :List1Generating, 'rattler/compiler/parser_generator/list1_generating'
+    autoload :PredicatePropogating, 'rattler/compiler/parser_generator/predicate_propogating'
+    autoload :TokenPropogating, 'rattler/compiler/parser_generator/token_propogating'
+    autoload :SkipPropogating, 'rattler/compiler/parser_generator/skip_propogating'
+    autoload :GroupMatchGenerator, 'rattler/compiler/parser_generator/group_match_generator'
+    autoload :GroupMatch, 'rattler/compiler/parser_generator/group_match'
+    autoload :GEN_METHOD_NAMES, 'rattler/compiler/parser_generator/gen_method_names'
+
+    # Generate parsing code for a parser model using a ruby generator +g+.
+    #
+    # @overload generate(g, grammar)
+    #   @param [RubyGenerator] g the ruby generator to use
+    #   @param [Rattler::Parsers::Grammar] grammar the grammar model
+    #   @return g
+    #
+    # @overload generate(g, rules)
+    #   @param [RubyGenerator] g the ruby generator to use
+    #   @param [Rules] rules the parse rules
+    #   @return g
+    #
+    # @overload generate(g, rule)
+    #   @param [RubyGenerator] g the ruby generator to use
+    #   @param [Rule] rule the parse rule
+    #   @return g
+    #
+    # @overload generate(g, parser)
+    #   @param [RubyGenerator] g the ruby generator to use
+    #   @param [Parser] parser the parser model
+    #   @return g
+    #
+    def self.generate(g, parser, opts={})
+      unless opts[:no_optimize]
+        parser = ::Rattler::Compiler::Optimizer.optimize(parser, opts)
+      end
+      GrammarGenerator.new(g).generate(parser, opts)
+      g
+    end
+
+    # Generate parsing code for +parser+ using a new {RubyGenerator} with the
+    # given options and return the generated code.
+    #
+    # @overload code_for(grammar, opts)
+    #   @param [Rattler::Parsers::Grammar] grammar the grammar model
+    #   @return [String] the generated code
+    #
+    # @overload code_for(rules, opts)
+    #   @param [Rules] rules the parse rules
+    #   @return [String] the generated code
+    #
+    # @overload code_for(rule, opts)
+    #   @param [Rule] rule the parse rule
+    #   @return [String] the generated code
+    #
+    # @overload code_for(parser, opts)
+    #   @param [Parser] parser the parser model
+    #   @return [String] the generated code
+    #
+    def self.code_for(parser, opts={})
+      ::Rattler::Compiler::RubyGenerator.code(opts) {|g| generate g, parser, opts }
+    end
+
+  end
+end

data/lib/rattler/{back_end → compiler}/parser_generator/apply_generator.rb

@@ -1,15 +1,15 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class ApplyGenerator < ExprGenerator #:nodoc:
 
-    def gen_basic(apply, scope={})
+    def gen_basic(apply, scope = ParserScope.empty)
       @g << "match(:#{apply.rule_name})"
     end
 
-    def gen_assert(apply, scope={})
+    def gen_assert(apply, scope = ParserScope.empty)
       expr :block do
         lookahead do
           @g.surround("#{result_name} = (", ')') { gen_bare_skip apply }
@@ -19,7 +19,7 @@ module Rattler::BackEnd::ParserGenerator
       end
     end
 
-    def gen_disallow(apply, scope={})
+    def gen_disallow(apply, scope = ParserScope.empty)
       expr :block do
         lookahead do
           @g.surround("#{result_name} = !", '') { gen_basic apply }
@@ -29,25 +29,11 @@ module Rattler::BackEnd::ParserGenerator
       end
     end
 
-    def gen_dispatch_action(apply, code, scope={})
-      expr do
-        gen_capture { gen_basic apply }
-        @g << ' && ' << code.bind(scope, dispatch_action_args)
-      end
-    end
-
-    def gen_direct_action(apply, code, scope={})
-      expr do
-        gen_capture { gen_basic apply }
-        @g << ' && (' << code.bind(scope, direct_action_args) << ')'
-      end
-    end
-
-    def gen_skip(apply, scope={})
+    def gen_skip(apply, scope = ParserScope.empty)
       expr { gen_bare_skip apply }
     end
 
-    def gen_intermediate_skip(apply, scope={})
+    def gen_intermediate_skip(apply, scope = ParserScope.empty)
       gen_basic apply
     end
 

data/lib/rattler/{back_end → compiler}/parser_generator/assert_generator.rb

@@ -1,53 +1,45 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class AssertGenerator < ExprGenerator #:nodoc:
 
-    def gen_basic(assert, scope={})
+    def gen_basic(assert, scope = ParserScope.empty)
       generate assert.child, :assert, scope
     end
 
-    def gen_assert(assert, scope={})
+    def gen_assert(assert, scope = ParserScope.empty)
       gen_basic assert, scope
     end
 
-    def gen_disallow(assert, scope={})
+    def gen_disallow(assert, scope = ParserScope.empty)
       @g << 'false'
     end
 
-    def gen_skip(assert, scope={})
+    def gen_skip(assert, scope = ParserScope.empty)
       gen_basic assert, scope
     end
 
-    def gen_dispatch_action(assert, code, scope={})
-      expr(:block) { gen_action assert, code.bind(scope, '[]'), scope }
-    end
-
-    def gen_direct_action(assert, code, scope={})
-      expr(:block) { gen_action assert, "(#{code.bind scope, []})", scope }
-    end
-
-    def gen_token(assert, scope={})
+    def gen_token(assert, scope = ParserScope.empty)
       expr(:block) { gen_action assert, "''", scope }
     end
 
-    def gen_intermediate(assert, scope={})
+    def gen_intermediate(assert, scope = ParserScope.empty)
       generate assert.child, :intermediate_assert, scope
     end
 
-    def gen_intermediate_assert(assert, scope={})
+    def gen_intermediate_assert(assert, scope = ParserScope.empty)
       gen_intermediate assert, scope
     end
 
-    def gen_intermediate_skip(assert, scope={})
+    def gen_intermediate_skip(assert, scope = ParserScope.empty)
       gen_intermediate assert, scope
     end
 
     private
 
-    def gen_action(assert, result_code, scope={})
+    def gen_action(assert, result_code, scope = ParserScope.empty)
       gen_intermediate assert, scope
       (@g << ' &&').newline << result_code
     end