rattler 0.5.0 → 0.6.0

data/lib/rattler/{back_end → compiler}/parser_generator/skip_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 SkipGenerator < ExprGenerator #:nodoc:
@@ -8,25 +8,11 @@ module Rattler::BackEnd::ParserGenerator
     include TokenPropogating
     include SkipPropogating
 
-    def gen_basic(skip, scope={})
+    def gen_basic(skip, scope = ParserScope.empty)
       generate skip.child, :skip, scope
     end
 
-    def gen_dispatch_action(skip, code, scope={})
-      expr :block do
-        gen_intermediate_skip skip, scope
-        (@g << ' &&').newline << code.bind(scope, '[]')
-      end
-    end
-
-    def gen_direct_action(skip, code, scope={})
-      expr :block do
-        gen_intermediate_skip skip, scope
-        (@g << ' &&').newline << '(' << code.bind(scope, []) << ')'
-      end
-    end
-
-    def gen_intermediate(skip, scope={})
+    def gen_intermediate(skip, scope = ParserScope.empty)
       gen_intermediate_skip skip, scope
     end
 

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

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

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

@@ -1,14 +1,12 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   module SubGenerating #:nodoc:
 
     include Rattler::Parsers
 
-    protected
-
     def generate(parser, as=:basic, *args)
       gen_with generator(parser), parser, as, *args
     end
@@ -21,6 +19,8 @@ module Rattler::BackEnd::ParserGenerator
       gen_with generator(parser, :top_level), parser, as, *args
     end
 
+    protected
+
     def propogate_gen(parser, type, scope)
       if nested?
         gen_nested parser, type, scope
@@ -47,7 +47,7 @@ module Rattler::BackEnd::ParserGenerator
         cache_generator ChoiceGenerator, context, :new_choice_level => true
 
       when Sequence
-        new_generator SequenceGenerator, context, :new_sequence_level => true
+        cache_generator SequenceGenerator, context, :new_sequence_level => true
 
       when Repeat
         cache_generator RepeatGenerator, context, :new_repeat_level => true
@@ -70,11 +70,14 @@ module Rattler::BackEnd::ParserGenerator
       when ESymbol
         cache_generator ESymbolGenerator, context
 
-      when DispatchAction
-        cache_generator DispatchActionGenerator, context
+      when SemanticAction
+        cache_generator SemanticActionGenerator, context
 
-      when DirectAction
-        cache_generator DirectActionGenerator, context
+      when NodeAction
+        cache_generator NodeActionGenerator, context
+
+      when AttributedSequence
+        cache_generator AttributedSequenceGenerator, context, :new_sequence_level => true
 
       when Token
         cache_generator TokenGenerator, context
@@ -82,6 +85,9 @@ module Rattler::BackEnd::ParserGenerator
       when Skip
         cache_generator SkipGenerator, context
 
+      when Super
+        cache_generator SuperGenerator, context
+
       when Label
         cache_generator LabelGenerator, context
 
@@ -124,7 +130,8 @@ module Rattler::BackEnd::ParserGenerator
 
   end
 
-  module NestedSubGenerating
+  # @private
+  module NestedSubGenerating #:nodoc:
     include SubGenerating
 
     protected
@@ -136,7 +143,8 @@ module Rattler::BackEnd::ParserGenerator
     alias_method :factory_method, :default_context
   end
 
-  module TopLevelSubGenerating
+  # @private
+  module TopLevelSubGenerating #:nodoc:
     include SubGenerating
 
     protected

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

@@ -0,0 +1,54 @@
+require 'rattler/compiler/parser_generator'
+
+module Rattler::Compiler::ParserGenerator
+
+  # @private
+  class SuperGenerator < ExprGenerator #:nodoc:
+
+    def gen_basic(*_)
+      @g << 'super'
+    end
+
+    def gen_assert(*_)
+      expr :block do
+        lookahead { (@g << "#{result_name} = (super && true)").newline }
+        @g << result_name
+      end
+    end
+
+    def gen_disallow(*_)
+      expr :block do
+        lookahead { (@g << "#{result_name} = !super").newline }
+        @g << result_name
+      end
+    end
+
+    def gen_token(*_)
+      @g << 'super.to_s'
+    end
+
+    def gen_skip(*_)
+      expr { @g << 'super && true' }
+    end
+
+  end
+
+  # @private
+  class NestedSuperGenerator < SuperGenerator #:nodoc:
+    include Nested
+  end
+
+  def SuperGenerator.nested(*args)
+    NestedSuperGenerator.new(*args)
+  end
+
+  # @private
+  class TopLevelSuperGenerator < SuperGenerator #:nodoc:
+    include TopLevel
+  end
+
+  def SuperGenerator.top_level(*args)
+    TopLevelSuperGenerator.new(*args)
+  end
+
+end

data/lib/rattler/{back_end → compiler}/parser_generator/token_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 TokenGenerator < ExprGenerator #:nodoc:
@@ -8,7 +8,7 @@ module Rattler::BackEnd::ParserGenerator
     include TokenPropogating
     include SkipPropogating
 
-    def gen_basic(token, scope={})
+    def gen_basic(token, scope = ParserScope.empty)
       generate token.child, :token, scope
     end
   end

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

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

data/lib/rattler/{back_end → compiler}/parser_generator/top_level.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 TopLevel #:nodoc:
 

data/lib/rattler/{back_end → compiler}/parser_generator/zero_or_more_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 ZeroOrMoreGenerating #:nodoc:
 
-    def gen_assert(zero_or_more, scope={})
+    def gen_assert(zero_or_more, scope = ParserScope.empty)
       @g << 'true'
     end
 
-    def gen_disallow(zero_or_more, scope={})
+    def gen_disallow(zero_or_more, scope = ParserScope.empty)
       @g << 'false'
     end
 
-    def gen_skip(zero_or_more, scope={})
+    def gen_skip(zero_or_more, scope = ParserScope.empty)
       expr :block do
         @g << 'while '
         generate zero_or_more.child, :intermediate_skip, scope

data/lib/rattler/compiler/rattler.rtlr

@@ -0,0 +1,201 @@
+require 'rattler/compiler'
+
+grammar Rattler::Compiler::Metagrammar
+
+include Rattler::Parsers
+
+%whitespace (SPACE+ / comment)*
+
+grammar           <-  heading rules EOF                                         <Grammar>
+
+heading           <-  requires module_decl? includes start_directive?           { heading *_ }
+
+requires          <-  require_statement*                                        { { :requires => _ } }
+
+require_statement <-  ~`require` @(!eol .)+ ~eol
+                    / ~`require_relative` @(!eol .)+ ~eol                       { expand_relative _ }
+
+module_decl       <-  ~`parser` constant (~'<' constant)? ~eol                  { parser_decl *_ }
+                    / ~`grammar` constant ~eol                                  { { :grammar_name => _ } }
+
+includes          <-  (~`include` constant ~eol)*                               { { :includes => _ } }
+
+start_directive   <-  ~`%start` identifier                                      { { :start_rule => _ } }
+
+rules             <-  (directive / rule / block_close)*                         <RuleSet>
+
+directive         <-  ws_directive / wc_directive / inline_directive / fragments
+
+ws_directive      <-  ws_decl ~'{'                                              { start_ws _ }
+                    / ws_decl                                                   { set_ws _ }
+
+ws_decl           <-  ~`%whitespace` unattributed
+
+wc_directive      <-  wc_decl ~'{'                                              { start_wc _ }
+                    / wc_decl                                                   { set_wc _ }
+
+wc_decl           <-  ~`%word_character` unattributed
+
+inline_directive  <-  ~`%inline` ~'{'                                           { start_inline }
+                    / ~`%inline`                                                { set_inline }
+
+fragments         <-  ~`%fragments` ~'{'                                        { start_fragments }
+                    / ~`%fragments`                                             { set_fragments }
+
+block_close       <-  ~'}'                                                      { end_block }
+
+rule              <-  identifier ~'<-' expression                               { rule *_ }
+
+unattributed      <-  unattributed ~'/' terms                                   <Choice>
+                    / terms
+
+expression        <-  expression ~'/' attributed                                <Choice>
+                    / attributed
+
+attributed        <-  attributed? (semantic_action / node_action)               <AttributedSequence>
+                    / attributed_terms
+
+old_node_action   <-  @(name (~'.' var_name)?)
+
+semantic_action   <-  ~'{' action_code ~'}'                                     <SemanticAction>
+
+action_code       <-  @(( '{' [^}]* '}'
+                        / [^{}]         )*)
+
+node_action       <-  ~'<' (name (~'.' var_name)?)? literal? ~'>'               <NodeAction>
+
+attributed_terms  <-  attributed term                                           <Sequence>
+                    / terms
+
+terms             <-  terms term                                                <Sequence>
+                    / term
+
+term              <-  fail_expr / labeled / labelable
+
+fail_expr         <-  fail_keyword fail_arg                                     <Fail>
+
+labeled           <-  var_name ~':' labelable                                   <Label>
+
+labelable         <-  semantic_term / list / list_term
+
+semantic_term     <-  ~'^' semantic_action
+                    / ~'&' semantic_action                                      { Assert[_] }
+                    / ~'!' semantic_action                                      { Disallow[_] }
+                    / ~'~' semantic_action                                      { Skip[_] }
+
+list              <-  list_term ~('*' ',') list_term                            { list0 *_ }
+                    / list_term ~('+' ',') list_term                            { list1 *_ }
+                    / list_term repeat_count ~',' list_term                     <ListParser>
+
+list_term         <-  prefixed
+                    / prefixable
+                    / expected 'term'
+
+prefixed          <-  ~'&' prefixable                                           <Assert>
+                    / ~'!' prefixable                                           <Disallow>
+                    / ~'~' prefixable                                           <Skip>
+                    / ~'@' prefixable                                           <Token>
+
+prefixable        <-  prefixed / suffixable
+                    / expected 'primary'
+
+suffixed          <-  suffixable ~'?'                                           { optional _ }
+                    / suffixable ~'*' !','                                      { zero_or_more _ }
+                    / suffixable ~'+' !','                                      { one_or_more _ }
+                    / suffixable repeat_count !','                              <Repeat>
+
+repeat_count      <-  @DIGIT+ ~'..' @DIGIT+                                     { _.map {|s| s.to_i } }
+                    / @DIGIT+ ~'..'                                             { [_.to_i, nil] }
+                    / @DIGIT+                                                   { [_.to_i] * 2 }
+
+suffixable        <-  suffixed / primary
+                    / expected 'primary'
+
+primary           <-  ~'(' expression ~')'
+                    / atom
+
+atom              <-  ~`EOF`                                                    <Eof>
+                    / ~`E`                                                      <ESymbol>
+                    / ~`super`                                                  { Super[:pending] }
+                    / posix_class                                               { posix_class _ }
+                    / identifier !'<-'                                          <Apply>
+                    / literal                                                   { literal _ }
+                    / word_literal                                              { word_literal _ }
+                    / class                                                     { char_class _ }
+                    / back_reference                                            <BackReference>
+                    / ~'.'                                                      { Match[/./] }
+
+%inline
+
+fail_keyword      <-  `fail` / `fail_rule` / `fail_parse` / `expected`
+
+fail_arg          <-  ~'(' literal ~')'
+                    / literal
+
+posix_class       <-  `ALNUM`
+                    / `ALPHA`
+                    / `ASCII`
+                    / `BLANK`
+                    / `CNTRL`
+                    / `DIGIT`
+                    / `GRAPH`
+                    / `LOWER`
+                    / `PRINT`
+                    / `PUNCT`
+                    / `SPACE`
+                    / `UPPER`
+                    / `XDIGIT`
+                    / `WORD`
+
+literal           <-  @('"' ('\\' . / [^"])* '"')
+                    / @("'" ('\\' . / [^'])* "'")
+                    / @('%(' ('\\' . / [^)])* ')')
+                    / @('%{' ('\\' . / [^}])* '}')
+                    / @('%[' ('\\' . / [^\]])* ']')
+                    / @('%<' ('\\' . / [^>])* '>')
+                    / @('%' q:PUNCT ('\\' . / !$q .)* $q)
+
+word_literal      <-  @("`" ('\\' . / [^`])* "`")
+
+class             <-  @('[' (!']' range)+  ']')
+
+name              <-  var_name
+                    / constant
+
+identifier        <-  !`EOF` @(ALPHA WORD*)
+
+back_reference    <-  @('$' LOWER WORD*)
+
+var_name          <-  @(LOWER WORD*)
+
+constant          <-  @((UPPER WORD* '::')* UPPER WORD*)
+
+const_name        <-  @(UPPER WORD*)
+
+%fragments
+
+range             <-  '[:' posix_name ':]'
+                    / class_char ('-' class_char)?
+
+posix_name        <-  `alnum`
+                    / `alpha`
+                    / `ascii`
+                    / `blank`
+                    / `cntrl`
+                    / `digit`
+                    / `graph`
+                    / `lower`
+                    / `print`
+                    / `punct`
+                    / `space`
+                    / `upper`
+                    / `xdigit`
+
+class_char        <-  '\\' [0-3] [0-7] [0-7]
+                    / '\\x' XDIGIT XDIGIT
+                    / '\\' .
+                    / [^\\\]]
+
+eol               <-  ~(BLANK* (EOF / ';' / "\r"? "\n" / comment))
+
+comment           <-  ~('#' [^\n]*)