Mercurial > hg > xemacs-beta
annotate man/lispref/eval.texi @ 5353:38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
lisp/ChangeLog addition:
2011-02-07 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el:
* bytecomp.el (byte-compile-initial-macro-environment):
Shadow `block', `return-from' here, we implement them differently
when byte-compiling.
* bytecomp.el (byte-compile-active-blocks): New.
* bytecomp.el (byte-compile-block-1): New.
* bytecomp.el (byte-compile-return-from-1): New.
* bytecomp.el (return-from-1): New.
* bytecomp.el (block-1): New.
These are two aliases that exist to have their own associated
byte-compile functions, which functions implement `block' and
`return-from'.
* cl-extra.el (cl-macroexpand-all):
Fix a bug here when macros in the environment have been compiled.
* cl-macs.el (block):
* cl-macs.el (return):
* cl-macs.el (return-from):
Be more careful about lexical scope in these macros.
* cl.el:
* cl.el ('cl-block-wrapper): Removed.
* cl.el ('cl-block-throw): Removed.
These aren't needed in code generated by this XEmacs. They
shouldn't be needed in code generated by XEmacs 21.4, but if it
turns out the packages do need them, we can put them back.
2011-01-30 Mike Sperber <mike@xemacs.org>
* font-lock.el (font-lock-fontify-pending-extents): Don't fail if
`font-lock-mode' is unset, which can happen in the middle of
`revert-buffer'.
2011-01-23 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (delete):
* cl-macs.el (delq):
* cl-macs.el (remove):
* cl-macs.el (remq):
Don't use the compiler macro if these functions were given the
wrong number of arguments, as happens in lisp-tests.el.
* cl-seq.el (remove, remq): Removed.
I added these to subr.el, and forgot to remove them from here.
2011-01-22 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-setq, byte-compile-set):
Remove kludge allowing keywords' values to be set, all the code
that does that is gone.
* cl-compat.el (elt-satisfies-test-p):
* faces.el (set-face-parent):
* faces.el (face-doc-string):
* gtk-font-menu.el:
* gtk-font-menu.el (gtk-reset-device-font-menus):
* msw-font-menu.el:
* msw-font-menu.el (mswindows-reset-device-font-menus):
* package-get.el (package-get-installedp):
* select.el (select-convert-from-image-data):
* sound.el:
* sound.el (load-sound-file):
* x-font-menu.el (x-reset-device-font-menus-core):
Don't quote keywords, they're self-quoting, and the
win from backward-compatibility is sufficiently small now that the
style problem overrides it.
2011-01-22 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (block, return-from): Require that NAME be a symbol
in these macros, as always documented in the #'block docstring and
as required by Common Lisp.
* descr-text.el (unidata-initialize-unihan-database):
Correct the use of non-symbols in #'block and #'return-from in
this function.
2011-01-15 Aidan Kehoe <kehoea@parhasard.net>
* cl-extra.el (concatenate): Accept more complicated TYPEs in this
function, handing the sequences over to #'coerce if we don't
understand them here.
* cl-macs.el (inline): Don't proclaim #'concatenate as inline, its
compiler macro is more useful than doing that.
2011-01-11 Aidan Kehoe <kehoea@parhasard.net>
* subr.el (delete, delq, remove, remq): Move #'remove, #'remq
here, they don't belong in cl-seq.el; move #'delete, #'delq here
from fns.c, implement them in terms of #'delete*, allowing support
for sequences generally.
* update-elc.el (do-autoload-commands): Use #'delete*, not #'delq
here, now the latter's no longer dumped.
* cl-macs.el (delete, delq): Add compiler macros transforming
#'delete and #'delq to #'delete* calls.
2011-01-10 Aidan Kehoe <kehoea@parhasard.net>
* dialog.el (make-dialog-box): Correct a misplaced parenthesis
here, thank you Mats Lidell in 87zkr9gqrh.fsf@mail.contactor.se !
2011-01-02 Aidan Kehoe <kehoea@parhasard.net>
* dialog.el (make-dialog-box):
* list-mode.el (display-completion-list):
These functions used to use cl-parsing-keywords; change them to
use defun* instead, fixing the build. (Not sure what led to me
not including this change in d1b17a33450b!)
2011-01-02 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (define-star-compiler-macros):
Make sure the form has ITEM and LIST specified before attempting
to change to calls with explicit tests; necessary for some tests
in lisp-tests.el to compile correctly.
(stable-union, stable-intersection): Add compiler macros for these
functions, in the same way we do for most of the other functions
in cl-seq.el.
2011-01-01 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (dolist, dotimes, do-symbols, macrolet)
(symbol-macrolet):
Define these macros with defmacro* instead of parsing the argument
list by hand, for the sake of style and readability; use backquote
where appropriate, instead of calling #'list and and friends, for
the same reason.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* x-misc.el (device-x-display):
Provide this function, documented in the Lispref for years, but
not existing previously. Thank you Julian Bradfield, thank you
Jeff Mincy.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* cl-seq.el:
Move the heavy lifting from this file to C. Dump the
cl-parsing-keywords macro, but don't use defun* for the functions
we define that do take keywords, dynamic scope lossage makes that
not practical.
* subr.el (sort, fillarray): Move these aliases here.
(map-plist): #'nsublis is now built-in, but at this point #'eql
isn't necessarily available as a test; use #'eq.
* obsolete.el (cl-delete-duplicates): Make this available for old
compiler macros and old code.
(memql): Document that this is equivalent to #'member*, and worse.
* cl.el (adjoin, subst): Removed. These are in C.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* simple.el (assoc-ignore-case): Remove a duplicate definition of
this function (it's already in subr.el).
* iso8859-1.el (char-width):
On non-Mule, make this function equivalent to that produced by
(constantly 1), but preserve its docstring.
* subr.el (subst-char-in-string): Define this in terms of
#'substitute, #'nsubstitute.
(string-width): Define this using #'reduce and #'char-width.
(char-width): Give this a simpler definition, it makes far more
sense to check for mule at load time and redefine, as we do in
iso8859-1.el.
(store-substring): Implement this in terms of #'replace, now
#'replace is cheap.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* update-elc.el (lisp-files-needed-for-byte-compilation)
(lisp-files-needing-early-byte-compilation):
cl-macs belongs in the former, not the latter, it is as
fundamental as bytecomp.el.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* cl.el:
Provde the Common Lisp program-error, type-error as error
symbols. This doesn't nearly go far enough for anyone using the
Common Lisp errors.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (delete-duplicates):
If the form has an incorrect number of arguments, don't attempt a
compiler macroexpansion.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (cl-safe-expr-p):
Forms that start with the symbol lambda are also safe.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (= < > <= >=):
For these functions' compiler macros, the optimisation is safe
even if the first and the last arguments have side effects, since
they're only used the once.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (inline-side-effect-free-compiler-macros):
Unroll a loop here at macro-expansion time, so these compiler
macros are compiled. Use #'eql instead of #'eq in a couple of
places for better style.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-extra.el (notany, notevery): Avoid some dynamic scope
stupidity with local variable names in these functions, when they
weren't prefixed with cl-; go into some more detail in the doc
strings.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* byte-optimize.el (side-effect-free-fns): #'remove, #'remq are
free of side-effects.
(side-effect-and-error-free-fns):
Drop dot, dot-marker from the list.
2010-11-17 Aidan Kehoe <kehoea@parhasard.net>
* cl-extra.el (coerce):
In the argument list, name the first argument OBJECT, not X; the
former name was always used in the doc string and is clearer.
Handle vector type specifications which include the length of the
target sequence, error if there's a mismatch.
* cl-macs.el (cl-make-type-test): Handle type specifications
starting with the symbol 'eql.
2010-11-14 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (eql): Don't remove the byte-compile property of this
symbol. That was necessary to override a bug in bytecomp.el where
#'eql was confused with #'eq, which bug we no longer have.
If neither expression is constant, don't attempt to handle the
expression in this compiler macro, leave it to byte-compile-eql,
which produces better code anyway.
* bytecomp.el (eq): #'eql is not the function associated with the
byte-eq byte code.
(byte-compile-eql): Add an explicit compile method for this
function, for cases where the cl-macs compiler macro hasn't
reduced it to #'eq or #'equal.
2010-10-25 Aidan Kehoe <kehoea@parhasard.net>
Add compiler macros and compilation sanity-checking for various
functions that take keywords.
* byte-optimize.el (side-effect-free-fns): #'symbol-value is
side-effect free and not error free.
* bytecomp.el (byte-compile-normal-call): Check keyword argument
lists for sanity; store information about the positions where
keyword arguments start using the new byte-compile-keyword-start
property.
* cl-macs.el (cl-const-expr-val): Take a new optional argument,
cl-not-constant, defaulting to nil, in this function; return it if
the expression is not constant.
(cl-non-fixnum-number-p): Make this into a separate function, we
want to pass it to #'every.
(eql): Use it.
(define-star-compiler-macros): Use the same code to generate the
member*, assoc* and rassoc* compiler macros; special-case some
code in #'add-to-list in subr.el.
(remove, remq): Add compiler macros for these two functions, in
preparation for #'remove being in C.
(define-foo-if-compiler-macros): Transform (remove-if-not ...) calls to
(remove ... :if-not) at compile time, which will be a real win
once the latter is in C.
(define-substitute-if-compiler-macros)
(define-subst-if-compiler-macros): Similarly for these functions.
(delete-duplicates): Change this compiler macro to use
#'plists-equal; if we don't have information about the type of
SEQUENCE at compile time, don't bother attempting to inline the
call, the function will be in C soon enough.
(equalp): Remove an old commented-out compiler macro for this, if
we want to see it it's in version control.
(subst-char-in-string): Transform this to a call to nsubstitute or
nsubstitute, if that is appropriate.
* cl.el (ldiff): Don't call setf here, this makes for a load-time
dependency problem in cl-macs.el
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* term/vt100.el:
Refer to XEmacs, not GNU Emacs, in permissions.
* term/bg-mouse.el:
* term/sup-mouse.el:
Put copyright notice in canonical "Copyright DATE AUTHOR" form.
Refer to XEmacs, not GNU Emacs, in permissions.
* site-load.el:
Add permission boilerplate.
* mule/canna-leim.el:
* alist.el:
Refer to XEmacs, not APEL/this program, in permissions.
* mule/canna-leim.el:
Remove my copyright, I've assigned it to the FSF.
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* gtk.el:
* gtk-widget-accessors.el:
* gtk-package.el:
* gtk-marshal.el:
* gtk-compose.el:
* gnome.el:
Add copyright notice based on internal evidence.
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* easymenu.el: Add reference to COPYING to permission notice.
* gutter.el:
* gutter-items.el:
* menubar-items.el:
Fix typo "Xmacs" in permissions notice.
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* auto-save.el:
* font.el:
* fontconfig.el:
* mule/kinsoku.el:
Add "part of XEmacs" text to permission notice.
2010-10-14 Aidan Kehoe <kehoea@parhasard.net>
* byte-optimize.el (side-effect-free-fns):
* cl-macs.el (remf, getf):
* cl-extra.el (tailp, cl-set-getf, cl-do-remf):
* cl.el (ldiff, endp):
Tighten up Common Lisp compatibility for #'ldiff, #'endp, #'tailp;
add circularity checking for the first two.
#'cl-set-getf and #'cl-do-remf were Lisp implementations of
#'plist-put and #'plist-remprop; change the names to aliases,
changes the macros that use them to using #'plist-put and
#'plist-remprop directly.
2010-10-12 Aidan Kehoe <kehoea@parhasard.net>
* abbrev.el (fundamental-mode-abbrev-table, global-abbrev-table):
Create both these abbrev tables using the usual
#'define-abbrev-table calls, rather than attempting to
special-case them.
* cl-extra.el: Force cl-macs to be loaded here, if cl-extra.el is
being loaded interpreted. Previously other, later files would
redundantly call (load "cl-macs") when interpreted, it's more
reasonable to do it here, once.
* cmdloop.el (read-quoted-char-radix): Use defcustom here, we
don't have any dump-order dependencies that would prevent that.
* custom.el (eval-when-compile): Don't load cl-macs when
interpreted or when byte-compiling, rely on cl-extra.el in the
former case and the appropriate entry in bytecomp-load-hook in the
latter. Get rid of custom-declare-variable-list, we have no
dump-time dependencies that would require it.
* faces.el (eval-when-compile): Don't load cl-macs when
interpreted or when byte-compiling.
* packages.el: Remove some inaccurate comments.
* post-gc.el (cleanup-simple-finalizers): Use #'delete-if-not
here, now the order of preloaded-file-list has been changed to
make it available.
* subr.el (custom-declare-variable-list): Remove. No need for it.
Also remove a stub define-abbrev-table from this file, given the
current order of preloaded-file-list there's no need for it.
2010-10-10 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-constp) Forms quoted with FUNCTION are
also constant.
(byte-compile-initial-macro-environment): In #'the, if FORM is
constant and does not match TYPE, warn at byte-compile time.
2010-10-10 Aidan Kehoe <kehoea@parhasard.net>
* backquote.el (bq-vector-contents, bq-list*): Remove; the former
is equivalent to (append VECTOR nil), the latter to (list* ...).
(bq-process-2): Use (append VECTOR nil) instead of using
#'bq-vector-contents to convert to a list.
(bq-process-1): Now we use list* instead of bq-list
* subr.el (list*): Moved from cl.el, since it is now required to
be available the first time a backquoted form is encountered.
* cl.el (list*): Move to subr.el.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* test-harness.el (Check-Message):
Add an omitted comma here, thank you the buildbot.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* hash-table.el (hash-table-key-list, hash-table-value-list)
(hash-table-key-value-alist, hash-table-key-value-plist):
Remove some useless #'nreverse calls in these files; our hash
tables have no order, it's not helpful to pretend they do.
* behavior.el (read-behavior):
Do the same in this file, in some code evidently copied from
hash-table.el.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* info.el (Info-insert-dir):
* format.el (format-deannotate-region):
* files.el (cd, save-buffers-kill-emacs):
Use #'some, #'every and related functions for applying boolean
operations to lists, instead of rolling our own ones that cons and
don't short-circuit.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-initial-macro-environment):
* cl-macs.el (the):
Rephrase the docstring, make its implementation when compiling
files a little nicer.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* descr-text.el (unidata-initialize-unicodedata-database)
(unidata-initialize-unihan-database, describe-char-unicode-data)
(describe-char-unicode-data):
Wrap calls to the database functions with (with-fboundp ...),
avoiding byte compile warnings on builds without support for the
database functions.
(describe-char): (reduce #'max ...), not (apply #'max ...), no
need to cons needlessly.
(describe-char): Remove a redundant lambda wrapping
#'extent-properties.
(describe-char-unicode-data): Call #'nsubst when replacing "" with
nil in the result of #'split-string, instead of consing inside
mapcar.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* x-faces.el (x-available-font-sizes):
* specifier.el (let-specifier):
* package-ui.el (pui-add-required-packages):
* msw-faces.el (mswindows-available-font-sizes):
* modeline.el (modeline-minor-mode-menu):
* minibuf.el (minibuf-directory-files):
Replace the O2N (delq nil (mapcar (lambda (W) (and X Y)) Z)) with
the ON (mapcan (lambda (W) (and X (list Y))) Z) in these files.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (= < > <= >=):
When these functions are handed more than two arguments, and those
arguments have no side effects, transform to a series of two
argument calls, avoiding funcall in the byte-compiled code.
* mule/mule-cmds.el (finish-set-language-environment):
Take advantage of this change in a function called 256 times at
startup.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-function-form, byte-compile-quote)
(byte-compile-quote-form):
Warn at compile time, and error at runtime, if a (quote ...) or a
(function ...) form attempts to quote more than one object.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* byte-optimize.el (byte-optimize-apply): Transform (apply 'nconc
(mapcar ...)) to (mapcan ...); warn about use of the first idiom.
* update-elc.el (do-autoload-commands):
* packages.el (packages-find-package-library-path):
* frame.el (frame-list):
* extents.el (extent-descendants):
* etags.el (buffer-tag-table-files):
* dumped-lisp.el (preloaded-file-list):
* device.el (device-list):
* bytecomp-runtime.el (proclaim-inline, proclaim-notinline)
Use #'mapcan, not (apply #'nconc (mapcar ...) in all these files.
* bytecomp-runtime.el (eval-when-compile, eval-and-compile):
In passing, mention that these macros also evaluate the body when
interpreted.
tests/ChangeLog addition:
2011-02-07 Aidan Kehoe <kehoea@parhasard.net>
* automated/lisp-tests.el:
Test lexical scope for `block', `return-from'; add a
Known-Bug-Expect-Failure for a contorted example that fails when
byte-compiled.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Mon, 07 Feb 2011 12:01:24 +0000 |
| parents | 378a34562cbe |
| children | 62b9ef1ed4ac |
| rev | line source |
|---|---|
| 428 | 1 @c -*-texinfo-*- |
| 2 @c This is part of the XEmacs Lisp Reference Manual. | |
| 444 | 3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. |
| 428 | 4 @c See the file lispref.texi for copying conditions. |
| 5 @setfilename ../../info/eval.info | |
| 6 @node Evaluation, Control Structures, Symbols, Top | |
| 7 @chapter Evaluation | |
| 8 @cindex evaluation | |
| 9 @cindex interpreter | |
| 10 @cindex interpreter | |
| 11 @cindex value of expression | |
| 12 | |
| 13 The @dfn{evaluation} of expressions in XEmacs Lisp is performed by the | |
| 14 @dfn{Lisp interpreter}---a program that receives a Lisp object as input | |
| 15 and computes its @dfn{value as an expression}. How it does this depends | |
| 16 on the data type of the object, according to rules described in this | |
| 17 chapter. The interpreter runs automatically to evaluate portions of | |
| 18 your program, but can also be called explicitly via the Lisp primitive | |
| 19 function @code{eval}. | |
| 20 | |
| 21 @ifinfo | |
| 22 @menu | |
| 23 * Intro Eval:: Evaluation in the scheme of things. | |
| 24 * Eval:: How to invoke the Lisp interpreter explicitly. | |
| 25 * Forms:: How various sorts of objects are evaluated. | |
| 26 * Quoting:: Avoiding evaluation (to put constants in the program). | |
|
5252
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
27 * Multiple values:: Functions may return more than one result. |
| 428 | 28 @end menu |
| 29 | |
| 30 @node Intro Eval | |
| 31 @section Introduction to Evaluation | |
| 32 | |
| 33 The Lisp interpreter, or evaluator, is the program that computes | |
| 444 | 34 the value of an expression that is given to it. When a function |
| 428 | 35 written in Lisp is called, the evaluator computes the value of the |
| 36 function by evaluating the expressions in the function body. Thus, | |
| 37 running any Lisp program really means running the Lisp interpreter. | |
| 38 | |
| 39 How the evaluator handles an object depends primarily on the data | |
| 40 type of the object. | |
| 41 @end ifinfo | |
| 42 | |
| 43 @cindex forms | |
| 44 @cindex expression | |
| 45 A Lisp object that is intended for evaluation is called an | |
| 46 @dfn{expression} or a @dfn{form}. The fact that expressions are data | |
| 47 objects and not merely text is one of the fundamental differences | |
| 48 between Lisp-like languages and typical programming languages. Any | |
| 49 object can be evaluated, but in practice only numbers, symbols, lists | |
| 50 and strings are evaluated very often. | |
| 51 | |
| 52 It is very common to read a Lisp expression and then evaluate the | |
| 53 expression, but reading and evaluation are separate activities, and | |
| 54 either can be performed alone. Reading per se does not evaluate | |
| 55 anything; it converts the printed representation of a Lisp object to the | |
| 56 object itself. It is up to the caller of @code{read} whether this | |
| 57 object is a form to be evaluated, or serves some entirely different | |
| 58 purpose. @xref{Input Functions}. | |
| 59 | |
| 60 Do not confuse evaluation with command key interpretation. The | |
| 61 editor command loop translates keyboard input into a command (an | |
| 62 interactively callable function) using the active keymaps, and then | |
| 63 uses @code{call-interactively} to invoke the command. The execution of | |
| 64 the command itself involves evaluation if the command is written in | |
| 65 Lisp, but that is not a part of command key interpretation itself. | |
| 66 @xref{Command Loop}. | |
| 67 | |
| 68 @cindex recursive evaluation | |
| 69 Evaluation is a recursive process. That is, evaluation of a form may | |
| 70 call @code{eval} to evaluate parts of the form. For example, evaluation | |
| 71 of a function call first evaluates each argument of the function call, | |
| 72 and then evaluates each form in the function body. Consider evaluation | |
| 73 of the form @code{(car x)}: the subform @code{x} must first be evaluated | |
| 74 recursively, so that its value can be passed as an argument to the | |
| 75 function @code{car}. | |
| 76 | |
| 77 Evaluation of a function call ultimately calls the function specified | |
| 2492 | 78 in it. @xref{Functions and Commands}. The execution of the function may itself work |
| 428 | 79 by evaluating the function definition; or the function may be a Lisp |
| 80 primitive implemented in C, or it may be a byte-compiled function | |
| 81 (@pxref{Byte Compilation}). | |
| 82 | |
| 83 @cindex environment | |
| 84 The evaluation of forms takes place in a context called the | |
| 85 @dfn{environment}, which consists of the current values and bindings of | |
| 86 all Lisp variables.@footnote{This definition of ``environment'' is | |
| 87 specifically not intended to include all the data that can affect the | |
| 88 result of a program.} Whenever the form refers to a variable without | |
| 89 creating a new binding for it, the value of the binding in the current | |
| 90 environment is used. @xref{Variables}. | |
| 91 | |
| 92 @cindex side effect | |
| 93 Evaluation of a form may create new environments for recursive | |
| 94 evaluation by binding variables (@pxref{Local Variables}). These | |
| 95 environments are temporary and vanish by the time evaluation of the form | |
| 96 is complete. The form may also make changes that persist; these changes | |
| 97 are called @dfn{side effects}. An example of a form that produces side | |
| 98 effects is @code{(setq foo 1)}. | |
| 99 | |
| 100 The details of what evaluation means for each kind of form are | |
| 101 described below (@pxref{Forms}). | |
| 102 | |
| 103 @node Eval | |
| 104 @section Eval | |
| 105 @c ??? Perhaps this should be the last section in the chapter. | |
| 106 | |
| 107 Most often, forms are evaluated automatically, by virtue of their | |
| 108 occurrence in a program being run. On rare occasions, you may need to | |
| 109 write code that evaluates a form that is computed at run time, such as | |
| 110 after reading a form from text being edited or getting one from a | |
| 111 property list. On these occasions, use the @code{eval} function. | |
| 112 | |
| 113 @strong{Please note:} it is generally cleaner and more flexible to call | |
| 114 functions that are stored in data structures, rather than to evaluate | |
| 115 expressions stored in data structures. Using functions provides the | |
| 116 ability to pass information to them as arguments. | |
| 117 | |
| 118 The functions and variables described in this section evaluate forms, | |
| 119 specify limits to the evaluation process, or record recently returned | |
| 120 values. Loading a file also does evaluation (@pxref{Loading}). | |
| 121 | |
| 122 @defun eval form | |
| 123 This is the basic function for performing evaluation. It evaluates | |
| 124 @var{form} in the current environment and returns the result. How the | |
| 125 evaluation proceeds depends on the type of the object (@pxref{Forms}). | |
| 126 | |
| 127 Since @code{eval} is a function, the argument expression that appears | |
| 128 in a call to @code{eval} is evaluated twice: once as preparation before | |
| 129 @code{eval} is called, and again by the @code{eval} function itself. | |
| 130 Here is an example: | |
| 131 | |
| 132 @example | |
| 133 @group | |
| 134 (setq foo 'bar) | |
| 135 @result{} bar | |
| 136 @end group | |
| 137 @group | |
| 138 (setq bar 'baz) | |
| 139 @result{} baz | |
| 140 ;; @r{@code{eval} receives argument @code{bar}, which is the value of @code{foo}} | |
| 141 (eval foo) | |
| 142 @result{} baz | |
| 143 (eval 'foo) | |
| 144 @result{} bar | |
| 145 @end group | |
| 146 @end example | |
| 147 | |
| 148 The number of currently active calls to @code{eval} is limited to | |
| 149 @code{max-lisp-eval-depth} (see below). | |
| 150 @end defun | |
| 151 | |
| 152 @deffn Command eval-region start end &optional stream | |
| 153 This function evaluates the forms in the current buffer in the region | |
| 154 defined by the positions @var{start} and @var{end}. It reads forms from | |
| 155 the region and calls @code{eval} on them until the end of the region is | |
| 156 reached, or until an error is signaled and not handled. | |
| 157 | |
| 158 If @var{stream} is supplied, @code{standard-output} is bound to it | |
| 159 during the evaluation. | |
| 160 | |
| 161 You can use the variable @code{load-read-function} to specify a function | |
| 162 for @code{eval-region} to use instead of @code{read} for reading | |
| 163 expressions. @xref{How Programs Do Loading}. | |
| 164 | |
| 165 @code{eval-region} always returns @code{nil}. | |
| 166 @end deffn | |
| 167 | |
| 168 @cindex evaluation of buffer contents | |
| 169 @deffn Command eval-buffer buffer &optional stream | |
| 170 This is like @code{eval-region} except that it operates on the whole | |
| 171 contents of @var{buffer}. | |
| 172 @end deffn | |
| 173 | |
| 174 @defvar max-lisp-eval-depth | |
| 175 This variable defines the maximum depth allowed in calls to @code{eval}, | |
| 176 @code{apply}, and @code{funcall} before an error is signaled (with error | |
| 177 message @code{"Lisp nesting exceeds max-lisp-eval-depth"}). This counts | |
| 178 internal uses of those functions, such as for calling the functions | |
| 179 mentioned in Lisp expressions, and recursive evaluation of function call | |
| 180 arguments and function body forms. | |
| 181 | |
| 182 This limit, with the associated error when it is exceeded, is one way | |
| 183 that Lisp avoids infinite recursion on an ill-defined function. | |
| 184 @cindex Lisp nesting error | |
| 185 | |
| 458 | 186 The default value of this variable is 1000. If you set it to a value |
| 428 | 187 less than 100, Lisp will reset it to 100 if the given value is reached. |
| 188 | |
| 189 @code{max-specpdl-size} provides another limit on nesting. | |
| 190 @xref{Local Variables}. | |
| 191 @end defvar | |
| 192 | |
| 193 @defvar values | |
| 194 The value of this variable is a list of the values returned by all the | |
| 195 expressions that were read from buffers (including the minibuffer), | |
| 196 evaluated, and printed. The elements are ordered most recent first. | |
| 197 | |
| 198 @example | |
| 199 @group | |
| 200 (setq x 1) | |
| 201 @result{} 1 | |
| 202 @end group | |
| 203 @group | |
| 204 (list 'A (1+ 2) auto-save-default) | |
| 205 @result{} (A 3 t) | |
| 206 @end group | |
| 207 @group | |
| 208 values | |
| 209 @result{} ((A 3 t) 1 @dots{}) | |
| 210 @end group | |
| 211 @end example | |
| 212 | |
| 213 This variable is useful for referring back to values of forms recently | |
| 214 evaluated. It is generally a bad idea to print the value of | |
| 215 @code{values} itself, since this may be very long. Instead, examine | |
| 216 particular elements, like this: | |
| 217 | |
| 218 @example | |
| 219 @group | |
| 220 ;; @r{Refer to the most recent evaluation result.} | |
| 221 (nth 0 values) | |
| 222 @result{} (A 3 t) | |
| 223 @end group | |
| 224 @group | |
| 225 ;; @r{That put a new element on,} | |
| 226 ;; @r{so all elements move back one.} | |
| 227 (nth 1 values) | |
| 228 @result{} (A 3 t) | |
| 229 @end group | |
| 230 @group | |
| 231 ;; @r{This gets the element that was next-to-most-recent} | |
| 232 ;; @r{before this example.} | |
| 233 (nth 3 values) | |
| 234 @result{} 1 | |
| 235 @end group | |
| 236 @end example | |
| 237 @end defvar | |
| 238 | |
| 239 @node Forms | |
| 240 @section Kinds of Forms | |
| 241 | |
| 242 A Lisp object that is intended to be evaluated is called a @dfn{form}. | |
| 243 How XEmacs evaluates a form depends on its data type. XEmacs has three | |
| 244 different kinds of form that are evaluated differently: symbols, lists, | |
| 245 and ``all other types''. This section describes all three kinds, | |
| 246 starting with ``all other types'' which are self-evaluating forms. | |
| 247 | |
| 248 @menu | |
| 249 * Self-Evaluating Forms:: Forms that evaluate to themselves. | |
| 250 * Symbol Forms:: Symbols evaluate as variables. | |
| 251 * Classifying Lists:: How to distinguish various sorts of list forms. | |
| 252 * Function Indirection:: When a symbol appears as the car of a list, | |
| 253 we find the real function via the symbol. | |
| 254 * Function Forms:: Forms that call functions. | |
| 255 * Macro Forms:: Forms that call macros. | |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
256 * Special Operators:: ``Special operators'' are idiosyncratic primitives, |
| 428 | 257 most of them extremely important. |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
258 Also known as special forms. |
| 428 | 259 * Autoloading:: Functions set up to load files |
| 260 containing their real definitions. | |
| 261 @end menu | |
| 262 | |
| 263 @node Self-Evaluating Forms | |
| 264 @subsection Self-Evaluating Forms | |
| 265 @cindex vector evaluation | |
| 266 @cindex literal evaluation | |
| 267 @cindex self-evaluating form | |
| 268 | |
| 269 A @dfn{self-evaluating form} is any form that is not a list or symbol. | |
| 270 Self-evaluating forms evaluate to themselves: the result of evaluation | |
| 271 is the same object that was evaluated. Thus, the number 25 evaluates to | |
| 272 25, and the string @code{"foo"} evaluates to the string @code{"foo"}. | |
| 273 Likewise, evaluation of a vector does not cause evaluation of the | |
| 274 elements of the vector---it returns the same vector with its contents | |
| 275 unchanged. | |
| 276 | |
| 277 @example | |
| 278 @group | |
| 279 '123 ; @r{An object, shown without evaluation.} | |
| 280 @result{} 123 | |
| 281 @end group | |
| 282 @group | |
| 283 123 ; @r{Evaluated as usual---result is the same.} | |
| 284 @result{} 123 | |
| 285 @end group | |
| 286 @group | |
| 287 (eval '123) ; @r{Evaluated ``by hand''---result is the same.} | |
| 288 @result{} 123 | |
| 289 @end group | |
| 290 @group | |
| 291 (eval (eval '123)) ; @r{Evaluating twice changes nothing.} | |
| 292 @result{} 123 | |
| 293 @end group | |
| 294 @end example | |
| 295 | |
| 296 It is common to write numbers, characters, strings, and even vectors | |
| 297 in Lisp code, taking advantage of the fact that they self-evaluate. | |
| 298 However, it is quite unusual to do this for types that lack a read | |
| 299 syntax, because there's no way to write them textually. It is possible | |
| 300 to construct Lisp expressions containing these types by means of a Lisp | |
| 301 program. Here is an example: | |
| 302 | |
| 303 @example | |
| 304 @group | |
| 305 ;; @r{Build an expression containing a buffer object.} | |
| 306 (setq buffer (list 'print (current-buffer))) | |
| 307 @result{} (print #<buffer eval.texi>) | |
| 308 @end group | |
| 309 @group | |
| 310 ;; @r{Evaluate it.} | |
| 311 (eval buffer) | |
| 312 @print{} #<buffer eval.texi> | |
| 313 @result{} #<buffer eval.texi> | |
| 314 @end group | |
| 315 @end example | |
| 316 | |
| 317 @node Symbol Forms | |
| 318 @subsection Symbol Forms | |
| 319 @cindex symbol evaluation | |
| 320 | |
| 321 When a symbol is evaluated, it is treated as a variable. The result | |
| 322 is the variable's value, if it has one. If it has none (if its value | |
| 323 cell is void), an error is signaled. For more information on the use of | |
| 324 variables, see @ref{Variables}. | |
| 325 | |
| 326 In the following example, we set the value of a symbol with | |
| 327 @code{setq}. Then we evaluate the symbol, and get back the value that | |
| 328 @code{setq} stored. | |
| 329 | |
| 330 @example | |
| 331 @group | |
| 332 (setq a 123) | |
| 333 @result{} 123 | |
| 334 @end group | |
| 335 @group | |
| 336 (eval 'a) | |
| 337 @result{} 123 | |
| 338 @end group | |
| 339 @group | |
| 340 a | |
| 341 @result{} 123 | |
| 342 @end group | |
| 343 @end example | |
| 344 | |
| 345 The symbols @code{nil} and @code{t} are treated specially, so that the | |
| 346 value of @code{nil} is always @code{nil}, and the value of @code{t} is | |
| 347 always @code{t}; you cannot set or bind them to any other values. Thus, | |
| 348 these two symbols act like self-evaluating forms, even though | |
| 349 @code{eval} treats them like any other symbol. | |
| 350 | |
| 351 @node Classifying Lists | |
| 352 @subsection Classification of List Forms | |
| 353 @cindex list form evaluation | |
| 354 | |
| 355 A form that is a nonempty list is either a function call, a macro | |
| 356 call, or a special form, according to its first element. These three | |
| 357 kinds of forms are evaluated in different ways, described below. The | |
| 358 remaining list elements constitute the @dfn{arguments} for the function, | |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
359 macro, or special operator. |
| 428 | 360 |
| 361 The first step in evaluating a nonempty list is to examine its first | |
| 362 element. This element alone determines what kind of form the list is | |
| 363 and how the rest of the list is to be processed. The first element is | |
| 364 @emph{not} evaluated, as it would be in some Lisp dialects such as | |
| 365 Scheme. | |
| 366 | |
| 367 @node Function Indirection | |
| 368 @subsection Symbol Function Indirection | |
| 369 @cindex symbol function indirection | |
| 370 @cindex indirection | |
| 371 @cindex void function | |
| 372 | |
| 373 If the first element of the list is a symbol then evaluation examines | |
| 374 the symbol's function cell, and uses its contents instead of the | |
| 375 original symbol. If the contents are another symbol, this process, | |
| 376 called @dfn{symbol function indirection}, is repeated until it obtains a | |
| 377 non-symbol. @xref{Function Names}, for more information about using a | |
| 378 symbol as a name for a function stored in the function cell of the | |
| 379 symbol. | |
| 380 | |
| 381 One possible consequence of this process is an infinite loop, in the | |
| 382 event that a symbol's function cell refers to the same symbol. Or a | |
| 383 symbol may have a void function cell, in which case the subroutine | |
| 384 @code{symbol-function} signals a @code{void-function} error. But if | |
| 385 neither of these things happens, we eventually obtain a non-symbol, | |
| 386 which ought to be a function or other suitable object. | |
| 387 | |
| 388 @kindex invalid-function | |
| 389 @cindex invalid function | |
| 390 More precisely, we should now have a Lisp function (a lambda | |
| 391 expression), a byte-code function, a primitive function, a Lisp macro, a | |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
392 special operator, or an autoload object. Each of these types is a case |
| 428 | 393 described in one of the following sections. If the object is not one of |
| 394 these types, the error @code{invalid-function} is signaled. | |
| 395 | |
| 396 The following example illustrates the symbol indirection process. We | |
| 397 use @code{fset} to set the function cell of a symbol and | |
| 398 @code{symbol-function} to get the function cell contents | |
| 399 (@pxref{Function Cells}). Specifically, we store the symbol @code{car} | |
| 400 into the function cell of @code{first}, and the symbol @code{first} into | |
| 401 the function cell of @code{erste}. | |
| 402 | |
| 403 @smallexample | |
| 404 @group | |
| 405 ;; @r{Build this function cell linkage:} | |
| 406 ;; ------------- ----- ------- ------- | |
| 407 ;; | #<subr car> | <-- | car | <-- | first | <-- | erste | | |
| 408 ;; ------------- ----- ------- ------- | |
| 409 @end group | |
| 410 @end smallexample | |
| 411 | |
| 412 @smallexample | |
| 413 @group | |
| 414 (symbol-function 'car) | |
| 415 @result{} #<subr car> | |
| 416 @end group | |
| 417 @group | |
| 418 (fset 'first 'car) | |
| 419 @result{} car | |
| 420 @end group | |
| 421 @group | |
| 422 (fset 'erste 'first) | |
| 423 @result{} first | |
| 424 @end group | |
| 425 @group | |
| 426 (erste '(1 2 3)) ; @r{Call the function referenced by @code{erste}.} | |
| 427 @result{} 1 | |
| 428 @end group | |
| 429 @end smallexample | |
| 430 | |
| 431 By contrast, the following example calls a function without any symbol | |
| 432 function indirection, because the first element is an anonymous Lisp | |
| 433 function, not a symbol. | |
| 434 | |
| 435 @smallexample | |
| 436 @group | |
| 437 ((lambda (arg) (erste arg)) | |
| 444 | 438 '(1 2 3)) |
| 428 | 439 @result{} 1 |
| 440 @end group | |
| 441 @end smallexample | |
| 442 | |
| 443 @noindent | |
| 444 Executing the function itself evaluates its body; this does involve | |
| 445 symbol function indirection when calling @code{erste}. | |
| 446 | |
| 447 The built-in function @code{indirect-function} provides an easy way to | |
| 448 perform symbol function indirection explicitly. | |
| 449 | |
| 444 | 450 @defun indirect-function object |
| 451 This function returns the meaning of @var{object} as a function. If | |
| 452 @var{object} is a symbol, then it finds @var{object}'s function | |
| 453 definition and starts over with that value. If @var{object} is not a | |
| 454 symbol, then it returns @var{object} itself. | |
| 428 | 455 |
| 456 Here is how you could define @code{indirect-function} in Lisp: | |
| 457 | |
| 458 @smallexample | |
| 459 (defun indirect-function (function) | |
| 460 (if (symbolp function) | |
| 461 (indirect-function (symbol-function function)) | |
| 462 function)) | |
| 463 @end smallexample | |
| 464 @end defun | |
| 465 | |
| 466 @node Function Forms | |
| 467 @subsection Evaluation of Function Forms | |
| 468 @cindex function form evaluation | |
| 469 @cindex function call | |
| 470 | |
| 471 If the first element of a list being evaluated is a Lisp function | |
| 472 object, byte-code object or primitive function object, then that list is | |
| 473 a @dfn{function call}. For example, here is a call to the function | |
| 474 @code{+}: | |
| 475 | |
| 476 @example | |
| 477 (+ 1 x) | |
| 478 @end example | |
| 479 | |
| 480 The first step in evaluating a function call is to evaluate the | |
| 481 remaining elements of the list from left to right. The results are the | |
| 482 actual argument values, one value for each list element. The next step | |
| 483 is to call the function with this list of arguments, effectively using | |
| 484 the function @code{apply} (@pxref{Calling Functions}). If the function | |
| 485 is written in Lisp, the arguments are used to bind the argument | |
| 486 variables of the function (@pxref{Lambda Expressions}); then the forms | |
| 487 in the function body are evaluated in order, and the value of the last | |
| 488 body form becomes the value of the function call. | |
| 489 | |
| 490 @node Macro Forms | |
| 491 @subsection Lisp Macro Evaluation | |
| 492 @cindex macro call evaluation | |
| 493 | |
| 494 If the first element of a list being evaluated is a macro object, then | |
| 495 the list is a @dfn{macro call}. When a macro call is evaluated, the | |
| 496 elements of the rest of the list are @emph{not} initially evaluated. | |
| 497 Instead, these elements themselves are used as the arguments of the | |
| 498 macro. The macro definition computes a replacement form, called the | |
| 499 @dfn{expansion} of the macro, to be evaluated in place of the original | |
| 500 form. The expansion may be any sort of form: a self-evaluating | |
| 501 constant, a symbol, or a list. If the expansion is itself a macro call, | |
| 502 this process of expansion repeats until some other sort of form results. | |
| 503 | |
| 504 Ordinary evaluation of a macro call finishes by evaluating the | |
| 505 expansion. However, the macro expansion is not necessarily evaluated | |
| 506 right away, or at all, because other programs also expand macro calls, | |
| 507 and they may or may not evaluate the expansions. | |
| 508 | |
| 509 Normally, the argument expressions are not evaluated as part of | |
| 510 computing the macro expansion, but instead appear as part of the | |
| 511 expansion, so they are computed when the expansion is computed. | |
| 512 | |
| 513 For example, given a macro defined as follows: | |
| 514 | |
| 515 @example | |
| 516 @group | |
| 517 (defmacro cadr (x) | |
| 518 (list 'car (list 'cdr x))) | |
| 519 @end group | |
| 520 @end example | |
| 521 | |
| 522 @noindent | |
| 523 an expression such as @code{(cadr (assq 'handler list))} is a macro | |
| 524 call, and its expansion is: | |
| 525 | |
| 526 @example | |
| 527 (car (cdr (assq 'handler list))) | |
| 528 @end example | |
| 529 | |
| 530 @noindent | |
| 531 Note that the argument @code{(assq 'handler list)} appears in the | |
| 532 expansion. | |
| 533 | |
| 534 @xref{Macros}, for a complete description of XEmacs Lisp macros. | |
| 535 | |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
536 @node Special Operators |
|
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
537 @subsection Special Operators |
|
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
538 @cindex special operator evaluation |
|
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
539 @cindex special form |
| 428 | 540 |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
541 A @dfn{special operator} (historically, and less logically, a |
|
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
542 @dfn{special form}) is a primitive function specially marked so that |
|
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
543 its arguments are not all evaluated. Most special operators define control |
| 428 | 544 structures or perform variable bindings---things which functions cannot |
| 545 do. | |
| 546 | |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
547 Each special operator has its own rules for which arguments are evaluated |
| 428 | 548 and which are used without evaluation. Whether a particular argument is |
| 549 evaluated may depend on the results of evaluating other arguments. | |
| 550 | |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
551 Here is a list, in alphabetical order, of all of the special operators in |
| 428 | 552 XEmacs Lisp with a reference to where each is described. |
| 553 | |
| 554 @table @code | |
| 555 @item and | |
| 556 @pxref{Combining Conditions} | |
| 557 | |
| 558 @item catch | |
| 559 @pxref{Catch and Throw} | |
| 560 | |
| 561 @item cond | |
| 562 @pxref{Conditionals} | |
| 563 | |
| 564 @item condition-case | |
| 565 @pxref{Handling Errors} | |
| 566 | |
| 567 @item defconst | |
| 568 @pxref{Defining Variables} | |
| 569 | |
| 570 @item defmacro | |
| 571 @pxref{Defining Macros} | |
| 572 | |
| 573 @item defun | |
| 574 @pxref{Defining Functions} | |
| 575 | |
| 576 @item defvar | |
| 577 @pxref{Defining Variables} | |
| 578 | |
| 579 @item function | |
| 580 @pxref{Anonymous Functions} | |
| 581 | |
| 582 @item if | |
| 583 @pxref{Conditionals} | |
| 584 | |
| 585 @item interactive | |
| 586 @pxref{Interactive Call} | |
| 587 | |
| 588 @item let | |
| 589 @itemx let* | |
| 590 @pxref{Local Variables} | |
| 591 | |
| 592 @item or | |
| 593 @pxref{Combining Conditions} | |
| 594 | |
| 595 @item prog1 | |
| 596 @itemx prog2 | |
| 597 @itemx progn | |
| 598 @pxref{Sequencing} | |
| 599 | |
| 600 @item quote | |
| 601 @pxref{Quoting} | |
| 602 | |
| 603 @item save-current-buffer | |
| 604 @pxref{Excursions} | |
| 605 | |
| 606 @item save-excursion | |
| 607 @pxref{Excursions} | |
| 608 | |
| 609 @item save-restriction | |
| 610 @pxref{Narrowing} | |
| 611 | |
| 612 @item save-selected-window | |
| 613 @pxref{Excursions} | |
| 614 | |
| 615 @item save-window-excursion | |
| 616 @pxref{Window Configurations} | |
| 617 | |
| 618 @item setq | |
| 619 @pxref{Setting Variables} | |
| 620 | |
| 621 @item setq-default | |
| 622 @pxref{Creating Buffer-Local} | |
| 623 | |
| 624 @item unwind-protect | |
| 625 @pxref{Nonlocal Exits} | |
| 626 | |
| 627 @item while | |
| 628 @pxref{Iteration} | |
| 629 | |
| 630 @item with-output-to-temp-buffer | |
| 631 @pxref{Temporary Displays} | |
| 632 @end table | |
| 633 | |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
634 @cindex CL note---special operators compared |
| 428 | 635 @quotation |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
636 @b{Common Lisp note:} here are some comparisons of special operators in |
| 428 | 637 XEmacs Lisp and Common Lisp. @code{setq}, @code{if}, and |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
638 @code{catch} are special operators in both XEmacs Lisp and Common Lisp. |
|
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
639 @code{defun} is a special operator in XEmacs Lisp, but a macro in Common |
|
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
640 Lisp. @code{save-excursion} is a special operator in XEmacs Lisp, but |
|
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
641 doesn't exist in Common Lisp. @code{throw} is a special operator in |
|
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
642 both Common Lisp and XEmacs Lisp (because it must be able to throw |
|
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
643 multiple values).@refill |
| 428 | 644 @end quotation |
| 645 | |
| 646 @node Autoloading | |
| 647 @subsection Autoloading | |
| 648 | |
| 649 The @dfn{autoload} feature allows you to call a function or macro | |
| 650 whose function definition has not yet been loaded into XEmacs. It | |
| 651 specifies which file contains the definition. When an autoload object | |
| 652 appears as a symbol's function definition, calling that symbol as a | |
| 653 function automatically loads the specified file; then it calls the real | |
| 654 definition loaded from that file. @xref{Autoload}. | |
| 655 | |
| 656 @node Quoting | |
| 657 @section Quoting | |
| 658 @cindex quoting | |
| 659 | |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
660 The special operator @code{quote} returns its single argument, as written, |
| 428 | 661 without evaluating it. This provides a way to include constant symbols |
| 662 and lists, which are not self-evaluating objects, in a program. (It is | |
| 663 not necessary to quote self-evaluating objects such as numbers, strings, | |
| 664 and vectors.) | |
| 665 | |
| 666 @defspec quote object | |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
667 This special operator returns @var{object}, without evaluating it. |
| 428 | 668 @end defspec |
| 669 | |
| 670 @cindex @samp{'} for quoting | |
| 671 @cindex quoting using apostrophe | |
| 672 @cindex apostrophe for quoting | |
| 673 Because @code{quote} is used so often in programs, Lisp provides a | |
| 674 convenient read syntax for it. An apostrophe character (@samp{'}) | |
| 675 followed by a Lisp object (in read syntax) expands to a list whose first | |
| 676 element is @code{quote}, and whose second element is the object. Thus, | |
| 677 the read syntax @code{'x} is an abbreviation for @code{(quote x)}. | |
| 678 | |
| 679 Here are some examples of expressions that use @code{quote}: | |
| 680 | |
| 681 @example | |
| 682 @group | |
| 683 (quote (+ 1 2)) | |
| 684 @result{} (+ 1 2) | |
| 685 @end group | |
| 686 @group | |
| 687 (quote foo) | |
| 688 @result{} foo | |
| 689 @end group | |
| 690 @group | |
| 691 'foo | |
| 692 @result{} foo | |
| 693 @end group | |
| 694 @group | |
| 695 ''foo | |
| 696 @result{} (quote foo) | |
| 697 @end group | |
| 698 @group | |
| 699 '(quote foo) | |
| 700 @result{} (quote foo) | |
| 701 @end group | |
| 702 @group | |
| 703 ['foo] | |
| 704 @result{} [(quote foo)] | |
| 705 @end group | |
| 706 @end example | |
| 707 | |
| 708 Other quoting constructs include @code{function} (@pxref{Anonymous | |
| 709 Functions}), which causes an anonymous lambda expression written in Lisp | |
| 710 to be compiled, and @samp{`} (@pxref{Backquote}), which is used to quote | |
| 711 only part of a list, while computing and substituting other parts. | |
|
5252
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
712 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
713 @node Multiple values |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
714 @section Multiple values |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
715 @cindex multiple values |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
716 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
717 @noindent |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
718 Under XEmacs, expressions can return zero or more results, using the |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
719 @code{values} and @code{values-list} functions. Results other than the |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
720 first are typically discarded, but special operators are provided to |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
721 access them. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
722 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
723 @defun values arguments@dots{} |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
724 This function returns @var{arguments} as multiple values. Callers will |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
725 always receive the first element of @var{arguments}, but must use |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
726 various special operators, described below, to access other elements of |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
727 @var{arguments}. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
728 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
729 The idiom @code{(values (function-call argument))}, with one |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
730 argument, is the normal mechanism to avoid passing multiple values to |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
731 the calling form where that is not desired. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
732 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
733 XEmacs implements the Common Lisp specification when it comes to the |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
734 exact details of when to discard and when to preserve multiple values; |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
735 see Common Lisp the Language or the Common Lisp hyperspec for more |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
736 details. The most important thing to keep in mind is when multiple |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
737 values are passed as an argument to a function, all but the first are |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
738 discarded. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
739 @end defun |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
740 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
741 @defun values-list argument |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
742 This function returns the elements of the lst @var{argument} as multiple |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
743 values. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
744 @end defun |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
745 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
746 @defspec multiple-value-bind (var@dots{}) values-form forms@dots{} |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
747 This special operator evaluates @var{values-form}, which may return |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
748 multiple values. It then binds the @var{var}s to these respective values, |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
749 as if by @code{let}, and then executes the body @var{forms}. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
750 If there are more @var{var}s than values, the extra @var{var}s |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
751 are bound to @code{nil}. If there are fewer @var{var}s than |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
752 values, the excess values are ignored. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
753 @end defspec |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
754 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
755 @defspec multiple-value-setq (var@dots{}) form |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
756 This special operator evaluates @var{form}, which may return multiple |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
757 values. It then sets the @var{var}s to these respective values, as if by |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
758 @code{setq}. Extra @var{var}s or values are treated the same as |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
759 in @code{multiple-value-bind}. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
760 @end defspec |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
761 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
762 @defspec multiple-value-call function forms@dots{} |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
763 This special operator evaluates function, discarding any multiple |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
764 values. It then evaluates @var{forms}, preserving any multiple values, |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
765 and calls @var{function} as a function with the results. Conceptually, this |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
766 function is a version of @code{apply'}that by-passes the multiple values |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
767 infrastructure, treating multiple values as intercalated lists. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
768 @end defspec |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
769 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
770 @defspec multiple-value-list form |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
771 This special operator evaluates @var{form} and returns a list of the |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
772 multiple values given by it. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
773 @end defspec |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
774 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
775 @defspec multiple-value-prog1 first body@dots{} |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
776 This special operator evaluates the form @var{first}, then the |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
777 forms @var{body}. It returns the value given by @var{first}, preserving |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
778 any multiple values. This is identical to @code{prog1}, except that |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
779 @code{prog1} always discards multiple values. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
780 @end defspec |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
781 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
782 @defspec nth-value n form |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
783 This special operator evaluates @var{form} and returns the @var{n}th |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
784 value it gave. @var{n} must be an integer of value zero or more. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
785 If @var{form} gave insufficient multiple values, @code{nth-value} |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
786 returns @code{nil}. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
787 @end defspec |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
788 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
789 @defvar multiple-values-limit |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
790 This constant describes the exclusive upper bound on the number of |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
791 multiple values that @code{values} accepts and that |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
792 @code{multiple-value-bind}, etc. will consume. |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
793 @end defvar |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
794 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
795 To take full advantage of multiple values, Emacs Lisp code must have |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
796 been compiled by XEmacs 21.5 or later, which is not yet true of the |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
797 XEmacs packages. Matched @code{values} and @code{multiple-value-bind} |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
798 calls will work in code included in the XEmacs packages when run on |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
799 21.5, though the following incantation may be necessary at the start of |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
800 your file, until appropriate code is included in XEmacs 21.4: |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
801 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
802 @example |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
803 (eval-when-compile (when (eq 'list (symbol-function 'values)) |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
804 (define-compiler-macro values (&rest args) |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
805 (cons 'list args)) |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
806 (define-compiler-macro values-list (list) list))) |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
807 @end example |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
808 |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
809 Such code cannot, unfortunately, rely on XEmacs to discard multiple |
|
378a34562cbe
Fix style, documentation for rounding functions and multiple values.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4905
diff
changeset
|
810 values where that is appropriate. |