use correct names for quasiquotation operators

Use #{`}#, #{,}# and #{,@}# as the quasiquote, unquote and
unquote-splicing operators, respectively. Previously they were named
escaping.

* module/language/elisp/compile-tree-il.scm (unquote?): Change "\," to
  "#{,}#".
  (unquote-splicing): Change "\,@" to "#{,@}#".
  (#{compile-`}#): Rename from #{compile-\`}#.
* module/language/elisp/runtime/function-slot.scm: Import #{compile-`}#
  instead of #{compile-\`}#, and re-export as #{`}# instead of as
  #{\`}#.
* module/language/elisp/parser.scm (quotation-symbols):
* test-suite/tests/elisp-compiler.test ("Eval", "Quotation"):
* test-suite/tests/elisp-reader.test ("Parser"): Change "\`", "\,", and
  "\,@" to "#{`}#", "#{,}#" and "#{,@}#", respectively.

module/language/elisp/compile-tree-il.scm

@@ -49,7 +49,7 @@
             compile-function
             compile-defmacro
             compile-defun
-            compile-\`
+            #{compile-`}#
             compile-quote))
 
 ;;; Certain common parameters (like the bindings data structure or
@@ -101,10 +101,10 @@
 ;;; unquote/unquote-splicing/backquote form.
 
 (define (unquote? sym)
-  (and (symbol? sym) (eq? sym '\,)))
+  (and (symbol? sym) (eq? sym '#{,}#)))
 
 (define (unquote-splicing? sym)
-  (and (symbol? sym) (eq? sym '\,@)))
+  (and (symbol? sym) (eq? sym '#{,@}#)))
 
 ;;; Build a call to a primitive procedure nicely.
 
@@ -876,7 +876,7 @@
                                                              body))
                               (make-const loc name)))))))
 
-(defspecial \` (loc args)
+(defspecial #{`}# (loc args)
   (pmatch args
     ((,val)
      (process-backquote loc val))))

module/language/elisp/parser.scm

@@ -164,9 +164,9 @@
 ;;; routine in our recursive-descent parser.
 
 (define quotation-symbols '((quote . quote)
-                            (backquote . \`)
+                            (backquote . #{`}#)
-                            (unquote . \,)
+                            (unquote . #{,}#)
-                            (unquote-splicing . \,@)))
+                            (unquote-splicing . #{,@}#)))
 
 (define (get-expression lex)
   (let* ((token (lex 'get))

module/language/elisp/runtime/function-slot.scm

@@ -56,7 +56,7 @@
                  (compile-function . function)
                  (compile-defun . defun)
                  (compile-defmacro . defmacro)
-                 (compile-\` . \`)
+                 (#{compile-`}# . #{`}#)
                  (compile-quote . quote)))
   #:duplicates (last)
   ;; special operators
@@ -79,7 +79,7 @@
                function
                defun
                defmacro
-               \`
+               #{`}#
                quote)
   ;; macros
   #:re-export (lambda

test-suite/tests/elisp-compiler.test

@@ -204,7 +204,7 @@
     (progn (setq depth 10 i depth)
            (setq code '(eval 0))
            (while (not (zerop i))
-             (setq code (\` (eval (quote (1+ (\, code))))))
+             (setq code (#{`}# (eval (quote (1+ (#{,}# code))))))
              (setq i (1- i)))
            (= (eval code) depth))))
 
@@ -527,19 +527,19 @@
          (equal '(1 2 . 3) '(1 2 . 3))))
 
   (pass-if "simple backquote"
-    (and (equal (\` 42) 42)
+    (and (equal (#{`}# 42) 42)
-         (equal (\` (1 (a))) '(1 (a)))
+         (equal (#{`}# (1 (a))) '(1 (a)))
-         (equal (\` (1 . 2)) '(1 . 2))))
+         (equal (#{`}# (1 . 2)) '(1 . 2))))
   (pass-if "unquote"
     (progn (setq a 42 l '(18 12))
-           (and (equal (\` (\, a)) 42)
+           (and (equal (#{`}# (#{,}# a)) 42)
-                (equal (\` (1 a ((\, l)) . (\, a))) '(1 a ((18 12)) . 42)))))
+                (equal (#{`}# (1 a ((#{,}# l)) . (#{,}# a))) '(1 a ((18 12)) . 42)))))
   (pass-if "unquote splicing"
     (progn (setq l '(18 12) empty '())
-           (and (equal (\` (\,@ l)) '(18 12))
+           (and (equal (#{`}# (#{,@}# l)) '(18 12))
-                (equal (\` (l 2 (3 (\,@ l)) ((\,@ l)) (\,@ l)))
+                (equal (#{`}# (l 2 (3 (#{,@}# l)) ((#{,@}# l)) (#{,@}# l)))
                        '(l 2 (3 18 12) (18 12) 18 12))
-                (equal (\` (1 2 (\,@ empty) 3)) '(1 2 3))))))
+                (equal (#{`}# (1 2 (#{,@}# empty) 3)) '(1 2 3))))))
       
 
 

test-suite/tests/elisp-reader.test

@@ -163,7 +163,7 @@ test\"ab\"\\ abcd
     (and (equal? (parse-str "'(1 2 3 '4)")
                  '(quote (1 2 3 (quote 4))))
          (equal? (parse-str "`(1 2 ,3 ,@a)")
-                 '(\` (1 2 (\, 3) (\,@ a))))))
+                 '(#{`}# (1 2 (#{,}# 3) (#{,@}# a))))))
 
   (pass-if "lists"
     (equal? (parse-str "(1 2 (3) () 4 (. 5) (1 2 . (3 4)) (1 . 2) . 42)")