lisp/emacs-lisp/cl-specs.el

   1 ;;; cl-specs.el --- Edebug specs for cl.el -*- no-byte-compile: t -*-
   2
   3 ;; Copyright (C) 1993 Free Software Foundation, Inc.
   4 ;; Author: Daniel LaLiberte <liberte@holonexus.org>
   5 ;; Keywords: lisp, tools, maint
   6
   7 ;; LCD Archive Entry:
   8 ;; cl-specs.el|Daniel LaLiberte|liberte@holonexus.org
   9 ;; |Edebug specs for cl.el
  10 ;; |$Date: 2001/07/16 12:22:59 $|1.1|
  11
  12 ;; This file is part of GNU Emacs.
  13
  14 ;; GNU Emacs is free software; you can redistribute it and/or modify
  15 ;; it under the terms of the GNU General Public License as published by
  16 ;; the Free Software Foundation; either version 2, or (at your option)
  17 ;; any later version.
  18
  19 ;; GNU Emacs is distributed in the hope that it will be useful,
  20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 ;; GNU General Public License for more details.
  23
  24 ;; You should have received a copy of the GNU General Public License
  25 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  26 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  27 ;; Boston, MA 02111-1307, USA.
  28
  29 ;;; Commentary:
  30
  31 ;; These specs are to be used with edebug.el version 3.3 or later and
  32 ;; cl.el version 2.03 or later, by Dave Gillespie <daveg@synaptics.com>.
  33
  34 ;; This file need not be byte-compiled, but it shouldn't hurt.
  35
  36 ;;; Code:
  37
  38 (provide 'cl-specs)
  39 ;; Do the above provide before the following require.
  40 ;; Otherwise if you load this before edebug if cl is already loaded
  41 ;; an infinite loading loop would occur.
  42 (require 'edebug)
  43
  44 ;; Blocks
  45
  46 (def-edebug-spec block (symbolp body))
  47 (def-edebug-spec return (&optional form))
  48 (def-edebug-spec return-from (symbolp &optional form))
  49
  50 ;; Loops
  51
  52 (def-edebug-spec case (form &rest (sexp body)))
  53 (def-edebug-spec ecase case)
  54 (def-edebug-spec do
  55   ((&rest &or symbolp (symbolp &optional form form))
  56    (form body)
  57    cl-declarations body))
  58 (def-edebug-spec do* do)
  59 (def-edebug-spec dolist
  60   ((symbolp form &optional form) cl-declarations body))
  61 (def-edebug-spec dotimes dolist)
  62 (def-edebug-spec do-symbols
  63   ((symbolp &optional form form) cl-declarations body))
  64 (def-edebug-spec do-all-symbols
  65   ((symbolp &optional form) cl-declarations body))
  66
  67 ;; Multiple values
  68
  69 (def-edebug-spec multiple-value-list (form))
  70 (def-edebug-spec multiple-value-call (function-form body))
  71 (def-edebug-spec multiple-value-bind
  72   ((&rest symbolp) form cl-declarations body))
  73 (def-edebug-spec multiple-value-setq ((&rest symbolp) form))
  74 (def-edebug-spec multiple-value-prog1 (form body))
  75
  76 ;; Bindings
  77
  78 (def-edebug-spec lexical-let let)
  79 (def-edebug-spec lexical-let* let)
  80
  81 (def-edebug-spec psetq setq)
  82 (def-edebug-spec progv (form form body))
  83
  84 (def-edebug-spec flet ((&rest (defun*)) cl-declarations body))
  85 (def-edebug-spec labels flet)
  86
  87 (def-edebug-spec macrolet
  88   ((&rest (&define name (&rest arg) cl-declarations-or-string def-body))
  89    cl-declarations body))
  90
  91 (def-edebug-spec symbol-macrolet
  92   ((&rest (symbol sexp)) cl-declarations body))
  93
  94 (def-edebug-spec destructuring-bind
  95   (&define cl-macro-list form cl-declarations def-body))
  96
  97 ;; Setf
  98
  99 (def-edebug-spec setf (&rest [place form])) ;; sexp is not specific enough
 100 (def-edebug-spec psetf setf)
 101
 102 (def-edebug-spec letf  ;; *not* available in Common Lisp
 103   ((&rest (gate place &optional form))
 104    body))
 105 (def-edebug-spec letf* letf)
 106
 107
 108 (def-edebug-spec defsetf
 109   (&define name
 110            [&or [symbolp &optional stringp]
 111                 [cl-lambda-list (symbolp)]]
 112            cl-declarations-or-string def-body))
 113
 114 (def-edebug-spec define-setf-method
 115   (&define name cl-lambda-list cl-declarations-or-string def-body))
 116
 117 (def-edebug-spec define-modify-macro
 118   (&define name cl-lambda-list ;; should exclude &key
 119            symbolp &optional stringp))
 120
 121 (def-edebug-spec callf (function* place &rest form))
 122 (def-edebug-spec callf2 (function* form place &rest form))
 123
 124 ;; Other operations on places
 125
 126 (def-edebug-spec remf (place form))
 127
 128 (def-edebug-spec incf (place &optional form))
 129 (def-edebug-spec decf incf)
 130 (def-edebug-spec push (form place))     ; different for CL
 131 (def-edebug-spec pushnew
 132   (form place &rest
 133         &or [[&or ":test" ":test-not" ":key"] function-form]
 134         [edebug-keywordp form]))
 135 (def-edebug-spec pop (place))           ; different for CL
 136
 137 (def-edebug-spec shiftf (&rest place))  ;; really [&rest place] form
 138 (def-edebug-spec rotatef (&rest place))
 139
 140
 141 ;; Functions with function args.  These are only useful if the
 142 ;; function arg is quoted with ' instead of function.
 143
 144 (def-edebug-spec some (function-form form &rest form))
 145 (def-edebug-spec every some)
 146 (def-edebug-spec notany some)
 147 (def-edebug-spec notevery some)
 148
 149 ;; Mapping
 150
 151 (def-edebug-spec map (form function-form form &rest form))
 152 (def-edebug-spec maplist (function-form form &rest form))
 153 (def-edebug-spec mapc maplist)
 154 (def-edebug-spec mapl maplist)
 155 (def-edebug-spec mapcan maplist)
 156 (def-edebug-spec mapcon maplist)
 157
 158 ;; Sequences
 159
 160 (def-edebug-spec reduce (function-form form &rest form))
 161
 162 ;; Types and assertions
 163
 164 (def-edebug-spec cl-type-spec (sexp)) ;; not worth the trouble to specify, yet.
 165
 166 (def-edebug-spec deftype defmacro*)
 167 (def-edebug-spec check-type (place cl-type-spec &optional stringp))
 168 ;; (def-edebug-spec assert (form &optional form stringp &rest form))
 169 (def-edebug-spec assert (form &rest form))
 170 (def-edebug-spec typecase (form &rest ([&or cl-type-spec "otherwise"] body)))
 171 (def-edebug-spec etypecase typecase)
 172
 173 (def-edebug-spec ignore-errors t)
 174
 175 ;; Time of Evaluation
 176
 177 (def-edebug-spec eval-when
 178   ((&rest &or "compile" "load" "eval") body))
 179 (def-edebug-spec load-time-value (form &optional &or "t" "nil"))
 180
 181 ;; Declarations
 182
 183 (def-edebug-spec cl-decl-spec
 184   ((symbolp &rest sexp)))
 185
 186 (def-edebug-spec cl-declarations
 187   (&rest ("declare" &rest cl-decl-spec)))
 188
 189 (def-edebug-spec cl-declarations-or-string
 190   (&or stringp cl-declarations))
 191
 192 (def-edebug-spec declaim (&rest cl-decl-spec))
 193 (def-edebug-spec declare (&rest cl-decl-spec))  ;; probably not needed.
 194 (def-edebug-spec locally (cl-declarations &rest form))
 195 (def-edebug-spec the (cl-type-spec form))
 196
 197 ;;======================================================
 198 ;; Lambda things
 199
 200 (def-edebug-spec cl-lambda-list
 201   (([&rest arg]
 202     [&optional ["&optional" cl-&optional-arg &rest cl-&optional-arg]]
 203     [&optional ["&rest" arg]]
 204     [&optional ["&key" [cl-&key-arg &rest cl-&key-arg]
 205                 &optional "&allow-other-keys"]]
 206     [&optional ["&aux" &rest
 207                 &or (symbolp &optional def-form) symbolp]]
 208     )))
 209
 210 (def-edebug-spec cl-&optional-arg
 211   (&or (arg &optional def-form arg) arg))
 212
 213 (def-edebug-spec cl-&key-arg
 214   (&or ([&or (symbolp arg) arg] &optional def-form arg) arg))
 215
 216 ;; The lambda list for macros is different from that of normal lambdas.
 217 ;; Note that &environment is only allowed as first or last items in the
 218 ;; top level list.
 219
 220 (def-edebug-spec cl-macro-list
 221   (([&optional "&environment" arg]
 222     [&rest cl-macro-arg]
 223     [&optional ["&optional" &rest
 224                 &or (cl-macro-arg &optional def-form cl-macro-arg) arg]]
 225     [&optional [[&or "&rest" "&body"] cl-macro-arg]]
 226     [&optional ["&key" [&rest
 227                         [&or ([&or (symbolp cl-macro-arg) arg]
 228                               &optional def-form cl-macro-arg)
 229                              arg]]
 230                 &optional "&allow-other-keys"]]
 231     [&optional ["&aux" &rest
 232                 &or (symbolp &optional def-form) symbolp]]
 233     [&optional "&environment" arg]
 234     )))
 235
 236 (def-edebug-spec cl-macro-arg
 237   (&or arg cl-macro-list1))
 238
 239 (def-edebug-spec cl-macro-list1
 240   (([&optional "&whole" arg]  ;; only allowed at lower levels
 241     [&rest cl-macro-arg]
 242     [&optional ["&optional" &rest
 243                 &or (cl-macro-arg &optional def-form cl-macro-arg) arg]]
 244     [&optional [[&or "&rest" "&body"] cl-macro-arg]]
 245     [&optional ["&key" [&rest
 246                         [&or ([&or (symbolp cl-macro-arg) arg]
 247                               &optional def-form cl-macro-arg)
 248                              arg]]
 249                 &optional "&allow-other-keys"]]
 250     [&optional ["&aux" &rest
 251                 &or (symbolp &optional def-form) symbolp]]
 252     . [&or arg nil])))
 253
 254
 255 (def-edebug-spec defun*
 256   ;; Same as defun but use cl-lambda-list.
 257   (&define [&or name
 258                 ("setf" :name setf name)]
 259            cl-lambda-list
 260            cl-declarations-or-string
 261            [&optional ("interactive" interactive)]
 262            def-body))
 263 (def-edebug-spec defsubst* defun*)
 264
 265 (def-edebug-spec defmacro*
 266   (&define name cl-macro-list cl-declarations-or-string def-body))
 267 (def-edebug-spec define-compiler-macro defmacro*)
 268
 269
 270 (def-edebug-spec function*
 271   (&or symbolp cl-lambda-expr))
 272
 273 (def-edebug-spec cl-lambda-expr
 274   (&define ("lambda" cl-lambda-list
 275             ;;cl-declarations-or-string
 276             ;;[&optional ("interactive" interactive)]
 277             def-body)))
 278
 279 ;; Redefine function-form to also match function*
 280 (def-edebug-spec function-form
 281   ;; form at the end could also handle "function",
 282   ;; but recognize it specially to avoid wrapping function forms.
 283   (&or ([&or "quote" "function"] &or symbolp lambda-expr)
 284        ("function*" function*)
 285        form))
 286
 287 ;;======================================================
 288 ;; Structures
 289 ;; (def-edebug-spec defstruct (&rest sexp)) would be sufficient, but...
 290
 291 ;; defstruct may contain forms that are evaluated when a structure is created.
 292 (def-edebug-spec defstruct
 293   (&define  ; makes top-level form not be wrapped
 294    [&or symbolp
 295         (gate
 296          symbolp &rest
 297                  (&or [":conc-name" &or stringp "nil"]
 298                       [":constructor" symbolp &optional cl-lambda-list]
 299                       [":copier" symbolp]
 300                       [":predicate" symbolp]
 301                       [":include" symbolp &rest sexp];; not finished
 302                       ;; The following are not supported.
 303                       ;; [":print-function" ...]
 304                       ;; [":type" ...]
 305                       ;; [":initial-offset" ...]
 306                       ))]
 307    [&optional stringp]
 308    ;; All the above is for the following def-form.
 309    &rest &or symbolp (symbolp def-form &optional ":read-only" sexp)))
 310
 311 ;;======================================================
 312 ;; Loop
 313
 314 ;; The loop macro is very complex, and a full spec is found below.
 315 ;; The following spec only minimally specifies that
 316 ;; parenthesized forms are executable, but single variables used as
 317 ;; expressions will be missed.  You may want to use this if the full
 318 ;; spec causes problems for you.
 319
 320 (def-edebug-spec loop
 321   (&rest &or symbolp form))
 322
 323 ;; Below is a complete spec for loop, in several parts that correspond
 324 ;; to the syntax given in CLtL2.  The specs do more than specify where
 325 ;; the forms are; it also specifies, as much as Edebug allows, all the
 326 ;; syntactically legal loop clauses.  The disadvantage of this
 327 ;; completeness is rigidity, but the "for ... being" clause allows
 328 ;; arbitrary extensions of the form: [symbolp &rest &or symbolp form].
 329
 330 (def-edebug-spec loop
 331   ([&optional ["named" symbolp]]
 332    [&rest
 333     &or
 334     ["repeat" form]
 335     loop-for-as
 336     loop-with
 337     loop-initial-final]
 338    [&rest loop-clause]
 339    ))
 340
 341 (def-edebug-spec loop-with
 342   ("with" loop-var
 343    loop-type-spec
 344    [&optional ["=" form]]
 345    &rest ["and" loop-var
 346           loop-type-spec
 347           [&optional ["=" form]]]))
 348
 349 (def-edebug-spec loop-for-as
 350   ([&or "for" "as"] loop-for-as-subclause
 351    &rest ["and" loop-for-as-subclause]))
 352
 353 (def-edebug-spec loop-for-as-subclause
 354   (loop-var
 355    loop-type-spec
 356    &or
 357    [[&or "in" "on" "in-ref" "across-ref"]
 358     form &optional ["by" function-form]]
 359
 360    ["=" form &optional ["then" form]]
 361    ["across" form]
 362    ["being"
 363     [&or "the" "each"]
 364     &or
 365     [[&or "element" "elements"]
 366      [&or "of" "in" "of-ref"] form
 367      &optional "using" ["index" symbolp]];; is this right?
 368     [[&or "hash-key" "hash-keys"
 369           "hash-value" "hash-values"]
 370      [&or "of" "in"]
 371      hash-table-p &optional ["using" ([&or "hash-value" "hash-values"
 372                                            "hash-key" "hash-keys"] sexp)]]
 373
 374     [[&or "symbol" "present-symbol" "external-symbol"
 375           "symbols" "present-symbols" "external-symbols"]
 376      [&or "in" "of"] package-p]
 377
 378     ;; Extensions for Emacs Lisp, including Lucid Emacs.
 379     [[&or "frame" "frames"
 380           "screen" "screens"
 381           "buffer" "buffers"]]
 382
 383     [[&or "window" "windows"]
 384      [&or "of" "in"] form]
 385
 386     [[&or "overlay" "overlays"
 387           "extent" "extents"]
 388      [&or "of" "in"] form
 389      &optional [[&or "from" "to"] form]]
 390
 391     [[&or "interval" "intervals"]
 392      [&or "in" "of"] form
 393      &optional [[&or "from" "to"] form]
 394      ["property" form]]
 395
 396     [[&or "key-code" "key-codes"
 397           "key-seq" "key-seqs"
 398           "key-binding" "key-bindings"]
 399      [&or "in" "of"] form
 400      &optional ["using" ([&or "key-code" "key-codes"
 401                               "key-seq" "key-seqs"
 402                               "key-binding" "key-bindings"]
 403                          sexp)]]
 404     ;; For arbitrary extensions, recognize anything else.
 405     [symbolp &rest &or symbolp form]
 406     ]
 407
 408    ;; arithmetic - must be last since all parts are optional.
 409    [[&optional [[&or "from" "downfrom" "upfrom"] form]]
 410     [&optional [[&or "to" "downto" "upto" "below" "above"] form]]
 411     [&optional ["by" form]]
 412     ]))
 413
 414 (def-edebug-spec loop-initial-final
 415   (&or ["initially"
 416         ;; [&optional &or "do" "doing"]  ;; CLtL2 doesn't allow this.
 417         &rest loop-non-atomic-expr]
 418        ["finally" &or
 419         [[&optional &or "do" "doing"] &rest loop-non-atomic-expr]
 420         ["return" form]]))
 421
 422 (def-edebug-spec loop-and-clause
 423   (loop-clause &rest ["and" loop-clause]))
 424
 425 (def-edebug-spec loop-clause
 426   (&or
 427    [[&or "while" "until" "always" "never" "thereis"] form]
 428
 429    [[&or "collect" "collecting"
 430          "append" "appending"
 431          "nconc" "nconcing"
 432          "concat" "vconcat"] form
 433          [&optional ["into" loop-var]]]
 434
 435    [[&or "count" "counting"
 436          "sum" "summing"
 437          "maximize" "maximizing"
 438          "minimize" "minimizing"] form
 439          [&optional ["into" loop-var]]
 440          loop-type-spec]
 441
 442    [[&or "if" "when" "unless"]
 443     form loop-and-clause
 444     [&optional ["else" loop-and-clause]]
 445     [&optional "end"]]
 446
 447    [[&or "do" "doing"] &rest loop-non-atomic-expr]
 448
 449    ["return" form]
 450    loop-initial-final
 451    ))
 452
 453 (def-edebug-spec loop-non-atomic-expr
 454   ([&not atom] form))
 455
 456 (def-edebug-spec loop-var
 457   ;; The symbolp must be last alternative to recognize e.g. (a b . c)
 458   ;; loop-var =>
 459   ;; (loop-var . [&or nil loop-var])
 460   ;; (symbolp . [&or nil loop-var])
 461   ;; (symbolp . loop-var)
 462   ;; (symbolp . (symbolp . [&or nil loop-var]))
 463   ;; (symbolp . (symbolp . loop-var))
 464   ;; (symbolp . (symbolp . symbolp)) == (symbolp symbolp . symbolp)
 465   (&or (loop-var . [&or nil loop-var]) [gate symbolp]))
 466
 467 (def-edebug-spec loop-type-spec
 468   (&optional ["of-type" loop-d-type-spec]))
 469
 470 (def-edebug-spec loop-d-type-spec
 471   (&or (loop-d-type-spec . [&or nil loop-d-type-spec]) cl-type-spec))
 472
 473 ;;; cl-specs.el ends here