rattler 0.5.0 → 0.6.0

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

@@ -1,46 +0,0 @@
-#
-# = 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_sequence.rb

@@ -1,17 +0,0 @@
-#
-# = 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_match.rb

@@ -1,17 +0,0 @@
-#
-# = 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_or_match.rb

@@ -1,17 +0,0 @@
-#
-# = 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

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

@@ -1,72 +0,0 @@
-#
-# = 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/remove_meaningless_wrapper.rb

@@ -1,32 +0,0 @@
-#
-# = 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/specialize_repeat.rb

@@ -1,40 +0,0 @@
-#
-# = rattler/back_end/optimizer/normalize_repeat.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-require 'rattler'
-
-module Rattler::BackEnd::Optimizer
-  #
-  # A Repeat with bounds equivalent to optional, zero-or-more, or one-or-more
-  # can be replaced by an Optional, a ZeroOrMore, or a OneOrMore, respectively.
-  #
-  # @author Jason Arhart
-  #
-  class SpecializeRepeat < Optimization
-
-    include Rattler::Parsers
-
-    protected
-
-    def _applies_to?(parser, context)
-      parser.is_a? Repeat and
-      ( parser.optional? or
-        parser.zero_or_more? or
-        parser.one_or_more? )
-    end
-
-    def _apply(parser, context)
-      if parser.optional?
-        Optional[parser.child]
-      elsif parser.zero_or_more?
-        ZeroOrMore[parser.child]
-      elsif parser.one_or_more?
-        OneOrMore[parser.child]
-      end
-    end
-
-  end
-end

data/lib/rattler/back_end/parser_generator.rb

@@ -1,113 +0,0 @@
-#
-# = rattler/back_end/parser_generator.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-require 'rattler/back_end'
-
-module Rattler::BackEnd
-  #
-  # A +ParserGenerator+ generates ruby parsing code from parser models.
-  #
-  # @author Jason Arhart
-  #
-  module ParserGenerator
-
-    autoload :RuleSetGenerator, 'rattler/back_end/parser_generator/rule_set_generator'
-    autoload :RuleGenerator, 'rattler/back_end/parser_generator/rule_generator'
-    autoload :ExprGenerator, 'rattler/back_end/parser_generator/expr_generator'
-    autoload :GeneratorHelper, 'rattler/back_end/parser_generator/generator_helper'
-    autoload :TopLevelGenerator, 'rattler/back_end/parser_generator/expr_generator'
-    autoload :SubGenerating, 'rattler/back_end/parser_generator/sub_generating'
-    autoload :NestedSubGenerating, 'rattler/back_end/parser_generator/sub_generating'
-    autoload :TopLevelSubGenerating, 'rattler/back_end/parser_generator/sub_generating'
-    autoload :Nested, 'rattler/back_end/parser_generator/nested'
-    autoload :TopLevel, 'rattler/back_end/parser_generator/top_level'
-    autoload :MatchGenerator, 'rattler/back_end/parser_generator/match_generator'
-    autoload :ChoiceGenerator, 'rattler/back_end/parser_generator/choice_generator'
-    autoload :SequenceGenerator, 'rattler/back_end/parser_generator/sequence_generator'
-    autoload :RepeatGenerator, 'rattler/back_end/parser_generator/repeat_generator'
-    autoload :GeneralRepeatGenerator, 'rattler/back_end/parser_generator/general_repeat_generator'
-    autoload :ListGenerator, 'rattler/back_end/parser_generator/list_generator'
-    autoload :GeneralListGenerator, 'rattler/back_end/parser_generator/general_list_generator'
-    autoload :ApplyGenerator, 'rattler/back_end/parser_generator/apply_generator'
-    autoload :AssertGenerator, 'rattler/back_end/parser_generator/assert_generator'
-    autoload :DisallowGenerator, 'rattler/back_end/parser_generator/disallow_generator'
-    autoload :EofGenerator, 'rattler/back_end/parser_generator/eof_generator'
-    autoload :ESymbolGenerator, 'rattler/back_end/parser_generator/e_symbol_generator'
-    autoload :DispatchActionGenerator, 'rattler/back_end/parser_generator/dispatch_action_generator'
-    autoload :DirectActionGenerator, 'rattler/back_end/parser_generator/direct_action_generator'
-    autoload :TokenGenerator, 'rattler/back_end/parser_generator/token_generator'
-    autoload :SkipGenerator, 'rattler/back_end/parser_generator/skip_generator'
-    autoload :LabelGenerator, 'rattler/back_end/parser_generator/label_generator'
-    autoload :BackReferenceGenerator, 'rattler/back_end/parser_generator/back_reference_generator'
-    autoload :FailGenerator, 'rattler/back_end/parser_generator/fail_generator'
-    autoload :DelegatingGenerator, 'rattler/back_end/parser_generator/delegating_generator'
-    autoload :ZeroOrMoreGenerating, 'rattler/back_end/parser_generator/zero_or_more_generating'
-    autoload :OptionalGenerating, 'rattler/back_end/parser_generator/optional_generating'
-    autoload :OneOrMoreGenerating, 'rattler/back_end/parser_generator/one_or_more_generating'
-    autoload :List0Generating, 'rattler/back_end/parser_generator/list0_generating'
-    autoload :List1Generating, 'rattler/back_end/parser_generator/list1_generating'
-    autoload :PredicatePropogating, 'rattler/back_end/parser_generator/predicate_propogating'
-    autoload :TokenPropogating, 'rattler/back_end/parser_generator/token_propogating'
-    autoload :SkipPropogating, 'rattler/back_end/parser_generator/skip_propogating'
-    autoload :GroupMatchGenerator, 'rattler/back_end/parser_generator/group_match_generator'
-    autoload :GroupMatch, 'rattler/back_end/parser_generator/group_match'
-    autoload :GEN_METHOD_NAMES, 'rattler/back_end/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::Grammar::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::BackEnd::Optimizer.optimize(parser, opts)
-      end
-      RuleSetGenerator.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::Grammar::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::BackEnd::RubyGenerator.code(opts) {|g| generate g, parser, opts }
-    end
-
-  end
-end

data/lib/rattler/back_end/parser_generator/direct_action_generator.rb

@@ -1,45 +0,0 @@
-require 'rattler/back_end/parser_generator'
-
-module Rattler::BackEnd::ParserGenerator
-
-  # @private
-  class DirectActionGenerator < ExprGenerator #:nodoc:
-    include PredicatePropogating
-    include TokenPropogating
-    include SkipPropogating
-
-    def gen_basic(action, scope={})
-      generate action.child, :direct_action, action.bindable_code, scope
-    end
-
-    def gen_dispatch_action(inner, code, scope={})
-      super { gen_nested inner, :basic, scope }
-    end
-
-    def gen_direct_action(inner, code, scope={})
-      super { gen_nested inner, :basic, scope }
-    end
-
-  end
-
-  # @private
-  class NestedDirectActionGenerator < DirectActionGenerator #:nodoc:
-    include Nested
-    include NestedSubGenerating
-  end
-
-  def DirectActionGenerator.nested(*args)
-    NestedDirectActionGenerator.new(*args)
-  end
-
-  # @private
-  class TopLevelDirectActionGenerator < DirectActionGenerator #:nodoc:
-    include TopLevel
-    include TopLevelSubGenerating
-  end
-
-  def DirectActionGenerator.top_level(*args)
-    TopLevelDirectActionGenerator.new(*args)
-  end
-
-end

data/lib/rattler/back_end/parser_generator/dispatch_action_generator.rb

@@ -1,45 +0,0 @@
-require 'rattler/back_end/parser_generator'
-
-module Rattler::BackEnd::ParserGenerator
-
-  # @private
-  class DispatchActionGenerator < ExprGenerator #:nodoc:
-    include PredicatePropogating
-    include TokenPropogating
-    include SkipPropogating
-
-    def gen_basic(action, scope={})
-      generate action.child, :dispatch_action, action.bindable_code, scope
-    end
-
-    def gen_dispatch_action(inner, code, scope={})
-      super { gen_nested inner, :basic, scope }
-    end
-
-    def gen_direct_action(inner, code, scope={})
-      super { gen_nested inner, :basic, scope }
-    end
-
-  end
-
-  # @private
-  class NestedDispatchActionGenerator < DispatchActionGenerator #:nodoc:
-    include Nested
-    include NestedSubGenerating
-  end
-
-  def DispatchActionGenerator.nested(*args)
-    NestedDispatchActionGenerator.new(*args)
-  end
-
-  # @private
-  class TopLevelDispatchActionGenerator < DispatchActionGenerator #:nodoc:
-    include TopLevel
-    include TopLevelSubGenerating
-  end
-
-  def DispatchActionGenerator.top_level(*args)
-    TopLevelDispatchActionGenerator.new(*args)
-  end
-
-end