udpate generated code

haya14busa · haya14busa · commit 8e13caf10331 · 2017-07-19T13:10:25.000Z
diff --git a/js/vimlparser.js b/js/vimlparser.js
@@ -1358,7 +1358,7 @@ VimLParser.prototype.parse_cmd_append = function() {
 }
 
 VimLParser.prototype.parse_cmd_insert = function() {
-    return this.parse_cmd_append();
+    this.parse_cmd_append();
 }
 
 VimLParser.prototype.parse_cmd_loadkeymap = function() {
@@ -1417,27 +1417,27 @@ VimLParser.prototype.parse_cmd_lua = function() {
 }
 
 VimLParser.prototype.parse_cmd_mzscheme = function() {
-    return this.parse_cmd_lua();
+    this.parse_cmd_lua();
 }
 
 VimLParser.prototype.parse_cmd_perl = function() {
-    return this.parse_cmd_lua();
+    this.parse_cmd_lua();
 }
 
 VimLParser.prototype.parse_cmd_python = function() {
-    return this.parse_cmd_lua();
+    this.parse_cmd_lua();
 }
 
 VimLParser.prototype.parse_cmd_python3 = function() {
-    return this.parse_cmd_lua();
+    this.parse_cmd_lua();
 }
 
 VimLParser.prototype.parse_cmd_ruby = function() {
-    return this.parse_cmd_lua();
+    this.parse_cmd_lua();
 }
 
 VimLParser.prototype.parse_cmd_tcl = function() {
-    return this.parse_cmd_lua();
+    this.parse_cmd_lua();
 }
 
 VimLParser.prototype.parse_cmd_finish = function() {
@@ -1449,7 +1449,7 @@ VimLParser.prototype.parse_cmd_finish = function() {
 
 // FIXME
 VimLParser.prototype.parse_cmd_usercmd = function() {
-    return this.parse_cmd_common();
+    this.parse_cmd_common();
 }
 
 VimLParser.prototype.parse_cmd_function = function() {
@@ -1458,12 +1458,14 @@ VimLParser.prototype.parse_cmd_function = function() {
     // :function
     if (this.ends_excmds(this.reader.peek())) {
         this.reader.seek_set(pos);
-        return this.parse_cmd_common();
+        this.parse_cmd_common();
+        return;
     }
     // :function /pattern
     if (this.reader.peekn(1) == "/") {
         this.reader.seek_set(pos);
-        return this.parse_cmd_common();
+        this.parse_cmd_common();
+        return;
     }
     var left = this.parse_lvalue_func();
     this.reader.skip_white();
@@ -1477,7 +1479,8 @@ VimLParser.prototype.parse_cmd_function = function() {
     // :function {name}
     if (this.reader.peekn(1) != "(") {
         this.reader.seek_set(pos);
-        return this.parse_cmd_common();
+        this.parse_cmd_common();
+        return;
     }
     // :function[!] {name}([arguments]) [range] [abort] [dict] [closure]
     var node = Node(NODE_FUNCTION);
@@ -1635,7 +1638,8 @@ VimLParser.prototype.parse_cmd_let = function() {
     // :let
     if (this.ends_excmds(this.reader.peek())) {
         this.reader.seek_set(pos);
-        return this.parse_cmd_common();
+        this.parse_cmd_common();
+        return;
     }
     var lhs = this.parse_letlhs();
     this.reader.skip_white();
@@ -1644,7 +1648,8 @@ VimLParser.prototype.parse_cmd_let = function() {
     // :let {var-name} ..
     if (this.ends_excmds(s1) || s2 != "+=" && s2 != "-=" && s2 != ".=" && s1 != "=") {
         this.reader.seek_set(pos);
-        return this.parse_cmd_common();
+        this.parse_cmd_common();
+        return;
     }
     // :let left op right
     var node = Node(NODE_LET);
@@ -3771,73 +3776,73 @@ Compiler.prototype.compile = function(node) {
         return this.compile_toplevel(node);
     }
     else if (node.type == NODE_COMMENT) {
-        return this.compile_comment(node);
+        this.compile_comment(node);
     }
     else if (node.type == NODE_EXCMD) {
-        return this.compile_excmd(node);
+        this.compile_excmd(node);
     }
     else if (node.type == NODE_FUNCTION) {
-        return this.compile_function(node);
+        this.compile_function(node);
     }
     else if (node.type == NODE_DELFUNCTION) {
-        return this.compile_delfunction(node);
+        this.compile_delfunction(node);
     }
     else if (node.type == NODE_RETURN) {
-        return this.compile_return(node);
+        this.compile_return(node);
     }
     else if (node.type == NODE_EXCALL) {
-        return this.compile_excall(node);
+        this.compile_excall(node);
     }
     else if (node.type == NODE_LET) {
-        return this.compile_let(node);
+        this.compile_let(node);
     }
     else if (node.type == NODE_UNLET) {
-        return this.compile_unlet(node);
+        this.compile_unlet(node);
     }
     else if (node.type == NODE_LOCKVAR) {
-        return this.compile_lockvar(node);
+        this.compile_lockvar(node);
     }
     else if (node.type == NODE_UNLOCKVAR) {
-        return this.compile_unlockvar(node);
+        this.compile_unlockvar(node);
     }
     else if (node.type == NODE_IF) {
-        return this.compile_if(node);
+        this.compile_if(node);
     }
     else if (node.type == NODE_WHILE) {
-        return this.compile_while(node);
+        this.compile_while(node);
     }
     else if (node.type == NODE_FOR) {
-        return this.compile_for(node);
+        this.compile_for(node);
     }
     else if (node.type == NODE_CONTINUE) {
-        return this.compile_continue(node);
+        this.compile_continue(node);
     }
     else if (node.type == NODE_BREAK) {
-        return this.compile_break(node);
+        this.compile_break(node);
     }
     else if (node.type == NODE_TRY) {
-        return this.compile_try(node);
+        this.compile_try(node);
     }
     else if (node.type == NODE_THROW) {
-        return this.compile_throw(node);
+        this.compile_throw(node);
     }
     else if (node.type == NODE_ECHO) {
-        return this.compile_echo(node);
+        this.compile_echo(node);
     }
     else if (node.type == NODE_ECHON) {
-        return this.compile_echon(node);
+        this.compile_echon(node);
     }
     else if (node.type == NODE_ECHOHL) {
-        return this.compile_echohl(node);
+        this.compile_echohl(node);
     }
     else if (node.type == NODE_ECHOMSG) {
-        return this.compile_echomsg(node);
+        this.compile_echomsg(node);
     }
     else if (node.type == NODE_ECHOERR) {
-        return this.compile_echoerr(node);
+        this.compile_echoerr(node);
     }
     else if (node.type == NODE_EXECUTE) {
-        return this.compile_execute(node);
+        this.compile_execute(node);
     }
     else if (node.type == NODE_TERNARY) {
         return this.compile_ternary(node);
@@ -4016,6 +4021,7 @@ Compiler.prototype.compile = function(node) {
     else {
         throw viml_printf("Compiler: unknown node: %s", viml_string(node));
     }
+    return NIL;
 }
 
 Compiler.prototype.compile_body = function(body) {
diff --git a/py/vimlparser.py b/py/vimlparser.py
@@ -1092,7 +1092,7 @@ def parse_cmd_append(self):
         self.add_node(node)
 
     def parse_cmd_insert(self):
-        return self.parse_cmd_append()
+        self.parse_cmd_append()
 
     def parse_cmd_loadkeymap(self):
         self.reader.setpos(self.ea.linepos)
@@ -1140,22 +1140,22 @@ def parse_cmd_lua(self):
         self.add_node(node)
 
     def parse_cmd_mzscheme(self):
-        return self.parse_cmd_lua()
+        self.parse_cmd_lua()
 
     def parse_cmd_perl(self):
-        return self.parse_cmd_lua()
+        self.parse_cmd_lua()
 
     def parse_cmd_python(self):
-        return self.parse_cmd_lua()
+        self.parse_cmd_lua()
 
     def parse_cmd_python3(self):
-        return self.parse_cmd_lua()
+        self.parse_cmd_lua()
 
     def parse_cmd_ruby(self):
-        return self.parse_cmd_lua()
+        self.parse_cmd_lua()
 
     def parse_cmd_tcl(self):
-        return self.parse_cmd_lua()
+        self.parse_cmd_lua()
 
     def parse_cmd_finish(self):
         self.parse_cmd_common()
@@ -1164,19 +1164,21 @@ def parse_cmd_finish(self):
 
 # FIXME
     def parse_cmd_usercmd(self):
-        return self.parse_cmd_common()
+        self.parse_cmd_common()
 
     def parse_cmd_function(self):
         pos = self.reader.tell()
         self.reader.skip_white()
         # :function
         if self.ends_excmds(self.reader.peek()):
             self.reader.seek_set(pos)
-            return self.parse_cmd_common()
+            self.parse_cmd_common()
+            return
         # :function /pattern
         if self.reader.peekn(1) == "/":
             self.reader.seek_set(pos)
-            return self.parse_cmd_common()
+            self.parse_cmd_common()
+            return
         left = self.parse_lvalue_func()
         self.reader.skip_white()
         if left.type == NODE_IDENTIFIER:
@@ -1187,7 +1189,8 @@ def parse_cmd_function(self):
         # :function {name}
         if self.reader.peekn(1) != "(":
             self.reader.seek_set(pos)
-            return self.parse_cmd_common()
+            self.parse_cmd_common()
+            return
         # :function[!] {name}([arguments]) [range] [abort] [dict] [closure]
         node = Node(NODE_FUNCTION)
         node.pos = self.ea.cmdpos
@@ -1312,15 +1315,17 @@ def parse_cmd_let(self):
         # :let
         if self.ends_excmds(self.reader.peek()):
             self.reader.seek_set(pos)
-            return self.parse_cmd_common()
+            self.parse_cmd_common()
+            return
         lhs = self.parse_letlhs()
         self.reader.skip_white()
         s1 = self.reader.peekn(1)
         s2 = self.reader.peekn(2)
         # :let {var-name} ..
         if self.ends_excmds(s1) or s2 != "+=" and s2 != "-=" and s2 != ".=" and s1 != "=":
             self.reader.seek_set(pos)
-            return self.parse_cmd_common()
+            self.parse_cmd_common()
+            return
         # :let left op right
         node = Node(NODE_LET)
         node.pos = self.ea.cmdpos
@@ -3005,51 +3010,51 @@ def compile(self, node):
         if node.type == NODE_TOPLEVEL:
             return self.compile_toplevel(node)
         elif node.type == NODE_COMMENT:
-            return self.compile_comment(node)
+            self.compile_comment(node)
         elif node.type == NODE_EXCMD:
-            return self.compile_excmd(node)
+            self.compile_excmd(node)
         elif node.type == NODE_FUNCTION:
-            return self.compile_function(node)
+            self.compile_function(node)
         elif node.type == NODE_DELFUNCTION:
-            return self.compile_delfunction(node)
+            self.compile_delfunction(node)
         elif node.type == NODE_RETURN:
-            return self.compile_return(node)
+            self.compile_return(node)
         elif node.type == NODE_EXCALL:
-            return self.compile_excall(node)
+            self.compile_excall(node)
         elif node.type == NODE_LET:
-            return self.compile_let(node)
+            self.compile_let(node)
         elif node.type == NODE_UNLET:
-            return self.compile_unlet(node)
+            self.compile_unlet(node)
         elif node.type == NODE_LOCKVAR:
-            return self.compile_lockvar(node)
+            self.compile_lockvar(node)
         elif node.type == NODE_UNLOCKVAR:
-            return self.compile_unlockvar(node)
+            self.compile_unlockvar(node)
         elif node.type == NODE_IF:
-            return self.compile_if(node)
+            self.compile_if(node)
         elif node.type == NODE_WHILE:
-            return self.compile_while(node)
+            self.compile_while(node)
         elif node.type == NODE_FOR:
-            return self.compile_for(node)
+            self.compile_for(node)
         elif node.type == NODE_CONTINUE:
-            return self.compile_continue(node)
+            self.compile_continue(node)
         elif node.type == NODE_BREAK:
-            return self.compile_break(node)
+            self.compile_break(node)
         elif node.type == NODE_TRY:
-            return self.compile_try(node)
+            self.compile_try(node)
         elif node.type == NODE_THROW:
-            return self.compile_throw(node)
+            self.compile_throw(node)
         elif node.type == NODE_ECHO:
-            return self.compile_echo(node)
+            self.compile_echo(node)
         elif node.type == NODE_ECHON:
-            return self.compile_echon(node)
+            self.compile_echon(node)
         elif node.type == NODE_ECHOHL:
-            return self.compile_echohl(node)
+            self.compile_echohl(node)
         elif node.type == NODE_ECHOMSG:
-            return self.compile_echomsg(node)
+            self.compile_echomsg(node)
         elif node.type == NODE_ECHOERR:
-            return self.compile_echoerr(node)
+            self.compile_echoerr(node)
         elif node.type == NODE_EXECUTE:
-            return self.compile_execute(node)
+            self.compile_execute(node)
         elif node.type == NODE_TERNARY:
             return self.compile_ternary(node)
         elif node.type == NODE_OR:
@@ -3168,6 +3173,7 @@ def compile(self, node):
             return self.compile_lambda(node)
         else:
             raise VimLParserException(viml_printf("Compiler: unknown node: %s", viml_string(node)))
+        return NIL
 
     def compile_body(self, body):
         for node in body:

Original file line number	Diff line number	Diff line change
`@@ -1358,7 +1358,7 @@ VimLParser.prototype.parse_cmd_append = function() {`
`1358`	`1358`	`}`
`1359`	`1359`
`1360`	`1360`	`VimLParser.prototype.parse_cmd_insert = function() {`
`1361`		`- return this.parse_cmd_append();`
	`1361`	`+ this.parse_cmd_append();`
`1362`	`1362`	`}`
`1363`	`1363`
`1364`	`1364`	`VimLParser.prototype.parse_cmd_loadkeymap = function() {`
`@@ -1417,27 +1417,27 @@ VimLParser.prototype.parse_cmd_lua = function() {`
`1417`	`1417`	`}`
`1418`	`1418`
`1419`	`1419`	`VimLParser.prototype.parse_cmd_mzscheme = function() {`
`1420`		`- return this.parse_cmd_lua();`
	`1420`	`+ this.parse_cmd_lua();`
`1421`	`1421`	`}`
`1422`	`1422`
`1423`	`1423`	`VimLParser.prototype.parse_cmd_perl = function() {`
`1424`		`- return this.parse_cmd_lua();`
	`1424`	`+ this.parse_cmd_lua();`
`1425`	`1425`	`}`
`1426`	`1426`
`1427`	`1427`	`VimLParser.prototype.parse_cmd_python = function() {`
`1428`		`- return this.parse_cmd_lua();`
	`1428`	`+ this.parse_cmd_lua();`
`1429`	`1429`	`}`
`1430`	`1430`
`1431`	`1431`	`VimLParser.prototype.parse_cmd_python3 = function() {`
`1432`		`- return this.parse_cmd_lua();`
	`1432`	`+ this.parse_cmd_lua();`
`1433`	`1433`	`}`
`1434`	`1434`
`1435`	`1435`	`VimLParser.prototype.parse_cmd_ruby = function() {`
`1436`		`- return this.parse_cmd_lua();`
	`1436`	`+ this.parse_cmd_lua();`
`1437`	`1437`	`}`
`1438`	`1438`
`1439`	`1439`	`VimLParser.prototype.parse_cmd_tcl = function() {`
`1440`		`- return this.parse_cmd_lua();`
	`1440`	`+ this.parse_cmd_lua();`
`1441`	`1441`	`}`
`1442`	`1442`
`1443`	`1443`	`VimLParser.prototype.parse_cmd_finish = function() {`
`@@ -1449,7 +1449,7 @@ VimLParser.prototype.parse_cmd_finish = function() {`
`1449`	`1449`
`1450`	`1450`	`// FIXME`
`1451`	`1451`	`VimLParser.prototype.parse_cmd_usercmd = function() {`
`1452`		`- return this.parse_cmd_common();`
	`1452`	`+ this.parse_cmd_common();`
`1453`	`1453`	`}`
`1454`	`1454`
`1455`	`1455`	`VimLParser.prototype.parse_cmd_function = function() {`
`@@ -1458,12 +1458,14 @@ VimLParser.prototype.parse_cmd_function = function() {`
`1458`	`1458`	`// :function`
`1459`	`1459`	`if (this.ends_excmds(this.reader.peek())) {`
`1460`	`1460`	`this.reader.seek_set(pos);`
`1461`		`- return this.parse_cmd_common();`
	`1461`	`+ this.parse_cmd_common();`
	`1462`	`+ return;`
`1462`	`1463`	`}`
`1463`	`1464`	`// :function /pattern`
`1464`	`1465`	`if (this.reader.peekn(1) == "/") {`
`1465`	`1466`	`this.reader.seek_set(pos);`
`1466`		`- return this.parse_cmd_common();`
	`1467`	`+ this.parse_cmd_common();`
	`1468`	`+ return;`
`1467`	`1469`	`}`
`1468`	`1470`	`var left = this.parse_lvalue_func();`
`1469`	`1471`	`this.reader.skip_white();`
`@@ -1477,7 +1479,8 @@ VimLParser.prototype.parse_cmd_function = function() {`
`1477`	`1479`	`// :function {name}`
`1478`	`1480`	`if (this.reader.peekn(1) != "(") {`
`1479`	`1481`	`this.reader.seek_set(pos);`
`1480`		`- return this.parse_cmd_common();`
	`1482`	`+ this.parse_cmd_common();`
	`1483`	`+ return;`
`1481`	`1484`	`}`
`1482`	`1485`	`// :function[!] {name}([arguments]) [range] [abort] [dict] [closure]`
`1483`	`1486`	`var node = Node(NODE_FUNCTION);`
`@@ -1635,7 +1638,8 @@ VimLParser.prototype.parse_cmd_let = function() {`
`1635`	`1638`	`// :let`
`1636`	`1639`	`if (this.ends_excmds(this.reader.peek())) {`
`1637`	`1640`	`this.reader.seek_set(pos);`
`1638`		`- return this.parse_cmd_common();`
	`1641`	`+ this.parse_cmd_common();`
	`1642`	`+ return;`
`1639`	`1643`	`}`
`1640`	`1644`	`var lhs = this.parse_letlhs();`
`1641`	`1645`	`this.reader.skip_white();`
`@@ -1644,7 +1648,8 @@ VimLParser.prototype.parse_cmd_let = function() {`
`1644`	`1648`	`// :let {var-name} ..`
`1645`	`1649`	`if (this.ends_excmds(s1) \|\| s2 != "+=" && s2 != "-=" && s2 != ".=" && s1 != "=") {`
`1646`	`1650`	`this.reader.seek_set(pos);`
`1647`		`- return this.parse_cmd_common();`
	`1651`	`+ this.parse_cmd_common();`
	`1652`	`+ return;`
`1648`	`1653`	`}`
`1649`	`1654`	`// :let left op right`
`1650`	`1655`	`var node = Node(NODE_LET);`
`@@ -3771,73 +3776,73 @@ Compiler.prototype.compile = function(node) {`
`3771`	`3776`	`return this.compile_toplevel(node);`
`3772`	`3777`	`}`
`3773`	`3778`	`else if (node.type == NODE_COMMENT) {`
`3774`		`- return this.compile_comment(node);`
	`3779`	`+ this.compile_comment(node);`
`3775`	`3780`	`}`
`3776`	`3781`	`else if (node.type == NODE_EXCMD) {`
`3777`		`- return this.compile_excmd(node);`
	`3782`	`+ this.compile_excmd(node);`
`3778`	`3783`	`}`
`3779`	`3784`	`else if (node.type == NODE_FUNCTION) {`
`3780`		`- return this.compile_function(node);`
	`3785`	`+ this.compile_function(node);`
`3781`	`3786`	`}`
`3782`	`3787`	`else if (node.type == NODE_DELFUNCTION) {`
`3783`		`- return this.compile_delfunction(node);`
	`3788`	`+ this.compile_delfunction(node);`
`3784`	`3789`	`}`
`3785`	`3790`	`else if (node.type == NODE_RETURN) {`
`3786`		`- return this.compile_return(node);`
	`3791`	`+ this.compile_return(node);`
`3787`	`3792`	`}`
`3788`	`3793`	`else if (node.type == NODE_EXCALL) {`
`3789`		`- return this.compile_excall(node);`
	`3794`	`+ this.compile_excall(node);`
`3790`	`3795`	`}`
`3791`	`3796`	`else if (node.type == NODE_LET) {`
`3792`		`- return this.compile_let(node);`
	`3797`	`+ this.compile_let(node);`
`3793`	`3798`	`}`
`3794`	`3799`	`else if (node.type == NODE_UNLET) {`
`3795`		`- return this.compile_unlet(node);`
	`3800`	`+ this.compile_unlet(node);`
`3796`	`3801`	`}`
`3797`	`3802`	`else if (node.type == NODE_LOCKVAR) {`
`3798`		`- return this.compile_lockvar(node);`
	`3803`	`+ this.compile_lockvar(node);`
`3799`	`3804`	`}`
`3800`	`3805`	`else if (node.type == NODE_UNLOCKVAR) {`
`3801`		`- return this.compile_unlockvar(node);`
	`3806`	`+ this.compile_unlockvar(node);`
`3802`	`3807`	`}`
`3803`	`3808`	`else if (node.type == NODE_IF) {`
`3804`		`- return this.compile_if(node);`
	`3809`	`+ this.compile_if(node);`
`3805`	`3810`	`}`
`3806`	`3811`	`else if (node.type == NODE_WHILE) {`
`3807`		`- return this.compile_while(node);`
	`3812`	`+ this.compile_while(node);`
`3808`	`3813`	`}`
`3809`	`3814`	`else if (node.type == NODE_FOR) {`
`3810`		`- return this.compile_for(node);`
	`3815`	`+ this.compile_for(node);`
`3811`	`3816`	`}`
`3812`	`3817`	`else if (node.type == NODE_CONTINUE) {`
`3813`		`- return this.compile_continue(node);`
	`3818`	`+ this.compile_continue(node);`
`3814`	`3819`	`}`
`3815`	`3820`	`else if (node.type == NODE_BREAK) {`
`3816`		`- return this.compile_break(node);`
	`3821`	`+ this.compile_break(node);`
`3817`	`3822`	`}`
`3818`	`3823`	`else if (node.type == NODE_TRY) {`
`3819`		`- return this.compile_try(node);`
	`3824`	`+ this.compile_try(node);`
`3820`	`3825`	`}`
`3821`	`3826`	`else if (node.type == NODE_THROW) {`
`3822`		`- return this.compile_throw(node);`
	`3827`	`+ this.compile_throw(node);`
`3823`	`3828`	`}`
`3824`	`3829`	`else if (node.type == NODE_ECHO) {`
`3825`		`- return this.compile_echo(node);`
	`3830`	`+ this.compile_echo(node);`
`3826`	`3831`	`}`
`3827`	`3832`	`else if (node.type == NODE_ECHON) {`
`3828`		`- return this.compile_echon(node);`
	`3833`	`+ this.compile_echon(node);`
`3829`	`3834`	`}`
`3830`	`3835`	`else if (node.type == NODE_ECHOHL) {`
`3831`		`- return this.compile_echohl(node);`
	`3836`	`+ this.compile_echohl(node);`
`3832`	`3837`	`}`
`3833`	`3838`	`else if (node.type == NODE_ECHOMSG) {`
`3834`		`- return this.compile_echomsg(node);`
	`3839`	`+ this.compile_echomsg(node);`
`3835`	`3840`	`}`
`3836`	`3841`	`else if (node.type == NODE_ECHOERR) {`
`3837`		`- return this.compile_echoerr(node);`
	`3842`	`+ this.compile_echoerr(node);`
`3838`	`3843`	`}`
`3839`	`3844`	`else if (node.type == NODE_EXECUTE) {`
`3840`		`- return this.compile_execute(node);`
	`3845`	`+ this.compile_execute(node);`
`3841`	`3846`	`}`
`3842`	`3847`	`else if (node.type == NODE_TERNARY) {`
`3843`	`3848`	`return this.compile_ternary(node);`
`@@ -4016,6 +4021,7 @@ Compiler.prototype.compile = function(node) {`
`4016`	`4021`	`else {`
`4017`	`4022`	`throw viml_printf("Compiler: unknown node: %s", viml_string(node));`
`4018`	`4023`	`}`
	`4024`	`+ return NIL;`
`4019`	`4025`	`}`
`4020`	`4026`
`4021`	`4027`	`Compiler.prototype.compile_body = function(body) {`