rattler 0.4.2 → 0.5.0

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

@@ -5,19 +5,19 @@ module Rattler::BackEnd::ParserGenerator
   module PredicatePropogating #:nodoc:
 
     def gen_assert(parser, scope={})
-      generate parser.child, :assert, scope
+      propogate_gen parser.child, :assert, scope
     end
 
     def gen_disallow(parser, scope={})
-      generate parser.child, :disallow, scope
+      propogate_gen parser.child, :disallow, scope
     end
 
     def gen_intermediate_assert(parser, scope={})
-      generate parser.child, :intermediate_assert, scope
+      propogate_gen parser.child, :intermediate_assert, scope
     end
 
     def gen_intermediate_disallow(parser, scope={})
-      generate parser.child, :intermediate_disallow, scope
+      propogate_gen parser.child, :intermediate_disallow, scope
     end
 
   end

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

@@ -0,0 +1,53 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+
+  # @private
+  class RepeatGenerator < DelegatingGenerator #:nodoc:
+    include NestedSubGenerating
+
+    protected
+
+    def impl(repeat, init_args)
+      generator = default_impl(repeat, init_args)
+      specialize_for repeat, generator
+      generator
+    end
+
+    def specialize_for(repeat, generator)
+      return unless repeat.respond_to? :lower_bound
+      if repeat.lower_bound == 0
+        if repeat.upper_bound == 1
+          generator.extend OptionalGenerating
+        else
+          generator.extend ZeroOrMoreGenerating
+        end
+      elsif repeat.lower_bound == 1
+        generator.extend OneOrMoreGenerating
+      end
+    end
+  end
+
+  # @private
+  class NestedRepeatGenerator < RepeatGenerator #:nodoc:
+    def default_impl(list, init_args)
+      GeneralRepeatGenerator.nested(*init_args)
+    end
+  end
+
+  def RepeatGenerator.nested(*args)
+    NestedRepeatGenerator.new(*args)
+  end
+
+  # @private
+  class TopLevelRepeatGenerator < RepeatGenerator #:nodoc:
+    def default_impl(list, init_args)
+      GeneralRepeatGenerator.top_level(*init_args)
+    end
+  end
+
+  def RepeatGenerator.top_level(*args)
+    TopLevelRepeatGenerator.new(*args)
+  end
+
+end

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

@@ -5,11 +5,11 @@ module Rattler::BackEnd::ParserGenerator
   module SkipPropogating #:nodoc:
 
     def gen_skip(parser, scope={})
-      generate parser.child, :skip, scope
+      propogate_gen parser.child, :skip, scope
     end
 
     def gen_intermediate_skip(parser, scope={})
-      generate parser.child, :intermediate_skip, scope
+      propogate_gen parser.child, :intermediate_skip, scope
     end
 
   end

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

@@ -21,17 +21,18 @@ module Rattler::BackEnd::ParserGenerator
       gen_with generator(parser, :top_level), parser, as, *args
     end
 
-    def gen_eof
-      @g << '@scanner.eos?'
+    def propogate_gen(parser, type, scope)
+      if nested?
+        gen_nested parser, type, scope
+      else
+        gen_top_level parser, type, scope
+      end
     end
 
     private
 
     def gen_with(g, parser, as=:basic, *args)
-      case parser
-      when Eof then gen_eof
-      else g.send(:"gen_#{as}", parser, *args)
-      end
+      g.send(:"gen_#{as}", parser, *args)
     end
 
     def generator(parser, context=nil)
@@ -48,21 +49,12 @@ module Rattler::BackEnd::ParserGenerator
       when Sequence
         new_generator SequenceGenerator, context, :new_sequence_level => true
 
-      when Optional
-        cache_generator OptionalGenerator, context
-
-      when ZeroOrMore
-        cache_generator ZeroOrMoreGenerator, context, :new_repeat_level => true
+      when Repeat
+        cache_generator RepeatGenerator, context, :new_repeat_level => true
 
-      when OneOrMore
-        cache_generator OneOrMoreGenerator, context, :new_repeat_level => true
-
-      when List0
+      when ListParser
         cache_generator ListGenerator, context, :new_repeat_level => true
 
-      when List1
-        cache_generator List1Generator, context, :new_repeat_level => true
-
       when Apply
         cache_generator ApplyGenerator, context
 
@@ -72,6 +64,12 @@ module Rattler::BackEnd::ParserGenerator
       when Disallow
         cache_generator DisallowGenerator, context
 
+      when Eof
+        cache_generator EofGenerator, context
+
+      when ESymbol
+        cache_generator ESymbolGenerator, context
+
       when DispatchAction
         cache_generator DispatchActionGenerator, context
 

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

@@ -4,7 +4,7 @@ module Rattler::BackEnd::ParserGenerator
   # @private
   module TokenPropogating #:nodoc:
     def gen_token(parser, scope={})
-      generate parser.child, :token, scope
+      propogate_gen parser.child, :token, scope
     end
   end
 end

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

@@ -0,0 +1,31 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+  # @private
+  module ZeroOrMoreGenerating #:nodoc:
+
+    def gen_assert(zero_or_more, scope={})
+      @g << 'true'
+    end
+
+    def gen_disallow(zero_or_more, scope={})
+      @g << 'false'
+    end
+
+    def gen_skip(zero_or_more, scope={})
+      expr :block do
+        @g << 'while '
+        generate zero_or_more.child, :intermediate_skip, scope
+        (@g << '; end').newline
+        @g << 'true'
+      end
+    end
+
+    protected
+
+    def gen_result(zero_or_more, captures)
+      @g << captures
+    end
+
+  end
+end

data/lib/rattler/grammar/grammar_parser.rb

@@ -71,6 +71,26 @@ module Rattler::Grammar
       {:parser_name => name, :base_name => base.first}
     end
 
+    def list0(term_parser, sep_parser)
+      ListParser[term_parser, sep_parser, 0, nil]
+    end
+
+    def list1(term_parser, sep_parser)
+      ListParser[term_parser, sep_parser, 1, nil]
+    end
+
+    def optional(parser)
+      Repeat[parser, 0, 1]
+    end
+
+    def zero_or_more(parser)
+      Repeat[parser, 0, nil]
+    end
+
+    def one_or_more(parser)
+      Repeat[parser, 1, nil]
+    end
+
     def rule(name, parser)
       Rule[name, (@ws ? parser.with_ws(@ws) : parser), {:inline => @inline}]
     end

data/lib/rattler/grammar/metagrammar.rb

@@ -131,7 +131,7 @@ module Rattler
                 begin
                   @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>EOF)(?![[:alnum:]_])))/) &&
                   (r1_0 = begin
-                    @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:alnum:]_])+))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><\-))/) &&
+                    @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:alpha:]])(?>(?>[[:alnum:]_])*)))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><\-))/) &&
                     @scanner[1]
                   end) &&
                   (r1_1 = match(:expression)) &&
@@ -212,7 +212,7 @@ module Rattler
         begin
           p0 = @scanner.pos
           begin
-            (r0_0 = match(:attributed)) &&
+            (r0_0 = ((r = match(:attributed)) ? [r] : [])) &&
             @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><)/) &&
             (r0_1 = ((r = begin
               @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>[[:lower:]])(?>(?>[[:alnum:]_])*))|(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>(?>(?>[[:upper:]])(?>(?>[[:alnum:]_])*)(?>::))*)(?>[[:upper:]])(?>(?>[[:alnum:]_])*)))(?>(?>(?>\.)(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>[[:lower:]])(?>(?>[[:alnum:]_])*))))?))/) &&
@@ -283,7 +283,7 @@ module Rattler
               end
             end) ? [r] : [])) &&
             @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>>)/) &&
-            DispatchAction.parsed(select_captures([r0_0, r0_1, r0_2]))
+            DispatchAction.parsed([r0_0, r0_1, r0_2])
           end || begin
             @scanner.pos = p0
             false
@@ -292,12 +292,75 @@ module Rattler
         begin
           p0 = @scanner.pos
           begin
-            (r0_0 = match(:attributed)) &&
+            (r0_0 = ((r = match(:attributed)) ? [r] : [])) &&
             (r0_1 = begin
               @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>\{)(?>(?>[^}])*)(?>\})|[^{}])*))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\}))/) &&
               @scanner[1]
             end) &&
-            DirectAction.parsed(select_captures([r0_0, r0_1]))
+            DirectAction.parsed([r0_0, r0_1])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = ((r = match(:attributed)) ? [r] : [])) &&
+            (r0_1 = begin
+              @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>~))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>\{)(?>(?>[^}])*)(?>\})|[^{}])*))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\}))/) &&
+              @scanner[1]
+            end) &&
+            SideEffect.parsed([r0_0, r0_1])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = ((r = match(:attributed)) ? [r] : [])) &&
+            (r0_1 = begin
+              @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>&))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>\{)(?>(?>[^}])*)(?>\})|[^{}])*))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\}))/) &&
+              @scanner[1]
+            end) &&
+            SemanticAssert.parsed([r0_0, r0_1])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = ((r = match(:attributed)) ? [r] : [])) &&
+            (r0_1 = begin
+              @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>!))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>\{)(?>(?>[^}])*)(?>\})|[^{}])*))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\}))/) &&
+              @scanner[1]
+            end) &&
+            SemanticDisallow.parsed([r0_0, r0_1])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        match(:attributed_terms)
+      end
+      
+      # @private
+      def match_attributed_terms #:nodoc:
+        memoize_lr :match_attributed_terms!
+      end
+      
+      # @private
+      def match_attributed_terms! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:attributed)) &&
+            (r0_1 = match(:term)) &&
+            Sequence.parsed(select_captures([r0_0, r0_1]))
           end || begin
             @scanner.pos = p0
             false
@@ -543,9 +606,9 @@ module Rattler
           p0 = @scanner.pos
           begin
             (r0_0 = match(:list_term)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\*,)/) &&
+            @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\*))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,))/) &&
             (r0_1 = match(:list_term)) &&
-            List0.parsed(select_captures([r0_0, r0_1]))
+            (list0 r0_0, r0_1)
           end || begin
             @scanner.pos = p0
             false
@@ -555,9 +618,35 @@ module Rattler
           p0 = @scanner.pos
           begin
             (r0_0 = match(:list_term)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\+,)/) &&
+            @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\+))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,))/) &&
             (r0_1 = match(:list_term)) &&
-            List1.parsed(select_captures([r0_0, r0_1]))
+            (list1 r0_0, r0_1)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:list_term)) &&
+            (r0_1 = begin
+              begin
+                @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:digit:]])+))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\.\.))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:digit:]])+))/) &&
+                ([@scanner[1], @scanner[2]].map {|s| s.to_i })
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:digit:]])+))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\.\.))/) &&
+                ([@scanner[1].to_i, nil])
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:digit:]])+)/) &&
+                ([@scanner[1].to_i] * 2)
+              end
+            end) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,)/) &&
+            (r0_2 = match(:list_term)) &&
+            ListParser.parsed(select_captures([r0_0, r0_1, r0_2]))
           end || begin
             @scanner.pos = p0
             false
@@ -653,7 +742,7 @@ module Rattler
           begin
             (r0_0 = match(:primary)) &&
             @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\?)/) &&
-            Optional.parsed(select_captures([r0_0]))
+            (optional r0_0)
           end || begin
             @scanner.pos = p0
             false
@@ -664,7 +753,7 @@ module Rattler
           begin
             (r0_0 = match(:primary)) &&
             @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\*))(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,))/) &&
-            ZeroOrMore.parsed(select_captures([r0_0]))
+            (zero_or_more r0_0)
           end || begin
             @scanner.pos = p0
             false
@@ -675,7 +764,32 @@ module Rattler
           begin
             (r0_0 = match(:primary)) &&
             @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\+))(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,))/) &&
-            OneOrMore.parsed(select_captures([r0_0]))
+            (one_or_more r0_0)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:primary)) &&
+            (r0_1 = begin
+              begin
+                @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:digit:]])+))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\.\.))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:digit:]])+))/) &&
+                ([@scanner[1], @scanner[2]].map {|s| s.to_i })
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:digit:]])+))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\.\.))/) &&
+                ([@scanner[1].to_i, nil])
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:digit:]])+)/) &&
+                ([@scanner[1].to_i] * 2)
+              end
+            end) &&
+            @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,))/) &&
+            Repeat.parsed(select_captures([r0_0, r0_1]))
           end || begin
             @scanner.pos = p0
             false
@@ -706,6 +820,10 @@ module Rattler
           @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>EOF)(?![[:alnum:]_]))/) &&
           Eof.parsed([])
         end ||
+        begin
+          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>E)(?![[:alnum:]_]))/) &&
+          ESymbol.parsed([])
+        end ||
         begin
           (r = begin
             begin
@@ -772,7 +890,7 @@ module Rattler
           begin
             @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>EOF)(?![[:alnum:]_])))/) &&
             (r0_0 = begin
-              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:alnum:]_])+)/) &&
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:alpha:]])(?>(?>[[:alnum:]_])*))/) &&
               @scanner[1]
             end) &&
             @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><\-))/) &&

data/lib/rattler/grammar/rattler.rtlr

@@ -44,14 +44,20 @@ include Rattler::Parsers
   expression        <-  expression ~'/' attributed                              <Choice>
                       / attributed
 
-  attributed        <-  attributed ~'<' node_action? literal? ~'>'              <DispatchAction>
-                      / attributed ~'{' action ~'}'                             <DirectAction>
-                      / terms
+  attributed        <-  attributed? ~'<' node_action? literal? ~'>'             <DispatchAction>
+                      / attributed? ~'{' action ~'}'                            <DirectAction>
+                      / attributed? ~'~' ~'{' action ~'}'                       <SideEffect>
+                      / attributed? ~'&' ~'{' action ~'}'                       <SemanticAssert>
+                      / attributed? ~'!' ~'{' action ~'}'                       <SemanticDisallow>
+                      / attributed_terms
 
   node_action       <-  @(name (~'.' var_name)?)
 
-  action            <-  @(  ('{' [^}]* '}'
-                          / [^{}])* )
+  action            <-  @(( '{' [^}]* '}'
+                          / [^{}]         )*)
+
+  attributed_terms  <-  attributed term                                         <Sequence>
+                      / terms
 
   terms             <-  terms term                                              <Sequence>
                       / term
@@ -68,8 +74,9 @@ include Rattler::Parsers
   labelable         <-  list
                       / list_term
 
-  list              <-  list_term ~'*,' list_term                               <List0>
-                      / list_term ~'+,' list_term                               <List1>
+  list              <-  list_term ~('*' ',') list_term                          { list0 *_ }
+                      / list_term ~('+' ',') list_term                          { list1 *_ }
+                      / list_term repeat_count ~',' list_term                   <ListParser>
 
   list_term         <-  prefixed
                       / prefixable
@@ -82,14 +89,20 @@ include Rattler::Parsers
 
   prefixable        <-  suffixed / primary
 
-  suffixed          <-  primary ~'?'                                            <Optional>
-                      / primary ~'*' !','                                       <ZeroOrMore>
-                      / primary ~'+' !','                                       <OneOrMore>
+  suffixed          <-  primary ~'?'                                            { optional _ }
+                      / primary ~'*' !','                                       { zero_or_more _ }
+                      / primary ~'+' !','                                       { one_or_more _ }
+                      / primary repeat_count !','                               <Repeat>
+
+  repeat_count      <-  @DIGIT+ ~'..' @DIGIT+                                   { _.map {|s| s.to_i } }
+                      / @DIGIT+ ~'..'                                           { [_.to_i, nil] }
+                      / @DIGIT+                                                 { [_.to_i] * 2 }
 
   primary           <-  ~'(' expression ~')'
                       / atom
 
   atom              <-  ~`EOF`                                                  <Eof>
+                      / ~`E`                                                    <ESymbol>
                       / posix_class                                             { posix_class _ }
                       / identifier !'<-'                                        <Apply>
                       / literal                                                 { literal _ }
@@ -132,7 +145,7 @@ include Rattler::Parsers
   name              <-  var_name
                       / constant
 
-  identifier        <-  !`EOF` @WORD+
+  identifier        <-  !`EOF` @(ALPHA WORD*)
 
   back_reference    <-  @('$' LOWER WORD*)
 
@@ -165,6 +178,6 @@ include Rattler::Parsers
                           / '\\' .
                           / [^\\\]] )
 
-  eol               <-  ~(BLANK* (EOF / ';' / ("\r"? "\n") / ('#' [^\n]*)))
+  eol               <-  ~(BLANK* (EOF / ';' / ("\r"? "\n") / comment))
 
   comment           <-  ~('#' [^\n]*)