musa-dsl 0.14.29 → 0.21.3

data/lib/musa-dsl/musicxml/builder/typed-text.rb

@@ -0,0 +1,43 @@
+require_relative 'helper'
+
+module Musa
+  module MusicXML
+    module Builder
+      module Internal
+        class TypedText
+          include Helper::ToXML
+
+          def initialize(type = nil, text)
+            @type = type
+            @text = text
+          end
+
+          attr_accessor :type, :text
+          attr_reader :tag
+
+          def _to_xml(io, indent:, tabs:)
+            io.puts "#{tabs}<#{tag}#{" type=\"#{@type}\"" if @type}>#{@text}</#{tag}>"
+          end
+        end
+
+        private_constant :TypedText
+
+        class Creator < TypedText
+          def initialize(type, name)
+            @tag = 'creator'
+            super type, name
+          end
+        end
+
+        class Rights < TypedText
+          def initialize(type, name)
+            @tag = 'rights'
+            super type, name
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/musa-dsl/musicxml/builder/unpitched-note.rb

@@ -0,0 +1,112 @@
+require_relative 'note'
+
+module Musa
+  module MusicXML
+    module Builder
+      module Internal
+        class UnpitchedNote < Note
+          def initialize( pizzicato: nil, # true
+                          grace: nil, # true
+                          cue: nil, # true
+                          chord: nil, # true
+                          duration: nil, # number positive divisions
+                          tie_start: nil, tie_stop: nil, # true
+                          voice: nil, # number
+                          type: nil, # whole / half / quarter / ...
+                          dots: nil, # number
+                          accidental: nil, # sharp / flat / ...
+                          time_modification: nil, # TimeModification class instance
+                          stem: nil, # up / down / double
+                          notehead: nil, # Notehead class instance
+                          staff: nil, # number
+
+                          # notations
+                          accidental_mark: nil, # sharp / natural / flat / ...
+                          arpeggiate: nil, # true / up / down
+
+                          tied: nil, # start / stop / continue
+                          tuplet: nil, # Tuplet class instance
+
+                          dynamics: nil, # pppp...ffff (single or array of)
+                          fermata: nil, # true / upright / inverted
+                          glissando: nil, # start / stop
+                          non_arpeggiate: nil, # top / bottom
+
+                          slide: nil, # start / stop
+                          slur: nil, # start / stop / continue
+
+                          ## articulations
+                          accent: nil, # true
+                          breath_mark: nil, # comma / tick
+                          caesura: nil, # true
+                          detached_legato:nil, # true
+                          doit: nil, # true
+                          falloff: nil, # true
+                          other_articulation: nil, # text
+                          plop: nil, # true
+                          scoop: nil, # true
+                          spiccato: nil, # true
+                          staccatissimo: nil, # true
+                          staccato: nil, # true
+                          stress: nil, # true
+                          strong_accent: nil, # true / up / down
+                          tenuto: nil, # true
+                          unstress: nil, # true
+
+                          ## ornaments
+                          delayed_inverted_turn: nil, # true
+                          delayed_turn: nil, # true
+                          inverted_mordent: nil, # true
+                          inverted_turn: nil, # true
+                          mordent: nil, # true
+                          schleifer: nil, # true
+                          shake: nil, # true
+                          tremolo: nil, # start / stop / single,
+                          trill_mark: nil, # true
+                          turn: nil, # true
+                          vertical_turn: nil, # true
+                          wavy_line: nil, # true
+                          other_ornament: nil, # true
+                          ornament_accidental_mark: nil, # sharp / natural / flat / ...
+
+                          ## technical
+                          arrow: nil, # Arrow class instance
+                          bend: nil, # Bend class instance
+                          double_tongue: nil, # true
+                          down_bow: nil, # true
+                          fingering: nil,  # Fingering class instance
+                          fingernails: nil, # true
+                          fret: nil, # number
+                          hammer_on: nil, # HammerOnPullOff class instance
+                          handbell: nil, # damp / echo / ...
+                          harmonic: nil, # Harmonic class instance
+                          heel: nil, # true
+                          hole: nil, # Hole class instance
+                          open_string: nil, # true
+                          other_technical: nil, # text
+                          pluck: nil, # text
+                          pull_off: nil, # HammerOnPullOff class insstance
+                          snap_pizzicato: nil, # true
+                          stopped: nil, # true
+                          string: nil, # number (string number)
+                          tap: nil, # text
+                          thumb_position: nil, # true
+                          toe: nil, # true
+                          triple_tongue: nil, # true
+                          up_bow: nil,  # true
+                          &block)
+
+            super
+          end
+
+          private
+
+          def specific_to_xml(io, indent:)
+            tabs = "\t" * indent
+            io.puts "#{tabs}<unpitched />"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/musa-dsl/neumalang.rb

@@ -1,3 +1,3 @@
-require 'musa-dsl/neumalang/neumalang'
+require_relative 'neumalang/neumalang'
 
 

data/lib/musa-dsl/neumalang/datatypes.citrus

@@ -0,0 +1,79 @@
+grammar Musa::Neumalang::Neumalang::Parser::Grammar::Datatypes
+    include Musa::Neumalang::Neumalang::Parser::Grammar::Terminals
+
+	rule constant
+		number | symbol | string | special
+	end
+
+    rule special
+        (true | false | nil) <Musa::Neumalang::Neumalang::Parser::Special>
+    end
+
+  	rule symbol
+  		(colon name) <Musa::Neumalang::Neumalang::Parser::Symbol>
+  	end
+
+  	rule raw_symbol
+  		(name) { to_str.to_sym }
+  	end
+
+    rule name
+        /[[:alpha:]]\w*/
+    end
+
+  	rule string
+  		(double_quote everything_except_double_quote double_quote) <Musa::Neumalang::Neumalang::Parser::String>
+  	end
+
+  	rule raw_string
+  		(double_quote everything_except_double_quote double_quote) { capture(:everything_except_double_quote).value }
+  	end
+
+	rule number
+    	(optional_separation raw_number) <Musa::Neumalang::Neumalang::Parser::Number>
+  	end
+
+	rule raw_number
+    	raw_float | raw_rational | raw_integer
+  	end
+
+    rule raw_unsigned_number
+        raw_unsigned_float | raw_unsigned_rational | raw_unsigned_integer
+    end
+
+    rule raw_float
+        raw_unsigned_float | raw_minus_float
+    end
+
+  	rule raw_minus_float
+    	(minus raw_unsigned_float) { -capture(:raw_unsigned_float).value }
+  	end
+
+  	rule raw_unsigned_float
+        (a:raw_unsigned_integer dot b:raw_unsigned_integer) { "#{capture(:a).value}.#{capture(:b).value}".to_f  }
+    end
+
+  	rule raw_rational
+  	    raw_unsigned_rational | raw_minus_rational
+  	end
+
+  	rule raw_minus_rational
+    	(minus raw_unsigned_rational) { -capture(:raw_unsigned_rational).value }
+  	end
+
+  	rule raw_unsigned_rational
+    	(a:raw_unsigned_integer slash b:raw_unsigned_integer) { Rational(capture(:a).value, capture(:b).value) }
+  	end
+
+  	rule raw_integer
+    	raw_unsigned_integer | raw_minus_integer
+  	end
+
+  	rule raw_minus_integer
+    	(minus raw_unsigned_integer) { -capture(:raw_unsigned_integer).value }
+  	end
+
+  	rule raw_unsigned_integer
+    	([0-9]+ ('_' [0-9]+)*) { to_str.to_i }
+  	end
+end

data/lib/musa-dsl/neumalang/neuma.citrus

@@ -0,0 +1,165 @@
+grammar Musa::Neumalang::Neumalang::Parser::Grammar::Neuma
+    include Musa::Neumalang::Neumalang::Parser::Grammar::Datatypes
+
+	rule neuma
+        neuma_between_parenthesis | appogiatura_neuma_between_parenthesis
+	end
+
+	rule appogiatura_neuma_between_parenthesis
+	    (lacute optional_separation appogiatura:neuma_between_parenthesis optional_separation racute base:neuma_between_parenthesis) <Musa::Neumalang::Neumalang::Parser::AppogiaturaNeuma>
+	end
+
+    rule neuma_between_parenthesis
+        neuma_between_parenthesis_beginning_with_grade_or_dot |
+        neuma_between_parenthesis_beginning_with_duration |
+        neuma_between_parenthesis_beginning_with_modifiers |
+        neuma_between_parenthesis_empty
+    end
+
+	rule neuma_between_parenthesis_beginning_with_grade_or_dot
+        (lpar optional_separation
+            (grade:grade_attribute | grade_dot:dot)
+                (optional_separation octave:octave_attribute)?
+                (optional_separation duration:duration_attribute)?
+                (optional_separation velocity:velocity_attribute)?
+                (optional_separation modifiers:modifier_attribute)*
+        optional_separation rpar)
+        <Musa::Neumalang::Neumalang::Parser::NeumaAsAttributes>
+	end
+
+	rule neuma_between_parenthesis_beginning_with_duration
+        (lpar optional_separation
+            (duration:duration_attribute)
+                (optional_separation velocity:velocity_attribute)?
+                (optional_separation modifiers:modifier_attribute)*
+        optional_separation rpar)
+        <Musa::Neumalang::Neumalang::Parser::NeumaAsAttributes>
+	end
+
+	rule neuma_between_parenthesis_beginning_with_modifiers
+        (lpar (optional_separation modifiers:modifier_attribute)* optional_separation rpar)
+        <Musa::Neumalang::Neumalang::Parser::NeumaAsAttributes>
+	end
+
+	rule neuma_between_parenthesis_empty
+        (lpar optional_separation rpar) <Musa::Neumalang::Neumalang::Parser::NeumaAsAttributes>
+	end
+
+    rule grade_attribute
+        delta_grade_attribute | abs_grade_attribute | delta_accidentals_attribute
+    end
+
+    rule abs_grade_attribute
+        ((grade:raw_unsigned_integer | (interval:name !lpar)) accidentals?) <Musa::Neumalang::Neumalang::Parser::AbsGradeAttribute>
+    end
+
+    rule delta_grade_attribute
+        (sign (grade:raw_unsigned_integer | interval:name) accidentals?) <Musa::Neumalang::Neumalang::Parser::DeltaGradeAttribute>
+    end
+
+    rule delta_accidentals_attribute
+        (sign? accidentals) <Musa::Neumalang::Neumalang::Parser::DeltaGradeAttribute>
+    end
+
+    rule octave_attribute
+        delta_octave_attribute | abs_octave_attribute
+    end
+
+    rule delta_octave_attribute
+        (sign 'o' number:raw_unsigned_integer) <Musa::Neumalang::Neumalang::Parser::DeltaOctaveAttribute>
+    end
+
+    rule abs_octave_attribute
+        ('o' number:raw_integer) <Musa::Neumalang::Neumalang::Parser::AbsOctaveAttribute>
+    end
+
+    rule duration_attribute
+        factor_duration_attribute | delta_duration_attribute | abs_duration_attribute
+    end
+
+    rule factor_duration_attribute
+        (factor number:raw_unsigned_number) <Musa::Neumalang::Neumalang::Parser::FactorDurationAttribute>
+    end
+
+    rule abs_duration_attribute
+        ((number:raw_unsigned_number | slashes) mid_dots?) <Musa::Neumalang::Neumalang::Parser::AbsDurationAttribute>
+    end
+
+    rule delta_duration_attribute
+        (sign ((number:raw_unsigned_number | slashes) mid_dots?)) <Musa::Neumalang::Neumalang::Parser::DeltaDurationAttribute>
+    end
+
+    rule velocity_attribute
+        (abs_velocity_attribute | delta_velocity_attribute)
+    end
+
+    rule abs_velocity_attribute
+        (dynamics) <Musa::Neumalang::Neumalang::Parser::AbsVelocityAttribute>
+    end
+
+    rule delta_velocity_attribute
+        (sign delta:delta_dynamics) <Musa::Neumalang::Neumalang::Parser::DeltaVelocityAttribute>
+    end
+
+	rule modifier_attribute
+	    (modifier_call_with_parameters | modifier_call_without_parameters)
+	end
+
+	rule modifier_call_without_parameters
+		((name &attribute_change) | (name lpar optional_separation rpar)) { { capture(:name).value.to_sym => true } }
+	end
+
+	rule modifier_call_with_parameters
+		(name lpar modifier_positional_parameters rpar) { { capture(:name).value.to_sym => capture(:modifier_positional_parameters).value } }
+	end
+
+	rule modifier_positional_parameters
+		(optional_separation a:modifier_parameter_constant (optional_separation comma optional_separation b:modifier_parameter_constant optional_separation)* optional_separation) {
+		    if capture(:b)
+			    [ capture(:a).value ] + captures(:b).collect { |c| c.value }
+            else
+                capture(:a).value
+            end
+        }
+	end
+
+    rule modifier_parameter_constant
+        raw_number | raw_symbol | raw_string
+    end
+
+    rule accidentals
+        hashes | underscores
+    end
+
+    rule hashes
+        (hsh+) { captures(:hsh).size }
+    end
+
+    rule underscores
+        (underscore+) { -captures(:underscore).size }
+    end
+
+    rule sign
+        (plus | minus) { capture(:plus) ? 1 : -1 }
+    end
+
+    rule factor
+        (asterisk | slash)
+    end
+
+    rule mid_dots
+        (mid_dot+) { captures(:mid_dot).size }
+    end
+
+    rule slashes
+        (slash+) { captures(:slash).size }
+    end
+
+    rule dynamics
+        (p:/p+/ | mp:'mp' | mf:'mf' | f:/f+/)
+    end
+
+    rule delta_dynamics
+        (/p+/ | /f+/)
+    end
+end

data/lib/musa-dsl/neumalang/neumalang.citrus

@@ -1,43 +1,49 @@
-grammar Neumalang
-
-	rule content
-		sentences
-	end
+grammar Musa::Neumalang::Neumalang::Parser::Grammar::Grammar
+    include Musa::Neumalang::Neumalang::Parser::Grammar::Terminals
+    include Musa::Neumalang::Neumalang::Parser::Grammar::Datatypes
+    include Musa::Neumalang::Neumalang::Parser::Grammar::Neuma
+    include Musa::Neumalang::Neumalang::Parser::Grammar::Vectors
+    include Musa::Neumalang::Neumalang::Parser::Grammar::Process
 
 	rule sentences
-		(spaces (sentence spaces)*) <Musa::Neumalang::Parser::Sentences>
-	end
-
-	rule sentence
-		expression
+		(optional_separation (expression optional_separation)*) <Musa::Neumalang::Neumalang::Parser::Sentences>
 	end
 
 	rule expression
-		variable_assign | call_methods_expression | object_expression | event
+		(variable_assign | call_methods_expression | object_expression | event)
 	end
 
 	rule object_expression
-		braced_command | reference_expression | bracketed_expression | use_variable | constant | neuma
+		braced_command |
+        reference_expression |
+        bracketed_expression |
+        use_variable |
+        constant |
+        neuma_between_parenthesis |
+        appogiatura_neuma_between_parenthesis |
+        process |
+        packed_vector |
+        vector
 	end
 
 	rule reference_expression
-		(ampersand spaces expression) <Musa::Neumalang::Parser::ReferenceExpression>
+		(ampersand optional_separation expression) <Musa::Neumalang::Neumalang::Parser::ReferenceExpression>
 	end
 
 	rule variable_assign
-		((use_variable spaces equal spaces)+ expression) <Musa::Neumalang::Parser::VariableAssign>
+		((use_variable optional_separation equal optional_separation)+ expression) <Musa::Neumalang::Neumalang::Parser::VariableAssign>
 	end
 
 	rule event
-		(double_colon name parameters?) <Musa::Neumalang::Parser::Event>
+		(double_colon name parameters?) <Musa::Neumalang::Neumalang::Parser::Event>
 	end
 
 	rule braced_command
-		(lbrace spaces complex_command spaces rbrace parameters?) <Musa::Neumalang::Parser::BracedCommand>
+		(lbrace optional_separation complex_command optional_separation rbrace parameters?) <Musa::Neumalang::Neumalang::Parser::BracedCommand>
 	end
 
 	rule call_methods_expression
-		(object_expression (dot method_call)+) <Musa::Neumalang::Parser::CallMethodsExpression>
+		(object_expression (dot method_call)+) <Musa::Neumalang::Neumalang::Parser::CallMethodsExpression>
 	end
 
 	rule bracketed_expression
@@ -48,247 +54,31 @@ grammar Neumalang
 		(name parameters?) { { method: capture(:name).value.to_sym }.merge(capture(:parameters) ? capture(:parameters).value : {}) }
 	end
 
-	rule neuma
-        appogiatura_neuma | simple_neuma
-	end
-
-	rule appogiatura_neuma
-	    (lpar spaces a:simple_neuma spaces rpar spaces b:simple_neuma) { capture(:b).value.tap { |_| _[:neuma] << { appogiatura: capture(:a).value[:neuma] } } }
-	end
-
-	rule simple_neuma
-		neuma_as_dotted_attributes_beginning_with_dot | neuma_as_dotted_attributes_beginning_with_simple_attribute | neuma_between_angles_attributes
-	end
-
-	rule constant
-		number | symbol | string
-	end
-
 	rule bracketed_bar_sentences
-		(lbracket spaces aa:sentences (bar spaces bb:sentences)+ rbracket) <Musa::Neumalang::Parser::BracketedBarSentences>
+		(lbracket aa:sentences (double_bar bb:sentences)+ rbracket) <Musa::Neumalang::Neumalang::Parser::BracketedBarSentences>
 	end
 
 	rule bracketed_sentences
-		(lbracket spaces sentences rbracket) <Musa::Neumalang::Parser::BracketedSentences>
+		(lbracket sentences rbracket) <Musa::Neumalang::Neumalang::Parser::BracketedSentences>
 	end
 
 	rule use_variable
-		(at name) <Musa::Neumalang::Parser::UseVariable>
+		(at name) <Musa::Neumalang::Neumalang::Parser::UseVariable>
 	end
 
 	rule parameters
-		parameters_a | parameters_b | parameters_c
-	end
-
-	rule parameters_a
-		(lpar positional_parameters comma key_parameters rpar) { { value_parameters: capture(:positional_parameters).value, key_parameters: capture(:key_parameters).value } }
+	    (lpar parameter (comma parameter)* optional_separation rpar) <Musa::Neumalang::Neumalang::Parser::Parameters>
 	end
 
-	rule parameters_b
-		(lpar key_parameters rpar) { { key_parameters: capture(:key_parameters).value } }
-	end
-
-	rule parameters_c
-		(lpar positional_parameters rpar) { { value_parameters: capture(:positional_parameters).value } }
-	end
-
-	rule positional_parameters
-		(spaces a:sentence (spaces comma spaces b:sentence spaces)* spaces) {
-			[ capture(:a).value ] + captures(:b).collect { |c| c.value }
-		}
-	end
-
-	rule key_parameters
-		(spaces a:key_value_parameter (spaces comma spaces b:key_value_parameter spaces)* spaces) {
-
-			result = capture(:a).value.clone
-
-			captures(:b).each { |c| result.merge! c.value }
-
-			result
-		}
-	end
+    rule parameter
+        (optional_separation (key_value_parameter | expression)) <Musa::Neumalang::Neumalang::Parser::Parameter>
+    end
 
 	rule key_value_parameter
-		(key:name colon spaces value:sentence) { { capture(:key).value.to_sym => capture(:value).value } }
+		(name colon optional_separation expression) { { capture(:name).value.to_sym => capture(:expression).value } }
 	end
 
 	rule complex_command
-	    (everything_except_braces? lbrace spaces complex_command spaces rbrace)* everything_except_braces?
-	end
-
-
-	rule neuma_as_dotted_attributes_beginning_with_simple_attribute
-	    (a:simple_attribute (dot b:attribute)*) <Musa::Neumalang::Parser::NeumaAsDottedAttributesBeginningWithSimpleAttribute>
-	end
-
-	rule neuma_as_dotted_attributes_beginning_with_dot
-	    ((dot attribute)+ | dot) <Musa::Neumalang::Parser::NeumaAsDottedAttributesBeginningWithDot>
-	end
-
-	rule neuma_between_angles_attributes
-		(langle spaces simple_attribute? spaces (attribute spaces)* rangle) <Musa::Neumalang::Parser::NeumaBetweenAnglesAttributes>
-	end
-
-    rule attribute
-        (modifier_attribute | simple_attribute)
-    end
-
-	rule simple_attribute
-		everything_that_can_be_an_attribute !colon
-	end
-
-	rule modifier_attribute
-	    modifier_call_without_parameters | modifier_call_with_parameters
-	end
-
-	rule modifier_call_without_parameters
-		(name &attribute_change) { { modifier: capture(:name).value.to_sym } }
-	end
-
-	rule modifier_call_with_parameters
-		(name modifier_parameters) { { modifier: capture(:name).value.to_sym }.merge(capture(:modifier_parameters) ? capture(:modifier_parameters).value : {}) }
-	end
-
-    rule modifier_parameters
-        (lpar modifier_positional_parameters rpar) { { parameters: capture(:modifier_positional_parameters).value } }
-    end
-
-	rule modifier_positional_parameters
-		(spaces a:modifier_parameter_constant (spaces comma spaces b:modifier_parameter_constant spaces)* spaces) {
-		    if capture(:b)
-			    [ capture(:a).value ] + captures(:b).collect { |c| c.value }
-            else
-                capture(:a).value
-            end
-        }
-	end
-
-    rule modifier_parameter_constant
-        raw_number | raw_symbol | raw_string
-    end
-
-	rule number
-    	float | rational | integer
-  	end
-
-	rule raw_number
-    	raw_float | raw_rational | raw_integer
-  	end
-
-  	rule symbol
-  		(colon name) <Musa::Neumalang::Parser::Symbol>
-  	end
-
-  	rule raw_symbol
-  		(name &spaces) { capture(:name).value.to_sym }
-  	end
-
-  	rule string
-  		(double_quote everything_except_double_quote double_quote) <Musa::Neumalang::Parser::String>
-  	end
-
-  	rule raw_string
-  		(double_quote everything_except_double_quote double_quote) { capture(:everything_except_double_quote).value }
-  	end
-
-  	rule float
-    	(single_quote str:(digits dot digits) spaces) <Musa::Neumalang::Parser::Float>
-  	end
-
-  	rule raw_float
-    	(str:(digits dot digits) spaces) { capture(:str).value.to_f }
-  	end
-
-  	rule integer
-    	(single_quote digits spaces) <Musa::Neumalang::Parser::Integer>
-  	end
-
-  	rule raw_integer
-    	(digits spaces) { capture(:digits).value.to_i }
-  	end
-
-  	rule rational
-    	(single_quote str:(digits slash digits) spaces) <Musa::Neumalang::Parser::Rational>
-  	end
-
-  	rule raw_rational
-    	(str: (digits slash digits) spaces) { capture(:str).value.to_r }
-  	end
-
-	rule comment
-		(lcomment complex_comment rcomment) | hash_comment
+	    (everything_except_braces? lbrace optional_separation complex_command optional_separation rbrace)* everything_except_braces?
 	end
-
-	rule hash_comment
-	    (hsh_at_start_of_line | space+) everything_until_eol
-	end
-
-	rule complex_comment
-		everything_except_comment? (lcomment complex_comment rcomment)* everything_except_comment?
-	end
-
-  	rule digits
-    	[0-9]+ ('_' [0-9]+)*
-  	end
-
-	rule name
-		/[[:alpha:]]\w*/
-	end
-
-	rule everything_that_can_be_an_attribute
-		/[^({|}|\[|\]|\(|\)|\<|\>|.|,|:|=| |\t|\n|\r|\"|@|&|\|)]+/m
-	end
-
-    rule attribute_change
-        space | dot | rbracket | rpar | rbrace | eol
-    end
-
-	rule everything_until_eol
-		~/$/
-	end
-
-	rule everything_except_comment
-		~/((\*\/)|(\/\*))/m
-	end
-
-	rule everything_except_braces
-		~/({|})/m
-	end
-
-	rule everything_except_double_quote
-		~/(\")/m
-	end
-
-	rule hsh_at_start_of_line
-	    /\A#/
-	end
-
-	rule double_quote '"' end
-	rule single_quote '\'' end
-	rule dot '.' end
-	rule comma ',' end
-	rule colon ':' end
-	rule double_colon '::' end
-	rule bar '|' end
-	rule slash '/' end
-	rule lpar '(' end
-	rule rpar ')' end
-	rule lbrace '{' end
-	rule rbrace '}' end
-	rule lbracket '[' end
-	rule rbracket ']' end
-	rule langle '<' end
-	rule rangle '>' end
-	rule at '@' end
-	rule ampersand '&' end
-	rule equal '=' end
-	rule lcomment '/*' end
-	rule rcomment '*/' end
-	rule hsh '#' end
-	rule eol /$/ end
-
-	rule space /[ \t\n\r]/m end
-	rule spaces (space | comment)* end
-
 end