rattler 0.3.0 → 0.4.0

data/lib/rattler/grammar/rattler.rtlr

@@ -4,149 +4,167 @@ grammar Rattler::Grammar::Metagrammar
 
 include Rattler::Parsers
 
-%whitespace (SPACE+ | ('#' [^\n]*))* {
-  
-  grammar         <-  heading rules EOF                                         <Grammar>
-  
-  heading         <-  requires module_decl? includes                            { heading *_ }
-  
-  requires        <-  (~`require` literal ~eol)*                                { { :requires => _ } }
-  
-  module_decl     <-  ~`parser` constant (~'<' constant)? ~eol                  { parser_decl *_ }
-                    | ~`grammar` constant ~eol                                  { { :grammar_name => _ } }
-  
-  includes        <-  (~`include` constant ~eol)*                               { { :includes => _ } }
-  
-  rules           <-  (directive | rule | block_close)+                         <Rules>
-  
-  directive       <-  ws_directive | wc_directive
-  
-  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
-  
-  block_close     <-  ~'}'                                                      { end_block }
-  
-  rule            <-  identifier ~'<-' expression                               { rule *_ }
-  
-  unattributed    <-  unattributed ~'|' terms                                   <Choice>
-                    | terms
-  
-  expression      <-  expression ~'|' attributed                                <Choice>
-                    | attributed
-  
-  attributed      <-  attributed ~'<' dispatch? ~'>'                            <DispatchAction>
-                    | attributed ~'{' action ~'}'                               <DirectAction>
-                    | terms
-  
-  dispatch        <-  @(name (~'.' var_name)?)
-  
-  action          <-  @(('{' [^}]* '}' | [^{}])*)
-  
-  terms           <-  terms term                                                <Sequence>
-                    | term
-  
-  term            <-  fail_expr | labeled | labelable
-  
-  fail_expr       <-  (`fail` | `fail_rule` | `fail_parse`) fail_arg            <Fail>
-  
-  fail_arg        <-  ~'(' literal ~')'
-                    | literal
-  
-  labeled         <-  var_name ~':' labelable                                   <Label>
-  
-  labelable       <-  list | list_term
-  
-  list            <-  list_term ~'*^' list_term                                 <List>
-                    | list_term ~'+^' list_term                                 <List1>
-  
-  list_term       <-  prefixed | prefixable
-  
-  prefixed        <-  ~'&' prefixable                                           <Assert>
-                    | ~'!' prefixable                                           <Disallow>
-                    | ~'~' prefixable                                           <Skip>
-                    | ~'@' prefixable                                           <Token>
-  
-  prefixable      <-  suffixed | primary
-  
-  suffixed        <-  primary ~'?'                                              <Optional>
-                    | primary ~'*' !'^'                                         <ZeroOrMore>
-                    | primary ~'+' !'^'                                         <OneOrMore>
-  
-  primary         <-  ~'(' expression ~')'
-                    | atom
-  
-  atom            <-  `EOF`                                                     <Eof>
-                    | posix_class                                               { posix_class _ }
-                    | identifier !'<-'                                          <Apply>
-                    | literal                                                   { literal _ }
-                    | word_literal                                              { word_literal _ }
-                    | class                                                     { char_class _ }
-                    | regexp                                                    <Match>
-                    | ~'.'                                                      { Match[/./] }
-  
-  posix_class     <-  `ALNUM`
-                    | `ALPHA`
-                    | `ASCII`
-                    | `BLANK`
-                    | `CNTRL`
-                    | `DIGIT`
-                    | `GRAPH`
-                    | `LOWER`
-                    | `PRINT`
-                    | `PUNCT`
-                    | `SPACE`
-                    | `UPPER`
-                    | `XDIGIT`
-                    | `WORD`
-  
-  literal         <-  /(["'])(?:\\.|(?:(?!\1).))*\1/
-  
-  word_literal    <-  @("`" ('\\' . | [^`])* "`")
-  
-  class           <-  @('[' (!']' range)+  ']')
-  
-  regexp          <-  /\/(?:\\.|[^\/])+\/(?:[iomx]+(?!\w))?/
-  
-  name            <-  var_name
-                    | constant
-  
-  identifier      <-  !`EOF` @WORD+
-  
-  var_name        <-  @(LOWER WORD*)
-  
-  constant        <-  @((const_name '::')* const_name)
-  
-  const_name      <-  @(UPPER WORD*)
+%whitespace (SPACE+ / comment)* {
+
+  grammar           <-  heading rules EOF                                       <Grammar>
+
+  heading           <-  requires module_decl? includes                          { heading *_ }
+
+  requires          <-  (~`require` @(!eol .)+ ~eol)*                           { { :requires => _ } }
+
+  module_decl       <-  ~`parser` constant (~'<' constant)? ~eol                { parser_decl *_ }
+                      / ~`grammar` constant ~eol                                { { :grammar_name => _ } }
+
+  includes          <-  (~`include` constant ~eol)*                             { { :includes => _ } }
+
+  rules             <-  (directive / rule / block_close)+                       <RuleSet>
+
+  directive         <-  ws_directive / wc_directive / inline_directive
+
+  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 }
+
+  block_close       <-  ~'}'                                                    { end_block }
+
+  rule              <-  identifier ~'<-' expression                             { rule *_ }
+
+  unattributed      <-  unattributed ~'/' terms                                 <Choice>
+                      / terms
+
+  expression        <-  expression ~'/' attributed                              <Choice>
+                      / attributed
+
+  attributed        <-  attributed ~'<' node_action? ~'>'                       <DispatchAction>
+                      / attributed ~'{' action ~'}'                             <DirectAction>
+                      / terms
+
+  node_action       <-  @(name (~'.' var_name)?)
+
+  action            <-  @(  ('{' [^}]* '}'
+                          / [^{}])* )
+
+  terms             <-  terms term                                              <Sequence>
+                      / term
+
+  term              <-  fail_expr / labeled / labelable
+
+  fail_expr         <-  (`fail` / `fail_rule` / `fail_parse`) fail_arg          <Fail>
+
+  fail_arg          <-  ~'(' literal ~')'
+                      / literal
+
+  labeled           <-  var_name ~':' labelable                                 <Label>
+
+  labelable         <-  list
+                      / list_term
+
+  list              <-  list_term ~'*,' list_term                               <List>
+                      / list_term ~'+,' list_term                               <List1>
+
+  list_term         <-  prefixed
+                      / prefixable
+                      / fail 'term expected'
+
+  prefixed          <-  ~'&' prefixable                                         <Assert>
+                      / ~'!' prefixable                                         <Disallow>
+                      / ~'~' prefixable                                         <Skip>
+                      / ~'@' prefixable                                         <Token>
+
+  prefixable        <-  suffixed / primary
+
+  suffixed          <-  primary ~'?'                                            <Optional>
+                      / primary ~'*' !','                                       <ZeroOrMore>
+                      / primary ~'+' !','                                       <OneOrMore>
+
+  primary           <-  ~'(' expression ~')'
+                      / atom
+
+  atom              <-  ~`EOF`                                                  <Eof>
+                      / posix_class                                             { posix_class _ }
+                      / identifier !'<-'                                        <Apply>
+                      / literal                                                 { literal _ }
+                      / word_literal                                            { word_literal _ }
+                      / class                                                   { char_class _ }
+                      / back_reference                                          <BackReference>
+                      / ~'.'                                                    { Match[/./] }
+                      / fail 'atom expected'
+
+%inline
+
+  posix_class       <-  `ALNUM`
+                      / `ALPHA`
+                      / `ASCII`
+                      / `BLANK`
+                      / `CNTRL`
+                      / `DIGIT`
+                      / `GRAPH`
+                      / `LOWER`
+                      / `PRINT`
+                      / `PUNCT`
+                      / `SPACE`
+                      / `UPPER`
+                      / `XDIGIT`
+                      / `WORD`
+                      / fail 'posix_class expected'
+
+  literal           <-  @('"' ('\\' . / [^"])* '"')
+                      / @("'" ('\\' . / [^'])* "'")
+                      / @('%(' ('\\' . / [^)])* ')')
+                      / @('%{' ('\\' . / [^}])* '}')
+                      / @('%[' ('\\' . / [^\]])* ']')
+                      / @('%<' ('\\' . / [^>])* '>')
+                      / @('%' q:PUNCT ('\\' . / !$q .)* $q)
+
+  word_literal      <-  @("`" ('\\' . / [^`])* "`")
+
+  class             <-  @('[' (!']' range)+  ']')
+
+  name              <-  var_name
+                      / constant
+
+  identifier        <-  !`EOF` @WORD+
+
+  back_reference    <-  @('$' LOWER WORD*)
+
+  var_name          <-  @(LOWER WORD*)
+
+  constant          <-  @((UPPER WORD* '::')* UPPER WORD*)
+
+  const_name        <-  @(UPPER WORD*)
 }
 
-  range           <-  @(  '[:' posix_name ':]'
-                        | class_char ('-' class_char)?)
-  
-  posix_name      <-  `alnum`
-                    | `alpha`
-                    | `ascii`
-                    | `blank`
-                    | `cntrl`
-                    | `digit`
-                    | `graph`
-                    | `lower`
-                    | `print`
-                    | `punct`
-                    | `space`
-                    | `upper`
-                    | `xdigit`
-                    | `word`
-  
-  class_char      <-  @(  '\\' [0-3] [0-7] [0-7]
-                        | '\\x' XDIGIT XDIGIT
-                        | '\\' .
-                        | [^\\\]] )
-  
-  eol             <-  ~(BLANK* (EOF | ';' | ("\r"? "\n") | ('#' [^\n]*)))
+  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") / ('#' [^\n]*)))
+
+  comment           <-  ~('#' [^\n]*)

data/lib/rattler/parsers.rb

@@ -16,7 +16,8 @@ module Rattler
   module Parsers
 
     autoload :Parser, 'rattler/parsers/parser'
-    autoload :Rules, 'rattler/parsers/rules'
+    autoload :CombinatorParser, 'rattler/parsers/combinator_parser'
+    autoload :RuleSet, 'rattler/parsers/rule_set'
     autoload :Rule, 'rattler/parsers/rule'
     autoload :Match, 'rattler/parsers/match'
     autoload :Choice, 'rattler/parsers/choice'
@@ -24,6 +25,7 @@ module Rattler
     autoload :Optional, 'rattler/parsers/optional'
     autoload :ZeroOrMore, 'rattler/parsers/zero_or_more'
     autoload :OneOrMore, 'rattler/parsers/one_or_more'
+    autoload :ListParser, 'rattler/parsers/list_parser'
     autoload :List, 'rattler/parsers/list'
     autoload :List1, 'rattler/parsers/list1'
     autoload :Apply, 'rattler/parsers/apply'
@@ -35,12 +37,14 @@ module Rattler
     autoload :Token, 'rattler/parsers/token'
     autoload :Skip, 'rattler/parsers/skip'
     autoload :Label, 'rattler/parsers/label'
+    autoload :BackReference, 'rattler/parsers/back_reference'
     autoload :Fail, 'rattler/parsers/fail'
     autoload :ParserDSL, 'rattler/parsers/parser_dsl'
     autoload :Predicate, 'rattler/parsers/predicate'
     autoload :Combining, 'rattler/parsers/combining'
     autoload :MatchJoining, 'rattler/parsers/match_joining'
     autoload :ActionCode, 'rattler/parsers/action_code'
+    autoload :NodeCode, 'rattler/parsers/node_code'
 
     class <<self
       # Define parse rules with the given block

data/lib/rattler/parsers/action_code.rb

@@ -23,21 +23,31 @@ module Rattler::Parsers
 
     attr_reader :param_names, :body
 
-    def bind(*args)
-      bindings = {}
-      if args.first.respond_to?(:to_ary)
-        a = args.shift
-        bindings.merge!(blank_binding(a)).merge!(arg_bindings(a))
-      end
-      bindings.merge!(args.shift) unless args.empty?
-      bind_in body, bindings
+    def bind(scope, bind_args)
+      bind_in body, scoped_bindings(scope, bind_args)
+    end
+
+    def scoped_bindings(scope, bind_args)
+      to_bindings(scope).
+        merge(blank_binding(bind_args)).
+        merge(arg_bindings(bind_args))
     end
 
     def blank_binding(args)
       case args.size
-      when 0 then {}
-      when 1 then { '_' => args.first }
-      else        { '_' => '[' + args.join(', ') + ']' }
+
+      when 0
+        {}
+
+      when 1
+        { /\*_\b/ => args.first,
+          /\b_\b/ => args.first }
+
+      else
+        list = args.join(', ')
+        { /\*_\b/ => list,
+          /\b_\b/ => '[' + list + ']' }
+
       end
     end
 
@@ -45,18 +55,22 @@ module Rattler::Parsers
       if param_names.count > args.count
         raise ArgumentError, 'more parameter names than arguments'
       end
-      bindings = {}
-      param_names.zip(args).each {|name, arg| bindings[name] = arg if name }
-      bindings
+      to_bindings param_names.zip(args)
     end
 
     private
 
+    def to_bindings(map)
+      bindings = {}
+      map.each {|name, arg| bindings[/\b#{name}\b/] = arg if name }
+      bindings
+    end
+
     def bind_in(code, bindings)
       new_code = code
       bindings.each do |k, v|
         next unless k and v
-        new_code = new_code.gsub(/\b#{k}\b/, v.to_s)
+        new_code = new_code.gsub(k, v.to_s)
       end
       new_code
     end

data/lib/rattler/parsers/apply.rb

@@ -14,7 +14,7 @@ module Rattler::Parsers
   # @author Jason Arhart
   #
   class Apply < Parser
-    
+
     # Create a new parser that parses by applying the parse rule referenced
     # by +rule_name+.
     #
@@ -25,20 +25,20 @@ module Rattler::Parsers
     def self.[](rule_name)
       self.new(:rule_name => rule_name.to_sym)
     end
-    
+
     # @private
     def self.parsed(results) #:nodoc:
       self[results.first]
     end
-    
+
     # Apply the parse rule referenced by the #rule_name.
     #
     # @param (see Parser#parse_labeled)
     #
     # @return the result of applying the referenced parse rule
-    def parse(scanner, rules, labeled = {})
+    def parse(scanner, rules, scope = {})
       (rule = rules[rule_name]) && rule.parse(scanner, rules)
     end
-    
+
   end
 end

data/lib/rattler/parsers/assert.rb

@@ -15,33 +15,19 @@ module Rattler::Parsers
   # @author Jason Arhart
   #
   class Assert < Predicate
-    
+
     # Succeed or fail like the decorated parser but do not consume any input
     # and return +true+ on success.
     #
     # @param (see Parser#parse_labeled)
     #
     # @return [Boolean] +true+ if the decorated parser succeeds
-    def parse(scanner, rules, labeled = {})
+    def parse(scanner, rules, scope = {})
       pos = scanner.pos
-      result = (child.parse(scanner, rules) && true)
+      result = (child.parse(scanner, rules, scope) && true)
       scanner.pos = pos
       result
     end
-    
-    # Return a parser that parses identically but may have a more optimized
-    # structure.
-    #
-    # @return a parser that parses identically but may have a more optimized
-    #   structure
-    def optimized
-      Assert[child.optimized]
-    end
-    
-    # @private
-    def as_match #:nodoc:
-      Match[child.assert_re] if Match === child
-    end
-    
+
   end
 end