Zig: support yyfn:throw configuration.

This is useful for --recursive-functions code model, as it's necessary to use
different syntax for function calls with an additional `try` keyword before the
call expression (which would be impossible to do before this change).

The test/codegen/zig/recursive_functions/basic.re test has been updated to
demonstrate the new functionality.

Author: skvadrik

bootstrap/src/default_syntax_zig.h

@@ -235,15 +235,17 @@ static constexpr const char* DEFAULT_SYNTAX_ZIG =
     "    topindent \"fn \" name \"(\"\n"
     "        [arg{0:-2}: argname \": \" argtype \", \"]\n"
     "        [arg{-1}:   argname \": \" argtype]\n"
-    "    \") \" type \" {\" nl\n"
+    "    \") \" (.yyfn.throw ? throw \"!\") type \" {\" nl\n"
     "        indent [stmt: stmt] dedent\n"
     "    \"}\" nl;\n"
     "\n"
     "code:fncall =\n"
-    "    topindent (.retval ? retval \" = \" name) \"(\" [arg{0:-2}: arg \", \"] [arg{-1}: arg] \");\" nl;\n"
+    "    topindent (.retval ? retval \" = \") (.yyfn.throw ? \"try \")\n"
+    "        name \"(\" [arg{0:-2}: arg \", \"] [arg{-1}: arg] \");\" nl;\n"
     "\n"
     "code:tailcall =\n"
-    "    topindent (.retval ? \"return \" name) \"(\" [arg{0:-2}: arg \", \"] [arg{-1}: arg] \");\" nl;\n"
+    "    topindent (.retval ? \"return \") (.yyfn.throw ? \"try \")\n"
+    "        name \"(\" [arg{0:-2}: arg \", \"] [arg{-1}: arg] \");\" nl;\n"
     "\n"
     "code:recursive_functions = [fn: fndef nl];\n"
     "\n"

include/syntax/zig

@@ -234,15 +234,17 @@ code:fndef =
     topindent "fn " name "("
         [arg{0:-2}: argname ": " argtype ", "]
         [arg{-1}:   argname ": " argtype]
-    ") " type " {" nl
+    ") " (.yyfn.throw ? throw "!") type " {" nl
         indent [stmt: stmt] dedent
     "}" nl;
 
 code:fncall =
-    topindent (.retval ? retval " = " name) "(" [arg{0:-2}: arg ", "] [arg{-1}: arg] ");" nl;
+    topindent (.retval ? retval " = ") (.yyfn.throw ? "try ")
+        name "(" [arg{0:-2}: arg ", "] [arg{-1}: arg] ");" nl;
 
 code:tailcall =
-    topindent (.retval ? "return " name) "(" [arg{0:-2}: arg ", "] [arg{-1}: arg] ");" nl;
+    topindent (.retval ? "return ") (.yyfn.throw ? "try ")
+        name "(" [arg{0:-2}: arg ", "] [arg{-1}: arg] ");" nl;
 
 code:recursive_functions = [fn: fndef nl];
 

test/codegen/zig/recursive_functions/basic.re

@@ -7,20 +7,25 @@ const State = struct {
     cur: u32,
 };
 
+const SyntaxError = error {
+    UnexpectedCharacter
+};
+
 /*!re2c
     re2c:api = custom;
-    re2c:define:YYFN = ["lex;bool", "st;*State"];
+    re2c:define:YYFN = ["lex;void", "st;*State"];
     re2c:define:YYPEEK = "st.str[st.cur]";
     re2c:define:YYSKIP = "st.cur += 1;";
     re2c:yyfill:enable = 0;
+    re2c:yyfn:throw = "SyntaxError";
 
     number = [1-9][0-9]*;
 
-    number { _ = st; return true; }
-    *      { _ = st; return false; }
+    number { _ = st; return; }
+    *      { _ = st; return SyntaxError.UnexpectedCharacter; }
 */
 
 test {
     var st = State{.str = "1234", .cur = 0};
-    try std.testing.expect(lex(&st));
+    try lex(&st);
 }

test/codegen/zig/recursive_functions/basic.zig

@@ -8,42 +8,46 @@ const State = struct {
     cur: u32,
 };
 
+const SyntaxError = error {
+    UnexpectedCharacter
+};
+
 
-fn yy0(st: *State) bool {
+fn yy0(st: *State) SyntaxError!void {
     const yych = st.str[st.cur];
     st.cur += 1;
     switch (yych) {
-        0x31...0x39 => { return yy2(st); },
-        else => { return yy1(st); },
+        0x31...0x39 => { return try yy2(st); },
+        else => { return try yy1(st); },
     }
 }
 
-fn yy1(st: *State) bool {
-    _ = st; return false;
+fn yy1(st: *State) SyntaxError!void {
+    _ = st; return SyntaxError.UnexpectedCharacter;
 }
 
-fn yy2(st: *State) bool {
+fn yy2(st: *State) SyntaxError!void {
     const yych = st.str[st.cur];
     switch (yych) {
         0x30...0x39 => {
             st.cur += 1;
-            return yy2(st);
+            return try yy2(st);
         },
-        else => { return yy3(st); },
+        else => { return try yy3(st); },
     }
 }
 
-fn yy3(st: *State) bool {
-    _ = st; return true;
+fn yy3(st: *State) SyntaxError!void {
+    _ = st; return;
 }
 
-fn lex(st: *State) bool {
-    return yy0(st);
+fn lex(st: *State) SyntaxError!void {
+    return try yy0(st);
 }
 
 
 
 test {
     var st = State{.str = "1234", .cur = 0};
-    try std.testing.expect(lex(&st));
+    try lex(&st);
 }