Merge pull request #13 from Kuniwak/curly-part-node

[WIP] NODE_CURLYNAME children should be also Nodes

Author: ynkdir

autoload/vimlparser.vim

@@ -127,6 +127,8 @@ let s:NODE_IDENTIFIER = 86
 let s:NODE_CURLYNAME = 87
 let s:NODE_ENV = 88
 let s:NODE_REG = 89
+let s:NODE_CURLYNAMEPART = 90
+let s:NODE_CURLYNAMEEXPR = 91
 
 let s:TOKEN_EOF = 1
 let s:TOKEN_EOL = 2
@@ -389,6 +391,8 @@ endfunction
 " CURLYNAME .value
 " ENV .value
 " REG .value
+" CURLYNAMEPART .value
+" CURLYNAMEEXPR .value
 function! s:Node(type)
   return {'type': a:type}
 endfunction
@@ -3257,43 +3261,62 @@ function! s:ExprParser.parse_dot(token, left)
 endfunction
 
 function! s:ExprParser.parse_identifier()
-  let id = []
   call self.reader.skip_white()
   let npos = self.reader.getpos()
+  let curly_parts = self.parse_curly_parts()
+  if len(curly_parts) == 1 && curly_parts[0].type == s:NODE_CURLYNAMEPART
+    let node = s:Node(s:NODE_IDENTIFIER)
+    let node.pos = npos
+    let node.value = curly_parts[0].value
+  else
+    let node = s:Node(s:NODE_CURLYNAME)
+    let node.pos = npos
+    let node.value = curly_parts
+  endif
+  return node
+endfunction
+
+function! s:ExprParser.parse_curly_parts()
+  let curly_parts = []
   let c = self.reader.peek()
+  let pos = self.reader.getpos()
   if c ==# '<' && self.reader.peekn(5) ==? '<SID>'
     let name = self.reader.getn(5)
-    call add(id, {'curly': 0, 'value': name})
+    let node = s:Node(s:NODE_CURLYNAMEPART)
+    let node.curly = 0 " Keep backword compatibility for the curly attribute
+    let node.pos = pos
+    let node.value = name
+    call add(curly_parts, node)
   endif
   while 1
     let c = self.reader.peek()
     if s:isnamec(c)
+      let pos = self.reader.getpos()
       let name = self.reader.read_name()
-      call add(id, {'curly': 0, 'value': name})
+      let node = s:Node(s:NODE_CURLYNAMEPART)
+      let node.curly = 0 " Keep backword compatibility for the curly attribute
+      let node.pos = pos
+      let node.value = name
+      call add(curly_parts, node)
     elseif c ==# '{'
       call self.reader.get()
-      let node = self.parse_expr1()
+      let pos = self.reader.getpos()
+      let node = s:Node(s:NODE_CURLYNAMEEXPR)
+      let node.curly = 1 " Keep backword compatibility for the curly attribute
+      let node.pos = pos
+      let node.value = self.parse_expr1()
+      call add(curly_parts, node)
       call self.reader.skip_white()
       let c = self.reader.p(0)
       if c !=# '}'
         throw s:Err(printf('unexpected token: %s', c), self.reader.getpos())
       endif
       call self.reader.seek_cur(1)
-      call add(id, {'curly': 1, 'value': node})
     else
       break
     endif
   endwhile
-  if len(id) == 1 && id[0].curly == 0
-    let node = s:Node(s:NODE_IDENTIFIER)
-    let node.pos = npos
-    let node.value = id[0].value
-  else
-    let node = s:Node(s:NODE_CURLYNAME)
-    let node.pos = npos
-    let node.value = id
-  endif
-  return node
+  return curly_parts
 endfunction
 
 let s:LvalueParser = copy(s:ExprParser)
@@ -3838,6 +3861,10 @@ function! s:Compiler.compile(node)
     return self.compile_env(a:node)
   elseif a:node.type == s:NODE_REG
     return self.compile_reg(a:node)
+  elseif a:node.type == s:NODE_CURLYNAMEPART
+    return self.compile_curlynamepart(a:node)
+  elseif a:node.type == s:NODE_CURLYNAMEEXPR
+    return self.compile_curlynameexpr(a:node)
   else
     throw printf('Compiler: unknown node: %s', string(a:node))
   endif
@@ -4274,15 +4301,7 @@ function! s:Compiler.compile_identifier(node)
 endfunction
 
 function! s:Compiler.compile_curlyname(node)
-  let name = ''
-  for x in a:node.value
-    if x.curly
-      let name .= '{' . self.compile(x.value) . '}'
-    else
-      let name .= x.value
-    endif
-  endfor
-  return name
+  return join(map(a:node.value, 'self.compile(v:val)'), '')
 endfunction
 
 function! s:Compiler.compile_env(node)
@@ -4293,6 +4312,14 @@ function! s:Compiler.compile_reg(node)
   return a:node.value
 endfunction
 
+function! s:Compiler.compile_curlynamepart(node)
+  return a:node.value
+endfunction
+
+function! s:Compiler.compile_curlynameexpr(node)
+  return '{' . self.compile(a:node.value) . '}'
+endfunction
+
 " TODO: under construction
 let s:RegexpParser = {}
 

js/vimlparser.js

@@ -302,6 +302,8 @@ var NODE_IDENTIFIER = 86;
 var NODE_CURLYNAME = 87;
 var NODE_ENV = 88;
 var NODE_REG = 89;
+var NODE_CURLYNAMEPART = 90;
+var NODE_CURLYNAMEEXPR = 91;
 var TOKEN_EOF = 1;
 var TOKEN_EOL = 2;
 var TOKEN_SPACE = 3;
@@ -561,6 +563,8 @@ function ExArg() {
 // CURLYNAME .value
 // ENV .value
 // REG .value
+// CURLYNAMEPART .value
+// CURLYNAMEEXPR .value
 function Node(type) {
     return {"type":type};
 }
@@ -3101,46 +3105,68 @@ ExprParser.prototype.parse_dot = function(token, left) {
 }
 
 ExprParser.prototype.parse_identifier = function() {
-    var id = [];
     this.reader.skip_white();
     var npos = this.reader.getpos();
+    var curly_parts = this.parse_curly_parts();
+    if (viml_len(curly_parts) == 1 && curly_parts[0].type == NODE_CURLYNAMEPART) {
+        var node = Node(NODE_IDENTIFIER);
+        node.pos = npos;
+        node.value = curly_parts[0].value;
+    }
+    else {
+        var node = Node(NODE_CURLYNAME);
+        node.pos = npos;
+        node.value = curly_parts;
+    }
+    return node;
+}
+
+ExprParser.prototype.parse_curly_parts = function() {
+    var curly_parts = [];
     var c = this.reader.peek();
+    var pos = this.reader.getpos();
     if (c == "<" && viml_equalci(this.reader.peekn(5), "<SID>")) {
         var name = this.reader.getn(5);
-        viml_add(id, {"curly":0, "value":name});
+        var node = Node(NODE_CURLYNAMEPART);
+        node.curly = 0;
+        // Keep backword compatibility for the curly attribute
+        node.pos = pos;
+        node.value = name;
+        viml_add(curly_parts, node);
     }
     while (1) {
         var c = this.reader.peek();
         if (isnamec(c)) {
+            var pos = this.reader.getpos();
             var name = this.reader.read_name();
-            viml_add(id, {"curly":0, "value":name});
+            var node = Node(NODE_CURLYNAMEPART);
+            node.curly = 0;
+            // Keep backword compatibility for the curly attribute
+            node.pos = pos;
+            node.value = name;
+            viml_add(curly_parts, node);
         }
         else if (c == "{") {
             this.reader.get();
-            var node = this.parse_expr1();
+            var pos = this.reader.getpos();
+            var node = Node(NODE_CURLYNAMEEXPR);
+            node.curly = 1;
+            // Keep backword compatibility for the curly attribute
+            node.pos = pos;
+            node.value = this.parse_expr1();
+            viml_add(curly_parts, node);
             this.reader.skip_white();
             var c = this.reader.p(0);
             if (c != "}") {
                 throw Err(viml_printf("unexpected token: %s", c), this.reader.getpos());
             }
             this.reader.seek_cur(1);
-            viml_add(id, {"curly":1, "value":node});
         }
         else {
             break;
         }
     }
-    if (viml_len(id) == 1 && id[0].curly == 0) {
-        var node = Node(NODE_IDENTIFIER);
-        node.pos = npos;
-        node.value = id[0].value;
-    }
-    else {
-        var node = Node(NODE_CURLYNAME);
-        node.pos = npos;
-        node.value = id;
-    }
-    return node;
+    return curly_parts;
 }
 
 function LvalueParser() { ExprParser.apply(this, arguments); this.__init__.apply(this, arguments); }
@@ -3772,6 +3798,12 @@ Compiler.prototype.compile = function(node) {
     else if (node.type == NODE_REG) {
         return this.compile_reg(node);
     }
+    else if (node.type == NODE_CURLYNAMEPART) {
+        return this.compile_curlynamepart(node);
+    }
+    else if (node.type == NODE_CURLYNAMEEXPR) {
+        return this.compile_curlynameexpr(node);
+    }
     else {
         throw viml_printf("Compiler: unknown node: %s", viml_string(node));
     }
@@ -4224,18 +4256,7 @@ Compiler.prototype.compile_identifier = function(node) {
 }
 
 Compiler.prototype.compile_curlyname = function(node) {
-    var name = "";
-    var __c11 = node.value;
-    for (var __i11 = 0; __i11 < __c11.length; ++__i11) {
-        var x = __c11[__i11];
-        if (x.curly) {
-            name += "{" + this.compile(x.value) + "}";
-        }
-        else {
-            name += x.value;
-        }
-    }
-    return name;
+    return viml_join(node.value.map((function(vval) { return this.compile(vval); }).bind(this)), "");
 }
 
 Compiler.prototype.compile_env = function(node) {
@@ -4246,6 +4267,14 @@ Compiler.prototype.compile_reg = function(node) {
     return node.value;
 }
 
+Compiler.prototype.compile_curlynamepart = function(node) {
+    return node.value;
+}
+
+Compiler.prototype.compile_curlynameexpr = function(node) {
+    return "{" + this.compile(node.value) + "}";
+}
+
 // TODO: under construction
 function RegexpParser() { this.__init__.apply(this, arguments); }
 RegexpParser.prototype.RE_VERY_NOMAGIC = 1;
@@ -4926,9 +4955,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 __c12 = class_names;
-            for (var __i12 = 0; __i12 < __c12.length; ++__i12) {
-                var name = __c12[__i12];
+            var __c11 = class_names;
+            for (var __i11 = 0; __i11 < __c11.length; ++__i11) {
+                var name = __c11[__i11];
                 if (r == name) {
                     return "[:" + name + ":]";
                 }
@@ -5061,9 +5090,9 @@ RegexpParser.prototype.getoctchrs = function() {
 
 RegexpParser.prototype.gethexchrs = function(n) {
     var r = "";
-    var __c13 = viml_range(n);
-    for (var __i13 = 0; __i13 < __c13.length; ++__i13) {
-        var i = __c13[__i13];
+    var __c12 = viml_range(n);
+    for (var __i12 = 0; __i12 < __c12.length; ++__i12) {
+        var i = __c12[__i12];
         var c = this.reader.peek();
         if (!isxdigit(c)) {
             break;