comparison lisp/emacs-lisp/backquote.el @ 6224:a27c028e757a

(backquote-listify): Renamed from bq-listify. (backquote-process): Renamed from bq-process. (backquote-list*-function): Renamed from list*-function. (backquote-list*-macro): Renamed from list*-macro. (backquote-list*): Renamed from list*.

6223:de6afd5ec418

;; Minimizes gratuitous consing.
;; Faster operation with simpler semantics.
;; Generates faster run-time expressions.
;; One third fewer calories than our regular beer.

;; This backquote will generate calls to the list* form.
;; Both a function version and a macro version are included.
;; The macro version is used by default because it is faster
;; and needs no run-time support.  It should really be a subr.

;;; Code:

(provide 'backquote)

;; function and macro versions of list*

(defun list*-function (first &rest list)
  "Like `list' but the last argument is the tail of the new list.

For example (list* 'a 'b 'c) => (a b . c)"
  (if list
      (let* ((rest list) (newlist (cons first nil)) (last newlist))
	(while (cdr rest)
	  (setcdr last (cons (car rest) nil))
	  (setq last (cdr last)
		rest (cdr rest)))
	(setcdr last (car rest))
	newlist)
    first))

(defmacro list*-macro (first &rest list)
  "Like `cons' but accepts more arguments.

For example (list* 'a 'b 'c) == (cons 'a (cons 'b 'c))"
  (setq list (reverse (cons first list))
	first (car list)
	list (cdr list))
  (if list
      (let* ((second (car list))

	  (setq newlist (list 'cons (car rest) newlist)
		rest (cdr rest)))
	newlist)
    first))

(fset 'list* (symbol-function 'list*-macro))

;; A few advertised variables that control which symbols are used
;; to represent the backquote, unquote, and splice operations.

(defvar backquote-backquote-symbol '`
  "*Symbol used to represent a backquote or nested backquote (e.g. `).")

(defvar backquote-unquote-symbol ',
  "*Symbol used to represent an unquote (e.g. ,) inside a backquote.")

(defvar backquote-splice-symbol ',@
  "*Symbol used to represent a splice (e.g. ,@) inside a backquote.")

(defmacro backquote (arg)
  "Argument STRUCTURE describes a template to build.

The whole structure acts as if it were quoted except for certain

b                 => (ba bb bc)		; assume b has this value
\(` (a b c))       => (a b c)		; backquote acts like quote
\(` (a (, b) c))   => (a (ba bb bc) c)	; insert the value of b
\(` (a (,@ b) c))  => (a ba bb bc c)	; splice in the value of b

Vectors work just like lists.  Nested backquotes are permitted.

Variables: backquote-backquote-symbol, backquote-unquote-symbol,
backquote-splice-symbol"
  (cdr (bq-process arg)))

;; GNU Emacs has no reader macros

(fset backquote-backquote-symbol (symbol-function 'backquote))

;; bq-process returns a dotted-pair of a tag (0, 1, or 2) and
;; the backquote-processed structure.  0 => the structure is
;; constant, 1 => to be unquoted, 2 => to be spliced in.
;; The top-level backquote macro just discards the tag.

(defun bq-process (s)
  (cond
   ((vectorp s)
    (let ((n (bq-process (append s ()))))
      (if (= (car n) 0)
	  (cons 0 s)
	(cons 1 (cond
		 ((eq (nth 1 n) 'list)
		  (cons 'vector (nthcdr 2 n)))

   ((eq (car s) backquote-unquote-symbol)
    (cons 1 (nth 1 s)))
   ((eq (car s) backquote-splice-symbol)
    (cons 2 (nth 1 s)))
   ((eq (car s) backquote-backquote-symbol)
    (bq-process (cdr (bq-process (nth 1 s)))))
   (t
    (let ((rest s) (item nil) (firstlist nil) (list nil) (lists nil))
      (while (consp rest)
	(if (eq (car rest) backquote-unquote-symbol)
	    (setq rest (list (list backquote-splice-symbol (nth 1 rest)))))
	(setq item (bq-process (car rest)))
	(cond
	 ((= (car item) 2)
	  (if (null firstlist)
	      (setq firstlist list
		    list nil))
	  (if list
	      (setq lists (cons (bq-listify list '(0 . nil)) lists)))
	  (setq lists (cons (cdr item) lists))
	  (setq list nil))
	 (t
	  (setq list (cons item list))))
	(setq rest (cdr rest)))
      (if (or rest list)
	  (setq lists (cons (bq-listify list (bq-process rest)) lists)))
      (setq lists
	    (if (or (cdr lists)
		    (and (consp (car lists))
			 (eq (car (car lists)) backquote-splice-symbol)))
		(cons 'append (nreverse lists))
	      (car lists)))
      (if firstlist
	  (setq lists (bq-listify firstlist (cons 1 lists))))
      (if (eq (car lists) 'quote)
	  (cons 0 (list 'quote s))
	(cons 1 lists))))))

;; bq-listify takes (tag . structure) pairs from bq-process
;; and decides between append, list, list*, and cons depending
;; on which tags are in the list.

(defun bq-listify (list old-tail)
  (let ((heads nil) (tail (cdr old-tail)) (list-tail list) (item nil))
    (if (= (car old-tail) 0)
	(setq tail (eval tail)
	      old-tail nil))
    (while (consp list-tail)

      (if heads
	  (let ((use-list* (or (cdr heads)
			       (and (consp (car heads))
				    (eq (car (car heads))
					backquote-splice-symbol)))))
	    (cons (if use-list* 'list* 'cons)
		  (append heads (list tail))))
	tail))
     (t (cons 'list heads)))))

;; backquote.el ends here

6224:a27c028e757a

;; Minimizes gratuitous consing.
;; Faster operation with simpler semantics.
;; Generates faster run-time expressions.
;; One third fewer calories than our regular beer.

;; This backquote will generate calls to the backquote-list* form.
;; Both a function version and a macro version are included.
;; The macro version is used by default because it is faster
;; and needs no run-time support.  It should really be a subr.

;;; Code:

(provide 'backquote)

;; function and macro versions of backquote-list*

(defun backquote-list*-function (first &rest list)
  "Like `list' but the last argument is the tail of the new list.

For example (backquote-list* 'a 'b 'c) => (a b . c)"
  (if list
      (let* ((rest list) (newlist (cons first nil)) (last newlist))
	(while (cdr rest)
	  (setcdr last (cons (car rest) nil))
	  (setq last (cdr last)
		rest (cdr rest)))
	(setcdr last (car rest))
	newlist)
    first))

(defmacro backquote-list*-macro (first &rest list)
  "Like `list' but the last argument is the tail of the new list.

For example (backquote-list* 'a 'b 'c) => (a b . c)"
  (setq list (reverse (cons first list))
	first (car list)
	list (cdr list))
  (if list
      (let* ((second (car list))

	  (setq newlist (list 'cons (car rest) newlist)
		rest (cdr rest)))
	newlist)
    first))

(fset 'backquote-list* (symbol-function 'backquote-list*-macro))

;; A few advertised variables that control which symbols are used
;; to represent the backquote, unquote, and splice operations.

(defvar backquote-backquote-symbol '`
  "*Symbol used to represent a backquote or nested backquote (e.g. `).")

(defvar backquote-unquote-symbol ',
  "*Symbol used to represent an unquote (e.g. `,') inside a backquote.")

(defvar backquote-splice-symbol ',@
  "*Symbol used to represent a splice (e.g. `,'@) inside a backquote.")

(defmacro backquote (arg)
  "Argument STRUCTURE describes a template to build.

The whole structure acts as if it were quoted except for certain

b                 => (ba bb bc)		; assume b has this value
\(` (a b c))       => (a b c)		; backquote acts like quote
\(` (a (, b) c))   => (a (ba bb bc) c)	; insert the value of b
\(` (a (,@ b) c))  => (a ba bb bc c)	; splice in the value of b

Vectors work just like lists.  Nested backquotes are permitted."
  (cdr (backquote-process arg)))

;; GNU Emacs has no reader macros

(fset backquote-backquote-symbol (symbol-function 'backquote))

;; backquote-process returns a dotted-pair of a tag (0, 1, or 2) and
;; the backquote-processed structure.  0 => the structure is
;; constant, 1 => to be unquoted, 2 => to be spliced in.
;; The top-level backquote macro just discards the tag.

(defun backquote-process (s)
  (cond
   ((vectorp s)
    (let ((n (backquote-process (append s ()))))
      (if (= (car n) 0)
	  (cons 0 s)
	(cons 1 (cond
		 ((eq (nth 1 n) 'list)
		  (cons 'vector (nthcdr 2 n)))

   ((eq (car s) backquote-unquote-symbol)
    (cons 1 (nth 1 s)))
   ((eq (car s) backquote-splice-symbol)
    (cons 2 (nth 1 s)))
   ((eq (car s) backquote-backquote-symbol)
    (backquote-process (cdr (backquote-process (nth 1 s)))))
   (t
    (let ((rest s) (item nil) (firstlist nil) (list nil) (lists nil))
      (while (consp rest)
	(if (eq (car rest) backquote-unquote-symbol)
	    (setq rest (list (list backquote-splice-symbol (nth 1 rest)))))
	(setq item (backquote-process (car rest)))
	(cond
	 ((= (car item) 2)
	  (if (null firstlist)
	      (setq firstlist list
		    list nil))
	  (if list
	      (setq lists (cons (backquote-listify list '(0 . nil)) lists)))
	  (setq lists (cons (cdr item) lists))
	  (setq list nil))
	 (t
	  (setq list (cons item list))))
	(setq rest (cdr rest)))
      (if (or rest list)
	  (setq lists (cons (backquote-listify list (backquote-process rest))
			    lists)))
      (setq lists
	    (if (or (cdr lists)
		    (and (consp (car lists))
			 (eq (car (car lists)) backquote-splice-symbol)))
		(cons 'append (nreverse lists))
	      (car lists)))
      (if firstlist
	  (setq lists (backquote-listify firstlist (cons 1 lists))))
      (if (eq (car lists) 'quote)
	  (cons 0 (list 'quote s))
	(cons 1 lists))))))

;; backquote-listify takes (tag . structure) pairs from backquote-process
;; and decides between append, list, backquote-list*, and cons depending
;; on which tags are in the list.

(defun backquote-listify (list old-tail)
  (let ((heads nil) (tail (cdr old-tail)) (list-tail list) (item nil))
    (if (= (car old-tail) 0)
	(setq tail (eval tail)
	      old-tail nil))
    (while (consp list-tail)

      (if heads
	  (let ((use-list* (or (cdr heads)
			       (and (consp (car heads))
				    (eq (car (car heads))
					backquote-splice-symbol)))))
	    (cons (if use-list* 'backquote-list* 'cons)
		  (append heads (list tail))))
	tail))
     (t (cons 'list heads)))))

;; backquote.el ends here