home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / languages / elisp / functions / new-backquote.el < prev    next >
Encoding:
Text File  |  1992-04-07  |  7.1 KB  |  222 lines
  1. ; Newsgroups: gnu.emacs.sources
  2. ; Path: hal.com!decwrl!uunet!world!jrs
  3. ; From: jrs@world.std.com (Rick Sladkey)
  4. ; Subject: New improved backquote.el with vectors and nesting
  5. ; Organization: The World Public Access UNIX
  6. ; Date: Thu, 26 Mar 1992 05:24:13 GMT
  7. ; 
  8. ; Here is a completely different implementation of the backquote macro
  9. ; which I think fixes some problems, handles more situations, is more
  10. ; efficient, and is more compact than the code it replaces.
  11. ; 
  12. ; Rick Sladkey
  13. ; jrs@world.std.com
  14. ; ----------
  15. ;;; -*- Mode: Emacs-Lisp -*-
  16. ;;; New backquote for GNU Emacs.
  17. ;;; Copyright (C) 1990, 1992 Rick Sladkey
  18.  
  19. ;; LCD Archive Entry:
  20. ;; new-backquote|Rick Sladkey|jrs@world.std.com|
  21. ;; New, improved version of the backquote macro.|
  22. ;; 92-03-26||~/functions/new-backquote.el.Z|
  23.  
  24. ;; This file is not part of GNU Emacs but is distributed under
  25. ;; the same conditions as GNU Emacs.
  26.  
  27. ;; GNU Emacs is free software; you can redistribute it and/or modify
  28. ;; it under the terms of the GNU General Public License as published by
  29. ;; the Free Software Foundation; either version 1, or (at your option)
  30. ;; any later version.
  31.  
  32. ;; GNU Emacs is distributed in the hope that it will be useful,
  33. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  34. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  35. ;; GNU General Public License for more details.
  36.  
  37. ;; You should have received a copy of the GNU General Public License
  38. ;; along with GNU Emacs; see the file COPYING.  If not, write to
  39. ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  40.  
  41.  
  42. ;; This is a new backquote for GNU Emacs written by
  43. ;; Rick Sladkey <jrs@world.std.com>.  It has the following
  44. ;; features compared to the version 18 backquote:
  45.  
  46. ;; Correctly handles nested backquotes.
  47. ;; Correctly handles constants after a splice.
  48. ;; Correctly handles top-level atoms and unquotes.
  49. ;; Correctly handles unquote after dot.
  50. ;; Understands vectors.
  51. ;; Minimizes gratuitous consing.
  52. ;; Faster operation with simpler semantics.
  53. ;; Generates faster run-time expressions.
  54. ;; One third fewer calories than our regular beer.
  55.  
  56. ;; This backquote will generate calls to the list* form.
  57. ;; Both a function version and a macro version are included.
  58. ;; The macro version is used by default because it is faster
  59. ;; and needs no run-time support.  It should really be a subr.
  60.  
  61.  
  62. (provide 'backquote)
  63.  
  64. ;; function and macro versions of list*
  65.  
  66. (defun list*-function (first &rest list)
  67.   "Like `list' but the last argument is the tail of the new list.
  68.  
  69. For example (list* 'a 'b 'c) => (a b . c)"
  70.   (if list
  71.       (let* ((rest list) (newlist (cons first nil)) (last newlist))
  72.     (while (cdr rest)
  73.       (setcdr last (cons (car rest) nil))
  74.       (setq last (cdr last)
  75.         rest (cdr rest)))
  76.     (setcdr last (car rest))
  77.     newlist)
  78.     first))
  79.  
  80. (defmacro list*-macro (first &rest list)
  81.   "Like `cons' but accepts more arguments.
  82.  
  83. For example (list* 'a 'b 'c) == (cons 'a (cons 'b 'c))"
  84.   (setq list (reverse (cons first list))
  85.     first (car list)
  86.     list (cdr list))
  87.   (if list
  88.       (let* ((second (car list))
  89.          (rest (cdr list))
  90.          (newlist (list 'cons second first)))
  91.     (while rest
  92.       (setq newlist (list 'cons (car rest) newlist)
  93.         rest (cdr rest)))
  94.     newlist)
  95.     first))
  96.  
  97. (fset 'list* (symbol-function 'list*-macro))
  98.  
  99. ;; A few advertised variables that control which symbols are used
  100. ;; to represent the backquote, unquote, and splice operations.
  101.  
  102. (defvar backquote-backquote-symbol '`
  103.   "*Symbol used to represent a backquote or nested backquote (e.g. `).")
  104.  
  105. (defvar backquote-unquote-symbol ',
  106.   "*Symbol used to represent an unquote (e.g. ,) inside a backquote.")
  107.  
  108. (defvar backquote-splice-symbol ',@
  109.   "*Symbol used to represent a splice (e.g. ,@) inside a backquote.")
  110.  
  111. (defmacro backquote (arg)
  112.   "Argument STRUCTURE describes a template to build.
  113.  
  114. The whole structure acts as if it were quoted except for certain
  115. places where expressions are evaluated and inserted or spliced in.
  116.  
  117. For example:
  118.  
  119. b                 => (ba bb bc)        ; assume b has this value
  120. (` (a b c))       => (a b c)        ; backquote acts like quote
  121. (` (a (, b) c))   => (a (ba bb bc) c)    ; insert the value of b
  122. (` (a (,@ b) c))  => (a ba bb bc c)    ; splice in the value of b
  123.  
  124. Vectors work just like lists.  Nested backquotes are permitted.
  125.  
  126. Variables: backquote-backquote-symbol, backquote-unquote-symbol,
  127. backquote-splice-symbol"
  128.   (cdr (bq-process arg)))
  129.  
  130. ;; GNU Emacs has no reader macros
  131.  
  132. (fset backquote-backquote-symbol (symbol-function 'backquote))
  133.  
  134. ;; bq-process returns a dotted-pair of a tag (0, 1, or 2) and
  135. ;; the backquote-processed structure.  0 => the structure is
  136. ;; constant, 1 => to be unquoted, 2 => to be spliced in.
  137. ;; The top-level backquote macro just discards the tag.
  138.  
  139. (defun bq-process (s)
  140.   (cond
  141.    ((vectorp s)
  142.     (let ((n (bq-process (append s ()))))
  143.       (if (= (car n) 0)
  144.       (cons 0 s)
  145.     (cons 1 (cond
  146.          ((eq (nth 1 n) 'list)
  147.           (cons 'vector (nthcdr 2 n)))
  148.          ((eq (nth 1 n) 'append)
  149.           (cons 'vconcat (nthcdr 2 n)))
  150.          (t
  151.           (list 'apply '(function vector) (cdr n))))))))
  152.    ((atom s)
  153.     (cons 0 (if (or (null s) (eq s t) (not (symbolp s)))
  154.         s
  155.           (list 'quote s))))
  156.    ((eq (car s) backquote-unquote-symbol)
  157.     (cons 1 (nth 1 s)))
  158.    ((eq (car s) backquote-splice-symbol)
  159.     (cons 2 (nth 1 s)))
  160.    ((eq (car s) backquote-backquote-symbol)
  161.     (bq-process (cdr (bq-process (nth 1 s)))))
  162.    (t
  163.     (let ((rest s) (item nil) (firstlist nil) (list nil) (lists nil))
  164.       (while (consp rest)
  165.     (if (eq (car rest) backquote-unquote-symbol)
  166.         (setq rest (list (list backquote-splice-symbol (nth 1 rest)))))
  167.     (setq item (bq-process (car rest)))
  168.     (cond
  169.      ((= (car item) 2)
  170.       (if (null firstlist)
  171.           (setq firstlist list
  172.             list nil))
  173.       (if list
  174.           (setq lists (cons (bq-listify list '(0 . nil)) lists)))
  175.       (setq lists (cons (cdr item) lists))
  176.       (setq list nil))
  177.      (t
  178.       (setq list (cons item list))))
  179.     (setq rest (cdr rest)))
  180.       (if (or rest list)
  181.       (setq lists (cons (bq-listify list (bq-process rest)) lists)))
  182.       (setq lists
  183.         (if (or (cdr lists)
  184.             (and (consp (car lists))
  185.              (eq (car (car lists)) backquote-splice-symbol)))
  186.         (cons 'append (nreverse lists))
  187.           (car lists)))
  188.       (if firstlist
  189.       (setq lists (bq-listify firstlist (cons 1 lists))))
  190.       (if (eq (car lists) 'quote)
  191.       (cons 0 (list 'quote s))
  192.     (cons 1 lists))))))
  193.  
  194. ;; bq-listify takes (tag . structure) pairs from bq-process
  195. ;; and decides between append, list, list*, and cons depending
  196. ;; on which tags are in the list.
  197.  
  198. (defun bq-listify (list old-tail)
  199.   (let ((heads nil) (tail (cdr old-tail)) (list-tail list) (item nil))
  200.     (if (= (car old-tail) 0)
  201.     (setq tail (eval tail)
  202.           old-tail nil))
  203.     (while (consp list-tail)
  204.       (setq item (car list-tail))
  205.       (setq list-tail (cdr list-tail))
  206.       (if (or heads old-tail (/= (car item) 0))
  207.       (setq heads (cons (cdr item) heads))
  208.     (setq tail (cons (eval (cdr item)) tail))))
  209.     (cond
  210.      (tail
  211.       (if (null old-tail)
  212.       (setq tail (list 'quote tail)))
  213.       (if heads
  214.       (let ((use-list* (or (cdr heads)
  215.                    (and (consp (car heads))
  216.                     (eq (car (car heads))
  217.                     backquote-splice-symbol)))))
  218.         (cons (if use-list* 'list* 'cons)
  219.           (append heads (list tail))))
  220.     tail))
  221.      (t (cons 'list heads)))))
  222.