rattler 0.5.0 → 0.6.0

data/lib/rattler/{back_end → compiler}/parser_generator/one_or_more_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 OneOrMoreGenerating #:nodoc:
     include PredicatePropogating
 
-    def gen_skip(one_or_more, scope={})
+    def gen_skip(one_or_more, scope = ParserScope.empty)
       expr :block do
         (@g << "#{result_name} = false").newline
         @g << 'while '

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

@@ -1,41 +1,25 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
   # @private
   module OptionalGenerating #: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_dispatch_action(optional, code, scope={})
-      expr :block do
-        gen_loop optional, scope
-        @g.newline << code.bind(scope, "#{result_name} ? [#{result_name}] : []")
-      end
-    end
-
-    def gen_direct_action(optional, code, scope={})
-      expr :block do
-        @g << "#{result_name} = "
-        generate optional.child, :basic, scope
-        @g.newline <<
-          '(' << code.bind(scope, ["(#{result_name} ? [#{result_name}] : [])"]) << ')'
-      end
-    end
-
-    def gen_token(optional, scope={})
+    def gen_token(optional, scope = ParserScope.empty)
       expr :block do
         generate optional.child, :token, scope
         @g << " || ''"
       end
     end
 
-    def gen_skip(optional, scope={})
+    def gen_skip(optional, scope = ParserScope.empty)
       expr :block do
         generate optional.child, :intermediate_skip, scope
         @g.newline << 'true'

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

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

data/lib/rattler/{back_end → compiler}/parser_generator/repeat_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 RepeatGenerator < DelegatingGenerator #:nodoc:

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

@@ -0,0 +1,66 @@
+require 'rattler/compiler/parser_generator'
+
+module Rattler::Compiler::ParserGenerator
+  # @private
+  class RuleGenerator #:nodoc:
+
+    include Rattler::Parsers
+
+    def initialize(g)
+      @g = g
+      @expr_generator = NestedExprGenerator.new(@g)
+    end
+
+    def generate(rule, opts={})
+      (@g << "# @private").newline
+      @g.block "def match_#{rule.name} #:nodoc:" do
+        @g << "apply :match_#{rule.name}!"
+      end.newline.newline
+      gen_match_method rule
+    end
+
+    private
+
+    def gen_match_method(rule)
+      (@g << "# @private").newline
+      @g.block "def match_#{rule.name}! #:nodoc:" do
+        gen_child rule.child
+        gen_fail rule if add_implicit_fail? rule
+      end
+    end
+
+    def add_implicit_fail?(rule)
+      not (rule.attrs[:inline] or has_explicit_fail?(rule.child))
+    end
+
+    def gen_child(child)
+      if child.is_a? Choice
+        @expr_generator.gen_top_level child
+      else
+        @expr_generator.generate child
+      end
+    end
+
+    def gen_fail(rule)
+      (@g << " ||").newline
+      if force_fail_message? rule.child
+        @g << "fail! { :#{rule.name} }"
+      else
+        @g << "fail { :#{rule.name} }"
+      end
+    end
+
+    def force_fail_message?(expr)
+      expr.is_a? Choice and
+      expr.any? {|_| _.is_a? Apply or force_fail_message? _ }
+    end
+
+    def has_explicit_fail?(expr)
+      case expr
+      when Fail then true
+      when Choice then expr.any? {|_| has_explicit_fail? _ }
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'rattler/compiler/parser_generator'
+
+module Rattler::Compiler::ParserGenerator
+  # @private
+  class RuleSetGenerator #:nodoc:
+
+    include Rattler::Parsers
+
+    def initialize(g)
+      @g = g
+      @rule_generator = RuleGenerator.new(@g)
+    end
+
+    def generate(parser, opts={})
+      gen_rules parser, opts
+      self
+    end
+
+    def gen_rules(rules, opts={})
+      gen_start_rule rules.start_rule if rules.start_rule
+      @g.intersperse(rules, :newlines => 2) do |rule|
+        @rule_generator.generate rule
+      end
+    end
+
+    def gen_start_rule(start_rule)
+      (@g << "# @private").newline
+      @g.block('def start_rule #:nodoc:') { @g << ":#{start_rule}"}.newline
+      @g.newline
+    end
+
+  end
+end

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

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

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

@@ -0,0 +1,138 @@
+require 'rattler/compiler/parser_generator'
+
+module Rattler::Compiler::ParserGenerator
+  # @private
+  module SequenceGenerating #:nodoc:
+    include NestedSubGenerating
+
+    def gen_assert(sequence, scope = ParserScope.empty)
+      expr :block do
+        lookahead do
+          @g.block("#{result_name} = begin") do
+            gen_children_matching(sequence, scope.nest) do |last_child, scope|
+              @g.suffix(' &&') { gen_nested last_child, :intermediate_skip, scope }
+              @g.newline << 'true'
+            end
+          end
+          @g.newline
+        end
+        @g << result_name
+      end
+    end
+
+    def gen_disallow(sequence, scope = ParserScope.empty)
+      expr :block do
+        lookahead do
+          @g.block("#{result_name} = !begin") do
+            gen_children_matching(sequence, scope.nest) do |last_child, scope|
+              gen_nested last_child, :intermediate_skip, scope
+            end
+          end
+          @g.newline
+        end
+        @g << result_name
+      end
+    end
+
+    def gen_token(sequence, scope = ParserScope.empty)
+      with_backtracking do
+        gen_children_matching(sequence, scope.nest) do |last_child, scope|
+          @g.suffix(' &&') { gen_nested last_child, :intermediate_skip, scope }
+          @g.newline << "@scanner.string[#{saved_pos_name}...(@scanner.pos)]"
+        end
+      end
+    end
+
+    def gen_skip(sequence, scope = ParserScope.empty)
+      with_backtracking do
+        gen_children_matching(sequence, scope.nest) do |last_child, scope|
+          @g.suffix(' &&') { gen_matching last_child, scope }
+          @g.newline << 'true'
+        end
+      end
+    end
+
+    protected
+
+    def gen_children_capturing(sequence, scope)
+      @g.intersperse_nl(sequence, ' &&') do |child|
+        if child.equal? sequence.children.last
+          yield child, scope
+        else
+          scope = gen_capturing(child, scope)
+        end
+      end
+    end
+
+    def gen_children_matching(sequence, scope)
+      @g.intersperse_nl(sequence, ' &&') do |child|
+        if child.equal? sequence.children.last
+          yield child, scope
+        elsif sequence.semantic?
+          scope = gen_capturing(child, scope)
+        else
+          scope = gen_matching(child, scope)
+        end
+      end
+    end
+
+    def gen_capturing(child, scope)
+      if child.capturing?
+        scope = capture_child(child, scope)
+      else
+        gen_nested child, :intermediate, scope
+      end
+      scope
+    end
+
+    def gen_matching(child, scope)
+      if child.labeled? and child.capturing?
+        scope = capture_child(child, scope)
+      else
+        gen_nested child, :intermediate_skip, scope
+      end
+      scope
+    end
+
+    def capture_child(child, scope)
+      scope = new_capture(child, scope) do |name|
+        @g.surround("(#{name} = ", ')') { gen_nested child, :basic, scope }
+      end
+      if child.labeled?
+        scope.bind(child.label => last_capture_name(scope))
+      else
+        scope
+      end
+    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 new_capture(child, scope)
+      new_scope = scope.capture("r#{sequence_level}_#{scope.captures.size}")
+      unless child.capturing_decidable?
+        new_scope = new_scope.with_undecidable_captures
+      end
+      yield last_capture_name(new_scope)
+      new_scope
+    end
+
+    def last_capture_name(scope)
+      scope.captures.last
+    end
+
+    def saved_pos_name
+      "p#{sequence_level}"
+    end
+
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'rattler/compiler/parser_generator'
+
+module Rattler::Compiler::ParserGenerator
+
+  # @private
+  class SequenceGenerator < ExprGenerator #:nodoc:
+    include SequenceGenerating
+
+    def gen_basic(sequence, scope = ParserScope.empty)
+      with_backtracking do
+        gen_children_capturing(sequence, scope.nest) do |last_child, scope|
+          if sequence.capture_count == 1 and last_child.capturing?
+            gen_nested last_child, :basic, scope
+          else
+            @g.suffix(' &&') { scope = gen_capturing last_child, scope }
+            @g.newline << result_expr(scope)
+          end
+        end
+      end
+    end
+
+    private
+
+    def result_expr(scope)
+      case scope.captures.size
+      when 0 then 'true'
+      when 1 then scope.captures[0]
+      else result_array_expr(scope)
+      end
+    end
+
+    def result_array_expr(scope)
+      expr = '[' + scope.captures.join(', ') + ']'
+      scope.captures_decidable? ? expr : "select_captures(#{expr})"
+    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