rattler 0.5.0 → 0.6.0

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

@@ -1,26 +0,0 @@
-require 'rattler/back_end/parser_generator'
-
-module Rattler::BackEnd::ParserGenerator
-  # @private
-  class GroupMatch < Rattler::Parsers::Parser #:nodoc:
-
-    alias_method :match, :child
-
-    def re
-      match.re
-    end
-
-    def capture_count
-      num_groups
-    end
-
-    def parse(scanner, rules, scope={})
-      scanner.scan(re) && if num_groups == 1
-        scanner[1]
-      else
-        (1..num_groups).map {|_| scanner[_] }
-      end
-    end
-
-  end
-end

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

@@ -1,64 +0,0 @@
-require 'rattler/back_end/parser_generator'
-
-module Rattler::BackEnd::ParserGenerator
-
-  # @private
-  class LabelGenerator < ExprGenerator #:nodoc:
-    include PredicatePropogating
-    include TokenPropogating
-    include SkipPropogating
-
-    def gen_basic(label, scope={})
-      generate label.child, :basic, scope
-    end
-
-    def gen_dispatch_action(label, code, scope={})
-      expr :block do
-        scope = gen_capturing label.child, scope, label.label
-        (@g << ' &&').newline << code.bind(scope, dispatch_action_args)
-      end
-    end
-
-    def gen_direct_action(label, code, scope={})
-      expr :block do
-        scope = gen_capturing label.child, scope, label.label
-        (@g << ' &&').newline
-        @g.surround('(', ')') { @g << code.bind(scope, direct_action_args) }
-      end
-    end
-
-    private
-
-    def gen_capturing(child, scope, label)
-      if child.capturing?
-        gen_capture { gen_nested child, :basic, scope }
-        scope.merge(label => result_name)
-      else
-        generate child, :intermediate, scope
-        scope
-      end
-    end
-
-  end
-
-  # @private
-  class NestedLabelGenerator < LabelGenerator #:nodoc:
-    include Nested
-    include NestedSubGenerating
-  end
-
-  def LabelGenerator.nested(*args)
-    NestedLabelGenerator.new(*args)
-  end
-
-  # @private
-  class TopLevelLabelGenerator < LabelGenerator #:nodoc:
-    include TopLevel
-    include TopLevelSubGenerating
-  end
-
-  def LabelGenerator.top_level(*args)
-    TopLevelLabelGenerator.new(*args)
-  end
-
-end

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

@@ -1,24 +0,0 @@
-require 'rattler/back_end/parser_generator'
-
-module Rattler::BackEnd::ParserGenerator
-  # @private
-  module PredicatePropogating #:nodoc:
-
-    def gen_assert(parser, scope={})
-      propogate_gen parser.child, :assert, scope
-    end
-
-    def gen_disallow(parser, scope={})
-      propogate_gen parser.child, :disallow, scope
-    end
-
-    def gen_intermediate_assert(parser, scope={})
-      propogate_gen parser.child, :intermediate_assert, scope
-    end
-
-    def gen_intermediate_disallow(parser, scope={})
-      propogate_gen parser.child, :intermediate_disallow, scope
-    end
-
-  end
-end

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

@@ -1,53 +0,0 @@
-require 'rattler/back_end/parser_generator'
-
-module Rattler::BackEnd::ParserGenerator
-  # @private
-  class RuleGenerator #:nodoc:
-
-    Grammar = Rattler::Grammar::Grammar
-    include Rattler::Parsers
-
-    def initialize(g)
-      @g = g
-      @top_level_generator = TopLevelGenerator.new(@g)
-    end
-
-    def generate(parser, opts={})
-      case parser
-      when Rule then gen_rule_modular parser
-      else @top_level_generator.generate parser
-      end
-      self
-    end
-
-    def gen_rule_standalone(rule, rule_set)
-      if rule_set.analysis.left_recursive? rule.name
-        gen_rule_hook rule, 'memoize_lr'
-      elsif rule_set.analysis.recursive? rule.name
-        gen_rule_hook rule, 'memoize'
-      else
-        gen_rule_method rule, "match_#{rule.name}"
-      end
-    end
-
-    def gen_rule_modular(rule)
-      gen_rule_hook rule, 'apply'
-    end
-
-    private
-
-    def gen_rule_hook(rule, hook_name)
-      (@g << "# @private").newline
-      @g.block("def match_#{rule.name} #:nodoc:") do
-        @g << "#{hook_name} :match_#{rule.name}!"
-      end.newline.newline
-      gen_rule_method rule, "match_#{rule.name}!"
-    end
-
-    def gen_rule_method(rule, method_name)
-      (@g << "# @private").newline
-      @g.block("def #{method_name} #:nodoc:") { generate rule.child }
-    end
-
-  end
-end

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

@@ -1,190 +0,0 @@
-require 'rattler/back_end/parser_generator'
-
-module Rattler::BackEnd::ParserGenerator
-
-  # @private
-  class SequenceGenerator < ExprGenerator #:nodoc:
-    include NestedSubGenerating
-
-    include Rattler::Parsers
-
-    def initialize(*args)
-      super
-      @capture_names = []
-    end
-
-    def gen_basic(sequence, scope={})
-      with_backtracking do
-        if sequence.capture_count == 1 and sequence.children.last.capturing?
-          @g.intersperse_nl(sequence, ' &&') do |child|
-            scope = gen_capturing(child, scope) { gen_nested child, :basic, scope }
-          end
-        else
-          sequence.each do |child|
-            @g.suffix(' &&') { scope = gen_capturing child, scope }.newline
-          end
-          @g << result_expr(sequence)
-        end
-      end
-    end
-
-    def gen_assert(sequence, scope={})
-      expr :block do
-        lookahead do
-          @g.block("#{result_name} = begin") do
-            sequence.each do |_|
-              @g.suffix(' &&') { scope = gen_matching _, scope }.newline
-            end
-            @g << "true"
-          end
-          @g.newline
-        end
-        @g << result_name
-      end
-    end
-
-    def gen_disallow(sequence, scope={})
-      expr :block do
-        lookahead do
-          @g.block("#{result_name} = !begin") do
-            @g.intersperse_nl(sequence, ' &&') do |_|
-              scope = gen_matching _, scope
-            end
-          end
-          @g.newline
-        end
-        @g << result_name
-      end
-    end
-
-    def gen_dispatch_action(sequence, code, scope={})
-      gen_action_code(sequence, scope) do |new_scope|
-        code.bind new_scope, result_array_expr(sequence)
-      end
-    end
-
-    def gen_direct_action(sequence, code, scope={})
-      gen_action_code(sequence, scope) do |new_scope|
-        "(#{code.bind new_scope, @capture_names})"
-      end
-    end
-
-    def gen_token(sequence, scope={})
-      with_backtracking do
-        sequence.each do |_|
-          @g.suffix(' &&') { scope = gen_matching _, scope }.newline
-        end
-        @g << "@scanner.string[#{saved_pos_name}...(@scanner.pos)]"
-      end
-    end
-
-    def gen_skip(sequence, scope={})
-      with_backtracking do
-        sequence.each do |_|
-          @g.suffix(' &&') { scope = gen_matching _, scope }.newline
-        end
-        @g << "true"
-      end
-    end
-
-    private
-
-    def gen_matching(child, scope)
-      if child.labeled?
-        @g.surround("(#{capture_name} = ", ')') { gen_nested child, :basic, scope }
-      else
-        gen_nested child, :intermediate_skip, scope
-      end
-      child.labeled? ? scope.merge(child.label => last_capture_name) : scope
-    end
-
-    def gen_capturing(child, scope)
-      if child.capturing?
-        if block_given?
-          yield
-        else
-          @g.surround("(#{capture_name} = ", ')') { gen_nested child, :basic, scope }
-        end
-      else
-        gen_nested child, :intermediate, scope
-      end
-      child.labeled? ? scope.merge(child.label => last_capture_name) : scope
-    end
-
-    def with_backtracking
-      expr :block do
-        (@g << "#{saved_pos_name} = @scanner.pos").newline
-        @g.block 'begin' do
-          yield
-        end
-        @g.block ' || begin' do
-          (@g << "@scanner.pos = #{saved_pos_name}").newline << 'false'
-        end
-      end
-    end
-
-    def result_expr(sequence)
-      case @capture_names.size
-      when 0 then 'true'
-      when 1 then @capture_names[0]
-      else result_array_expr(sequence)
-      end
-    end
-
-    def result_array_expr(sequence)
-      if sequence.any? {|_| Apply === _ }
-        "select_captures(#{capture_names_expr})"
-      else
-        capture_names_expr
-      end
-    end
-
-    def gen_action_code(sequence, scope={})
-      with_backtracking do
-        for child in sequence
-          @g.suffix(' &&') { scope = gen_capturing child, scope }.newline
-        end
-        @g << yield(scope)
-      end
-    end
-
-    def capture_names_expr
-      '[' + @capture_names.join(', ') + ']'
-    end
-
-    def capture_name
-      @capture_names << "r#{sequence_level}_#{@capture_names.size}"
-      @capture_names.last
-    end
-
-    def last_capture_name
-      @capture_names.last
-    end
-
-    attr_reader :capture_names
-
-    def saved_pos_name
-      "p#{sequence_level}"
-    end
-
-  end
-
-  # @private
-  class NestedSequenceGenerator < SequenceGenerator #:nodoc:
-    include Nested
-  end
-
-  def SequenceGenerator.nested(*args)
-    NestedSequenceGenerator.new(*args)
-  end
-
-  # @private
-  class TopLevelSequenceGenerator < SequenceGenerator #:nodoc:
-    include TopLevel
-  end
-
-  def SequenceGenerator.top_level(*args)
-    TopLevelSequenceGenerator.new(*args)
-  end
-
-end

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

@@ -1,16 +0,0 @@
-require 'rattler/back_end/parser_generator'
-
-module Rattler::BackEnd::ParserGenerator
-  # @private
-  module SkipPropogating #:nodoc:
-
-    def gen_skip(parser, scope={})
-      propogate_gen parser.child, :skip, scope
-    end
-
-    def gen_intermediate_skip(parser, scope={})
-      propogate_gen parser.child, :intermediate_skip, scope
-    end
-
-  end
-end

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

@@ -1,10 +0,0 @@
-require 'rattler/back_end/parser_generator'
-
-module Rattler::BackEnd::ParserGenerator
-  # @private
-  module TokenPropogating #:nodoc:
-    def gen_token(parser, scope={})
-      propogate_gen parser.child, :token, scope
-    end
-  end
-end

data/lib/rattler/grammar.rb

@@ -1,43 +0,0 @@
-#
-# = rattler/grammar.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-require 'rattler'
-
-module Rattler
-  #
-  # The +Grammar+ module defines the grammar parser
-  #
-  # @author Jason Arhart
-  #
-  module Grammar
-    autoload :Grammar, 'rattler/grammar/grammar'
-    autoload :GrammarParser, 'rattler/grammar/grammar_parser'
-    autoload :GrammarDSL, 'rattler/grammar/grammar_dsl'
-    autoload :Metagrammar, 'rattler/grammar/metagrammar'
-    autoload :Analysis, 'rattler/grammar/analysis'
-
-    # Parse +source+ as a grammar and raise a {Rattler::Runtime::SyntaxError}
-    # if the parse fails.
-    #
-    # @param (see Rattler::RecursiveDescentParser#initialize)
-    # @raise (see Rattler::RecursiveDescentParser#parse!)
-    #
-    # @return [Grammar] the parsed grammar
-    def self.parse!(source, options={})
-      GrammarParser.parse!(source, options={})
-    end
-
-    # Parse +source+ as a grammar.
-    #
-    # @param (see Rattler::RecursiveDescentParser#initialize)
-    #
-    # @return [Grammar] the parsed grammar
-    def self.parser(source, options={})
-      GrammarParser.new(source, options={})
-    end
-
-  end
-end

data/lib/rattler/grammar/grammar_dsl.rb

@@ -1,51 +0,0 @@
-#
-# = rattler/grammar/grammar_dsl.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-require 'rattler/grammar'
-
-module Rattler::Grammar
-  # @private
-  module GrammarDSL #:nodoc:
-    
-    def self.included(mod)
-      mod.extend ClassMethods
-    end
-    
-    # @private
-    module ClassMethods
-      
-      def start_rule(name)
-        define_method(:start_rule) { name }
-      end
-      
-      def grammar(source=nil, &block)
-        Rattler.compile(self, source, &block)
-      end
-      
-      def rules(&block)
-        Rattler.compile(self, &block)
-      end
-      
-      def rule(name, &block)
-        rules { rule(name) {|b| b.instance_exec(&block) } }
-      end
-      
-      def token(name, &block)
-        rules { token(name) {|b| b.instance_exec(&block) } }
-      end
-      
-      def with_options(options, &block)
-        rules { with_options(options, &block) }
-      end
-      
-      def with_ws(ws, &block)
-        rules { with_ws(ws, &block) }
-      end
-      
-    end
-    
-  end
-end