more pass by references, set err_expr only when necessary

kimtg · kimtg · commit 8054db969bc2 · 2023-08-21T00:41:12.000+09:00
diff --git a/arc.cpp b/arc.cpp
@@ -7,7 +7,7 @@ namespace arc {
 	std::shared_ptr<struct env> global_env = std::make_shared<struct env>(nullptr); /* the global environment */
 	/* symbols for faster execution */
 	atom sym_t, sym_quote, sym_quasiquote, sym_unquote, sym_unquote_splicing, sym_assign, sym_fn, sym_if, sym_mac, sym_apply, sym_cons, sym_sym, sym_string, sym_num, sym__, sym_o, sym_table, sym_int, sym_char, sym_do;
-	atom cur_expr;
+	atom err_expr; /* for error reporting */
 	atom thrown;
 	std::unordered_map<std::string, std::string *> id_of_sym;
 
@@ -32,11 +32,11 @@ namespace arc {
 		return r;
 	}
 
-	atom & car(atom & a) {
+	atom & car(const atom & a) {
 		return a.as<arc::cons>().car;
 	}
 
-	atom & cdr(atom & a) {
+	atom & cdr(const atom & a) {
 		return a.as<arc::cons>().cdr;
 	}
 
@@ -68,7 +68,7 @@ namespace arc {
 		return a;
 	}
 
-	atom make_sym(std::string s)
+	atom make_sym(const std::string &s)
 	{
 		atom a;
 		a.type = T_SYM;
@@ -115,7 +115,7 @@ namespace arc {
 		return ERROR_OK;
 	}
 
-	atom make_string(const std::string x)
+	atom make_string(const std::string &x)
 	{
 		atom a;
 		a.type = T_STRING;
@@ -151,12 +151,12 @@ namespace arc {
 		return a;
 	}
 
-	void print_expr(atom a)
+	void print_expr(const atom &a)
 	{
 		std::cout << to_string(a, 1);
 	}
 
-	void pr(atom a)
+	void pr(const atom &a)
 	{
 		std::cout << to_string(a, 0);
 	}
@@ -1675,7 +1675,7 @@ A symbol can be coerced to a string.
 
 	error builtin_err(const std::vector<atom> &vargs, atom *result) {
 		if (vargs.size() == 0) return ERROR_ARGS;
-		cur_expr = nil;
+		err_expr = nil;
 		size_t i;
 		for (i = 0; i < vargs.size(); i++) {
 			std::cout << to_string(vargs[i], 0) << '\n';
@@ -1824,45 +1824,47 @@ A symbol can be coerced to a string.
 
 	/* end builtin */
 
-	std::string to_string(atom a, int write) {
+	std::string to_string(const atom &a, int write) {
 		std::string s;
 		switch (a.type) {
 		case T_NIL:
 			s = "nil";
 			break;
-		case T_CONS:
-			if (listp(a) && len(a) == 2) {
-				if (is(car(a), sym_quote)) {
-					s = "'" + to_string(car(cdr(a)), write);
+		case T_CONS: {
+			atom a2 = a;
+			if (listp(a2) && len(a2) == 2) {
+				if (is(car(a2), sym_quote)) {
+					s = "'" + to_string(car(cdr(a2)), write);
 					break;
 				}
-				else if (is(car(a), sym_quasiquote)) {
-					s = "`" + to_string(car(cdr(a)), write);
+				else if (is(car(a2), sym_quasiquote)) {
+					s = "`" + to_string(car(cdr(a2)), write);
 					break;
 				}
-				else if (is(car(a), sym_unquote)) {
-					s = "," + to_string(car(cdr(a)), write);
+				else if (is(car(a2), sym_unquote)) {
+					s = "," + to_string(car(cdr(a2)), write);
 					break;
 				}
-				else if (is(car(a), sym_unquote_splicing)) {
-					s = ",@" + to_string(car(cdr(a)), write);
+				else if (is(car(a2), sym_unquote_splicing)) {
+					s = ",@" + to_string(car(cdr(a2)), write);
 					break;
 				}
 			}
-			s = "(" + to_string(car(a), write);
-			a = cdr(a);
-			while (!no(a)) {
+			s = "(" + to_string(car(a2), write);
+			a2 = cdr(a2);
+			while (!no(a2)) {
 				if (a.type == T_CONS) {
-					s += " " + to_string(car(a), write);
-					a = cdr(a);
+					s += " " + to_string(car(a2), write);
+					a2 = cdr(a2);
 				}
 				else {
-					s += " . " + to_string(a, write);
+					s += " . " + to_string(a2, write);
 					break;
 				}
 			}
 			s += ")";
 			break;
+		}
 		case T_SYM:
 			s = *a.as<std::string *>();
 			break;
@@ -1981,7 +1983,7 @@ A symbol can be coerced to a string.
 	error macex(atom expr, atom *result) {
 		error err = ERROR_OK;
 
-		cur_expr = expr; /* for error reporting */
+		err_expr = expr;
 
 		if (expr.type != T_CONS || !listp(expr)) {
 			*result = expr;
@@ -2095,21 +2097,22 @@ A symbol can be coerced to a string.
 	{
 		error err;
 	start_eval:
-
-		cur_expr = expr; /* for error reporting */
+				
 		if (expr.type == T_SYM) {
 			err = env_get(env, expr.as<std::string *>(), result);
+			if (err) err_expr = expr;
 			return err;
 		}
 		else if (expr.type != T_CONS) {
 			*result = expr;
 			return ERROR_OK;
 		}
 		else if (!listp(expr)) {
+			err_expr = expr;
 			return ERROR_SYNTAX;
 		}
 		else {
-			atom op = car(expr);
+			const atom &op = car(expr);
 			atom args = cdr(expr);
 
 			if (op.type == T_SYM) {
@@ -2123,6 +2126,7 @@ A symbol can be coerced to a string.
 						}
 						err = eval_expr(car(args), env, result);
 						if (err) {
+							err_expr = expr;
 							return err;
 						}
 						if (!no(*result)) { /* then */
@@ -2137,6 +2141,7 @@ A symbol can be coerced to a string.
 				else if (sym_is(op, sym_assign)) {
 					atom sym;
 					if (no(args) || no(cdr(args))) {
+						err_expr = expr;
 						return ERROR_ARGS;
 					}
 
@@ -2147,14 +2152,17 @@ A symbol can be coerced to a string.
 							return err;
 						}
 						err = env_assign_eq(env, sym.as<std::string *>(), *result);
+						if (err) err_expr = expr;
 						return err;
 					}
 					else {
+						err_expr = expr;
 						return ERROR_TYPE;
 					}
 				}
 				else if (sym_is(op, sym_quote)) {
 					if (no(args) || !no(cdr(args))) {
+						err_expr = expr;
 						return ERROR_ARGS;
 					}
 
@@ -2163,9 +2171,11 @@ A symbol can be coerced to a string.
 				}
 				else if (sym_is(op, sym_fn)) {
 					if (no(args)) {
+						err_expr = expr;
 						return ERROR_ARGS;
 					}
 					err = make_closure(env, car(args), cdr(args), result);
+					if (err) err_expr = expr;
 					return err;
 				}
 				else if (sym_is(op, sym_do)) {
@@ -2179,6 +2189,7 @@ A symbol can be coerced to a string.
 						}
 						error err = eval_expr(car(args), env, result);
 						if (err) {
+							err_expr = expr;
 							return err;
 						}
 						args = cdr(args);
@@ -2189,11 +2200,13 @@ A symbol can be coerced to a string.
 					atom name, macro;
 
 					if (no(args) || no(cdr(args)) || no(cdr(cdr(args)))) {
+						err_expr = expr;
 						return ERROR_ARGS;
 					}
 
 					name = car(args);
 					if (name.type != T_SYM) {
+						err_expr = expr;
 						return ERROR_TYPE;
 					}
 
@@ -2202,9 +2215,11 @@ A symbol can be coerced to a string.
 						macro.type = T_MACRO;
 						*result = name;
 						err = env_assign(env, name.as<std::string *>(), macro);
+						if (err) err_expr = expr;
 						return err;
 					}
 					else {
+						err_expr = expr;
 						return err;
 					}
 				}
@@ -2214,6 +2229,7 @@ A symbol can be coerced to a string.
 			atom fn;
 			err = eval_expr(op, env, &fn);
 			if (err) {
+				err_expr = expr;
 				return err;
 			}
 
@@ -2224,6 +2240,7 @@ A symbol can be coerced to a string.
 				atom r;
 				err = eval_expr(car(*p), env, &r);
 				if (err) {
+					err_expr = expr;
 					return err;
 				}
 				vargs.push_back(r);
@@ -2250,6 +2267,7 @@ A symbol can be coerced to a string.
 					atom r;
 					error err = eval_expr(car(body), env, &r);
 					if (err) {
+						err_expr = expr;
 						return err;
 					}
 					body = cdr(body);
@@ -2258,6 +2276,7 @@ A symbol can be coerced to a string.
 			}
 			else {
 				err = apply(fn, vargs, result);
+				if (err) err_expr = expr;
 			}
 			return err;
 		}
@@ -2367,7 +2386,7 @@ A symbol can be coerced to a string.
 	void print_error(error e) {
 		if (e != ERROR_USER) {
 			printf("%s : ", error_string[e]);
-			print_expr(cur_expr);
+			print_expr(err_expr);
 			puts("");
 		}
 	}
diff --git a/arc.h b/arc.h
@@ -34,7 +34,7 @@
 #endif
 
 namespace arc {
-	constexpr auto VERSION = "0.26";
+	constexpr auto VERSION = "0.26.1";
 
 	enum type {
 		T_NIL,
@@ -100,7 +100,7 @@ namespace arc {
 	char *slurp(const char *path);
 	error eval_expr(atom expr, std::shared_ptr<struct env> env, atom *result);
 	error macex(atom expr, atom *result);
-	std::string to_string(atom a, int write);
+	std::string to_string(const atom &a, int write);
 	error macex_eval(atom expr, atom *result);
 	error arc_load_file(const char *path);
 	void arc_init();
@@ -109,15 +109,15 @@ namespace arc {
 #endif
 	char *readline_fp(const char *prompt, FILE *fp);
 	error read_expr(const char *input, const char **end, atom *result);
-	void print_expr(atom a);
+	void print_expr(const atom &a);
 	void print_error(error e);
 	bool is(const atom &a, const atom &b);
 	bool iso(const atom& a, const atom& b);
 	atom make_table();
 	void repl();
 	atom make_cons(const atom &car_val, const atom &cdr_val);
-	atom & car(atom & a);
-	atom & cdr(atom & a);
+	atom & car(const atom & a);
+	atom & cdr(const atom & a);
 	bool no(const atom & a);
 	bool sym_is(const atom & a, const atom & b);
 	/* end forward */

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ namespace arc {`
`7`	`7`	`std::shared_ptr<struct env> global_env = std::make_shared<struct env>(nullptr); /* the global environment */`
`8`	`8`	`/* symbols for faster execution */`
`9`	`9`	`atom sym_t, sym_quote, sym_quasiquote, sym_unquote, sym_unquote_splicing, sym_assign, sym_fn, sym_if, sym_mac, sym_apply, sym_cons, sym_sym, sym_string, sym_num, sym__, sym_o, sym_table, sym_int, sym_char, sym_do;`
`10`		`- atom cur_expr;`
	`10`	`+ atom err_expr; /* for error reporting */`
`11`	`11`	`atom thrown;`
`12`	`12`	`std::unordered_map<std::string, std::string *> id_of_sym;`
`13`	`13`
`@@ -32,11 +32,11 @@ namespace arc {`
`32`	`32`	`return r;`
`33`	`33`	`}`
`34`	`34`
`35`		`- atom & car(atom & a) {`
	`35`	`+ atom & car(const atom & a) {`
`36`	`36`	`return a.as<arc::cons>().car;`
`37`	`37`	`}`
`38`	`38`
`39`		`- atom & cdr(atom & a) {`
	`39`	`+ atom & cdr(const atom & a) {`
`40`	`40`	`return a.as<arc::cons>().cdr;`
`41`	`41`	`}`
`42`	`42`
`@@ -68,7 +68,7 @@ namespace arc {`
`68`	`68`	`return a;`
`69`	`69`	`}`
`70`	`70`
`71`		`- atom make_sym(std::string s)`
	`71`	`+ atom make_sym(const std::string &s)`
`72`	`72`	`{`
`73`	`73`	`atom a;`
`74`	`74`	`a.type = T_SYM;`
`@@ -115,7 +115,7 @@ namespace arc {`
`115`	`115`	`return ERROR_OK;`
`116`	`116`	`}`
`117`	`117`
`118`		`- atom make_string(const std::string x)`
	`118`	`+ atom make_string(const std::string &x)`
`119`	`119`	`{`
`120`	`120`	`atom a;`
`121`	`121`	`a.type = T_STRING;`
`@@ -151,12 +151,12 @@ namespace arc {`
`151`	`151`	`return a;`
`152`	`152`	`}`
`153`	`153`
`154`		`- void print_expr(atom a)`
	`154`	`+ void print_expr(const atom &a)`
`155`	`155`	`{`
`156`	`156`	`std::cout << to_string(a, 1);`
`157`	`157`	`}`
`158`	`158`
`159`		`- void pr(atom a)`
	`159`	`+ void pr(const atom &a)`
`160`	`160`	`{`
`161`	`161`	`std::cout << to_string(a, 0);`
`162`	`162`	`}`
`@@ -1675,7 +1675,7 @@ A symbol can be coerced to a string.`
`1675`	`1675`
`1676`	`1676`	`error builtin_err(const std::vector<atom> &vargs, atom *result) {`
`1677`	`1677`	`if (vargs.size() == 0) return ERROR_ARGS;`
`1678`		`- cur_expr = nil;`
	`1678`	`+ err_expr = nil;`
`1679`	`1679`	`size_t i;`
`1680`	`1680`	`for (i = 0; i < vargs.size(); i++) {`
`1681`	`1681`	`std::cout << to_string(vargs[i], 0) << '\n';`
`@@ -1824,45 +1824,47 @@ A symbol can be coerced to a string.`
`1824`	`1824`
`1825`	`1825`	`/* end builtin */`
`1826`	`1826`
`1827`		`- std::string to_string(atom a, int write) {`
	`1827`	`+ std::string to_string(const atom &a, int write) {`
`1828`	`1828`	`std::string s;`
`1829`	`1829`	`switch (a.type) {`
`1830`	`1830`	`case T_NIL:`
`1831`	`1831`	`s = "nil";`
`1832`	`1832`	`break;`
`1833`		`- case T_CONS:`
`1834`		`- if (listp(a) && len(a) == 2) {`
`1835`		`- if (is(car(a), sym_quote)) {`
`1836`		`- s = "'" + to_string(car(cdr(a)), write);`
	`1833`	`+ case T_CONS: {`
	`1834`	`+ atom a2 = a;`
	`1835`	`+ if (listp(a2) && len(a2) == 2) {`
	`1836`	`+ if (is(car(a2), sym_quote)) {`
	`1837`	`+ s = "'" + to_string(car(cdr(a2)), write);`
`1837`	`1838`	`break;`
`1838`	`1839`	`}`
`1839`		`- else if (is(car(a), sym_quasiquote)) {`
`1840`		- s = "`" + to_string(car(cdr(a)), write);
	`1840`	`+ else if (is(car(a2), sym_quasiquote)) {`
	`1841`	+ s = "`" + to_string(car(cdr(a2)), write);
`1841`	`1842`	`break;`
`1842`	`1843`	`}`
`1843`		`- else if (is(car(a), sym_unquote)) {`
`1844`		`- s = "," + to_string(car(cdr(a)), write);`
	`1844`	`+ else if (is(car(a2), sym_unquote)) {`
	`1845`	`+ s = "," + to_string(car(cdr(a2)), write);`
`1845`	`1846`	`break;`
`1846`	`1847`	`}`
`1847`		`- else if (is(car(a), sym_unquote_splicing)) {`
`1848`		`- s = ",@" + to_string(car(cdr(a)), write);`
	`1848`	`+ else if (is(car(a2), sym_unquote_splicing)) {`
	`1849`	`+ s = ",@" + to_string(car(cdr(a2)), write);`
`1849`	`1850`	`break;`
`1850`	`1851`	`}`
`1851`	`1852`	`}`
`1852`		`- s = "(" + to_string(car(a), write);`
`1853`		`- a = cdr(a);`
`1854`		`- while (!no(a)) {`
	`1853`	`+ s = "(" + to_string(car(a2), write);`
	`1854`	`+ a2 = cdr(a2);`
	`1855`	`+ while (!no(a2)) {`
`1855`	`1856`	`if (a.type == T_CONS) {`
`1856`		`- s += " " + to_string(car(a), write);`
`1857`		`- a = cdr(a);`
	`1857`	`+ s += " " + to_string(car(a2), write);`
	`1858`	`+ a2 = cdr(a2);`
`1858`	`1859`	`}`
`1859`	`1860`	`else {`
`1860`		`- s += " . " + to_string(a, write);`
	`1861`	`+ s += " . " + to_string(a2, write);`
`1861`	`1862`	`break;`
`1862`	`1863`	`}`
`1863`	`1864`	`}`
`1864`	`1865`	`s += ")";`
`1865`	`1866`	`break;`
	`1867`	`+ }`
`1866`	`1868`	`case T_SYM:`
`1867`	`1869`	`s = a.as<std::string >();`
`1868`	`1870`	`break;`
`@@ -1981,7 +1983,7 @@ A symbol can be coerced to a string.`
`1981`	`1983`	`error macex(atom expr, atom *result) {`
`1982`	`1984`	`error err = ERROR_OK;`
`1983`	`1985`
`1984`		`- cur_expr = expr; /* for error reporting */`
	`1986`	`+ err_expr = expr;`
`1985`	`1987`
`1986`	`1988`	`if (expr.type != T_CONS \|\| !listp(expr)) {`
`1987`	`1989`	`*result = expr;`
`@@ -2095,21 +2097,22 @@ A symbol can be coerced to a string.`
`2095`	`2097`	`{`
`2096`	`2098`	`error err;`
`2097`	`2099`	`start_eval:`
`2098`		`-`
`2099`		`- cur_expr = expr; /* for error reporting */`
	`2100`	`+`
`2100`	`2101`	`if (expr.type == T_SYM) {`
`2101`	`2102`	`err = env_get(env, expr.as<std::string *>(), result);`
	`2103`	`+ if (err) err_expr = expr;`
`2102`	`2104`	`return err;`
`2103`	`2105`	`}`
`2104`	`2106`	`else if (expr.type != T_CONS) {`
`2105`	`2107`	`*result = expr;`
`2106`	`2108`	`return ERROR_OK;`
`2107`	`2109`	`}`
`2108`	`2110`	`else if (!listp(expr)) {`
	`2111`	`+ err_expr = expr;`
`2109`	`2112`	`return ERROR_SYNTAX;`
`2110`	`2113`	`}`
`2111`	`2114`	`else {`
`2112`		`- atom op = car(expr);`
	`2115`	`+ const atom &op = car(expr);`
`2113`	`2116`	`atom args = cdr(expr);`
`2114`	`2117`
`2115`	`2118`	`if (op.type == T_SYM) {`
`@@ -2123,6 +2126,7 @@ A symbol can be coerced to a string.`
`2123`	`2126`	`}`
`2124`	`2127`	`err = eval_expr(car(args), env, result);`
`2125`	`2128`	`if (err) {`
	`2129`	`+ err_expr = expr;`
`2126`	`2130`	`return err;`
`2127`	`2131`	`}`
`2128`	`2132`	`if (!no(result)) { / then */`
`@@ -2137,6 +2141,7 @@ A symbol can be coerced to a string.`
`2137`	`2141`	`else if (sym_is(op, sym_assign)) {`
`2138`	`2142`	`atom sym;`
`2139`	`2143`	`if (no(args) \|\| no(cdr(args))) {`
	`2144`	`+ err_expr = expr;`
`2140`	`2145`	`return ERROR_ARGS;`
`2141`	`2146`	`}`
`2142`	`2147`
`@@ -2147,14 +2152,17 @@ A symbol can be coerced to a string.`
`2147`	`2152`	`return err;`
`2148`	`2153`	`}`
`2149`	`2154`	`err = env_assign_eq(env, sym.as<std::string >(), result);`
	`2155`	`+ if (err) err_expr = expr;`
`2150`	`2156`	`return err;`
`2151`	`2157`	`}`
`2152`	`2158`	`else {`
	`2159`	`+ err_expr = expr;`
`2153`	`2160`	`return ERROR_TYPE;`
`2154`	`2161`	`}`
`2155`	`2162`	`}`
`2156`	`2163`	`else if (sym_is(op, sym_quote)) {`
`2157`	`2164`	`if (no(args) \|\| !no(cdr(args))) {`
	`2165`	`+ err_expr = expr;`
`2158`	`2166`	`return ERROR_ARGS;`
`2159`	`2167`	`}`
`2160`	`2168`
`@@ -2163,9 +2171,11 @@ A symbol can be coerced to a string.`
`2163`	`2171`	`}`
`2164`	`2172`	`else if (sym_is(op, sym_fn)) {`
`2165`	`2173`	`if (no(args)) {`
	`2174`	`+ err_expr = expr;`
`2166`	`2175`	`return ERROR_ARGS;`
`2167`	`2176`	`}`
`2168`	`2177`	`err = make_closure(env, car(args), cdr(args), result);`
	`2178`	`+ if (err) err_expr = expr;`
`2169`	`2179`	`return err;`
`2170`	`2180`	`}`
`2171`	`2181`	`else if (sym_is(op, sym_do)) {`
`@@ -2179,6 +2189,7 @@ A symbol can be coerced to a string.`
`2179`	`2189`	`}`
`2180`	`2190`	`error err = eval_expr(car(args), env, result);`
`2181`	`2191`	`if (err) {`
	`2192`	`+ err_expr = expr;`
`2182`	`2193`	`return err;`
`2183`	`2194`	`}`
`2184`	`2195`	`args = cdr(args);`
`@@ -2189,11 +2200,13 @@ A symbol can be coerced to a string.`
`2189`	`2200`	`atom name, macro;`
`2190`	`2201`
`2191`	`2202`	`if (no(args) \|\| no(cdr(args)) \|\| no(cdr(cdr(args)))) {`
	`2203`	`+ err_expr = expr;`
`2192`	`2204`	`return ERROR_ARGS;`
`2193`	`2205`	`}`
`2194`	`2206`
`2195`	`2207`	`name = car(args);`
`2196`	`2208`	`if (name.type != T_SYM) {`
	`2209`	`+ err_expr = expr;`
`2197`	`2210`	`return ERROR_TYPE;`
`2198`	`2211`	`}`
`2199`	`2212`
`@@ -2202,9 +2215,11 @@ A symbol can be coerced to a string.`
`2202`	`2215`	`macro.type = T_MACRO;`
`2203`	`2216`	`*result = name;`
`2204`	`2217`	`err = env_assign(env, name.as<std::string *>(), macro);`
	`2218`	`+ if (err) err_expr = expr;`
`2205`	`2219`	`return err;`
`2206`	`2220`	`}`
`2207`	`2221`	`else {`
	`2222`	`+ err_expr = expr;`
`2208`	`2223`	`return err;`
`2209`	`2224`	`}`
`2210`	`2225`	`}`
`@@ -2214,6 +2229,7 @@ A symbol can be coerced to a string.`
`2214`	`2229`	`atom fn;`
`2215`	`2230`	`err = eval_expr(op, env, &fn);`
`2216`	`2231`	`if (err) {`
	`2232`	`+ err_expr = expr;`
`2217`	`2233`	`return err;`
`2218`	`2234`	`}`
`2219`	`2235`
`@@ -2224,6 +2240,7 @@ A symbol can be coerced to a string.`
`2224`	`2240`	`atom r;`
`2225`	`2241`	`err = eval_expr(car(*p), env, &r);`
`2226`	`2242`	`if (err) {`
	`2243`	`+ err_expr = expr;`
`2227`	`2244`	`return err;`
`2228`	`2245`	`}`
`2229`	`2246`	`vargs.push_back(r);`
`@@ -2250,6 +2267,7 @@ A symbol can be coerced to a string.`
`2250`	`2267`	`atom r;`
`2251`	`2268`	`error err = eval_expr(car(body), env, &r);`
`2252`	`2269`	`if (err) {`
	`2270`	`+ err_expr = expr;`
`2253`	`2271`	`return err;`
`2254`	`2272`	`}`
`2255`	`2273`	`body = cdr(body);`
`@@ -2258,6 +2276,7 @@ A symbol can be coerced to a string.`
`2258`	`2276`	`}`
`2259`	`2277`	`else {`
`2260`	`2278`	`err = apply(fn, vargs, result);`
	`2279`	`+ if (err) err_expr = expr;`
`2261`	`2280`	`}`
`2262`	`2281`	`return err;`
`2263`	`2282`	`}`
`@@ -2367,7 +2386,7 @@ A symbol can be coerced to a string.`
`2367`	`2386`	`void print_error(error e) {`
`2368`	`2387`	`if (e != ERROR_USER) {`
`2369`	`2388`	`printf("%s : ", error_string[e]);`
`2370`		`- print_expr(cur_expr);`
	`2389`	`+ print_expr(err_expr);`
`2371`	`2390`	`puts("");`
`2372`	`2391`	`}`
`2373`	`2392`	`}`