git.chise.org Git - chise/xemacs-chise.git.1/blob - lisp/cl-macs.el

   1 ;;; cl-macs.el --- Common Lisp extensions for GNU Emacs Lisp (part four)
   2
   3 ;; Copyright (C) 1993 Free Software Foundation, Inc.
   4
   5 ;; Author: Dave Gillespie <daveg@synaptics.com>
   6 ;; Version: 2.02
   7 ;; Keywords: extensions
   8
   9 ;; This file is part of XEmacs.
  10
  11 ;; XEmacs is free software; you can redistribute it and/or modify it
  12 ;; under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation; either version 2, or (at your option)
  14 ;; any later version.
  15
  16 ;; XEmacs is distributed in the hope that it will be useful, but
  17 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19 ;; General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with XEmacs; see the file COPYING.  If not, write to the Free
  23 ;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  24 ;; 02111-1307, USA.
  25
  26 ;;; Synched up with: FSF 19.34.
  27
  28 ;;; Commentary:
  29
  30 ;; These are extensions to Emacs Lisp that provide a degree of
  31 ;; Common Lisp compatibility, beyond what is already built-in
  32 ;; in Emacs Lisp.
  33 ;;
  34 ;; This package was written by Dave Gillespie; it is a complete
  35 ;; rewrite of Cesar Quiroz's original cl.el package of December 1986.
  36 ;;
  37 ;; This package works with Emacs 18, Emacs 19, and Lucid Emacs 19.
  38 ;;
  39 ;; Bug reports, comments, and suggestions are welcome!
  40
  41 ;; This file contains the portions of the Common Lisp extensions
  42 ;; package which should be autoloaded, but need only be present
  43 ;; if the compiler or interpreter is used---this file is not
  44 ;; necessary for executing compiled code.
  45
  46 ;; See cl.el for Change Log.
  47
  48
  49 ;;; Code:
  50
  51 (or (memq 'cl-19 features)
  52     (error "Tried to load `cl-macs' before `cl'!"))
  53
  54
  55 ;;; We define these here so that this file can compile without having
  56 ;;; loaded the cl.el file already.
  57
  58 (defmacro cl-push (x place) (list 'setq place (list 'cons x place)))
  59 (defmacro cl-pop (place)
  60   (list 'car (list 'prog1 place (list 'setq place (list 'cdr place)))))
  61 (defmacro cl-pop2 (place)
  62   (list 'prog1 (list 'car (list 'cdr place))
  63         (list 'setq place (list 'cdr (list 'cdr place)))))
  64 (put 'cl-push 'edebug-form-spec 'edebug-sexps)
  65 (put 'cl-pop 'edebug-form-spec 'edebug-sexps)
  66 (put 'cl-pop2 'edebug-form-spec 'edebug-sexps)
  67
  68 (defvar cl-emacs-type)
  69 (defvar cl-optimize-safety)
  70 (defvar cl-optimize-speed)
  71
  72
  73 ;;; This kludge allows macros which use cl-transform-function-property
  74 ;;; to be called at compile-time.
  75
  76 (require
  77  (progn
  78    (or (fboundp 'defalias) (fset 'defalias 'fset))
  79    (or (fboundp 'cl-transform-function-property)
  80        (defalias 'cl-transform-function-property
  81          #'(lambda (n p f)
  82              (list 'put (list 'quote n) (list 'quote p)
  83                    (list 'function (cons 'lambda f))))))
  84    'xemacs))
  85
  86
  87 ;;; Initialization.
  88
  89 (defvar cl-old-bc-file-form nil)
  90
  91 ;; Patch broken Emacs 18 compiler (re top-level macros).
  92 ;; Emacs 19 compiler doesn't need this patch.
  93 ;; Also, undo broken definition of `eql' that uses same bytecode as `eq'.
  94
  95 ;;;###autoload
  96 (defun cl-compile-time-init ()
  97   (setq cl-old-bc-file-form (symbol-function 'byte-compile-file-form))
  98   (or (fboundp 'byte-compile-flush-pending)   ; Emacs 19 compiler?
  99       (defalias 'byte-compile-file-form
 100         #'(lambda (form)
 101             (setq form (macroexpand form byte-compile-macro-environment))
 102             (if (eq (car-safe form) 'progn)
 103                 (cons 'progn (mapcar 'byte-compile-file-form (cdr form)))
 104               (funcall cl-old-bc-file-form form)))))
 105   (put 'eql 'byte-compile 'cl-byte-compile-compiler-macro)
 106   (run-hooks 'cl-hack-bytecomp-hook))
 107
 108
 109 ;;; Program structure.
 110
 111 ;;;###autoload
 112 (defmacro defun* (name args &rest body)
 113   "(defun* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function.
 114 Like normal `defun', except ARGLIST allows full Common Lisp conventions,
 115 and BODY is implicitly surrounded by (block NAME ...)."
 116   (let* ((res (cl-transform-lambda (cons args body) name))
 117          (form (list* 'defun name (cdr res))))
 118     (if (car res) (list 'progn (car res) form) form)))
 119
 120 ;;;###autoload
 121 (defmacro defmacro* (name args &rest body)
 122   "(defmacro* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a macro.
 123 Like normal `defmacro', except ARGLIST allows full Common Lisp conventions,
 124 and BODY is implicitly surrounded by (block NAME ...)."
 125   (let* ((res (cl-transform-lambda (cons args body) name))
 126          (form (list* 'defmacro name (cdr res))))
 127     (if (car res) (list 'progn (car res) form) form)))
 128
 129 ;;;###autoload
 130 (defmacro function* (func)
 131   "(function* SYMBOL-OR-LAMBDA): introduce a function.
 132 Like normal `function', except that if argument is a lambda form, its
 133 ARGLIST allows full Common Lisp conventions."
 134   (if (eq (car-safe func) 'lambda)
 135       (let* ((res (cl-transform-lambda (cdr func) 'cl-none))
 136              (form (list 'function (cons 'lambda (cdr res)))))
 137         (if (car res) (list 'progn (car res) form) form))
 138     (list 'function func)))
 139
 140 (defun cl-transform-function-property (func prop form)
 141   (let ((res (cl-transform-lambda form func)))
 142     (append '(progn) (cdr (cdr (car res)))
 143             (list (list 'put (list 'quote func) (list 'quote prop)
 144                         (list 'function (cons 'lambda (cdr res))))))))
 145
 146 (defconst lambda-list-keywords
 147   '(&optional &rest &key &allow-other-keys &aux &whole &body &environment))
 148
 149 (defvar cl-macro-environment nil)
 150 (defvar bind-block) (defvar bind-defs) (defvar bind-enquote)
 151 (defvar bind-inits) (defvar bind-lets) (defvar bind-forms)
 152
 153 ;; npak@ispras.ru
 154 (defun cl-upcase-arg (arg)
 155   ;; Changes all non-keyword sysmbols in `arg' to symbols
 156   ;; with name in upper case.
 157   ;; arg is either symbol or list of symbols or lists
 158   (cond ((symbolp arg)
 159          (if (memq arg lambda-list-keywords)
 160              ;; Do not upcase &optional, &key etc.
 161              arg
 162            (intern (upcase (symbol-name arg)))))
 163         ((listp arg)
 164          (mapcar 'cl-upcase-arg arg))))
 165
 166 ;; npak@ispras.ru
 167 (defun cl-function-arglist (function agrlist)
 168   "Returns string with printed representation of arguments list.
 169 Supports Common Lisp lambda lists."
 170   (prin1-to-string
 171    (cons function (cl-upcase-arg agrlist))))
 172
 173 (defun cl-transform-lambda (form bind-block)
 174   (let* ((args (car form)) (body (cdr form))
 175          (bind-defs nil) (bind-enquote nil)
 176          (bind-inits nil) (bind-lets nil) (bind-forms nil)
 177          (header nil) (simple-args nil)
 178          (doc ""))
 179     ;; Add CL lambda list to documentation. npak@ispras.ru
 180     (if (stringp (car body))
 181         (setq doc (cl-pop body)))
 182     (cl-push (concat "\nCommon Lisp lambda list:\n"
 183                      "  " (cl-function-arglist bind-block args)
 184                      "\n\n"
 185                      doc)
 186              header)
 187
 188     (while (or (stringp (car body)) (eq (car-safe (car body)) 'interactive))
 189       (cl-push (cl-pop body) header))
 190     (setq args (if (listp args) (copy-list args) (list '&rest args)))
 191     (let ((p (last args))) (if (cdr p) (setcdr p (list '&rest (cdr p)))))
 192     (if (setq bind-defs (cadr (memq '&cl-defs args)))
 193         (setq args (delq '&cl-defs (delq bind-defs args))
 194               bind-defs (cadr bind-defs)))
 195     (if (setq bind-enquote (memq '&cl-quote args))
 196         (setq args (delq '&cl-quote args)))
 197     (if (memq '&whole args) (error "&whole not currently implemented"))
 198     (let* ((p (memq '&environment args)) (v (cadr p)))
 199       (if p (setq args (nconc (delq (car p) (delq v args))
 200                               (list '&aux (list v 'cl-macro-environment))))))
 201     (while (and args (symbolp (car args))
 202                 (not (memq (car args) '(nil &rest &body &key &aux)))
 203                 (not (and (eq (car args) '&optional)
 204                           (or bind-defs (consp (cadr args))))))
 205       (cl-push (cl-pop args) simple-args))
 206     (or (eq bind-block 'cl-none)
 207         (setq body (list (list* 'block bind-block body))))
 208     (if (null args)
 209         (list* nil (nreverse simple-args) (nconc (nreverse header) body))
 210       (if (memq '&optional simple-args) (cl-push '&optional args))
 211       (cl-do-arglist args nil (- (length simple-args)
 212                                  (if (memq '&optional simple-args) 1 0)))
 213       (setq bind-lets (nreverse bind-lets))
 214       (list* (and bind-inits (list* 'eval-when '(compile load eval)
 215                                     (nreverse bind-inits)))
 216              (nconc (nreverse simple-args)
 217                     (list '&rest (car (cl-pop bind-lets))))
 218              (nconc (nreverse header)
 219                     (list (nconc (list 'let* bind-lets)
 220                                  (nreverse bind-forms) body)))))))
 221
 222 (defun cl-do-arglist (args expr &optional num)   ; uses bind-*
 223   (if (nlistp args)
 224       (if (or (memq args lambda-list-keywords) (not (symbolp args)))
 225           (error "Invalid argument name: %s" args)
 226         (cl-push (list args expr) bind-lets))
 227     (setq args (copy-list args))
 228     (let ((p (last args))) (if (cdr p) (setcdr p (list '&rest (cdr p)))))
 229     (let ((p (memq '&body args))) (if p (setcar p '&rest)))
 230     (if (memq '&environment args) (error "&environment used incorrectly"))
 231     (let ((save-args args)
 232           (restarg (memq '&rest args))
 233           (safety (if (cl-compiling-file) cl-optimize-safety 3))
 234           (keys nil)
 235           (laterarg nil) (exactarg nil) minarg)
 236       (or num (setq num 0))
 237       (if (listp (cadr restarg))
 238           (setq restarg (gensym "--rest--"))
 239         (setq restarg (cadr restarg)))
 240       (cl-push (list restarg expr) bind-lets)
 241       (if (eq (car args) '&whole)
 242           (cl-push (list (cl-pop2 args) restarg) bind-lets))
 243       (let ((p args))
 244         (setq minarg restarg)
 245         (while (and p (not (memq (car p) lambda-list-keywords)))
 246           (or (eq p args) (setq minarg (list 'cdr minarg)))
 247           (setq p (cdr p)))
 248         (if (memq (car p) '(nil &aux))
 249             (setq minarg (list '= (list 'length restarg)
 250                                (length (ldiff args p)))
 251                   exactarg (not (eq args p)))))
 252       (while (and args (not (memq (car args) lambda-list-keywords)))
 253         (let ((poparg (list (if (or (cdr args) (not exactarg)) 'pop 'car)
 254                             restarg)))
 255           (cl-do-arglist
 256            (cl-pop args)
 257            (if (or laterarg (= safety 0)) poparg
 258              (list 'if minarg poparg
 259                    (list 'signal '(quote wrong-number-of-arguments)
 260                          (list 'list (and (not (eq bind-block 'cl-none))
 261                                           (list 'quote bind-block))
 262                                (list 'length restarg)))))))
 263         (setq num (1+ num) laterarg t))
 264       (while (and (eq (car args) '&optional) (cl-pop args))
 265         (while (and args (not (memq (car args) lambda-list-keywords)))
 266           (let ((arg (cl-pop args)))
 267             (or (consp arg) (setq arg (list arg)))
 268             (if (cddr arg) (cl-do-arglist (nth 2 arg) (list 'and restarg t)))
 269             (let ((def (if (cdr arg) (nth 1 arg)
 270                          (or (car bind-defs)
 271                              (nth 1 (assq (car arg) bind-defs)))))
 272                   (poparg (list 'pop restarg)))
 273               (and def bind-enquote (setq def (list 'quote def)))
 274               (cl-do-arglist (car arg)
 275                              (if def (list 'if restarg poparg def) poparg))
 276               (setq num (1+ num))))))
 277       (if (eq (car args) '&rest)
 278           (let ((arg (cl-pop2 args)))
 279             (if (consp arg) (cl-do-arglist arg restarg)))
 280         (or (eq (car args) '&key) (= safety 0) exactarg
 281             (cl-push (list 'if restarg
 282                            (list 'signal '(quote wrong-number-of-arguments)
 283                                  (list 'list
 284                                        (and (not (eq bind-block 'cl-none))
 285                                             (list 'quote bind-block))
 286                                        (list '+ num (list 'length restarg)))))
 287                      bind-forms)))
 288       (while (and (eq (car args) '&key) (cl-pop args))
 289         (while (and args (not (memq (car args) lambda-list-keywords)))
 290           (let ((arg (cl-pop args)))
 291             (or (consp arg) (setq arg (list arg)))
 292             (let* ((karg (if (consp (car arg)) (caar arg)
 293                            (intern (format ":%s" (car arg)))))
 294                    (varg (if (consp (car arg)) (cadar arg) (car arg)))
 295                    (def (if (cdr arg) (cadr arg)
 296                           (or (car bind-defs) (cadr (assq varg bind-defs)))))
 297                    (look (list 'memq (list 'quote karg) restarg)))
 298               (and def bind-enquote (setq def (list 'quote def)))
 299               (if (cddr arg)
 300                   (let* ((temp (or (nth 2 arg) (gensym)))
 301                          (val (list 'car (list 'cdr temp))))
 302                     (cl-do-arglist temp look)
 303                     (cl-do-arglist varg
 304                                    (list 'if temp
 305                                          (list 'prog1 val (list 'setq temp t))
 306                                          def)))
 307                 (cl-do-arglist
 308                  varg
 309                  (list 'car
 310                        (list 'cdr
 311                              (if (null def)
 312                                  look
 313                                (list 'or look
 314                                      (if (eq (cl-const-expr-p def) t)
 315                                          (list
 316                                           'quote
 317                                           (list nil (cl-const-expr-val def)))
 318                                        (list 'list nil def))))))))
 319               (cl-push karg keys)
 320               (if (= (aref (symbol-name karg) 0) ?:)
 321                   (progn (set karg karg)
 322                          (cl-push (list 'setq karg (list 'quote karg))
 323                                   bind-inits)))))))
 324       (setq keys (nreverse keys))
 325       (or (and (eq (car args) '&allow-other-keys) (cl-pop args))
 326           (null keys) (= safety 0)
 327           (let* ((var (gensym "--keys--"))
 328                  (allow '(:allow-other-keys))
 329                  (check (list
 330                          'while var
 331                          (list
 332                           'cond
 333                           (list (list 'memq (list 'car var)
 334                                       (list 'quote (append keys allow)))
 335                                 (list 'setq var (list 'cdr (list 'cdr var))))
 336                           (list (list 'car
 337                                       (list 'cdr
 338                                             (list 'memq (cons 'quote allow)
 339                                                   restarg)))
 340                                 (list 'setq var nil))
 341                           (list t
 342                                 (list
 343                                  'error
 344                                  (format "Keyword argument %%s not one of %s"
 345                                          keys)
 346                                  (list 'car var)))))))
 347             (cl-push (list 'let (list (list var restarg)) check) bind-forms)))
 348       (while (and (eq (car args) '&aux) (cl-pop args))
 349         (while (and args (not (memq (car args) lambda-list-keywords)))
 350           (if (consp (car args))
 351               (if (and bind-enquote (cadar args))
 352                   (cl-do-arglist (caar args)
 353                                  (list 'quote (cadr (cl-pop args))))
 354                 (cl-do-arglist (caar args) (cadr (cl-pop args))))
 355             (cl-do-arglist (cl-pop args) nil))))
 356       (if args (error "Malformed argument list %s" save-args)))))
 357
 358 (defun cl-arglist-args (args)
 359   (if (nlistp args) (list args)
 360     (let ((res nil) (kind nil) arg)
 361       (while (consp args)
 362         (setq arg (cl-pop args))
 363         (if (memq arg lambda-list-keywords) (setq kind arg)
 364           (if (eq arg '&cl-defs) (cl-pop args)
 365             (and (consp arg) kind (setq arg (car arg)))
 366             (and (consp arg) (cdr arg) (eq kind '&key) (setq arg (cadr arg)))
 367             (setq res (nconc res (cl-arglist-args arg))))))
 368       (nconc res (and args (list args))))))
 369
 370 ;;;###autoload
 371 (defmacro destructuring-bind (args expr &rest body)
 372   (let* ((bind-lets nil) (bind-forms nil) (bind-inits nil)
 373          (bind-defs nil) (bind-block 'cl-none))
 374     (cl-do-arglist (or args '(&aux)) expr)
 375     (append '(progn) bind-inits
 376             (list (nconc (list 'let* (nreverse bind-lets))
 377                          (nreverse bind-forms) body)))))
 378
 379
 380 ;;; The `eval-when' form.
 381
 382 (defvar cl-not-toplevel nil)
 383
 384 ;;;###autoload
 385 (defmacro eval-when (when &rest body)
 386   "(eval-when (WHEN...) BODY...): control when BODY is evaluated.
 387 If `compile' is in WHEN, BODY is evaluated when compiled at top-level.
 388 If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
 389 If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level."
 390   (if (and (fboundp 'cl-compiling-file) (cl-compiling-file)
 391            (not cl-not-toplevel) (not (boundp 'for-effect)))  ; horrible kludge
 392       (let ((comp (or (memq 'compile when) (memq ':compile-toplevel when)))
 393             (cl-not-toplevel t))
 394         (if (or (memq 'load when) (memq ':load-toplevel when))
 395             (if comp (cons 'progn (mapcar 'cl-compile-time-too body))
 396               (list* 'if nil nil body))
 397           (progn (if comp (eval (cons 'progn body))) nil)))
 398     (and (or (memq 'eval when) (memq ':execute when))
 399          (cons 'progn body))))
 400
 401 (defun cl-compile-time-too (form)
 402   (or (and (symbolp (car-safe form)) (get (car-safe form) 'byte-hunk-handler))
 403       (setq form (macroexpand
 404                   form (cons '(eval-when) byte-compile-macro-environment))))
 405   (cond ((eq (car-safe form) 'progn)
 406          (cons 'progn (mapcar 'cl-compile-time-too (cdr form))))
 407         ((eq (car-safe form) 'eval-when)
 408          (let ((when (nth 1 form)))
 409            (if (or (memq 'eval when) (memq ':execute when))
 410                (list* 'eval-when (cons 'compile when) (cddr form))
 411              form)))
 412         (t (eval form) form)))
 413
 414 (or (and (fboundp 'eval-when-compile)
 415          (not (eq (car-safe (symbol-function 'eval-when-compile)) 'autoload)))
 416     (eval '(defmacro eval-when-compile (&rest body)
 417              "Like `progn', but evaluates the body at compile time.
 418 The result of the body appears to the compiler as a quoted constant."
 419              (list 'quote (eval (cons 'progn body))))))
 420
 421 ;;;###autoload
 422 (defmacro load-time-value (form &optional read-only)
 423   "Like `progn', but evaluates the body at load time.
 424 The result of the body appears to the compiler as a quoted constant."
 425   (if (cl-compiling-file)
 426       (let* ((temp (gentemp "--cl-load-time--"))
 427              (set (list 'set (list 'quote temp) form)))
 428         (if (and (fboundp 'byte-compile-file-form-defmumble)
 429                  (boundp 'this-kind) (boundp 'that-one))
 430             (fset 'byte-compile-file-form
 431                   (list 'lambda '(form)
 432                         (list 'fset '(quote byte-compile-file-form)
 433                               (list 'quote
 434                                     (symbol-function 'byte-compile-file-form)))
 435                         (list 'byte-compile-file-form (list 'quote set))
 436                         '(byte-compile-file-form form)))
 437           ;; XEmacs change
 438           (print set (symbol-value ;;'outbuffer
 439                                    'byte-compile-output-buffer
 440                                    )))
 441         (list 'symbol-value (list 'quote temp)))
 442     (list 'quote (eval form))))
 443
 444
 445 ;;; Conditional control structures.
 446
 447 ;;;###autoload
 448 (defmacro case (expr &rest clauses)
 449   "(case EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
 450 Each clause looks like (KEYLIST BODY...).  EXPR is evaluated and compared
 451 against each key in each KEYLIST; the corresponding BODY is evaluated.
 452 If no clause succeeds, case returns nil.  A single atom may be used in
 453 place of a KEYLIST of one atom.  A KEYLIST of `t' or `otherwise' is
 454 allowed only in the final clause, and matches if no other keys match.
 455 Key values are compared by `eql'."
 456   (let* ((temp (if (cl-simple-expr-p expr 3) expr (gensym)))
 457          (head-list nil)
 458          (last-clause (car (last clauses)))
 459          (body (cons
 460                 'cond
 461                 (mapcar
 462                  #'(lambda (c)
 463                      (cons (cond ((memq (car c) '(t otherwise))
 464                                   (or (eq c last-clause)
 465                                       (error
 466                                        "`%s' is allowed only as the last case clause"
 467                                        (car c)))
 468                                   t)
 469                                  ((eq (car c) 'ecase-error-flag)
 470                                   (list 'error "ecase failed: %s, %s"
 471                                         temp (list 'quote (reverse head-list))))
 472                                  ((listp (car c))
 473                                   (setq head-list (append (car c) head-list))
 474                                   (list 'member* temp (list 'quote (car c))))
 475                                  (t
 476                                   (if (memq (car c) head-list)
 477                                       (error "Duplicate key in case: %s"
 478                                              (car c)))
 479                                   (cl-push (car c) head-list)
 480                                   (list 'eql temp (list 'quote (car c)))))
 481                            (or (cdr c) '(nil))))
 482                  clauses))))
 483     (if (eq temp expr) body
 484       (list 'let (list (list temp expr)) body))))
 485
 486 ;; #### CL standard also requires `ccase', which signals a continuable
 487 ;; error (`cerror' in XEmacs).  However, I don't think it buys us
 488 ;; anything to introduce it, as there is probably much more CL stuff
 489 ;; missing, and the feature is not essential.  --hniksic
 490
 491 ;;;###autoload
 492 (defmacro ecase (expr &rest clauses)
 493   "(ecase EXPR CLAUSES...): like `case', but error if no case fits.
 494 `otherwise'-clauses are not allowed."
 495   (let ((disallowed (or (assq t clauses)
 496                         (assq 'otherwise clauses))))
 497     (if disallowed
 498         (error "`%s' is not allowed in ecase" (car disallowed))))
 499   (list* 'case expr (append clauses '((ecase-error-flag)))))
 500
 501 ;;;###autoload
 502 (defmacro typecase (expr &rest clauses)
 503   "(typecase EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value.
 504 Each clause looks like (TYPE BODY...).  EXPR is evaluated and, if it
 505 satisfies TYPE, the corresponding BODY is evaluated.  If no clause succeeds,
 506 typecase returns nil.  A TYPE of `t' or `otherwise' is allowed only in the
 507 final clause, and matches if no other keys match."
 508   (let* ((temp (if (cl-simple-expr-p expr 3) expr (gensym)))
 509          (type-list nil)
 510          (body (cons
 511                 'cond
 512                 (mapcar
 513                  #'(lambda (c)
 514                      (cons (cond ((eq (car c) 'otherwise) t)
 515                                  ((eq (car c) 'ecase-error-flag)
 516                                   (list 'error "etypecase failed: %s, %s"
 517                                         temp (list 'quote (reverse type-list))))
 518                                  (t
 519                                   (cl-push (car c) type-list)
 520                                   (cl-make-type-test temp (car c))))
 521                            (or (cdr c) '(nil))))
 522                  clauses))))
 523     (if (eq temp expr) body
 524       (list 'let (list (list temp expr)) body))))
 525
 526 ;;;###autoload
 527 (defmacro etypecase (expr &rest clauses)
 528   "(etypecase EXPR CLAUSES...): like `typecase', but error if no case fits.
 529 `otherwise'-clauses are not allowed."
 530   (list* 'typecase expr (append clauses '((ecase-error-flag)))))
 531
 532
 533 ;;; Blocks and exits.
 534
 535 ;;;###autoload
 536 (defmacro block (name &rest body)
 537   "(block NAME BODY...): define a lexically-scoped block named NAME.
 538 NAME may be any symbol.  Code inside the BODY forms can call `return-from'
 539 to jump prematurely out of the block.  This differs from `catch' and `throw'
 540 in two respects:  First, the NAME is an unevaluated symbol rather than a
 541 quoted symbol or other form; and second, NAME is lexically rather than
 542 dynamically scoped:  Only references to it within BODY will work.  These
 543 references may appear inside macro expansions, but not inside functions
 544 called from BODY."
 545   (if (cl-safe-expr-p (cons 'progn body)) (cons 'progn body)
 546     (list 'cl-block-wrapper
 547           (list* 'catch (list 'quote (intern (format "--cl-block-%s--" name)))
 548                  body))))
 549
 550 (defvar cl-active-block-names nil)
 551
 552 (put 'cl-block-wrapper 'byte-compile 'cl-byte-compile-block)
 553 (defun cl-byte-compile-block (cl-form)
 554   (if (fboundp 'byte-compile-form-do-effect)  ; Check for optimizing compiler
 555       (progn
 556         (let* ((cl-entry (cons (nth 1 (nth 1 (nth 1 cl-form))) nil))
 557                (cl-active-block-names (cons cl-entry cl-active-block-names))
 558                (cl-body (byte-compile-top-level
 559                          (cons 'progn (cddr (nth 1 cl-form))))))
 560           (if (cdr cl-entry)
 561               (byte-compile-form (list 'catch (nth 1 (nth 1 cl-form)) cl-body))
 562             (byte-compile-form cl-body))))
 563     (byte-compile-form (nth 1 cl-form))))
 564
 565 (put 'cl-block-throw 'byte-compile 'cl-byte-compile-throw)
 566 (defun cl-byte-compile-throw (cl-form)
 567   (let ((cl-found (assq (nth 1 (nth 1 cl-form)) cl-active-block-names)))
 568     (if cl-found (setcdr cl-found t)))
 569   (byte-compile-normal-call (cons 'throw (cdr cl-form))))
 570
 571 ;;;###autoload
 572 (defmacro return (&optional res)
 573   "(return [RESULT]): return from the block named nil.
 574 This is equivalent to `(return-from nil RESULT)'."
 575   (list 'return-from nil res))
 576
 577 ;;;###autoload
 578 (defmacro return-from (name &optional res)
 579   "(return-from NAME [RESULT]): return from the block named NAME.
 580 This jumps out to the innermost enclosing `(block NAME ...)' form,
 581 returning RESULT from that form (or nil if RESULT is omitted).
 582 This is compatible with Common Lisp, but note that `defun' and
 583 `defmacro' do not create implicit blocks as they do in Common Lisp."
 584   (let ((name2 (intern (format "--cl-block-%s--" name))))
 585     (list 'cl-block-throw (list 'quote name2) res)))
 586
 587
 588 ;;; The "loop" macro.
 589
 590 (defvar args) (defvar loop-accum-var) (defvar loop-accum-vars)
 591 (defvar loop-bindings) (defvar loop-body) (defvar loop-destr-temps)
 592 (defvar loop-finally) (defvar loop-finish-flag) (defvar loop-first-flag)
 593 (defvar loop-initially) (defvar loop-map-form) (defvar loop-name)
 594 (defvar loop-result) (defvar loop-result-explicit)
 595 (defvar loop-result-var) (defvar loop-steps) (defvar loop-symbol-macs)
 596
 597 ;;;###autoload
 598 (defmacro loop (&rest args)
 599   "(loop CLAUSE...): The Common Lisp `loop' macro.
 600 Valid clauses are:
 601   for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM,
 602   for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR,
 603   for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND,
 604   always COND, never COND, thereis COND, collect EXPR into VAR,
 605   append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR,
 606   count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR,
 607   if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
 608   unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...],
 609   do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR,
 610   finally return EXPR, named NAME."
 611   (if (not (memq t (mapcar 'symbolp (delq nil (delq t (copy-list args))))))
 612       (list 'block nil (list* 'while t args))
 613     (let ((loop-name nil)       (loop-bindings nil)
 614           (loop-body nil)       (loop-steps nil)
 615           (loop-result nil)     (loop-result-explicit nil)
 616           (loop-result-var nil) (loop-finish-flag nil)
 617           (loop-accum-var nil)  (loop-accum-vars nil)
 618           (loop-initially nil)  (loop-finally nil)
 619           (loop-map-form nil)   (loop-first-flag nil)
 620           (loop-destr-temps nil) (loop-symbol-macs nil))
 621       (setq args (append args '(cl-end-loop)))
 622       (while (not (eq (car args) 'cl-end-loop)) (cl-parse-loop-clause))
 623       (if loop-finish-flag
 624           (cl-push (list (list loop-finish-flag t)) loop-bindings))
 625       (if loop-first-flag
 626           (progn (cl-push (list (list loop-first-flag t)) loop-bindings)
 627                  (cl-push (list 'setq loop-first-flag nil) loop-steps)))
 628       (let* ((epilogue (nconc (nreverse loop-finally)
 629                               (list (or loop-result-explicit loop-result))))
 630              (ands (cl-loop-build-ands (nreverse loop-body)))
 631              (while-body (nconc (cadr ands) (nreverse loop-steps)))
 632              (body (append
 633                     (nreverse loop-initially)
 634                     (list (if loop-map-form
 635                               (list 'block '--cl-finish--
 636                                     (subst
 637                                      (if (eq (car ands) t) while-body
 638                                        (cons (list 'or (car ands)
 639                                                    '(return-from --cl-finish--
 640                                                       nil))
 641                                              while-body))
 642                                      '--cl-map loop-map-form))
 643                             (list* 'while (car ands) while-body)))
 644                     (if loop-finish-flag
 645                         (if (equal epilogue '(nil)) (list loop-result-var)
 646                           (list (list 'if loop-finish-flag
 647                                       (cons 'progn epilogue) loop-result-var)))
 648                       epilogue))))
 649         (if loop-result-var (cl-push (list loop-result-var) loop-bindings))
 650         (while loop-bindings
 651           (if (cdar loop-bindings)
 652               (setq body (list (cl-loop-let (cl-pop loop-bindings) body t)))
 653             (let ((lets nil))
 654               (while (and loop-bindings
 655                           (not (cdar loop-bindings)))
 656                 (cl-push (car (cl-pop loop-bindings)) lets))
 657               (setq body (list (cl-loop-let lets body nil))))))
 658         (if loop-symbol-macs
 659             (setq body (list (list* 'symbol-macrolet loop-symbol-macs body))))
 660         (list* 'block loop-name body)))))
 661
 662 (defun cl-parse-loop-clause ()   ; uses args, loop-*
 663   (let ((word (cl-pop args))
 664         (hash-types '(hash-key hash-keys hash-value hash-values))
 665         (key-types '(key-code key-codes key-seq key-seqs
 666                      key-binding key-bindings)))
 667     (cond
 668
 669      ((null args)
 670       (error "Malformed `loop' macro"))
 671
 672      ((eq word 'named)
 673       (setq loop-name (cl-pop args)))
 674
 675      ((eq word 'initially)
 676       (if (memq (car args) '(do doing)) (cl-pop args))
 677       (or (consp (car args)) (error "Syntax error on `initially' clause"))
 678       (while (consp (car args))
 679         (cl-push (cl-pop args) loop-initially)))
 680
 681      ((eq word 'finally)
 682       (if (eq (car args) 'return)
 683           (setq loop-result-explicit (or (cl-pop2 args) '(quote nil)))
 684         (if (memq (car args) '(do doing)) (cl-pop args))
 685         (or (consp (car args)) (error "Syntax error on `finally' clause"))
 686         (if (and (eq (caar args) 'return) (null loop-name))
 687             (setq loop-result-explicit (or (nth 1 (cl-pop args)) '(quote nil)))
 688           (while (consp (car args))
 689             (cl-push (cl-pop args) loop-finally)))))
 690
 691      ((memq word '(for as))
 692       (let ((loop-for-bindings nil) (loop-for-sets nil) (loop-for-steps nil)
 693             (ands nil))
 694         (while
 695             (let ((var (or (cl-pop args) (gensym))))
 696               (setq word (cl-pop args))
 697               (if (eq word 'being) (setq word (cl-pop args)))
 698               (if (memq word '(the each)) (setq word (cl-pop args)))
 699               (if (memq word '(buffer buffers))
 700                   (setq word 'in args (cons '(buffer-list) args)))
 701               (cond
 702
 703                ((memq word '(from downfrom upfrom to downto upto
 704                              above below by))
 705                 (cl-push word args)
 706                 (if (memq (car args) '(downto above))
 707                     (error "Must specify `from' value for downward loop"))
 708                 (let* ((down (or (eq (car args) 'downfrom)
 709                                  (memq (caddr args) '(downto above))))
 710                        (excl (or (memq (car args) '(above below))
 711                                  (memq (caddr args) '(above below))))
 712                        (start (and (memq (car args) '(from upfrom downfrom))
 713                                    (cl-pop2 args)))
 714                        (end (and (memq (car args)
 715                                        '(to upto downto above below))
 716                                  (cl-pop2 args)))
 717                        (step (and (eq (car args) 'by) (cl-pop2 args)))
 718                        (end-var (and (not (cl-const-expr-p end)) (gensym)))
 719                        (step-var (and (not (cl-const-expr-p step))
 720                                       (gensym))))
 721                   (and step (numberp step) (<= step 0)
 722                        (error "Loop `by' value is not positive: %s" step))
 723                   (cl-push (list var (or start 0)) loop-for-bindings)
 724                   (if end-var (cl-push (list end-var end) loop-for-bindings))
 725                   (if step-var (cl-push (list step-var step)
 726                                         loop-for-bindings))
 727                   (if end
 728                       (cl-push (list
 729                                 (if down (if excl '> '>=) (if excl '< '<=))
 730                                 var (or end-var end)) loop-body))
 731                   (cl-push (list var (list (if down '- '+) var
 732                                            (or step-var step 1)))
 733                            loop-for-steps)))
 734
 735                ((memq word '(in in-ref on))
 736                 (let* ((on (eq word 'on))
 737                        (temp (if (and on (symbolp var)) var (gensym))))
 738                   (cl-push (list temp (cl-pop args)) loop-for-bindings)
 739                   (cl-push (list 'consp temp) loop-body)
 740                   (if (eq word 'in-ref)
 741                       (cl-push (list var (list 'car temp)) loop-symbol-macs)
 742                     (or (eq temp var)
 743                         (progn
 744                           (cl-push (list var nil) loop-for-bindings)
 745                           (cl-push (list var (if on temp (list 'car temp)))
 746                                    loop-for-sets))))
 747                   (cl-push (list temp
 748                                  (if (eq (car args) 'by)
 749                                      (let ((step (cl-pop2 args)))
 750                                        (if (and (memq (car-safe step)
 751                                                       '(quote function
 752                                                               function*))
 753                                                 (symbolp (nth 1 step)))
 754                                            (list (nth 1 step) temp)
 755                                          (list 'funcall step temp)))
 756                                    (list 'cdr temp)))
 757                            loop-for-steps)))
 758
 759                ((eq word '=)
 760                 (let* ((start (cl-pop args))
 761                        (then (if (eq (car args) 'then) (cl-pop2 args) start)))
 762                   (cl-push (list var nil) loop-for-bindings)
 763                   (if (or ands (eq (car args) 'and))
 764                       (progn
 765                         (cl-push (list var
 766                                        (list 'if
 767                                              (or loop-first-flag
 768                                                  (setq loop-first-flag
 769                                                        (gensym)))
 770                                              start var))
 771                                  loop-for-sets)
 772                         (cl-push (list var then) loop-for-steps))
 773                     (cl-push (list var
 774                                    (if (eq start then) start
 775                                      (list 'if
 776                                            (or loop-first-flag
 777                                                (setq loop-first-flag (gensym)))
 778                                            start then)))
 779                              loop-for-sets))))
 780
 781                ((memq word '(across across-ref))
 782                 (let ((temp-vec (gensym)) (temp-idx (gensym)))
 783                   (cl-push (list temp-vec (cl-pop args)) loop-for-bindings)
 784                   (cl-push (list temp-idx -1) loop-for-bindings)
 785                   (cl-push (list '< (list 'setq temp-idx (list '1+ temp-idx))
 786                                  (list 'length temp-vec)) loop-body)
 787                   (if (eq word 'across-ref)
 788                       (cl-push (list var (list 'aref temp-vec temp-idx))
 789                                loop-symbol-macs)
 790                     (cl-push (list var nil) loop-for-bindings)
 791                     (cl-push (list var (list 'aref temp-vec temp-idx))
 792                              loop-for-sets))))
 793
 794                ((memq word '(element elements))
 795                 (let ((ref (or (memq (car args) '(in-ref of-ref))
 796                                (and (not (memq (car args) '(in of)))
 797                                     (error "Expected `of'"))))
 798                       (seq (cl-pop2 args))
 799                       (temp-seq (gensym))
 800                       (temp-idx (if (eq (car args) 'using)
 801                                     (if (and (= (length (cadr args)) 2)
 802                                              (eq (caadr args) 'index))
 803                                         (cadr (cl-pop2 args))
 804                                       (error "Bad `using' clause"))
 805                                   (gensym))))
 806                   (cl-push (list temp-seq seq) loop-for-bindings)
 807                   (cl-push (list temp-idx 0) loop-for-bindings)
 808                   (if ref
 809                       (let ((temp-len (gensym)))
 810                         (cl-push (list temp-len (list 'length temp-seq))
 811                                  loop-for-bindings)
 812                         (cl-push (list var (list 'elt temp-seq temp-idx))
 813                                  loop-symbol-macs)
 814                         (cl-push (list '< temp-idx temp-len) loop-body))
 815                     (cl-push (list var nil) loop-for-bindings)
 816                     (cl-push (list 'and temp-seq
 817                                    (list 'or (list 'consp temp-seq)
 818                                          (list '< temp-idx
 819                                                (list 'length temp-seq))))
 820                              loop-body)
 821                     (cl-push (list var (list 'if (list 'consp temp-seq)
 822                                              (list 'pop temp-seq)
 823                                              (list 'aref temp-seq temp-idx)))
 824                              loop-for-sets))
 825                   (cl-push (list temp-idx (list '1+ temp-idx))
 826                            loop-for-steps)))
 827
 828                ((memq word hash-types)
 829                 (or (memq (car args) '(in of)) (error "Expected `of'"))
 830                 (let* ((table (cl-pop2 args))
 831                        (other (if (eq (car args) 'using)
 832                                   (if (and (= (length (cadr args)) 2)
 833                                            (memq (caadr args) hash-types)
 834                                            (not (eq (caadr args) word)))
 835                                       (cadr (cl-pop2 args))
 836                                     (error "Bad `using' clause"))
 837                                 (gensym))))
 838                   (if (memq word '(hash-value hash-values))
 839                       (setq var (prog1 other (setq other var))))
 840                   (setq loop-map-form
 841                         (list 'maphash (list 'function
 842                                              (list* 'lambda (list var other)
 843                                                     '--cl-map)) table))))
 844
 845                ((memq word '(symbol present-symbol external-symbol
 846                              symbols present-symbols external-symbols))
 847                 (let ((ob (and (memq (car args) '(in of)) (cl-pop2 args))))
 848                   (setq loop-map-form
 849                         (list 'mapatoms (list 'function
 850                                               (list* 'lambda (list var)
 851                                                      '--cl-map)) ob))))
 852
 853                ((memq word '(overlay overlays extent extents))
 854                 (let ((buf nil) (from nil) (to nil))
 855                   (while (memq (car args) '(in of from to))
 856                     (cond ((eq (car args) 'from) (setq from (cl-pop2 args)))
 857                           ((eq (car args) 'to) (setq to (cl-pop2 args)))
 858                           (t (setq buf (cl-pop2 args)))))
 859                   (setq loop-map-form
 860                         (list 'cl-map-extents
 861                               (list 'function (list 'lambda (list var (gensym))
 862                                                     '(progn . --cl-map) nil))
 863                               buf from to))))
 864
 865                ((memq word '(interval intervals))
 866                 (let ((buf nil) (prop nil) (from nil) (to nil)
 867                       (var1 (gensym)) (var2 (gensym)))
 868                   (while (memq (car args) '(in of property from to))
 869                     (cond ((eq (car args) 'from) (setq from (cl-pop2 args)))
 870                           ((eq (car args) 'to) (setq to (cl-pop2 args)))
 871                           ((eq (car args) 'property)
 872                            (setq prop (cl-pop2 args)))
 873                           (t (setq buf (cl-pop2 args)))))
 874                   (if (and (consp var) (symbolp (car var)) (symbolp (cdr var)))
 875                       (setq var1 (car var) var2 (cdr var))
 876                     (cl-push (list var (list 'cons var1 var2)) loop-for-sets))
 877                   (setq loop-map-form
 878                         (list 'cl-map-intervals
 879                               (list 'function (list 'lambda (list var1 var2)
 880                                                     '(progn . --cl-map)))
 881                               buf prop from to))))
 882
 883                ((memq word key-types)
 884                 (or (memq (car args) '(in of)) (error "Expected `of'"))
 885                 (let ((map (cl-pop2 args))
 886                       (other (if (eq (car args) 'using)
 887                                  (if (and (= (length (cadr args)) 2)
 888                                           (memq (caadr args) key-types)
 889                                           (not (eq (caadr args) word)))
 890                                      (cadr (cl-pop2 args))
 891                                    (error "Bad `using' clause"))
 892                                (gensym))))
 893                   (if (memq word '(key-binding key-bindings))
 894                       (setq var (prog1 other (setq other var))))
 895                   (setq loop-map-form
 896                         (list (if (memq word '(key-seq key-seqs))
 897                                   'cl-map-keymap-recursively 'cl-map-keymap)
 898                               (list 'function (list* 'lambda (list var other)
 899                                                      '--cl-map)) map))))
 900
 901                ((memq word '(frame frames screen screens))
 902                 (let ((temp (gensym)))
 903                   (cl-push (list var '(selected-frame))
 904                            loop-for-bindings)
 905                   (cl-push (list temp nil) loop-for-bindings)
 906                   (cl-push (list 'prog1 (list 'not (list 'eq var temp))
 907                                  (list 'or temp (list 'setq temp var)))
 908                            loop-body)
 909                   (cl-push (list var (list 'next-frame var))
 910                            loop-for-steps)))
 911
 912                ((memq word '(window windows))
 913                 (let ((scr (and (memq (car args) '(in of)) (cl-pop2 args)))
 914                       (temp (gensym)))
 915                   (cl-push (list var (if scr
 916                                          (list 'frame-selected-window scr)
 917                                        '(selected-window)))
 918                            loop-for-bindings)
 919                   (cl-push (list temp nil) loop-for-bindings)
 920                   (cl-push (list 'prog1 (list 'not (list 'eq var temp))
 921                                  (list 'or temp (list 'setq temp var)))
 922                            loop-body)
 923                   (cl-push (list var (list 'next-window var)) loop-for-steps)))
 924
 925                (t
 926                 (let ((handler (and (symbolp word)
 927                                     (get word 'cl-loop-for-handler))))
 928                   (if handler
 929                       (funcall handler var)
 930                     (error "Expected a `for' preposition, found %s" word)))))
 931               (eq (car args) 'and))
 932           (setq ands t)
 933           (cl-pop args))
 934         (if (and ands loop-for-bindings)
 935             (cl-push (nreverse loop-for-bindings) loop-bindings)
 936           (setq loop-bindings (nconc (mapcar 'list loop-for-bindings)
 937                                      loop-bindings)))
 938         (if loop-for-sets
 939             (cl-push (list 'progn
 940                            (cl-loop-let (nreverse loop-for-sets) 'setq ands)
 941                            t) loop-body))
 942         (if loop-for-steps
 943             (cl-push (cons (if ands 'psetq 'setq)
 944                            (apply 'append (nreverse loop-for-steps)))
 945                      loop-steps))))
 946
 947      ((eq word 'repeat)
 948       (let ((temp (gensym)))
 949         (cl-push (list (list temp (cl-pop args))) loop-bindings)
 950         (cl-push (list '>= (list 'setq temp (list '1- temp)) 0) loop-body)))
 951
 952      ((eq word 'collect)
 953       (let ((what (cl-pop args))
 954             (var (cl-loop-handle-accum nil 'nreverse)))
 955         (if (eq var loop-accum-var)
 956             (cl-push (list 'progn (list 'push what var) t) loop-body)
 957           (cl-push (list 'progn
 958                          (list 'setq var (list 'nconc var (list 'list what)))
 959                          t) loop-body))))
 960
 961      ((memq word '(nconc nconcing append appending))
 962       (let ((what (cl-pop args))
 963             (var (cl-loop-handle-accum nil 'nreverse)))
 964         (cl-push (list 'progn
 965                        (list 'setq var
 966                              (if (eq var loop-accum-var)
 967                                  (list 'nconc
 968                                        (list (if (memq word '(nconc nconcing))
 969                                                  'nreverse 'reverse)
 970                                              what)
 971                                        var)
 972                                (list (if (memq word '(nconc nconcing))
 973                                          'nconc 'append)
 974                                      var what))) t) loop-body)))
 975
 976      ((memq word '(concat concating))
 977       (let ((what (cl-pop args))
 978             (var (cl-loop-handle-accum "")))
 979         (cl-push (list 'progn (list 'callf 'concat var what) t) loop-body)))
 980
 981      ((memq word '(vconcat vconcating))
 982       (let ((what (cl-pop args))
 983             (var (cl-loop-handle-accum [])))
 984         (cl-push (list 'progn (list 'callf 'vconcat var what) t) loop-body)))
 985
 986      ((memq word '(sum summing))
 987       (let ((what (cl-pop args))
 988             (var (cl-loop-handle-accum 0)))
 989         (cl-push (list 'progn (list 'incf var what) t) loop-body)))
 990
 991      ((memq word '(count counting))
 992       (let ((what (cl-pop args))
 993             (var (cl-loop-handle-accum 0)))
 994         (cl-push (list 'progn (list 'if what (list 'incf var)) t) loop-body)))
 995
 996      ((memq word '(minimize minimizing maximize maximizing))
 997       (let* ((what (cl-pop args))
 998              (temp (if (cl-simple-expr-p what) what (gensym)))
 999              (var (cl-loop-handle-accum nil))
1000              (func (intern (substring (symbol-name word) 0 3)))
1001              (set (list 'setq var (list 'if var (list func var temp) temp))))
1002         (cl-push (list 'progn (if (eq temp what) set
1003                                 (list 'let (list (list temp what)) set))
1004                        t) loop-body)))
1005
1006      ((eq word 'with)
1007       (let ((bindings nil))
1008         (while (progn (cl-push (list (cl-pop args)
1009                                      (and (eq (car args) '=) (cl-pop2 args)))
1010                                bindings)
1011                       (eq (car args) 'and))
1012           (cl-pop args))
1013         (cl-push (nreverse bindings) loop-bindings)))
1014
1015      ((eq word 'while)
1016       (cl-push (cl-pop args) loop-body))
1017
1018      ((eq word 'until)
1019       (cl-push (list 'not (cl-pop args)) loop-body))
1020
1021      ((eq word 'always)
1022       (or loop-finish-flag (setq loop-finish-flag (gensym)))
1023       (cl-push (list 'setq loop-finish-flag (cl-pop args)) loop-body)
1024       (setq loop-result t))
1025
1026      ((eq word 'never)
1027       (or loop-finish-flag (setq loop-finish-flag (gensym)))
1028       (cl-push (list 'setq loop-finish-flag (list 'not (cl-pop args)))
1029                loop-body)
1030       (setq loop-result t))
1031
1032      ((eq word 'thereis)
1033       (or loop-finish-flag (setq loop-finish-flag (gensym)))
1034       (or loop-result-var (setq loop-result-var (gensym)))
1035       (cl-push (list 'setq loop-finish-flag
1036                      (list 'not (list 'setq loop-result-var (cl-pop args))))
1037                loop-body))
1038
1039      ((memq word '(if when unless))
1040       (let* ((cond (cl-pop args))
1041              (then (let ((loop-body nil))
1042                      (cl-parse-loop-clause)
1043                      (cl-loop-build-ands (nreverse loop-body))))
1044              (else (let ((loop-body nil))
1045                      (if (eq (car args) 'else)
1046                          (progn (cl-pop args) (cl-parse-loop-clause)))
1047                      (cl-loop-build-ands (nreverse loop-body))))
1048              (simple (and (eq (car then) t) (eq (car else) t))))
1049         (if (eq (car args) 'end) (cl-pop args))
1050         (if (eq word 'unless) (setq then (prog1 else (setq else then))))
1051         (let ((form (cons (if simple (cons 'progn (nth 1 then)) (nth 2 then))
1052                           (if simple (nth 1 else) (list (nth 2 else))))))
1053           (if (cl-expr-contains form 'it)
1054               (let ((temp (gensym)))
1055                 (cl-push (list temp) loop-bindings)
1056                 (setq form (list* 'if (list 'setq temp cond)
1057                                   (subst temp 'it form))))
1058             (setq form (list* 'if cond form)))
1059           (cl-push (if simple (list 'progn form t) form) loop-body))))
1060
1061      ((memq word '(do doing))
1062       (let ((body nil))
1063         (or (consp (car args)) (error "Syntax error on `do' clause"))
1064         (while (consp (car args)) (cl-push (cl-pop args) body))
1065         (cl-push (cons 'progn (nreverse (cons t body))) loop-body)))
1066
1067      ((eq word 'return)
1068       (or loop-finish-flag (setq loop-finish-flag (gensym)))
1069       (or loop-result-var (setq loop-result-var (gensym)))
1070       (cl-push (list 'setq loop-result-var (cl-pop args)
1071                      loop-finish-flag nil) loop-body))
1072
1073      (t
1074       (let ((handler (and (symbolp word) (get word 'cl-loop-handler))))
1075         (or handler (error "Expected a loop keyword, found %s" word))
1076         (funcall handler))))
1077     (if (eq (car args) 'and)
1078         (progn (cl-pop args) (cl-parse-loop-clause)))))
1079
1080 (defun cl-loop-let (specs body par)   ; uses loop-*
1081   (let ((p specs) (temps nil) (new nil))
1082     (while (and p (or (symbolp (car-safe (car p))) (null (cadar p))))
1083       (setq p (cdr p)))
1084     (and par p
1085          (progn
1086            (setq par nil p specs)
1087            (while p
1088              (or (cl-const-expr-p (cadar p))
1089                  (let ((temp (gensym)))
1090                    (cl-push (list temp (cadar p)) temps)
1091                    (setcar (cdar p) temp)))
1092              (setq p (cdr p)))))
1093     (while specs
1094       (if (and (consp (car specs)) (listp (caar specs)))
1095           (let* ((spec (caar specs)) (nspecs nil)
1096                  (expr (cadr (cl-pop specs)))
1097                  (temp (cdr (or (assq spec loop-destr-temps)
1098                                 (car (cl-push (cons spec (or (last spec 0)
1099                                                              (gensym)))
1100                                               loop-destr-temps))))))
1101             (cl-push (list temp expr) new)
1102             (while (consp spec)
1103               (cl-push (list (cl-pop spec)
1104                              (and expr (list (if spec 'pop 'car) temp)))
1105                        nspecs))
1106             (setq specs (nconc (nreverse nspecs) specs)))
1107         (cl-push (cl-pop specs) new)))
1108     (if (eq body 'setq)
1109         (let ((set (cons (if par 'psetq 'setq) (apply 'nconc (nreverse new)))))
1110           (if temps (list 'let* (nreverse temps) set) set))
1111       (list* (if par 'let 'let*)
1112              (nconc (nreverse temps) (nreverse new)) body))))
1113
1114 (defun cl-loop-handle-accum (def &optional func)   ; uses args, loop-*
1115   (if (eq (car args) 'into)
1116       (let ((var (cl-pop2 args)))
1117         (or (memq var loop-accum-vars)
1118             (progn (cl-push (list (list var def)) loop-bindings)
1119                    (cl-push var loop-accum-vars)))
1120         var)
1121     (or loop-accum-var
1122         (progn
1123           (cl-push (list (list (setq loop-accum-var (gensym)) def))
1124                    loop-bindings)
1125           (setq loop-result (if func (list func loop-accum-var)
1126                               loop-accum-var))
1127           loop-accum-var))))
1128
1129 (defun cl-loop-build-ands (clauses)
1130   (let ((ands nil)
1131         (body nil))
1132     (while clauses
1133       (if (and (eq (car-safe (car clauses)) 'progn)
1134                (eq (car (last (car clauses))) t))
1135           (if (cdr clauses)
1136               (setq clauses (cons (nconc (butlast (car clauses))
1137                                          (if (eq (car-safe (cadr clauses))
1138                                                  'progn)
1139                                              (cdadr clauses)
1140                                            (list (cadr clauses))))
1141                                   (cddr clauses)))
1142             (setq body (cdr (butlast (cl-pop clauses)))))
1143         (cl-push (cl-pop clauses) ands)))
1144     (setq ands (or (nreverse ands) (list t)))
1145     (list (if (cdr ands) (cons 'and ands) (car ands))
1146           body
1147           (let ((full (if body
1148                           (append ands (list (cons 'progn (append body '(t)))))
1149                         ands)))
1150             (if (cdr full) (cons 'and full) (car full))))))
1151
1152
1153 ;;; Other iteration control structures.
1154
1155 ;;;###autoload
1156 (defmacro do (steps endtest &rest body)
1157   "The Common Lisp `do' loop.
1158 Format is: (do ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)"
1159   (cl-expand-do-loop steps endtest body nil))
1160
1161 ;;;###autoload
1162 (defmacro do* (steps endtest &rest body)
1163   "The Common Lisp `do*' loop.
1164 Format is: (do* ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)"
1165   (cl-expand-do-loop steps endtest body t))
1166
1167 (defun cl-expand-do-loop (steps endtest body star)
1168   (list 'block nil
1169         (list* (if star 'let* 'let)
1170                (mapcar #'(lambda (c) (if (consp c) (list (car c) (nth 1 c)) c))
1171                        steps)
1172                (list* 'while (list 'not (car endtest))
1173                       (append body
1174                               (let ((sets (mapcar
1175                                            #'(lambda (c)
1176                                                (and (consp c) (cdr (cdr c))
1177                                                     (list (car c) (nth 2 c))))
1178                                            steps)))
1179                                 (setq sets (delq nil sets))
1180                                 (and sets
1181                                      (list (cons (if (or star (not (cdr sets)))
1182                                                      'setq 'psetq)
1183                                                  (apply 'append sets)))))))
1184                (or (cdr endtest) '(nil)))))
1185
1186 ;;;###autoload
1187 (defmacro dolist (spec &rest body)
1188   "(dolist (VAR LIST [RESULT]) BODY...): loop over a list.
1189 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
1190 Then evaluate RESULT to get return value, default nil."
1191   (let ((temp (gensym "--dolist-temp--")))
1192     (list 'block nil
1193           (list* 'let (list (list temp (nth 1 spec)) (car spec))
1194                  (list* 'while temp (list 'setq (car spec) (list 'car temp))
1195                         (append body (list (list 'setq temp
1196                                                  (list 'cdr temp)))))
1197                  (if (cdr (cdr spec))
1198                      (cons (list 'setq (car spec) nil) (cdr (cdr spec)))
1199                    '(nil))))))
1200
1201 ;;;###autoload
1202 (defmacro dotimes (spec &rest body)
1203   "(dotimes (VAR COUNT [RESULT]) BODY...): loop a certain number of times.
1204 Evaluate BODY with VAR bound to successive integers from 0, inclusive,
1205 to COUNT, exclusive.  Then evaluate RESULT to get return value, default
1206 nil."
1207   (let ((temp (gensym "--dotimes-temp--")))
1208     (list 'block nil
1209           (list* 'let (list (list temp (nth 1 spec)) (list (car spec) 0))
1210                  (list* 'while (list '< (car spec) temp)
1211                         (append body (list (list 'incf (car spec)))))
1212                  (or (cdr (cdr spec)) '(nil))))))
1213
1214 ;;;###autoload
1215 (defmacro do-symbols (spec &rest body)
1216   "(dosymbols (VAR [OBARRAY [RESULT]]) BODY...): loop over all symbols.
1217 Evaluate BODY with VAR bound to each interned symbol, or to each symbol
1218 from OBARRAY."
1219   ;; Apparently this doesn't have an implicit block.
1220   (list 'block nil
1221         (list 'let (list (car spec))
1222               (list* 'mapatoms
1223                      (list 'function (list* 'lambda (list (car spec)) body))
1224                      (and (cadr spec) (list (cadr spec))))
1225               (caddr spec))))
1226
1227 ;;;###autoload
1228 (defmacro do-all-symbols (spec &rest body)
1229   (list* 'do-symbols (list (car spec) nil (cadr spec)) body))
1230
1231
1232 ;;; Assignments.
1233
1234 ;;;###autoload
1235 (defmacro psetq (&rest args)
1236   "(psetq SYM VAL SYM VAL ...): set SYMs to the values VALs in parallel.
1237 This is like `setq', except that all VAL forms are evaluated (in order)
1238 before assigning any symbols SYM to the corresponding values."
1239   (cons 'psetf args))
1240
1241
1242 ;;; Binding control structures.
1243
1244 ;;;###autoload
1245 (defmacro progv (symbols values &rest body)
1246   "(progv SYMBOLS VALUES BODY...): bind SYMBOLS to VALUES dynamically in BODY.
1247 The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
1248 Each SYMBOL in the first list is bound to the corresponding VALUE in the
1249 second list (or made unbound if VALUES is shorter than SYMBOLS); then the
1250 BODY forms are executed and their result is returned.  This is much like
1251 a `let' form, except that the list of symbols can be computed at run-time."
1252   (list 'let '((cl-progv-save nil))
1253         (list 'unwind-protect
1254               (list* 'progn (list 'cl-progv-before symbols values) body)
1255               '(cl-progv-after))))
1256
1257 ;;; This should really have some way to shadow 'byte-compile properties, etc.
1258 ;;;###autoload
1259 (defmacro flet (bindings &rest body)
1260   "(flet ((FUNC ARGLIST BODY...) ...) FORM...): make temporary function defns.
1261 This is an analogue of `let' that operates on the function cell of FUNC
1262 rather than its value cell.  The FORMs are evaluated with the specified
1263 function definitions in place, then the definitions are undone (the FUNCs
1264 go back to their previous definitions, or lack thereof)."
1265   (list* 'letf*
1266          (mapcar
1267           #'(lambda (x)
1268               (if (or (and (fboundp (car x))
1269                            (eq (car-safe (symbol-function (car x))) 'macro))
1270                       (cdr (assq (car x) cl-macro-environment)))
1271                   (error "Use `labels', not `flet', to rebind macro names"))
1272               (let ((func (list 'function*
1273                                 (list 'lambda (cadr x)
1274                                       (list* 'block (car x) (cddr x))))))
1275                 (if (and (cl-compiling-file)
1276                          (boundp 'byte-compile-function-environment))
1277                     (cl-push (cons (car x) (eval func))
1278                              byte-compile-function-environment))
1279                 (list (list 'symbol-function (list 'quote (car x))) func)))
1280           bindings)
1281          body))
1282
1283 ;;;###autoload
1284 (defmacro labels (bindings &rest body)
1285   "(labels ((FUNC ARGLIST BODY...) ...) FORM...): make temporary func bindings.
1286 This is like `flet', except the bindings are lexical instead of dynamic.
1287 Unlike `flet', this macro is fully compliant with the Common Lisp standard."
1288   (let ((vars nil) (sets nil) (cl-macro-environment cl-macro-environment))
1289     (while bindings
1290       (let ((var (gensym)))
1291         (cl-push var vars)
1292         (cl-push (list 'function* (cons 'lambda (cdar bindings))) sets)
1293         (cl-push var sets)
1294         (cl-push (list (car (cl-pop bindings)) 'lambda '(&rest cl-labels-args)
1295                        (list 'list* '(quote funcall) (list 'quote var)
1296                              'cl-labels-args))
1297                  cl-macro-environment)))
1298     (cl-macroexpand-all (list* 'lexical-let vars (cons (cons 'setq sets) body))
1299                         cl-macro-environment)))
1300
1301 ;; The following ought to have a better definition for use with newer
1302 ;; byte compilers.
1303 ;;;###autoload
1304 (defmacro macrolet (bindings &rest body)
1305   "(macrolet ((NAME ARGLIST BODY...) ...) FORM...): make temporary macro defns.
1306 This is like `flet', but for macros instead of functions."
1307   (if (cdr bindings)
1308       (list 'macrolet
1309             (list (car bindings)) (list* 'macrolet (cdr bindings) body))
1310     (if (null bindings) (cons 'progn body)
1311       (let* ((name (caar bindings))
1312              (res (cl-transform-lambda (cdar bindings) name)))
1313         (eval (car res))
1314         (cl-macroexpand-all (cons 'progn body)
1315                             (cons (list* name 'lambda (cdr res))
1316                                   cl-macro-environment))))))
1317
1318 ;;;###autoload
1319 (defmacro symbol-macrolet (bindings &rest body)
1320   "(symbol-macrolet ((NAME EXPANSION) ...) FORM...): make symbol macro defns.
1321 Within the body FORMs, references to the variable NAME will be replaced
1322 by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...)."
1323   (if (cdr bindings)
1324       (list 'symbol-macrolet
1325             (list (car bindings)) (list* 'symbol-macrolet (cdr bindings) body))
1326     (if (null bindings) (cons 'progn body)
1327       (cl-macroexpand-all (cons 'progn body)
1328                           (cons (list (symbol-name (caar bindings))
1329                                       (cadar bindings))
1330                                 cl-macro-environment)))))
1331
1332 (defvar cl-closure-vars nil)
1333 ;;;###autoload
1334 (defmacro lexical-let (bindings &rest body)
1335   "(lexical-let BINDINGS BODY...): like `let', but lexically scoped.
1336 The main visible difference is that lambdas inside BODY will create
1337 lexical closures as in Common Lisp."
1338   (let* ((cl-closure-vars cl-closure-vars)
1339          (vars (mapcar #'(lambda (x)
1340                            (or (consp x) (setq x (list x)))
1341                            (cl-push (gensym (format "--%s--" (car x)))
1342                                     cl-closure-vars)
1343                            (list (car x) (cadr x) (car cl-closure-vars)))
1344                        bindings))
1345          (ebody
1346           (cl-macroexpand-all
1347            (cons 'progn body)
1348            (nconc (mapcar #'(lambda (x)
1349                               (list (symbol-name (car x))
1350                                     (list 'symbol-value (caddr x))
1351                                     t))
1352                           vars)
1353                   (list '(defun . cl-defun-expander))
1354                   cl-macro-environment))))
1355     (if (not (get (car (last cl-closure-vars)) 'used))
1356         (list 'let (mapcar #'(lambda (x) (list (caddr x) (cadr x))) vars)
1357               (sublis (mapcar #'(lambda (x)
1358                                   (cons (caddr x) (list 'quote (caddr x))))
1359                               vars)
1360                       ebody))
1361       (list 'let (mapcar #'(lambda (x)
1362                              (list (caddr x)
1363                                    (list 'make-symbol
1364                                          (format "--%s--" (car x)))))
1365                          vars)
1366             (apply 'append '(setf)
1367                    (mapcar #'(lambda (x)
1368                                (list (list 'symbol-value (caddr x)) (cadr x)))
1369                            vars))
1370             ebody))))
1371
1372 ;;;###autoload
1373 (defmacro lexical-let* (bindings &rest body)
1374   "(lexical-let* BINDINGS BODY...): like `let*', but lexically scoped.
1375 The main visible difference is that lambdas inside BODY will create
1376 lexical closures as in Common Lisp."
1377   (if (null bindings) (cons 'progn body)
1378     (setq bindings (reverse bindings))
1379     (while bindings
1380       (setq body (list (list* 'lexical-let (list (cl-pop bindings)) body))))
1381     (car body)))
1382
1383 (defun cl-defun-expander (func &rest rest)
1384   (list 'progn
1385         (list 'defalias (list 'quote func)
1386               (list 'function (cons 'lambda rest)))
1387         (list 'quote func)))
1388
1389
1390 ;;; Multiple values.
1391
1392 ;;;###autoload
1393 (defmacro multiple-value-bind (vars form &rest body)
1394   "(multiple-value-bind (SYM SYM...) FORM BODY): collect multiple return values.
1395 FORM must return a list; the BODY is then executed with the first N elements
1396 of this list bound (`let'-style) to each of the symbols SYM in turn.  This
1397 is analogous to the Common Lisp `multiple-value-bind' macro, using lists to
1398 simulate true multiple return values.  For compatibility, (values A B C) is
1399 a synonym for (list A B C)."
1400   (let ((temp (gensym)) (n -1))
1401     (list* 'let* (cons (list temp form)
1402                        (mapcar #'(lambda (v)
1403                                    (list v (list 'nth (setq n (1+ n)) temp)))
1404                                vars))
1405            body)))
1406
1407 ;;;###autoload
1408 (defmacro multiple-value-setq (vars form)
1409   "(multiple-value-setq (SYM SYM...) FORM): collect multiple return values.
1410 FORM must return a list; the first N elements of this list are stored in
1411 each of the symbols SYM in turn.  This is analogous to the Common Lisp
1412 `multiple-value-setq' macro, using lists to simulate true multiple return
1413 values.  For compatibility, (values A B C) is a synonym for (list A B C)."
1414   (cond ((null vars) (list 'progn form nil))
1415         ((null (cdr vars)) (list 'setq (car vars) (list 'car form)))
1416         (t
1417          (let* ((temp (gensym)) (n 0))
1418            (list 'let (list (list temp form))
1419                  (list 'prog1 (list 'setq (cl-pop vars) (list 'car temp))
1420                        (cons 'setq
1421                              (apply 'nconc
1422                                     (mapcar
1423                                      #'(lambda (v)
1424                                          (list v (list
1425                                                   'nth
1426                                                   (setq n (1+ n))
1427                                                   temp)))
1428                                             vars)))))))))
1429
1430
1431 ;;; Declarations.
1432
1433 ;;;###autoload
1434 (defmacro locally (&rest body) (cons 'progn body))
1435 ;;;###autoload
1436 (defmacro the (type form) form)
1437
1438 (defvar cl-proclaim-history t)    ; for future compilers
1439 (defvar cl-declare-stack t)       ; for future compilers
1440
1441 (defun cl-do-proclaim (spec hist)
1442   (and hist (listp cl-proclaim-history) (cl-push spec cl-proclaim-history))
1443   (cond ((eq (car-safe spec) 'special)
1444          (if (boundp 'byte-compile-bound-variables)
1445              (setq byte-compile-bound-variables
1446                    (append
1447                     (mapcar #'(lambda (v) (cons v byte-compile-global-bit))
1448                             (cdr spec))
1449                     byte-compile-bound-variables))))
1450
1451         ((eq (car-safe spec) 'inline)
1452          (while (setq spec (cdr spec))
1453            (or (memq (get (car spec) 'byte-optimizer)
1454                      '(nil byte-compile-inline-expand))
1455                (error "%s already has a byte-optimizer, can't make it inline"
1456                       (car spec)))
1457            (put (car spec) 'byte-optimizer 'byte-compile-inline-expand)))
1458
1459         ((eq (car-safe spec) 'notinline)
1460          (while (setq spec (cdr spec))
1461            (if (eq (get (car spec) 'byte-optimizer)
1462                    'byte-compile-inline-expand)
1463                (put (car spec) 'byte-optimizer nil))))
1464
1465         ((eq (car-safe spec) 'optimize)
1466          (let ((speed (assq (nth 1 (assq 'speed (cdr spec)))
1467                             '((0 . nil) (1 . t) (2 . t) (3 . t))))
1468                (safety (assq (nth 1 (assq 'safety (cdr spec)))
1469                              '((0 . t) (1 . t) (2 . t) (3 . nil)))))
1470            (when speed
1471              (setq cl-optimize-speed (car speed)
1472                    byte-optimize (cdr speed)))
1473            (when safety
1474              (setq cl-optimize-safety (car safety)
1475                    byte-compile-delete-errors (cdr safety)))))
1476
1477         ((and (eq (car-safe spec) 'warn) (boundp 'byte-compile-warnings))
1478          (if (eq byte-compile-warnings t)
1479              ;; XEmacs change
1480              (setq byte-compile-warnings byte-compile-default-warnings))
1481          (while (setq spec (cdr spec))
1482            (if (consp (car spec))
1483                (if (eq (cadar spec) 0)
1484                    (setq byte-compile-warnings
1485                          (delq (caar spec) byte-compile-warnings))
1486                  (setq byte-compile-warnings
1487                        (adjoin (caar spec) byte-compile-warnings)))))))
1488   nil)
1489
1490 ;;; Process any proclamations made before cl-macs was loaded.
1491 (defvar cl-proclaims-deferred)
1492 (let ((p (reverse cl-proclaims-deferred)))
1493   (while p (cl-do-proclaim (cl-pop p) t))
1494   (setq cl-proclaims-deferred nil))
1495
1496 ;;;###autoload
1497 (defmacro declare (&rest specs)
1498   (if (cl-compiling-file)
1499       (while specs
1500         (if (listp cl-declare-stack) (cl-push (car specs) cl-declare-stack))
1501         (cl-do-proclaim (cl-pop specs) nil)))
1502   nil)
1503
1504
1505
1506 ;;; Generalized variables.
1507
1508 ;;;###autoload
1509 (defmacro define-setf-method (func args &rest body)
1510   "(define-setf-method NAME ARGLIST BODY...): define a `setf' method.
1511 This method shows how to handle `setf's to places of the form (NAME ARGS...).
1512 The argument forms ARGS are bound according to ARGLIST, as if NAME were
1513 going to be expanded as a macro, then the BODY forms are executed and must
1514 return a list of five elements: a temporary-variables list, a value-forms
1515 list, a store-variables list (of length one), a store-form, and an access-
1516 form.  See `defsetf' for a simpler way to define most setf-methods."
1517   (append '(eval-when (compile load eval))
1518           (if (stringp (car body))
1519               (list (list 'put (list 'quote func) '(quote setf-documentation)
1520                           (cl-pop body))))
1521           (list (cl-transform-function-property
1522                  func 'setf-method (cons args body)))))
1523
1524 ;;;###autoload
1525 (defmacro defsetf (func arg1 &rest args)
1526   "(defsetf NAME FUNC): define a `setf' method.
1527 This macro is an easy-to-use substitute for `define-setf-method' that works
1528 well for simple place forms.  In the simple `defsetf' form, `setf's of
1529 the form (setf (NAME ARGS...) VAL) are transformed to function or macro
1530 calls of the form (FUNC ARGS... VAL).  Example: (defsetf aref aset).
1531 Alternate form: (defsetf NAME ARGLIST (STORE) BODY...).
1532 Here, the above `setf' call is expanded by binding the argument forms ARGS
1533 according to ARGLIST, binding the value form VAL to STORE, then executing
1534 BODY, which must return a Lisp form that does the necessary `setf' operation.
1535 Actually, ARGLIST and STORE may be bound to temporary variables which are
1536 introduced automatically to preserve proper execution order of the arguments.
1537 Example: (defsetf nth (n x) (v) (list 'setcar (list 'nthcdr n x) v))."
1538   (if (listp arg1)
1539       (let* ((largs nil) (largsr nil)
1540              (temps nil) (tempsr nil)
1541              (restarg nil) (rest-temps nil)
1542              (store-var (car (prog1 (car args) (setq args (cdr args)))))
1543              (store-temp (intern (format "--%s--temp--" store-var)))
1544              (lets1 nil) (lets2 nil)
1545              (docstr nil) (p arg1))
1546         (if (stringp (car args))
1547             (setq docstr (prog1 (car args) (setq args (cdr args)))))
1548         (while (and p (not (eq (car p) '&aux)))
1549           (if (eq (car p) '&rest)
1550               (setq p (cdr p) restarg (car p))
1551             (or (memq (car p) '(&optional &key &allow-other-keys))
1552                 (setq largs (cons (if (consp (car p)) (car (car p)) (car p))
1553                                   largs)
1554                       temps (cons (intern (format "--%s--temp--" (car largs)))
1555                                   temps))))
1556           (setq p (cdr p)))
1557         (setq largs (nreverse largs) temps (nreverse temps))
1558         (if restarg
1559             (setq largsr (append largs (list restarg))
1560                   rest-temps (intern (format "--%s--temp--" restarg))
1561                   tempsr (append temps (list rest-temps)))
1562           (setq largsr largs tempsr temps))
1563         (let ((p1 largs) (p2 temps))
1564           (while p1
1565             (setq lets1 (cons (list (car p2)
1566                                     (list 'gensym (format "--%s--" (car p1))))
1567                               lets1)
1568                   lets2 (cons (list (car p1) (car p2)) lets2)
1569                   p1 (cdr p1) p2 (cdr p2))))
1570         (if restarg (setq lets2 (cons (list restarg rest-temps) lets2)))
1571         (append (list 'define-setf-method func arg1)
1572                 (and docstr (list docstr))
1573                 (list
1574                  (list 'let*
1575                        (nreverse
1576                         (cons (list store-temp
1577                                     (list 'gensym (format "--%s--" store-var)))
1578                               (if restarg
1579                                   (append
1580                                    (list
1581                                     (list rest-temps
1582                                           (list 'mapcar '(quote gensym)
1583                                                 restarg)))
1584                                    lets1)
1585                                 lets1)))
1586                        (list 'list  ; 'values
1587                              (cons (if restarg 'list* 'list) tempsr)
1588                              (cons (if restarg 'list* 'list) largsr)
1589                              (list 'list store-temp)
1590                              (cons 'let*
1591                                    (cons (nreverse
1592                                           (cons (list store-var store-temp)
1593                                                 lets2))
1594                                          args))
1595                              (cons (if restarg 'list* 'list)
1596                                    (cons (list 'quote func) tempsr)))))))
1597     (list 'defsetf func '(&rest args) '(store)
1598           (let ((call (list 'cons (list 'quote arg1)
1599                             '(append args (list store)))))
1600             (if (car args)
1601                 (list 'list '(quote progn) call 'store)
1602               call)))))
1603
1604 ;;; Some standard place types from Common Lisp.
1605 (eval-when-compile (defvar ignored-arg)) ; Warning suppression
1606 (defsetf aref aset)
1607 (defsetf car setcar)
1608 (defsetf cdr setcdr)
1609 (defsetf elt (seq n) (store)
1610   (list 'if (list 'listp seq) (list 'setcar (list 'nthcdr n seq) store)
1611         (list 'aset seq n store)))
1612 (defsetf get (x y &optional ignored-arg) (store) (list 'put x y store))
1613 (defsetf get* (x y &optional ignored-arg) (store) (list 'put x y store))
1614 (defsetf gethash (x h &optional ignored-arg) (store) (list 'cl-puthash x store h))
1615 (defsetf nth (n x) (store) (list 'setcar (list 'nthcdr n x) store))
1616 (defsetf subseq (seq start &optional end) (new)
1617   (list 'progn (list 'replace seq new ':start1 start ':end1 end) new))
1618 (defsetf symbol-function fset)
1619 (defsetf symbol-plist setplist)
1620 (defsetf symbol-value set)
1621
1622 ;;; Various car/cdr aliases.  Note that `cadr' is handled specially.
1623 (defsetf first setcar)
1624 (defsetf second (x) (store) (list 'setcar (list 'cdr x) store))
1625 (defsetf third (x) (store) (list 'setcar (list 'cddr x) store))
1626 (defsetf fourth (x) (store) (list 'setcar (list 'cdddr x) store))
1627 (defsetf fifth (x) (store) (list 'setcar (list 'nthcdr 4 x) store))
1628 (defsetf sixth (x) (store) (list 'setcar (list 'nthcdr 5 x) store))
1629 (defsetf seventh (x) (store) (list 'setcar (list 'nthcdr 6 x) store))
1630 (defsetf eighth (x) (store) (list 'setcar (list 'nthcdr 7 x) store))
1631 (defsetf ninth (x) (store) (list 'setcar (list 'nthcdr 8 x) store))
1632 (defsetf tenth (x) (store) (list 'setcar (list 'nthcdr 9 x) store))
1633 (defsetf rest setcdr)
1634
1635 ;;; Some more Emacs-related place types.
1636 (defsetf buffer-file-name set-visited-file-name t)
1637 (defsetf buffer-modified-p set-buffer-modified-p t)
1638 (defsetf buffer-name rename-buffer t)
1639 (defsetf buffer-string () (store)
1640   (list 'progn '(erase-buffer) (list 'insert store)))
1641 (defsetf buffer-substring cl-set-buffer-substring)
1642 (defsetf current-buffer set-buffer)
1643 (defsetf current-case-table set-case-table)
1644 (defsetf current-column move-to-column t)
1645 (defsetf current-global-map use-global-map t)
1646 (defsetf current-input-mode () (store)
1647   (list 'progn (list 'apply 'set-input-mode store) store))
1648 (defsetf current-local-map use-local-map t)
1649 (defsetf current-window-configuration set-window-configuration t)
1650 (defsetf default-file-modes set-default-file-modes t)
1651 (defsetf default-value set-default)
1652 (defsetf documentation-property put)
1653 (defsetf extent-face set-extent-face)
1654 (defsetf extent-priority set-extent-priority)
1655 (defsetf extent-property (x y &optional ignored-arg) (arg)
1656   (list 'set-extent-property x y arg))
1657 (defsetf extent-start-position (ext) (store)
1658   `(progn (set-extent-endpoints ,ext ,store (extent-end-position ,ext))
1659           ,store))
1660 (defsetf extent-end-position (ext) (store)
1661   `(progn (set-extent-endpoints ,ext (extent-start-position ,ext) ,store)
1662           ,store))
1663 (defsetf face-background (f &optional s) (x) (list 'set-face-background f x s))
1664 (defsetf face-background-pixmap (f &optional s) (x)
1665   (list 'set-face-background-pixmap f x s))
1666 (defsetf face-font (f &optional s) (x) (list 'set-face-font f x s))
1667 (defsetf face-foreground (f &optional s) (x) (list 'set-face-foreground f x s))
1668 (defsetf face-underline-p (f &optional s) (x)
1669   (list 'set-face-underline-p f x s))
1670 (defsetf file-modes set-file-modes t)
1671 (defsetf frame-parameters modify-frame-parameters t)
1672 (defsetf frame-visible-p cl-set-frame-visible-p)
1673 (defsetf frame-properties (&optional f) (p)
1674   `(progn (set-frame-properties ,f ,p) ,p))
1675 (defsetf frame-property (f p &optional ignored-arg) (v)
1676   `(progn (set-frame-property ,f ,v) ,p))
1677 (defsetf frame-width (&optional f) (v)
1678   `(progn (set-frame-width ,f ,v) ,v))
1679 (defsetf frame-height (&optional f) (v)
1680   `(progn (set-frame-height ,f ,v) ,v))
1681 (defsetf current-frame-configuration set-frame-configuration)
1682
1683 ;; XEmacs: new stuff
1684 ;; Consoles
1685 (defsetf selected-console select-console t)
1686 (defsetf selected-device select-device t)
1687 (defsetf device-baud-rate (&optional d) (v)
1688   `(set-device-baud-rate ,d ,v))
1689 ;; This setf method is a bad idea, because set-specifier *adds* a
1690 ;; specification, rather than just setting it.  The net effect is that
1691 ;; it makes specifier-instance return VAL, but other things don't work
1692 ;; as expected -- letf, to name one.
1693 ;(defsetf specifier-instance (spec &optional dom def nof) (val)
1694 ;  `(set-specifier ,spec ,val ,dom))
1695
1696 ;; Annotations
1697 (defsetf annotation-glyph set-annotation-glyph)
1698 (defsetf annotation-down-glyph set-annotation-down-glyph)
1699 (defsetf annotation-face set-annotation-face)
1700 (defsetf annotation-layout set-annotation-layout)
1701 (defsetf annotation-data set-annotation-data)
1702 (defsetf annotation-action set-annotation-action)
1703 (defsetf annotation-menu set-annotation-menu)
1704 ;; Widget
1705 (defsetf widget-get widget-put t)
1706 (defsetf widget-value widget-value-set t)
1707
1708 ;; Misc
1709 (defsetf recent-keys-ring-size set-recent-keys-ring-size)
1710 (defsetf symbol-value-in-buffer (s b &optional ignored-arg) (store)
1711   `(with-current-buffer ,b (set ,s ,store)))
1712 (defsetf symbol-value-in-console (s c &optional ignored-arg) (store)
1713   `(letf (((selected-console) ,c))
1714      (set ,s ,store)))
1715
1716 (defsetf buffer-dedicated-frame (&optional b) (v)
1717   `(set-buffer-dedicated-frame ,b ,v))
1718 (defsetf console-type-image-conversion-list
1719   set-console-type-image-conversion-list)
1720 (defsetf default-toolbar-position set-default-toolbar-position)
1721 (defsetf device-class (&optional d) (v)
1722   `(set-device-class ,d ,v))
1723 (defsetf extent-begin-glyph set-extent-begin-glyph)
1724 (defsetf extent-begin-glyph-layout set-extent-begin-glyph-layout)
1725 (defsetf extent-end-glyph set-extent-end-glyph)
1726 (defsetf extent-end-glyph-layout set-extent-end-glyph-layout)
1727 (defsetf extent-keymap set-extent-keymap)
1728 (defsetf extent-parent set-extent-parent)
1729 (defsetf extent-properties set-extent-properties)
1730 ;; Avoid adding various face and glyph functions.
1731 (defsetf frame-selected-window (&optional f) (v)
1732   `(set-frame-selected-window ,f ,v))
1733 (defsetf glyph-image (glyph &optional domain) (i)
1734   (list 'set-glyph-image glyph i domain))
1735 (defsetf itimer-function set-itimer-function)
1736 (defsetf itimer-function-arguments set-itimer-function-arguments)
1737 (defsetf itimer-is-idle set-itimer-is-idle)
1738 (defsetf itimer-recorded-run-time set-itimer-recorded-run-time)
1739 (defsetf itimer-restart set-itimer-restart)
1740 (defsetf itimer-uses-arguments set-itimer-uses-arguments)
1741 (defsetf itimer-value set-itimer-value)
1742 (defsetf keymap-parents set-keymap-parents)
1743 (defsetf marker-insertion-type set-marker-insertion-type)
1744 (defsetf mouse-pixel-position (&optional d) (v)
1745   `(progn
1746      (set-mouse-pixel-position ,d ,(car v) ,(car (cdr v)) ,(cdr (cdr v)))
1747      ,v))
1748 (defsetf trunc-stack-length set-trunc-stack-length)
1749 (defsetf trunc-stack-stack set-trunc-stack-stack)
1750 (defsetf undoable-stack-max set-undoable-stack-max)
1751 (defsetf weak-list-list set-weak-list-list)
1752
1753
1754 (defsetf getenv setenv t)
1755 (defsetf get-register set-register)
1756 (defsetf global-key-binding global-set-key)
1757 (defsetf keymap-parent set-keymap-parent)
1758 (defsetf keymap-name set-keymap-name)
1759 (defsetf keymap-prompt set-keymap-prompt)
1760 (defsetf keymap-default-binding set-keymap-default-binding)
1761 (defsetf local-key-binding local-set-key)
1762 (defsetf mark set-mark t)
1763 (defsetf mark-marker set-mark t)
1764 (defsetf marker-position set-marker t)
1765 (defsetf match-data store-match-data t)
1766 (defsetf mouse-position (scr) (store)
1767   (list 'set-mouse-position scr (list 'car store) (list 'cadr store)
1768         (list 'cddr store)))
1769 (defsetf overlay-get overlay-put)
1770 (defsetf overlay-start (ov) (store)
1771   (list 'progn (list 'move-overlay ov store (list 'overlay-end ov)) store))
1772 (defsetf overlay-end (ov) (store)
1773   (list 'progn (list 'move-overlay ov (list 'overlay-start ov) store) store))
1774 (defsetf point goto-char)
1775 (defsetf point-marker goto-char t)
1776 (defsetf point-max () (store)
1777   (list 'progn (list 'narrow-to-region '(point-min) store) store))
1778 (defsetf point-min () (store)
1779   (list 'progn (list 'narrow-to-region store '(point-max)) store))
1780 (defsetf process-buffer set-process-buffer)
1781 (defsetf process-filter set-process-filter)
1782 (defsetf process-sentinel set-process-sentinel)
1783 (defsetf read-mouse-position (scr) (store)
1784   (list 'set-mouse-position scr (list 'car store) (list 'cdr store)))
1785 (defsetf selected-window select-window)
1786 (defsetf selected-frame select-frame)
1787 (defsetf standard-case-table set-standard-case-table)
1788 (defsetf syntax-table set-syntax-table)
1789 (defsetf visited-file-modtime set-visited-file-modtime t)
1790 (defsetf window-buffer set-window-buffer t)
1791 (defsetf window-display-table set-window-display-table t)
1792 (defsetf window-dedicated-p set-window-dedicated-p t)
1793 (defsetf window-height (&optional window) (store)
1794   `(progn (enlarge-window (- ,store (window-height)) nil ,window) ,store))
1795 (defsetf window-hscroll set-window-hscroll)
1796 (defsetf window-point set-window-point)
1797 (defsetf window-start set-window-start)
1798 (defsetf window-width (&optional window) (store)
1799   `(progn (enlarge-window (- ,store (window-width)) t ,window) ,store))
1800 (defsetf x-get-cutbuffer x-store-cutbuffer t)
1801 (defsetf x-get-cut-buffer x-store-cut-buffer t)   ; groan.
1802 (defsetf x-get-secondary-selection x-own-secondary-selection t)
1803 (defsetf x-get-selection x-own-selection t)
1804 (defsetf get-selection own-selection t)
1805
1806 ;;; More complex setf-methods.
1807 ;;; These should take &environment arguments, but since full arglists aren't
1808 ;;; available while compiling cl-macs, we fake it by referring to the global
1809 ;;; variable cl-macro-environment directly.
1810
1811 (define-setf-method apply (func arg1 &rest rest)
1812   (or (and (memq (car-safe func) '(quote function function*))
1813            (symbolp (car-safe (cdr-safe func))))
1814       (error "First arg to apply in setf is not (function SYM): %s" func))
1815   (let* ((form (cons (nth 1 func) (cons arg1 rest)))
1816          (method (get-setf-method form cl-macro-environment)))
1817     (list (car method) (nth 1 method) (nth 2 method)
1818           (cl-setf-make-apply (nth 3 method) (cadr func) (car method))
1819           (cl-setf-make-apply (nth 4 method) (cadr func) (car method)))))
1820
1821 (defun cl-setf-make-apply (form func temps)
1822   (if (eq (car form) 'progn)
1823       (list* 'progn (cl-setf-make-apply (cadr form) func temps) (cddr form))
1824     (or (equal (last form) (last temps))
1825         (error "%s is not suitable for use with setf-of-apply" func))
1826     (list* 'apply (list 'quote (car form)) (cdr form))))
1827
1828 (define-setf-method nthcdr (n place)
1829   (let ((method (get-setf-method place cl-macro-environment))
1830         (n-temp (gensym "--nthcdr-n--"))
1831         (store-temp (gensym "--nthcdr-store--")))
1832     (list (cons n-temp (car method))
1833           (cons n (nth 1 method))
1834           (list store-temp)
1835           (list 'let (list (list (car (nth 2 method))
1836                                  (list 'cl-set-nthcdr n-temp (nth 4 method)
1837                                        store-temp)))
1838                 (nth 3 method) store-temp)
1839           (list 'nthcdr n-temp (nth 4 method)))))
1840
1841 (define-setf-method getf (place tag &optional def)
1842   (let ((method (get-setf-method place cl-macro-environment))
1843         (tag-temp (gensym "--getf-tag--"))
1844         (def-temp (gensym "--getf-def--"))
1845         (store-temp (gensym "--getf-store--")))
1846     (list (append (car method) (list tag-temp def-temp))
1847           (append (nth 1 method) (list tag def))
1848           (list store-temp)
1849           (list 'let (list (list (car (nth 2 method))
1850                                  (list 'cl-set-getf (nth 4 method)
1851                                        tag-temp store-temp)))
1852                 (nth 3 method) store-temp)
1853           (list 'getf (nth 4 method) tag-temp def-temp))))
1854
1855 (define-setf-method substring (place from &optional to)
1856   (let ((method (get-setf-method place cl-macro-environment))
1857         (from-temp (gensym "--substring-from--"))
1858         (to-temp (gensym "--substring-to--"))
1859         (store-temp (gensym "--substring-store--")))
1860     (list (append (car method) (list from-temp to-temp))
1861           (append (nth 1 method) (list from to))
1862           (list store-temp)
1863           (list 'let (list (list (car (nth 2 method))
1864                                  (list 'cl-set-substring (nth 4 method)
1865                                        from-temp to-temp store-temp)))
1866                 (nth 3 method) store-temp)
1867           (list 'substring (nth 4 method) from-temp to-temp))))
1868
1869 (define-setf-method values (&rest args)
1870   (let ((methods (mapcar #'(lambda (x)
1871                              (get-setf-method x cl-macro-environment))
1872                          args))
1873         (store-temp (gensym "--values-store--")))
1874     (list (apply 'append (mapcar 'first methods))
1875           (apply 'append (mapcar 'second methods))
1876           (list store-temp)
1877           (cons 'list
1878                 (mapcar #'(lambda (m)
1879                             (cl-setf-do-store (cons (car (third m)) (fourth m))
1880                                               (list 'pop store-temp)))
1881                         methods))
1882           (cons 'list (mapcar 'fifth methods)))))
1883
1884 ;;; Getting and optimizing setf-methods.
1885 ;;;###autoload
1886 (defun get-setf-method (place &optional env)
1887   "Return a list of five values describing the setf-method for PLACE.
1888 PLACE may be any Lisp form which can appear as the PLACE argument to
1889 a macro like `setf' or `incf'."
1890   (if (symbolp place)
1891       (let ((temp (gensym "--setf--")))
1892         (list nil nil (list temp) (list 'setq place temp) place))
1893     (or (and (symbolp (car place))
1894              (let* ((func (car place))
1895                     (name (symbol-name func))
1896                     (method (get func 'setf-method))
1897                     (case-fold-search nil))
1898                (or (and method
1899                         (let ((cl-macro-environment env))
1900                           (setq method (apply method (cdr place))))
1901                         (if (and (consp method) (= (length method) 5))
1902                             method
1903                           (error "Setf-method for %s returns malformed method"
1904                                  func)))
1905                    (and (save-match-data
1906                           (string-match "\\`c[ad][ad][ad]?[ad]?r\\'" name))
1907                         (get-setf-method (compiler-macroexpand place)))
1908                    (and (eq func 'edebug-after)
1909                         (get-setf-method (nth (1- (length place)) place)
1910                                          env)))))
1911         (if (eq place (setq place (macroexpand place env)))
1912             (if (and (symbolp (car place)) (fboundp (car place))
1913                      (symbolp (symbol-function (car place))))
1914                 (get-setf-method (cons (symbol-function (car place))
1915                                        (cdr place)) env)
1916               (error "No setf-method known for %s" (car place)))
1917           (get-setf-method place env)))))
1918
1919 (defun cl-setf-do-modify (place opt-expr)
1920   (let* ((method (get-setf-method place cl-macro-environment))
1921          (temps (car method)) (values (nth 1 method))
1922          (lets nil) (subs nil)
1923          (optimize (and (not (eq opt-expr 'no-opt))
1924                         (or (and (not (eq opt-expr 'unsafe))
1925                                  (cl-safe-expr-p opt-expr))
1926                             (cl-setf-simple-store-p (car (nth 2 method))
1927                                                     (nth 3 method)))))
1928          (simple (and optimize (consp place) (cl-simple-exprs-p (cdr place)))))
1929     (while values
1930       (if (or simple (cl-const-expr-p (car values)))
1931           (cl-push (cons (cl-pop temps) (cl-pop values)) subs)
1932         (cl-push (list (cl-pop temps) (cl-pop values)) lets)))
1933     (list (nreverse lets)
1934           (cons (car (nth 2 method)) (sublis subs (nth 3 method)))
1935           (sublis subs (nth 4 method)))))
1936
1937 (defun cl-setf-do-store (spec val)
1938   (let ((sym (car spec))
1939         (form (cdr spec)))
1940     (if (or (cl-const-expr-p val)
1941             (and (cl-simple-expr-p val) (eq (cl-expr-contains form sym) 1))
1942             (cl-setf-simple-store-p sym form))
1943         (subst val sym form)
1944       (list 'let (list (list sym val)) form))))
1945
1946 (defun cl-setf-simple-store-p (sym form)
1947   (and (consp form) (eq (cl-expr-contains form sym) 1)
1948        (eq (nth (1- (length form)) form) sym)
1949        (symbolp (car form)) (fboundp (car form))
1950        (not (eq (car-safe (symbol-function (car form))) 'macro))))
1951
1952 ;;; The standard modify macros.
1953 ;;;###autoload
1954 (defmacro setf (&rest args)
1955   "(setf PLACE VAL PLACE VAL ...): set each PLACE to the value of its VAL.
1956 This is a generalized version of `setq'; the PLACEs may be symbolic
1957 references such as (car x) or (aref x i), as well as plain symbols.
1958 For example, (setf (cadar x) y) is equivalent to (setcar (cdar x) y).
1959 The return value is the last VAL in the list."
1960   (if (cdr (cdr args))
1961       (let ((sets nil))
1962         (while args (cl-push (list 'setf (cl-pop args) (cl-pop args)) sets))
1963         (cons 'progn (nreverse sets)))
1964     (if (symbolp (car args))
1965         (and args (cons 'setq args))
1966       (let* ((method (cl-setf-do-modify (car args) (nth 1 args)))
1967              (store (cl-setf-do-store (nth 1 method) (nth 1 args))))
1968         (if (car method) (list 'let* (car method) store) store)))))
1969
1970 ;;;###autoload
1971 (defmacro psetf (&rest args)
1972   "(psetf PLACE VAL PLACE VAL ...): set PLACEs to the values VALs in parallel.
1973 This is like `setf', except that all VAL forms are evaluated (in order)
1974 before assigning any PLACEs to the corresponding values."
1975   (let ((p args) (simple t) (vars nil))
1976     (while p
1977       (if (or (not (symbolp (car p))) (cl-expr-depends-p (nth 1 p) vars))
1978           (setq simple nil))
1979       (if (memq (car p) vars)
1980           (error "Destination duplicated in psetf: %s" (car p)))
1981       (cl-push (cl-pop p) vars)
1982       (or p (error "Odd number of arguments to psetf"))
1983       (cl-pop p))
1984     (if simple
1985         (list 'progn (cons 'setf args) nil)
1986       (setq args (reverse args))
1987       (let ((expr (list 'setf (cadr args) (car args))))
1988         (while (setq args (cddr args))
1989           (setq expr (list 'setf (cadr args) (list 'prog1 (car args) expr))))
1990         (list 'progn expr nil)))))
1991
1992 ;;;###autoload
1993 (defun cl-do-pop (place)
1994   (if (cl-simple-expr-p place)
1995       (list 'prog1 (list 'car place) (list 'setf place (list 'cdr place)))
1996     (let* ((method (cl-setf-do-modify place t))
1997            (temp (gensym "--pop--")))
1998       (list 'let*
1999             (append (car method)
2000                     (list (list temp (nth 2 method))))
2001             (list 'prog1
2002                   (list 'car temp)
2003                   (cl-setf-do-store (nth 1 method) (list 'cdr temp)))))))
2004
2005 ;;;###autoload
2006 (defmacro remf (place tag)
2007   "(remf PLACE TAG): remove TAG from property list PLACE.
2008 PLACE may be a symbol, or any generalized variable allowed by `setf'.
2009 The form returns true if TAG was found and removed, nil otherwise."
2010   (let* ((method (cl-setf-do-modify place t))
2011          (tag-temp (and (not (cl-const-expr-p tag)) (gensym "--remf-tag--")))
2012          (val-temp (and (not (cl-simple-expr-p place))
2013                         (gensym "--remf-place--")))
2014          (ttag (or tag-temp tag))
2015          (tval (or val-temp (nth 2 method))))
2016     (list 'let*
2017           (append (car method)
2018                   (and val-temp (list (list val-temp (nth 2 method))))
2019                   (and tag-temp (list (list tag-temp tag))))
2020           (list 'if (list 'eq ttag (list 'car tval))
2021                 (list 'progn
2022                       (cl-setf-do-store (nth 1 method) (list 'cddr tval))
2023                       t)
2024                 (list 'cl-do-remf tval ttag)))))
2025
2026 ;;;###autoload
2027 (defmacro shiftf (place &rest args)
2028   "(shiftf PLACE PLACE... VAL): shift left among PLACEs.
2029 Example: (shiftf A B C) sets A to B, B to C, and returns the old A.
2030 Each PLACE may be a symbol, or any generalized variable allowed by `setf'."
2031   (if (not (memq nil (mapcar 'symbolp (butlast (cons place args)))))
2032       (list* 'prog1 place
2033              (let ((sets nil))
2034                (while args
2035                  (cl-push (list 'setq place (car args)) sets)
2036                  (setq place (cl-pop args)))
2037                (nreverse sets)))
2038     (let* ((places (reverse (cons place args)))
2039            (form (cl-pop places)))
2040       (while places
2041         (let ((method (cl-setf-do-modify (cl-pop places) 'unsafe)))
2042           (setq form (list 'let* (car method)
2043                            (list 'prog1 (nth 2 method)
2044                                  (cl-setf-do-store (nth 1 method) form))))))
2045       form)))
2046
2047 ;;;###autoload
2048 (defmacro rotatef (&rest args)
2049   "(rotatef PLACE...): rotate left among PLACEs.
2050 Example: (rotatef A B C) sets A to B, B to C, and C to A.  It returns nil.
2051 Each PLACE may be a symbol, or any generalized variable allowed by `setf'."
2052   (if (not (memq nil (mapcar 'symbolp args)))
2053       (and (cdr args)
2054            (let ((sets nil)
2055                  (first (car args)))
2056              (while (cdr args)
2057                (setq sets (nconc sets (list (cl-pop args) (car args)))))
2058              (nconc (list 'psetf) sets (list (car args) first))))
2059     (let* ((places (reverse args))
2060            (temp (gensym "--rotatef--"))
2061            (form temp))
2062       (while (cdr places)
2063         (let ((method (cl-setf-do-modify (cl-pop places) 'unsafe)))
2064           (setq form (list 'let* (car method)
2065                            (list 'prog1 (nth 2 method)
2066                                  (cl-setf-do-store (nth 1 method) form))))))
2067       (let ((method (cl-setf-do-modify (car places) 'unsafe)))
2068         (list 'let* (append (car method) (list (list temp (nth 2 method))))
2069               (cl-setf-do-store (nth 1 method) form) nil)))))
2070
2071 ;;;###autoload
2072 (defmacro letf (bindings &rest body)
2073   "(letf ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
2074 This is the analogue of `let', but with generalized variables (in the
2075 sense of `setf') for the PLACEs.  Each PLACE is set to the corresponding
2076 VALUE, then the BODY forms are executed.  On exit, either normally or
2077 because of a `throw' or error, the PLACEs are set back to their original
2078 values.  Note that this macro is *not* available in Common Lisp.
2079 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
2080 the PLACE is not modified before executing BODY."
2081   (if (and (not (cdr bindings)) (cdar bindings) (symbolp (caar bindings)))
2082       (list* 'let bindings body)
2083     (let ((lets nil)
2084           (rev (reverse bindings)))
2085       (while rev
2086         (let* ((place (if (symbolp (caar rev))
2087                           (list 'symbol-value (list 'quote (caar rev)))
2088                         (caar rev)))
2089                (value (cadar rev))
2090                (method (cl-setf-do-modify place 'no-opt))
2091                (save (gensym "--letf-save--"))
2092                (bound (and (memq (car place) '(symbol-value symbol-function))
2093                            (gensym "--letf-bound--")))
2094                (temp (and (not (cl-const-expr-p value)) (cdr bindings)
2095                           (gensym "--letf-val--"))))
2096           (setq lets (nconc (car method)
2097                             (if bound
2098                                 (list (list bound
2099                                             (list (if (eq (car place)
2100                                                           'symbol-value)
2101                                                       'boundp 'fboundp)
2102                                                   (nth 1 (nth 2 method))))
2103                                       (list save (list 'and bound
2104                                                        (nth 2 method))))
2105                               (list (list save (nth 2 method))))
2106                             (and temp (list (list temp value)))
2107                             lets)
2108                 body (list
2109                       (list 'unwind-protect
2110                             (cons 'progn
2111                                   (if (cdr (car rev))
2112                                       (cons (cl-setf-do-store (nth 1 method)
2113                                                               (or temp value))
2114                                             body)
2115                                     body))
2116                             (if bound
2117                                 (list 'if bound
2118                                       (cl-setf-do-store (nth 1 method) save)
2119                                       (list (if (eq (car place) 'symbol-value)
2120                                                 'makunbound 'fmakunbound)
2121                                             (nth 1 (nth 2 method))))
2122                               (cl-setf-do-store (nth 1 method) save))))
2123                 rev (cdr rev))))
2124       (list* 'let* lets body))))
2125
2126 ;;;###autoload
2127 (defmacro letf* (bindings &rest body)
2128   "(letf* ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs.
2129 This is the analogue of `let*', but with generalized variables (in the
2130 sense of `setf') for the PLACEs.  Each PLACE is set to the corresponding
2131 VALUE, then the BODY forms are executed.  On exit, either normally or
2132 because of a `throw' or error, the PLACEs are set back to their original
2133 values.  Note that this macro is *not* available in Common Lisp.
2134 As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)',
2135 the PLACE is not modified before executing BODY."
2136   (if (null bindings)
2137       (cons 'progn body)
2138     (setq bindings (reverse bindings))
2139     (while bindings
2140       (setq body (list (list* 'letf (list (cl-pop bindings)) body))))
2141     (car body)))
2142
2143 ;;;###autoload
2144 (defmacro callf (func place &rest args)
2145   "(callf FUNC PLACE ARGS...): set PLACE to (FUNC PLACE ARGS...).
2146 FUNC should be an unquoted function name.  PLACE may be a symbol,
2147 or any generalized variable allowed by `setf'."
2148   (let* ((method (cl-setf-do-modify place (cons 'list args)))
2149          (rargs (cons (nth 2 method) args)))
2150     (list 'let* (car method)
2151           (cl-setf-do-store (nth 1 method)
2152                             (if (symbolp func) (cons func rargs)
2153                               (list* 'funcall (list 'function func)
2154                                      rargs))))))
2155
2156 ;;;###autoload
2157 (defmacro callf2 (func arg1 place &rest args)
2158   "(callf2 FUNC ARG1 PLACE ARGS...): set PLACE to (FUNC ARG1 PLACE ARGS...).
2159 Like `callf', but PLACE is the second argument of FUNC, not the first."
2160   (if (and (cl-safe-expr-p arg1) (cl-simple-expr-p place) (symbolp func))
2161       (list 'setf place (list* func arg1 place args))
2162     (let* ((method (cl-setf-do-modify place (cons 'list args)))
2163            (temp (and (not (cl-const-expr-p arg1)) (gensym "--arg1--")))
2164            (rargs (list* (or temp arg1) (nth 2 method) args)))
2165       (list 'let* (append (and temp (list (list temp arg1))) (car method))
2166             (cl-setf-do-store (nth 1 method)
2167                               (if (symbolp func) (cons func rargs)
2168                                 (list* 'funcall (list 'function func)
2169                                        rargs)))))))
2170
2171 ;;;###autoload
2172 (defmacro define-modify-macro (name arglist func &optional doc)
2173   "(define-modify-macro NAME ARGLIST FUNC): define a `setf'-like modify macro.
2174 If NAME is called, it combines its PLACE argument with the other arguments
2175 from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +)"
2176   (if (memq '&key arglist) (error "&key not allowed in define-modify-macro"))
2177   (let ((place (gensym "--place--")))
2178     (list 'defmacro* name (cons place arglist) doc
2179           (list* (if (memq '&rest arglist) 'list* 'list)
2180                  '(quote callf) (list 'quote func) place
2181                  (cl-arglist-args arglist)))))
2182
2183
2184 ;;; Structures.
2185
2186 ;;;###autoload
2187 (defmacro defstruct (struct &rest descs)
2188   "(defstruct (NAME OPTIONS...) (SLOT SLOT-OPTS...)...): define a struct type.
2189 This macro defines a new Lisp data type called NAME, which contains data
2190 stored in SLOTs.  This defines a `make-NAME' constructor, a `copy-NAME'
2191 copier, a `NAME-p' predicate, and setf-able `NAME-SLOT' accessors."
2192   (let* ((name (if (consp struct) (car struct) struct))
2193          (opts (cdr-safe struct))
2194          (slots nil)
2195          (defaults nil)
2196          (conc-name (concat (symbol-name name) "-"))
2197          (constructor (intern (format "make-%s" name)))
2198          (constrs nil)
2199          (copier (intern (format "copy-%s" name)))
2200          (predicate (intern (format "%s-p" name)))
2201          (print-func nil) (print-auto nil)
2202          (safety (if (cl-compiling-file) cl-optimize-safety 3))
2203          (include nil)
2204          (tag (intern (format "cl-struct-%s" name)))
2205          (tag-symbol (intern (format "cl-struct-%s-tags" name)))
2206          (include-descs nil)
2207          (side-eff nil)
2208          (type nil)
2209          (named nil)
2210          (forms nil)
2211          pred-form pred-check)
2212     (if (stringp (car descs))
2213         (cl-push (list 'put (list 'quote name) '(quote structure-documentation)
2214                        (cl-pop descs)) forms))
2215     (setq descs (cons '(cl-tag-slot)
2216                       (mapcar #'(lambda (x) (if (consp x) x (list x)))
2217                               descs)))
2218     (while opts
2219       (let ((opt (if (consp (car opts)) (caar opts) (car opts)))
2220             (args (cdr-safe (cl-pop opts))))
2221         (cond ((eq opt ':conc-name)
2222                (if args
2223                    (setq conc-name (if (car args)
2224                                        (symbol-name (car args)) ""))))
2225               ((eq opt ':constructor)
2226                (if (cdr args)
2227                    (cl-push args constrs)
2228                  (if args (setq constructor (car args)))))
2229               ((eq opt ':copier)
2230                (if args (setq copier (car args))))
2231               ((eq opt ':predicate)
2232                (if args (setq predicate (car args))))
2233               ((eq opt ':include)
2234                (setq include (car args)
2235                      include-descs (mapcar #'(lambda (x)
2236                                                (if (consp x) x (list x)))
2237                                            (cdr args))))
2238               ((eq opt ':print-function)
2239                (setq print-func (car args)))
2240               ((eq opt ':type)
2241                (setq type (car args)))
2242               ((eq opt ':named)
2243                (setq named t))
2244               ((eq opt ':initial-offset)
2245                (setq descs (nconc (make-list (car args) '(cl-skip-slot))
2246                                   descs)))
2247               (t
2248                (error "Slot option %s unrecognized" opt)))))
2249     (if print-func
2250         (setq print-func (list 'progn
2251                                (list 'funcall (list 'function print-func)
2252                                      'cl-x 'cl-s 'cl-n) t))
2253       (or type (and include (not (get include 'cl-struct-print)))
2254           (setq print-auto t
2255                 print-func (and (or (not (or include type)) (null print-func))
2256                                 (list 'progn
2257                                       (list 'princ (format "#S(%s" name)
2258                                             'cl-s))))))
2259     (if include
2260         (let ((inc-type (get include 'cl-struct-type))
2261               (old-descs (get include 'cl-struct-slots)))
2262           (or inc-type (error "%s is not a struct name" include))
2263           (and type (not (eq (car inc-type) type))
2264                (error ":type disagrees with :include for %s" name))
2265           (while include-descs
2266             (setcar (memq (or (assq (caar include-descs) old-descs)
2267                               (error "No slot %s in included struct %s"
2268                                      (caar include-descs) include))
2269                           old-descs)
2270                     (cl-pop include-descs)))
2271           (setq descs (append old-descs (delq (assq 'cl-tag-slot descs) descs))
2272                 type (car inc-type)
2273                 named (assq 'cl-tag-slot descs))
2274           (if (cadr inc-type) (setq tag name named t))
2275           (let ((incl include))
2276             (while incl
2277               (cl-push (list 'pushnew (list 'quote tag)
2278                              (intern (format "cl-struct-%s-tags" incl)))
2279                        forms)
2280               (setq incl (get incl 'cl-struct-include)))))
2281       (if type
2282           (progn
2283             (or (memq type '(vector list))
2284                 (error "Illegal :type specifier: %s" type))
2285             (if named (setq tag name)))
2286         (setq type 'vector named 'true)))
2287     (or named (setq descs (delq (assq 'cl-tag-slot descs) descs)))
2288     (cl-push (list 'defvar tag-symbol) forms)
2289     (setq pred-form (and named
2290                          (let ((pos (- (length descs)
2291                                        (length (memq (assq 'cl-tag-slot descs)
2292                                                      descs)))))
2293                            (if (eq type 'vector)
2294                                (list 'and '(vectorp cl-x)
2295                                      (list '>= '(length cl-x) (length descs))
2296                                      (list 'memq (list 'aref 'cl-x pos)
2297                                            tag-symbol))
2298                              (if (= pos 0)
2299                                  (list 'memq '(car-safe cl-x) tag-symbol)
2300                                (list 'and '(consp cl-x)
2301                                      (list 'memq (list 'nth pos 'cl-x)
2302                                            tag-symbol))))))
2303           pred-check (and pred-form (> safety 0)
2304                           (if (and (eq (caadr pred-form) 'vectorp)
2305                                    (= safety 1))
2306                               (cons 'and (cdddr pred-form)) pred-form)))
2307     (let ((pos 0) (descp descs))
2308       (while descp
2309         (let* ((desc (cl-pop descp))
2310                (slot (car desc)))
2311           (if (memq slot '(cl-tag-slot cl-skip-slot))
2312               (progn
2313                 (cl-push nil slots)
2314                 (cl-push (and (eq slot 'cl-tag-slot) (list 'quote tag))
2315                          defaults))
2316             (if (assq slot descp)
2317                 (error "Duplicate slots named %s in %s" slot name))
2318             (let ((accessor (intern (format "%s%s" conc-name slot))))
2319               (cl-push slot slots)
2320               (cl-push (nth 1 desc) defaults)
2321               (cl-push (list*
2322                         'defsubst* accessor '(cl-x)
2323                         (append
2324                          (and pred-check
2325                               (list (list 'or pred-check
2326                                           (list 'error
2327                                                 (format "%s accessing a non-%s"
2328                                                         accessor name)
2329                                                 'cl-x))))
2330                          (list (if (eq type 'vector) (list 'aref 'cl-x pos)
2331                                  (if (= pos 0) '(car cl-x)
2332                                    (list 'nth pos 'cl-x)))))) forms)
2333               (cl-push (cons accessor t) side-eff)
2334               (cl-push (list 'define-setf-method accessor '(cl-x)
2335                              (if (cadr (memq ':read-only (cddr desc)))
2336                                  (list 'error (format "%s is a read-only slot"
2337                                                       accessor))
2338                                (list 'cl-struct-setf-expander 'cl-x
2339                                      (list 'quote name) (list 'quote accessor)
2340                                      (and pred-check (list 'quote pred-check))
2341                                      pos)))
2342                        forms)
2343               (if print-auto
2344                   (nconc print-func
2345                          (list (list 'princ (format " %s" slot) 'cl-s)
2346                                (list 'prin1 (list accessor 'cl-x) 'cl-s)))))))
2347         (setq pos (1+ pos))))
2348     (setq slots (nreverse slots)
2349           defaults (nreverse defaults))
2350     (and predicate pred-form
2351          (progn (cl-push (list 'defsubst* predicate '(cl-x)
2352                                (if (eq (car pred-form) 'and)
2353                                    (append pred-form '(t))
2354                                  (list 'and pred-form t))) forms)
2355                 (cl-push (cons predicate 'error-free) side-eff)))
2356     (and copier
2357          (progn (cl-push (list 'defun copier '(x) '(copy-sequence x)) forms)
2358                 (cl-push (cons copier t) side-eff)))
2359     (if constructor
2360         (cl-push (list constructor
2361                        (cons '&key (delq nil (copy-sequence slots))))
2362                  constrs))
2363     (while constrs
2364       (let* ((name (caar constrs))
2365              (args (cadr (cl-pop constrs)))
2366              (anames (cl-arglist-args args))
2367              (make (mapcar* #'(lambda (s d) (if (memq s anames) s d))
2368                             slots defaults)))
2369         (cl-push (list 'defsubst* name
2370                        (list* '&cl-defs (list 'quote (cons nil descs)) args)
2371                        (cons type make)) forms)
2372         (if (cl-safe-expr-p (cons 'progn (mapcar 'second descs)))
2373             (cl-push (cons name t) side-eff))))
2374     (if print-auto (nconc print-func (list '(princ ")" cl-s) t)))
2375     (if print-func
2376         (cl-push (list 'push
2377                        (list 'function
2378                              (list 'lambda '(cl-x cl-s cl-n)
2379                                    (list 'and pred-form print-func)))
2380                        'custom-print-functions) forms))
2381     (cl-push (list 'setq tag-symbol (list 'list (list 'quote tag))) forms)
2382     (cl-push (list* 'eval-when '(compile load eval)
2383                     (list 'put (list 'quote name) '(quote cl-struct-slots)
2384                           (list 'quote descs))
2385                     (list 'put (list 'quote name) '(quote cl-struct-type)
2386                           (list 'quote (list type (eq named t))))
2387                     (list 'put (list 'quote name) '(quote cl-struct-include)
2388                           (list 'quote include))
2389                     (list 'put (list 'quote name) '(quote cl-struct-print)
2390                           print-auto)
2391                     (mapcar #'(lambda (x)
2392                                 (list 'put (list 'quote (car x))
2393                                       '(quote side-effect-free)
2394                                       (list 'quote (cdr x))))
2395                             side-eff))
2396              forms)
2397     (cons 'progn (nreverse (cons (list 'quote name) forms)))))
2398
2399 ;;;###autoload
2400 (defun cl-struct-setf-expander (x name accessor pred-form pos)
2401   (let* ((temp (gensym "--x--")) (store (gensym "--store--")))
2402     (list (list temp) (list x) (list store)
2403           (append '(progn)
2404                   (and pred-form
2405                        (list (list 'or (subst temp 'cl-x pred-form)
2406                                    (list 'error
2407                                          (format
2408                                           "%s storing a non-%s" accessor name)
2409                                          temp))))
2410                   (list (if (eq (car (get name 'cl-struct-type)) 'vector)
2411                             (list 'aset temp pos store)
2412                           (list 'setcar
2413                                 (if (<= pos 5)
2414                                     (let ((xx temp))
2415                                       (while (>= (setq pos (1- pos)) 0)
2416                                         (setq xx (list 'cdr xx)))
2417                                       xx)
2418                                   (list 'nthcdr pos temp))
2419                                 store))))
2420           (list accessor temp))))
2421
2422
2423 ;;; Types and assertions.
2424
2425 ;;;###autoload
2426 (defmacro deftype (name args &rest body)
2427   "(deftype NAME ARGLIST BODY...): define NAME as a new data type.
2428 The type name can then be used in `typecase', `check-type', etc."
2429   (list 'eval-when '(compile load eval)
2430         (cl-transform-function-property
2431          name 'cl-deftype-handler (cons (list* '&cl-defs ''('*) args) body))))
2432
2433 (defun cl-make-type-test (val type)
2434   (if (symbolp type)
2435       (cond ((get type 'cl-deftype-handler)
2436              (cl-make-type-test val (funcall (get type 'cl-deftype-handler))))
2437             ((memq type '(nil t)) type)
2438             ((eq type 'string-char) (list 'characterp val))
2439             ((eq type 'null) (list 'null val))
2440             ((eq type 'float) (list 'floatp-safe val))
2441             ((eq type 'real) (list 'numberp val))
2442             ((eq type 'fixnum) (list 'integerp val))
2443             (t
2444              (let* ((name (symbol-name type))
2445                     (namep (intern (concat name "p"))))
2446                (if (fboundp namep) (list namep val)
2447                  (list (intern (concat name "-p")) val)))))
2448     (cond ((get (car type) 'cl-deftype-handler)
2449            (cl-make-type-test val (apply (get (car type) 'cl-deftype-handler)
2450                                          (cdr type))))
2451           ((memq (car-safe type) '(integer float real number))
2452            (delq t (list 'and (cl-make-type-test val (car type))
2453                          (if (memq (cadr type) '(* nil)) t
2454                            (if (consp (cadr type)) (list '> val (caadr type))
2455                              (list '>= val (cadr type))))
2456                          (if (memq (caddr type) '(* nil)) t
2457                            (if (consp (caddr type)) (list '< val (caaddr type))
2458                              (list '<= val (caddr type)))))))
2459           ((memq (car-safe type) '(and or not))
2460            (cons (car type)
2461                  (mapcar #'(lambda (x) (cl-make-type-test val x))
2462                          (cdr type))))
2463           ((memq (car-safe type) '(member member*))
2464            (list 'and (list 'member* val (list 'quote (cdr type))) t))
2465           ((eq (car-safe type) 'satisfies) (list (cadr type) val))
2466           (t (error "Bad type spec: %s" type)))))
2467
2468 ;;;###autoload
2469 (defun typep (object type)   ; See compiler macro below.
2470   "Check that OBJECT is of type TYPE.
2471 TYPE is a Common Lisp-style type specifier."
2472   (eval (cl-make-type-test 'object type)))
2473
2474 ;;;###autoload
2475 (defmacro check-type (place type &optional string)
2476   "Verify that PLACE is of type TYPE; signal a continuable error if not.
2477 STRING is an optional description of the desired type."
2478   (when (or (not (cl-compiling-file))
2479             (< cl-optimize-speed 3)
2480             (= cl-optimize-safety 3))
2481     (let* ((temp (if (cl-simple-expr-p place 3) place (gensym)))
2482            (test (cl-make-type-test temp type))
2483            (signal-error `(signal 'wrong-type-argument
2484                                   ,(list 'list (or string (list 'quote type))
2485                                          temp (list 'quote place))))
2486            (body
2487             (condition-case nil
2488                 `(while (not ,test)
2489                    ,(macroexpand `(setf ,place ,signal-error)))
2490               (error
2491                `(if ,test (progn ,signal-error nil))))))
2492       (if (eq temp place)
2493           body
2494         `(let ((,temp ,place)) ,body)))))
2495
2496 ;;;###autoload
2497 (defmacro assert (form &optional show-args string &rest args)
2498   "Verify that FORM returns non-nil; signal an error if not.
2499 Second arg SHOW-ARGS means to include arguments of FORM in message.
2500 Other args STRING and ARGS... are arguments to be passed to `error'.
2501 They are not evaluated unless the assertion fails.  If STRING is
2502 omitted, a default message listing FORM itself is used."
2503   (and (or (not (cl-compiling-file))
2504            (< cl-optimize-speed 3) (= cl-optimize-safety 3))
2505        (let ((sargs (and show-args (delq nil (mapcar
2506                                                #'(lambda (x)
2507                                                    (and (not (cl-const-expr-p x))
2508                                                         x))
2509                                                (cdr form))))))
2510          (list 'progn
2511                (list 'or form
2512                      (if string
2513                          (list* 'error string (append sargs args))
2514                        (list 'signal '(quote cl-assertion-failed)
2515                              (list* 'list (list 'quote form) sargs))))
2516                nil))))
2517
2518 ;;;###autoload
2519 (defmacro ignore-errors (&rest body)
2520   "Execute FORMS; if an error occurs, return nil.
2521 Otherwise, return result of last FORM."
2522   `(condition-case nil (progn ,@body) (error nil)))
2523
2524 ;;;###autoload
2525 (defmacro ignore-file-errors (&rest body)
2526   "Execute FORMS; if an error of type `file-error' occurs, return nil.
2527 Otherwise, return result of last FORM."
2528   `(condition-case nil (progn ,@body) (file-error nil)))
2529
2530 ;;; Some predicates for analyzing Lisp forms.  These are used by various
2531 ;;; macro expanders to optimize the results in certain common cases.
2532
2533 (defconst cl-simple-funcs '(car cdr nth aref elt if and or + - 1+ 1- min max
2534                             car-safe cdr-safe progn prog1 prog2))
2535 (defconst cl-safe-funcs '(* / % length memq list vector vectorp
2536                           < > <= >= = error))
2537
2538 ;;; Check if no side effects, and executes quickly.
2539 (defun cl-simple-expr-p (x &optional size)
2540   (or size (setq size 10))
2541   (if (and (consp x) (not (memq (car x) '(quote function function*))))
2542       (and (symbolp (car x))
2543            (or (memq (car x) cl-simple-funcs)
2544                (get (car x) 'side-effect-free))
2545            (progn
2546              (setq size (1- size))
2547              (while (and (setq x (cdr x))
2548                          (setq size (cl-simple-expr-p (car x) size))))
2549              (and (null x) (>= size 0) size)))
2550     (and (> size 0) (1- size))))
2551
2552 (defun cl-simple-exprs-p (xs)
2553   (while (and xs (cl-simple-expr-p (car xs)))
2554     (setq xs (cdr xs)))
2555   (not xs))
2556
2557 ;;; Check if no side effects.
2558 (defun cl-safe-expr-p (x)
2559   (or (not (and (consp x) (not (memq (car x) '(quote function function*)))))
2560       (and (symbolp (car x))
2561            (or (memq (car x) cl-simple-funcs)
2562                (memq (car x) cl-safe-funcs)
2563                (get (car x) 'side-effect-free))
2564            (progn
2565              (while (and (setq x (cdr x)) (cl-safe-expr-p (car x))))
2566              (null x)))))
2567
2568 ;;; Check if constant (i.e., no side effects or dependencies).
2569 (defun cl-const-expr-p (x)
2570   (cond ((consp x)
2571          (or (eq (car x) 'quote)
2572              (and (memq (car x) '(function function*))
2573                   (or (symbolp (nth 1 x))
2574                       (and (eq (car-safe (nth 1 x)) 'lambda) 'func)))))
2575         ((symbolp x) (and (memq x '(nil t)) t))
2576         (t t)))
2577
2578 (defun cl-const-exprs-p (xs)
2579   (while (and xs (cl-const-expr-p (car xs)))
2580     (setq xs (cdr xs)))
2581   (not xs))
2582
2583 (defun cl-const-expr-val (x)
2584   (and (eq (cl-const-expr-p x) t) (if (consp x) (nth 1 x) x)))
2585
2586 (defun cl-expr-access-order (x v)
2587   (if (cl-const-expr-p x) v
2588     (if (consp x)
2589         (progn
2590           (while (setq x (cdr x)) (setq v (cl-expr-access-order (car x) v)))
2591           v)
2592       (if (eq x (car v)) (cdr v) '(t)))))
2593
2594 ;;; Count number of times X refers to Y.  Return NIL for 0 times.
2595 (defun cl-expr-contains (x y)
2596   (cond ((equal y x) 1)
2597         ((and (consp x) (not (memq (car-safe x) '(quote function function*))))
2598          (let ((sum 0))
2599            (while x
2600              (setq sum (+ sum (or (cl-expr-contains (cl-pop x) y) 0))))
2601            (and (> sum 0) sum)))
2602         (t nil)))
2603
2604 (defun cl-expr-contains-any (x y)
2605   (while (and y (not (cl-expr-contains x (car y)))) (cl-pop y))
2606   y)
2607
2608 ;;; Check whether X may depend on any of the symbols in Y.
2609 (defun cl-expr-depends-p (x y)
2610   (and (not (cl-const-expr-p x))
2611        (or (not (cl-safe-expr-p x)) (cl-expr-contains-any x y))))
2612
2613
2614 ;;; Compiler macros.
2615
2616 ;;;###autoload
2617 (defmacro define-compiler-macro (func args &rest body)
2618   "(define-compiler-macro FUNC ARGLIST BODY...): Define a compiler-only macro.
2619 This is like `defmacro', but macro expansion occurs only if the call to
2620 FUNC is compiled (i.e., not interpreted).  Compiler macros should be used
2621 for optimizing the way calls to FUNC are compiled; the form returned by
2622 BODY should do the same thing as a call to the normal function called
2623 FUNC, though possibly more efficiently.  Note that, like regular macros,
2624 compiler macros are expanded repeatedly until no further expansions are
2625 possible.  Unlike regular macros, BODY can decide to \"punt\" and leave the
2626 original function call alone by declaring an initial `&whole foo' parameter
2627 and then returning foo."
2628   (let ((p (if (listp args) args (list '&rest args))) (res nil))
2629     (while (consp p) (cl-push (cl-pop p) res))
2630     (setq args (nreverse res)) (setcdr res (and p (list '&rest p))))
2631   (list 'eval-when '(compile load eval)
2632         (cl-transform-function-property
2633          func 'cl-compiler-macro
2634          (cons (if (memq '&whole args) (delq '&whole args)
2635                  (cons '--cl-whole-arg-- args)) body))
2636         (list 'or (list 'get (list 'quote func) '(quote byte-compile))
2637               (list 'put (list 'quote func) '(quote byte-compile)
2638                     '(quote cl-byte-compile-compiler-macro)))))
2639
2640 ;;;###autoload
2641 (defun compiler-macroexpand (form)
2642   (while
2643       (let ((func (car-safe form)) (handler nil))
2644         (while (and (symbolp func)
2645                     (not (setq handler (get func 'cl-compiler-macro)))
2646                     (fboundp func)
2647                     (or (not (eq (car-safe (symbol-function func)) 'autoload))
2648                         (load (nth 1 (symbol-function func)))))
2649           (setq func (symbol-function func)))
2650         (and handler
2651              (not (eq form (setq form (apply handler form (cdr form))))))))
2652   form)
2653
2654 (defun cl-byte-compile-compiler-macro (form)
2655   (if (eq form (setq form (compiler-macroexpand form)))
2656       (byte-compile-normal-call form)
2657     (byte-compile-form form)))
2658
2659 (defmacro defsubst* (name args &rest body)
2660   "(defsubst* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function.
2661 Like `defun', except the function is automatically declared `inline',
2662 ARGLIST allows full Common Lisp conventions, and BODY is implicitly
2663 surrounded by (block NAME ...)."
2664   (let* ((argns (cl-arglist-args args)) (p argns)
2665          (pbody (cons 'progn body))
2666          (unsafe (not (cl-safe-expr-p pbody))))
2667     (while (and p (eq (cl-expr-contains args (car p)) 1)) (cl-pop p))
2668     (list 'progn
2669           (if p nil   ; give up if defaults refer to earlier args
2670             (list 'define-compiler-macro name
2671                   (list* '&whole 'cl-whole '&cl-quote args)
2672                   (list* 'cl-defsubst-expand (list 'quote argns)
2673                          (list 'quote (list* 'block name body))
2674                          (not (or unsafe (cl-expr-access-order pbody argns)))
2675                          (and (memq '&key args) 'cl-whole) unsafe argns)))
2676           (list* 'defun* name args body))))
2677
2678 (defun cl-defsubst-expand (argns body simple whole unsafe &rest argvs)
2679   (if (and whole (not (cl-safe-expr-p (cons 'progn argvs)))) whole
2680     (if (cl-simple-exprs-p argvs) (setq simple t))
2681     (let ((lets (delq nil
2682                       (mapcar* #'(lambda (argn argv)
2683                                    (if (or simple (cl-const-expr-p argv))
2684                                        (progn (setq body (subst argv argn body))
2685                                               (and unsafe (list argn argv)))
2686                                      (list argn argv)))
2687                                argns argvs))))
2688       (if lets (list 'let lets body) body))))
2689
2690
2691 ;;; Compile-time optimizations for some functions defined in this package.
2692 ;;; Note that cl.el arranges to force cl-macs to be loaded at compile-time,
2693 ;;; mainly to make sure these macros will be present.
2694
2695 (put 'eql 'byte-compile nil)
2696 (define-compiler-macro eql (&whole form a b)
2697   (cond ((eq (cl-const-expr-p a) t)
2698          (let ((val (cl-const-expr-val a)))
2699            (if (and (numberp val) (not (integerp val)))
2700                (list 'equal a b)
2701              (list 'eq a b))))
2702         ((eq (cl-const-expr-p b) t)
2703          (let ((val (cl-const-expr-val b)))
2704            (if (and (numberp val) (not (integerp val)))
2705                (list 'equal a b)
2706              (list 'eq a b))))
2707         ((cl-simple-expr-p a 5)
2708          (list 'if (list 'numberp a)
2709                (list 'equal a b)
2710                (list 'eq a b)))
2711         ((and (cl-safe-expr-p a)
2712               (cl-simple-expr-p b 5))
2713          (list 'if (list 'numberp b)
2714                (list 'equal a b)
2715                (list 'eq a b)))
2716         (t form)))
2717
2718 (define-compiler-macro member* (&whole form a list &rest keys)
2719   (let ((test (and (= (length keys) 2) (eq (car keys) ':test)
2720                    (cl-const-expr-val (nth 1 keys)))))
2721     (cond ((eq test 'eq) (list 'memq a list))
2722           ((eq test 'equal) (list 'member a list))
2723           ((or (null keys) (eq test 'eql))
2724            (if (eq (cl-const-expr-p a) t)
2725                (list (if (floatp-safe (cl-const-expr-val a)) 'member 'memq)
2726                      a list)
2727              (if (eq (cl-const-expr-p list) t)
2728                  (let ((p (cl-const-expr-val list)) (mb nil) (mq nil))
2729                    (if (not (cdr p))
2730                        (and p (list 'eql a (list 'quote (car p))))
2731                      (while p
2732                        (if (floatp-safe (car p)) (setq mb t)
2733                          (or (integerp (car p)) (symbolp (car p)) (setq mq t)))
2734                        (setq p (cdr p)))
2735                      (if (not mb) (list 'memq a list)
2736                        (if (not mq) (list 'member a list) form))))
2737                form)))
2738           (t form))))
2739
2740 (define-compiler-macro assoc* (&whole form a list &rest keys)
2741   (let ((test (and (= (length keys) 2) (eq (car keys) ':test)
2742                    (cl-const-expr-val (nth 1 keys)))))
2743     (cond ((eq test 'eq) (list 'assq a list))
2744           ((eq test 'equal) (list 'assoc a list))
2745           ((and (eq (cl-const-expr-p a) t) (or (null keys) (eq test 'eql)))
2746            (if (floatp-safe (cl-const-expr-val a))
2747                (list 'assoc a list) (list 'assq a list)))
2748           (t form))))
2749
2750 (define-compiler-macro adjoin (&whole form a list &rest keys)
2751   (if (and (cl-simple-expr-p a) (cl-simple-expr-p list)
2752            (not (memq ':key keys)))
2753       (list 'if (list* 'member* a list keys) list (list 'cons a list))
2754     form))
2755
2756 (define-compiler-macro list* (arg &rest others)
2757   (let* ((args (reverse (cons arg others)))
2758          (form (car args)))
2759     (while (setq args (cdr args))
2760       (setq form (list 'cons (car args) form)))
2761     form))
2762
2763 (define-compiler-macro get* (sym prop &optional default)
2764   (list 'get sym prop default))
2765
2766 (define-compiler-macro getf (sym prop &optional default)
2767   (list 'plist-get sym prop default))
2768
2769 (define-compiler-macro typep (&whole form val type)
2770   (if (cl-const-expr-p type)
2771       (let ((res (cl-make-type-test val (cl-const-expr-val type))))
2772         (if (or (memq (cl-expr-contains res val) '(nil 1))
2773                 (cl-simple-expr-p val)) res
2774           (let ((temp (gensym)))
2775             (list 'let (list (list temp val)) (subst temp val res)))))
2776     form))
2777
2778
2779 (mapc
2780  #'(lambda (y)
2781      (put (car y) 'side-effect-free t)
2782      (put (car y) 'byte-compile 'cl-byte-compile-compiler-macro)
2783      (put (car y) 'cl-compiler-macro
2784           (list 'lambda '(w x)
2785                 (if (symbolp (cadr y))
2786                     (list 'list (list 'quote (cadr y))
2787                           (list 'list (list 'quote (caddr y)) 'x))
2788                   (cons 'list (cdr y))))))
2789  '((first 'car x) (second 'cadr x) (third 'caddr x) (fourth 'cadddr x)
2790    (fifth 'nth 4 x) (sixth 'nth 5 x) (seventh 'nth 6 x)
2791    (eighth 'nth 7 x) (ninth 'nth 8 x) (tenth 'nth 9 x)
2792    (rest 'cdr x) (endp 'null x) (plusp '> x 0) (minusp '< x 0)
2793    (oddp  'eq (list 'logand x 1) 1)
2794    (evenp 'eq (list 'logand x 1) 0)
2795    (caar car car) (cadr car cdr) (cdar cdr car) (cddr cdr cdr)
2796    (caaar car caar) (caadr car cadr) (cadar car cdar)
2797    (caddr car cddr) (cdaar cdr caar) (cdadr cdr cadr)
2798    (cddar cdr cdar) (cdddr cdr cddr) (caaaar car caaar)
2799    (caaadr car caadr) (caadar car cadar) (caaddr car caddr)
2800    (cadaar car cdaar) (cadadr car cdadr) (caddar car cddar)
2801    (cadddr car cdddr) (cdaaar cdr caaar) (cdaadr cdr caadr)
2802    (cdadar cdr cadar) (cdaddr cdr caddr) (cddaar cdr cdaar)
2803    (cddadr cdr cdadr) (cdddar cdr cddar) (cddddr cdr cdddr)))
2804
2805 ;;; Things that are inline.
2806 (proclaim '(inline floatp-safe acons map concatenate notany notevery
2807 ;; XEmacs change
2808                    cl-set-elt revappend nreconc
2809                    ))
2810
2811 ;;; Things that are side-effect-free.  Moved to byte-optimize.el
2812 ;(dolist (fun '(oddp evenp plusp minusp
2813 ;                   abs expt signum last butlast ldiff
2814 ;                   pairlis gcd lcm
2815 ;                   isqrt floor* ceiling* truncate* round* mod* rem* subseq
2816 ;                   list-length getf))
2817 ;  (put fun 'side-effect-free t))
2818
2819 ;;; Things that are side-effect-and-error-free.  Moved to byte-optimize.el
2820 ;(dolist (fun '(eql floatp-safe list* subst acons equalp random-state-p
2821 ;                  copy-tree sublis))
2822 ;  (put fun 'side-effect-free 'error-free))
2823
2824
2825 (run-hooks 'cl-macs-load-hook)
2826
2827 ;;; cl-macs.el ends here