rattler 0.5.0 → 0.6.0

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

@@ -1,12 +1,12 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class GeneralRepeatGenerator < ExprGenerator #:nodoc:
     include NestedSubGenerating
 
-    def gen_basic(repeat, scope={})
+    def gen_basic(repeat, scope = ParserScope.empty)
       if repeat.capturing?
         gen_capturing repeat, scope
       else
@@ -14,36 +14,22 @@ module Rattler::BackEnd::ParserGenerator
       end
     end
 
-    def gen_assert(repeat, scope={})
+    def gen_assert(repeat, scope = ParserScope.empty)
       gen_predicate(repeat, scope) { gen_assert_result repeat }
     end
 
-    def gen_disallow(repeat, scope={})
+    def gen_disallow(repeat, scope = ParserScope.empty)
       gen_predicate(repeat, scope) { gen_disallow_result repeat }
     end
 
-    def gen_dispatch_action(repeat, code, scope={})
-      expr :block do
-        gen_loop repeat, scope
-        gen_result repeat, code.bind(scope, "select_captures(#{accumulator_name})")
-      end
-    end
-
-    def gen_direct_action(repeat, code, scope={})
-      expr :block do
-        gen_loop repeat, scope
-        gen_result(repeat, '(' + code.bind(scope, ["select_captures(#{accumulator_name})"]) + ')')
-      end
-    end
-
-    def gen_token(repeat, scope={})
+    def gen_token(repeat, scope = ParserScope.empty)
       expr :block do
         gen_loop(repeat, scope) { |child| generate child, :token, scope }
         gen_result repeat, "#{accumulator_name}.join"
       end
     end
 
-    def gen_skip(repeat, scope={})
+    def gen_skip(repeat, scope = ParserScope.empty)
       expr :block do
         setup_skip_loop repeat
         @g << 'while '
@@ -58,7 +44,7 @@ module Rattler::BackEnd::ParserGenerator
     def gen_capturing(repeat, scope)
       expr :block do
         gen_loop(repeat, scope) { |child| gen_nested child, :basic, scope }
-        gen_result repeat, accumulator_name
+        gen_result repeat, result_expr(repeat)
       end
     end
 
@@ -142,6 +128,14 @@ module Rattler::BackEnd::ParserGenerator
       @g.newline << "(#{count_name} < #{repeat.lower_bound})"
     end
 
+    def result_expr(repeat)
+      if repeat.child.capturing_decidable?
+        accumulator_name
+      else
+        "select_captures(#{accumulator_name})"
+      end
+    end
+
     def accumulator_name
       "a#{repeat_level}"
     end

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

@@ -1,36 +1,33 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
   # @private
-  class RuleSetGenerator #:nodoc:
-
-    Grammar = Rattler::Grammar::Grammar
-    include Rattler::Parsers
-
-    def initialize(g)
-      @g = g
-      @rule_generator = RuleGenerator.new(@g)
-    end
+  class GrammarGenerator < RuleSetGenerator #:nodoc:
 
     def generate(parser, opts={})
       case parser
-      when Grammar  then gen_parser parser, opts
-      when RuleSet  then gen_rules parser, opts
+      when Grammar then gen_parser(parser, opts)
+      when RuleSet then gen_rules(parser, opts)
       end
       self
     end
 
     def gen_parser(grammar, opts={})
+      gen_encoding
       gen_requires grammar.requires
       gen_module(grammar) do
         gen_includes grammar.includes
-        gen_rules grammar.rules, opts
+        gen_rules(grammar.rules, opts)
       end
     end
 
+    def gen_encoding
+      (@g << "# encoding: utf-8").newline
+    end
+
     def gen_requires(requires)
-      requires.each {|_| (@g << "require #{_}").newline }
-      @g.newline
+      requires.each {|_| @g.newline << "require #{_}" }
+      @g.newline unless requires.empty?
     end
 
     def gen_module(grammar)
@@ -50,35 +47,29 @@ module Rattler::BackEnd::ParserGenerator
       end
     end
 
-    def gen_rules(rules, opts={})
-      gen_start_rule rules.start_rule if rules.start_rule
-      @g.intersperse(rules, :newlines => 2) do |rule|
-        if opts[:standalone]
-          @rule_generator.gen_rule_standalone rule, rules
-        else
-          @rule_generator.gen_rule_modular rule
-        end
-      end
-    end
-
-    def gen_start_rule(start_rule)
-      (@g << "# @private").newline
-      @g.block('def start_rule #:nodoc:') { @g << ":#{start_rule}"}.newline
-      @g.newline
-    end
-
     def gen_grammar_def(grammar_name)
+      @g.newline
       nest_modules(grammar_name.split('::')) do |name|
         (@g << "# @private").newline
         module_block("module #{name} #:nodoc:") { yield }
       end
+      gen_cli(:GrammarCLI, grammar_name)
     end
 
     def gen_parser_def(parser_name, base_name)
+      @g.newline
       nest_modules(parser_name.split('::')) do |name|
         (@g << "# @private").newline
         module_block("class #{name} < #{base_name} #:nodoc:") { yield }
       end
+      gen_cli(:ParserCLI, parser_name)
+    end
+
+    def gen_cli(cli, module_name)
+      @g.newline.newline.block('if __FILE__ == $0') do
+        %w{rubygems rattler}.each {|_| (@g << "require '#{_}'").newline }
+        @g << "Rattler::Util::#{cli}.run(#{module_name})"
+      end
     end
 
     def nest_modules(path)

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

@@ -0,0 +1,33 @@
+require 'rattler/compiler/parser_generator'
+
+module Rattler::Compiler::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 = ParserScope.empty)
+      scanner.scan(re) && if num_groups == 1
+        yield scope.nest.capture(scanner[1]) if block_given?
+        scanner[1]
+      else
+        rs = (1..num_groups).map {|_| scanner[_] }
+        yield scope.nest.capture(*rs) if block_given?
+        rs
+      end
+    end
+
+    def sequence?
+      num_groups > 1
+    end
+
+  end
+end

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

@@ -1,6 +1,6 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class GroupMatchGenerator < ExprGenerator #:nodoc:
@@ -8,23 +8,10 @@ module Rattler::BackEnd::ParserGenerator
     include TokenPropogating
     include SkipPropogating
 
-    def gen_basic(group_match, scope={})
+    def gen_basic(group_match, scope = ParserScope.empty)
       expr(:block) { gen_capture group_match, result_expr(group_match) }
     end
 
-    def gen_dispatch_action(group_match, code, scope={})
-      expr :block do
-        gen_capture group_match,
-          code.bind(scope, "[#{group_exprs(group_match).join ', '}]")
-      end
-    end
-
-    def gen_direct_action(group_match, code, scope={})
-      expr :block do
-        gen_capture group_match, "(#{code.bind(scope, group_exprs(group_match))})"
-      end
-    end
-
     private
 
     def gen_capture(group_match, expr)
@@ -33,7 +20,7 @@ module Rattler::BackEnd::ParserGenerator
     end
 
     def result_expr(group_match)
-      if group_match.num_groups == 1
+      if group_match.capture_count == 1
         group_exprs(group_match).first
       else
         "[#{group_exprs(group_match).join ', '}]"

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

@@ -0,0 +1,37 @@
+require 'rattler/compiler/parser_generator'
+
+module Rattler::Compiler::ParserGenerator
+
+  # @private
+  class LabelGenerator < ExprGenerator #:nodoc:
+    include PredicatePropogating
+    include TokenPropogating
+    include SkipPropogating
+
+    def gen_basic(label, scope = ParserScope.empty)
+      generate label.child, :basic, scope
+    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 → compiler}/parser_generator/list0_generating.rb

@@ -1,18 +1,18 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
   # @private
   module List0Generating #:nodoc:
 
-    def gen_assert(optional, scope={})
+    def gen_assert(optional, scope = ParserScope.empty)
       @g << 'true'
     end
 
-    def gen_disallow(optional, scope={})
+    def gen_disallow(optional, scope = ParserScope.empty)
       @g << 'false'
     end
 
-    def gen_skip(list, scope={})
+    def gen_skip(list, scope = ParserScope.empty)
       expr :block do
         gen_skipping list, scope
         @g << "@scanner.pos = #{end_pos_name} unless #{end_pos_name}.nil?"

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

@@ -1,11 +1,11 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
   # @private
   module List1Generating #:nodoc:
     include PredicatePropogating
 
-    def gen_skip(list, scope={})
+    def gen_skip(list, scope = ParserScope.empty)
       expr :block do
         (@g << "#{result_name} = false").newline
         gen_skipping(list, scope) { (@g << "#{result_name} = true").newline }

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

@@ -1,6 +1,6 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class ListGenerator < DelegatingGenerator #:nodoc:

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

@@ -1,48 +1,48 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class MatchGenerator < ExprGenerator #:nodoc:
 
-    def gen_basic(match, scope={})
+    def gen_basic(match, scope = ParserScope.empty)
       @g << "@scanner.scan(#{match.re.inspect})"
     end
 
-    def gen_assert(match, scope={})
+    def gen_assert(match, scope = ParserScope.empty)
       expr do
         gen_intermediate_assert match, scope
         @g << ' && true'
       end
     end
 
-    def gen_disallow(match, scope={})
+    def gen_disallow(match, scope = ParserScope.empty)
       expr do
         gen_intermediate_disallow match, scope
         @g << ' && true'
       end
     end
 
-    def gen_token(match, scope={})
+    def gen_token(match, scope = ParserScope.empty)
       gen_basic match, scope
     end
 
-    def gen_skip(match, scope={})
+    def gen_skip(match, scope = ParserScope.empty)
       expr do
         gen_intermediate_skip match, scope
         @g << ' && true'
       end
     end
 
-    def gen_intermediate_assert(match, scope={})
+    def gen_intermediate_assert(match, scope = ParserScope.empty)
       @g << "@scanner.skip(#{/(?=#{match.re.source})/.inspect})"
     end
 
-    def gen_intermediate_disallow(match, scope={})
+    def gen_intermediate_disallow(match, scope = ParserScope.empty)
       @g << "@scanner.skip(#{/(?!#{match.re.source})/.inspect})"
     end
 
-    def gen_intermediate_skip(match, scope={})
+    def gen_intermediate_skip(match, scope = ParserScope.empty)
       @g << "@scanner.skip(#{match.re.inspect})"
     end
 

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

@@ -1,6 +1,6 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
   # @private
   module Nested #:nodoc:
 

data/lib/rattler/compiler/parser_generator/node_action_generator.rb

@@ -0,0 +1,49 @@
+require 'rattler/compiler/parser_generator'
+
+module Rattler::Compiler::ParserGenerator
+
+  # @private
+  class NodeActionGenerator < ExprGenerator #:nodoc:
+
+    def gen_basic(action, scope = ParserScope.empty)
+      @g << action.bindable_code.bind(scope)
+    end
+
+    def gen_assert(action, scope = ParserScope.empty)
+      expr { @g.suffix(' && true') { gen_basic action, scope } }
+    end
+
+    def gen_disallow(action, scope = ParserScope.empty)
+      @g << '!'
+      gen_basic action, scope
+    end
+
+    def gen_token(action, scope = ParserScope.empty)
+      @g.suffix('.to_s') { gen_basic action, scope }
+    end
+
+    def gen_skip(action, scope = ParserScope.empty)
+      expr { @g.suffix('; true') { gen_basic action, scope } }
+    end
+
+  end
+
+  # @private
+  class NestedNodeActionGenerator < NodeActionGenerator #:nodoc:
+    include Nested
+  end
+
+  def NodeActionGenerator.nested(*args)
+    NestedNodeActionGenerator.new(*args)
+  end
+
+  # @private
+  class TopLevelNodeActionGenerator < NodeActionGenerator #:nodoc:
+    include TopLevel
+  end
+
+  def NodeActionGenerator.top_level(*args)
+    TopLevelNodeActionGenerator.new(*args)
+  end
+
+end