Handle words correctly, Implement escape_string

Author: mattn

autoload/vimlparser.vim

@@ -1506,11 +1506,6 @@ function! s:VimLParser.parse_heredoc()
       let node.op = key
     endif
   endwhile
-  if empty(words)
-    call self.reader.seek_set(pos)
-    call self.parse_cmd_common()
-    return
-  endif
   let node.rlist = words
   let lines = []
   call self.parse_trail()
@@ -1573,7 +1568,7 @@ function! s:VimLParser.parse_cmd_let()
   elseif s2 ==# '=<<'
     call self.reader.getn(len(s2))
     call self.reader.skip_white()
-    let node.op = '='
+    let node.op = s2
     let node.right = self.parse_heredoc()
     call self.add_node(node)
     return
@@ -4879,21 +4874,28 @@ function! s:Compiler.compile_curlynameexpr(node)
   return '{' . self.compile(a:node.value) . '}'
 endfunction
 
+function! s:Compiler.escape_string(str)
+  let m = {"\n": '\n', "\t": '\t', "\r": '\r'}
+  let out = '"'
+  for i in range(len(a:str))
+    let c = a:str[i]
+    if has_key(m, c)
+      let out .= m[c]
+    else
+      let out .= c
+    endif
+  endfor
+  let out .= '"'
+  return out
+endfunction
+
 function! s:Compiler.compile_lambda(node)
   let rlist = map(a:node.rlist, 'self.compile(v:val)')
   return printf('(lambda (%s) %s)', join(rlist, ' '), self.compile(a:node.left))
 endfunction
 
-function! s:escape_string(str)
-  let str = '"' . escape(a:str, '\"') . '"'
-  let str = substitute(str, "\r", '\\r', 'g')
-  let str = substitute(str, "\n", '\\n', 'g')
-  let str = substitute(str, "\t", '\\t', 'g')
-  return str
-endfunction
-
 function! s:Compiler.compile_heredoc(node)
-  return printf('(heredoc (%s) "%s" %s))', join(a:node.rlist, ' '), a:node.op, s:escape_string(a:node.str))
+  return printf('(heredoc (%s) "%s" %s))', join(a:node.rlist, ' '), a:node.op, self.escape_string(a:node.str))
 endfunction
 
 " TODO: under construction

js/vimlparser.js

@@ -1793,11 +1793,6 @@ VimLParser.prototype.parse_heredoc = function() {
             node.op = key;
         }
     }
-    if (viml_empty(words)) {
-        this.reader.seek_set(pos);
-        this.parse_cmd_common();
-        return;
-    }
     node.rlist = words;
     var lines = [];
     this.parse_trail();
@@ -1858,7 +1853,7 @@ VimLParser.prototype.parse_cmd_let = function() {
     else if (s2 == "=<<") {
         this.reader.getn(viml_len(s2));
         this.reader.skip_white();
-        node.op = "=";
+        node.op = s2;
         node.right = this.parse_heredoc();
         this.add_node(node);
         return;
@@ -4863,21 +4858,31 @@ Compiler.prototype.compile_curlynameexpr = function(node) {
     return "{" + this.compile(node.value) + "}";
 }
 
+Compiler.prototype.escape_string = function(str) {
+    var m = {"\n":"\\n", "\t":"\\t", "\r":"\\r"};
+    var out = "\"";
+    var __c13 = viml_range(viml_len(str));
+    for (var __i13 = 0; __i13 < __c13.length; ++__i13) {
+        var i = __c13[__i13];
+        var c = str[i];
+        if (viml_has_key(m, c)) {
+            out += m[c];
+        }
+        else {
+            out += c;
+        }
+    }
+    out += "\"";
+    return out;
+}
+
 Compiler.prototype.compile_lambda = function(node) {
     var rlist = node.rlist.map((function(vval) { return this.compile(vval); }).bind(this));
     return viml_printf("(lambda (%s) %s)", viml_join(rlist, " "), this.compile(node.left));
 }
 
-function escape_string(str) {
-    var str = "\"" + viml_escape(str, "\\\"") + "\"";
-    var str = viml_substitute(str, "\r", "\\\\r", "g");
-    var str = viml_substitute(str, "\n", "\\\\n", "g");
-    var str = viml_substitute(str, "\t", "\\\\t", "g");
-    return str;
-}
-
 Compiler.prototype.compile_heredoc = function(node) {
-    return viml_printf("(heredoc (%s) \"%s\" %s))", viml_join(node.rlist, " "), node.op, escape_string(node.str));
+    return viml_printf("(heredoc (%s) \"%s\" %s))", viml_join(node.rlist, " "), node.op, this.escape_string(node.str));
 }
 
 // TODO: under construction
@@ -5560,9 +5565,9 @@ RegexpParser.prototype.get_token_sq_char_class = function() {
         var r = this.reader.read_alpha();
         if (this.reader.p(0) == ":" && this.reader.p(1) == "]") {
             this.reader.seek_cur(2);
-            var __c13 = class_names;
-            for (var __i13 = 0; __i13 < __c13.length; ++__i13) {
-                var name = __c13[__i13];
+            var __c14 = class_names;
+            for (var __i14 = 0; __i14 < __c14.length; ++__i14) {
+                var name = __c14[__i14];
                 if (r == name) {
                     return "[:" + name + ":]";
                 }
@@ -5695,9 +5700,9 @@ RegexpParser.prototype.getoctchrs = function() {
 
 RegexpParser.prototype.gethexchrs = function(n) {
     var r = "";
-    var __c14 = viml_range(n);
-    for (var __i14 = 0; __i14 < __c14.length; ++__i14) {
-        var i = __c14[__i14];
+    var __c15 = viml_range(n);
+    for (var __i15 = 0; __i15 < __c15.length; ++__i15) {
+        var i = __c15[__i15];
         var c = this.reader.peek();
         if (!isxdigit(c)) {
             break;

py/vimlparser.py

@@ -1420,10 +1420,6 @@ def parse_heredoc(self):
                 viml_add(words, key)
             else:
                 node.op = key
-        if viml_empty(words):
-            self.reader.seek_set(pos)
-            self.parse_cmd_common()
-            return
         node.rlist = words
         lines = []
         self.parse_trail()
@@ -1475,7 +1471,7 @@ def parse_cmd_let(self):
         elif s2 == "=<<":
             self.reader.getn(viml_len(s2))
             self.reader.skip_white()
-            node.op = "="
+            node.op = s2
             node.right = self.parse_heredoc()
             self.add_node(node)
             return
@@ -3811,19 +3807,24 @@ def compile_curlynamepart(self, node):
     def compile_curlynameexpr(self, node):
         return "{" + self.compile(node.value) + "}"
 
+    def escape_string(self, str):
+        m = AttributeDict({"\n":"\\n", "\t":"\\t", "\r":"\\r"})
+        out = "\""
+        for i in viml_range(viml_len(str)):
+            c = str[i]
+            if viml_has_key(m, c):
+                out += m[c]
+            else:
+                out += c
+        out += "\""
+        return out
+
     def compile_lambda(self, node):
         rlist = [self.compile(vval) for vval in node.rlist]
         return viml_printf("(lambda (%s) %s)", viml_join(rlist, " "), self.compile(node.left))
 
-def escape_string(str):
-    str = "\"" + viml_escape(str, "\\\"") + "\""
-    str = viml_substitute(str, "\r", "\\\\r", "g")
-    str = viml_substitute(str, "\n", "\\\\n", "g")
-    str = viml_substitute(str, "\t", "\\\\t", "g")
-    return str
-
     def compile_heredoc(self, node):
-        return viml_printf("(heredoc (%s) \"%s\" %s))", viml_join(node.rlist, " "), node.op, escape_string(node.str))
+        return viml_printf("(heredoc (%s) \"%s\" %s))", viml_join(node.rlist, " "), node.op, self.escape_string(node.str))
 
 # TODO: under construction
 class RegexpParser:

test/test_heredoc.ok

@@ -1,2 +1,2 @@
-(let = a (heredoc () "EOS" "hello\n world\n")))
-(let = a (heredoc (trim) "EOS" "\thello\nworld\n")))
+(let =<< a (heredoc () "EOS" "hello\n world\n")))
+(let =<< a (heredoc (trim) "EOS" "\thello\nworld\n")))