Merge pull request #1048 from herby/parser-clean

Parser clean

support/parser.pegjs

@@ -1,17 +1,17 @@
 start = method
 
 separator      = [ \t\v\f\u00A0\uFEFF\n\r\u2028\u2029]+
-comments       = (["][^"]*["])+
+comments       = ('"' [^"]* '"')+
 ws             = (separator / comments)*
 identifier     = first:[a-zA-Z] others:[a-zA-Z0-9]* {return first + others.join("");}
-keyword        = first:identifier last:[:] {return first + last;}
+keyword        = first:identifier last:":" {return first + last;}
 selector      = first:[a-zA-Z] others:[a-zA-Z0-9\:]* {return first + others.join("");}
 className      = first:[A-Z] others:[a-zA-Z0-9]* {return first + others.join("");}
-string         = ['] val:(("''" {return "'";} / [^'])*) ['] {
+string         = "'" val:(("''" {return "'";} / [^'])*) "'" {
                      return globals.ValueNode._new()
                             ._position_((line()).__at(column()))
                             ._source_(text())
-                            ._value_(val.join("").replace(/\"/ig, '"'));
+                            ._value_(val.join(""));
                  }
 character      = "$" char:. 
                   {
@@ -35,13 +35,13 @@ number         = n:(numberExp / hex / float / integer) {
                             ._value_(n);
                  }
 numberExp      = n:((float / integer) "e" integer) {return parseFloat(n.join(""));}
-hex            = neg:[-]? "16r" num:[0-9a-fA-F]+ {return parseInt(((neg || '') + num.join("")), 16);}
-float          = neg:[-]?digits:[0-9]+ "." dec:[0-9]+ {return parseFloat(((neg || '') + digits.join("") + "." + dec.join("")), 10);}
-integer        = neg:[-]?digits:[0-9]+ {return (parseInt((neg || '') +digits.join(""), 10));}
+hex            = neg:"-"? "16r" num:[0-9a-fA-F]+ {return parseInt(((neg || '') + num.join("")), 16);}
+float          = neg:"-"? digits:[0-9]+ "." dec:[0-9]+ {return parseFloat(((neg || '') + digits.join("") + "." + dec.join("")), 10);}
+integer        = neg:"-"? digits:[0-9]+ {return (parseInt((neg || '') + digits.join(""), 10));}
 
 literalArray   = "#(" rest:literalArrayRest {return rest;}
 bareLiteralArray   = "(" rest:literalArrayRest {return rest;}
-literalArrayRest   = ws lits:(lit:(parseTimeLiteral / bareLiteralArray / bareSymbol) ws {return lit._value();})* ws ")" {
+literalArrayRest   = lits:(ws lit:(parseTimeLiteral / bareLiteralArray / bareSymbol) {return lit._value();})* ws ")" {
                      return globals.ValueNode._new()
                             ._position_((line()).__at(column()))
                             ._source_(text())
@@ -53,7 +53,7 @@ dynamicArray   = "{" ws expressions:expressions? ws "."? "}" {
                             ._source_(text())
                             ._nodes_(expressions || []);
                  }
-dynamicDictionary = "#{" ws expressions: associations? ws "}" {
+dynamicDictionary = "#{" ws expressions:associations? ws "}" {
                         return globals.DynamicDictionaryNode._new()
                                ._position_((line()).__at(column()))
                                ._source_(text())
@@ -82,12 +82,12 @@ variable       = identifier:identifier {
 
 reference      = variable
 
-keywordPair    = key:keyword ws arg:binarySend ws {return {key:key, arg: arg};}
+keywordPair    = ws key:keyword ws arg:binarySend {return {key:key, arg:arg};}
 
 binarySelector = bin:[\\+*/=><,@%~|&-]+ {return bin.join("");}
 unarySelector  = identifier
 
-keywordPattern = pairs:(ws key:keyword ws arg:identifier {return {key:key, arg: arg};})+ {
+keywordPattern = pairs:(ws key:keyword ws arg:identifier {return {key:key, arg:arg};})+ {
                      var keywords = [];
                      var params = [];
                      var i = 0;
@@ -122,19 +122,19 @@ ret            = '^' ws expression:expression ws '.'? {
                             ._nodes_([expression]);
                  }
   
-temps          = "|" vars:(ws variable:identifier ws {return variable;})* "|" {return vars;}
+temps          = "|" vars:(ws variable:identifier {return variable;})* ws "|" {return vars;}
 
 blockParamList = params:((ws ":" ws param:identifier {return param;})+) ws "|" {return params;}
 
 subexpression  = '(' ws expression:expression ws ')' {return expression;}
 
-statements     = ret:ret [.]* {return [ret];}
-                 / exps:expressions ws [.]+ ws ret:ret [.]* {
+statements     = ret:ret "."* {return [ret];}
+                 / exps:expressions ws "."+ ws ret:ret "."* {
                        var expressions = exps;
                        expressions.push(ret);
                        return expressions;
                    }
-                 / expressions:expressions? [.]* {
+                 / expressions:expressions? "."* {
                        return expressions || [];
                    }
 
@@ -150,7 +150,7 @@ stSequence     = temps:temps? ws statements:statements? ws {
 
 jsSequence     = jsStatement
 
-block          = '[' ws params:blockParamList? ws sequence:sequence? ws ']' {
+block          = '[' params:blockParamList? ws sequence:sequence? ws ']' {
                      return globals.BlockNode._new()
                             ._position_((line()).__at(column()))
                             ._source_(text())
@@ -162,7 +162,7 @@ operand        = literal / reference / subexpression
 
 
 
-unaryMessage   = ws selector:unarySelector ![:] {
+unaryMessage   = ws selector:unarySelector !":" {
                      return globals.SendNode._new()
                             ._position_((line()).__at(column()))
                             ._source_(text())
@@ -214,7 +214,7 @@ binarySend     = receiver:unarySend tail:binaryTail? {
                  }
 
 
-keywordMessage = ws pairs:(pair:keywordPair ws {return pair;})+ {
+keywordMessage = pairs:keywordPair+ {
                      var selector = [];
                      var args = [];
                       for(var i = 0; i < pairs.length; i++) {
@@ -234,7 +234,7 @@ keywordSend    = receiver:binarySend tail:keywordMessage {
 
 message        = binaryMessage / unaryMessage / keywordMessage
 
-cascade        = ws send:(keywordSend / binarySend) messages:(ws ";" ws mess:message ws {return mess;})+ {
+cascade        = ws send:(keywordSend / binarySend) messages:(ws ";" ws mess:message {return mess;})+ {
                      var cascade = [];
                      cascade.push(send);
                      for(var i = 0; i < messages.length; i++) {
@@ -254,7 +254,7 @@ jsStatement    = "<" val:((">>" {return ">";} / [^>])*) ">" {
                  }
 
 
-method         = ws pattern:(keywordPattern / binaryPattern / unaryPattern) ws sequence:sequence? ws {
+method         = pattern:(keywordPattern / binaryPattern / unaryPattern) ws sequence:sequence? ws {
                       return globals.MethodNode._new()
                              ._position_((line()).__at(column()))
                              ._source_(text())
@@ -268,4 +268,3 @@ associationSend     = send:binarySend & { return send._selector() === "->" } { r
 
 associationList = ws "." ws expression:associationSend {return expression;}
 associations    = first:associationSend others:associationList* { return first.concat.apply(first, others); }
-