New quasiquote idea: let's have two quasiquote macros sharing one

expander. One macro based on sys:qquote, sys:unquote and sys:splice,
and the other based on qquote, unquote and splice in the user package.
The read syntax puts out the sys: one.

* eval.c (expand_qquote): Takes three additional arguments: the
qquote, unquote and splice symbols to recognize.
The invalid splice diagnostic is adjusted based on which backquote
we are expanding.
(me_qquote): Look at the symbol in the first position of the form
and then expand either the internal quasiquote macro or the public one,
passing the right symbols into expand_qquote.
(eval_init): Register error-throwing stub functions
for the sys_qquote_s, sys_unquote_s and sys_splice_s symbols.
Register a macro for sys_qquote_s.

* lib.c (sys_qquote_s, sys_unquote_s, sys_splice_s): New symbol
variables.
(obj_init): Initialize new variables. Change qquote_s,
unquote_s and splice_s to user package.
(obj_print, obj_pprint): Convert only sys_qquote_s,
sys_unquote_s and sys_splice_s to the read syntax.
The quote_s, unquote_s and splice_s symbols are not
treated specially.

* lib.h (sys_qquote_s, sys_unquote_s, sys_splice_s): Declared.

* parser.y (n_expr): Use sys_qquote_s, sys_unquote_s and
sys_splice_s rather than qquote_s, unquote_s and splice_s.
(unquotes_occur): Likewise.

* txr.1: Documented.

1 files changed, 9 insertions, 7 deletions

diff --git a/parser.y b/parser.y
index b1540c90..2c48e43b 100644
--- a/parser.y
+++ b/parser.y
@@ -754,15 +754,17 @@ n_expr : SYMTOK                 { $$ = sym_helper($1, t); }
        | strlit                 { $$ = $1; }
        | quasilit               { $$ = $1; }
        | ',' n_expr             { val expr = $2;
-                                  if (consp(expr) && first(expr) == qquote_s)
+                                  if (consp(expr) && car(expr) == sys_qquote_s)
                                     expr = cons(quote_s, rest(expr));
-                                  $$ = rlcp(list(unquote_s, expr, nao), $2); }
+                                  $$ = rlcp(list(sys_unquote_s, expr, nao),
+				            $2); }
        | '\'' n_expr            { $$ = rlcp(list(choose_quote($2),
                                                  $2, nao), $2); }
        | SPLICE n_expr          { val expr = $2;
-                                  if (consp(expr) && first(expr) == qquote_s)
+                                  if (consp(expr) && car(expr) == sys_qquote_s)
                                     expr = cons(quote_s, rest(expr));
-                                  $$ = rlcp(list(splice_s, expr, nao), $2); }
+                                  $$ = rlcp(list(sys_splice_s, expr, nao),
+				            $2); }
        ;
 
 regex : '/' regexpr '/'         { $$ = cons(regex_s, $2); end_of_regex();
@@ -1112,9 +1114,9 @@ static val unquotes_occur(val quoted_form, int level)
     return nil;
   } else {
     val sym = car(quoted_form);
-    if (sym == unquote_s || sym == splice_s)
+    if (sym == unquote_s || sym == sys_splice_s)
       return (level == 0) ? t : unquotes_occur(cdr(quoted_form), level - 1);
-    if (sym == qquote_s)
+    if (sym == sys_qquote_s)
       return unquotes_occur(cdr(quoted_form), level + 1);
     return or2(unquotes_occur(sym, level),
                unquotes_occur(cdr(quoted_form), level));
@@ -1123,7 +1125,7 @@ static val unquotes_occur(val quoted_form, int level)
 
 static val choose_quote(val quoted_form)
 {
-  return unquotes_occur(quoted_form, 0) ? qquote_s : quote_s;
+  return unquotes_occur(quoted_form, 0) ? sys_qquote_s : quote_s;
 }
 
 static val expand_meta(val form, val menv)