Mercurial > hg > xemacs-beta
annotate man/lispref/symbols.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 | 755ae5b97edb |
| children | febc025c4e0c |
| 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/symbols.info | |
| 6 @node Symbols, Evaluation, Sequences Arrays Vectors, Top | |
| 7 @chapter Symbols | |
| 8 @cindex symbol | |
| 9 | |
| 10 A @dfn{symbol} is an object with a unique name. This chapter | |
| 11 describes symbols, their components, their property lists, and how they | |
| 12 are created and interned. Separate chapters describe the use of symbols | |
| 13 as variables and as function names; see @ref{Variables}, and | |
| 2492 | 14 @ref{Functions and Commands}. For the precise read syntax for symbols, |
| 15 see @ref{Symbol Type}. | |
| 428 | 16 |
| 17 You can test whether an arbitrary Lisp object is a symbol | |
| 18 with @code{symbolp}: | |
| 19 | |
| 20 @defun symbolp object | |
| 21 This function returns @code{t} if @var{object} is a symbol, @code{nil} | |
| 22 otherwise. | |
| 23 @end defun | |
| 24 | |
| 25 @menu | |
| 26 * Symbol Components:: Symbols have names, values, function definitions | |
| 27 and property lists. | |
| 28 * Definitions:: A definition says how a symbol will be used. | |
| 29 * Creating Symbols:: How symbols are kept unique. | |
| 30 * Symbol Properties:: Each symbol has a property list | |
| 31 for recording miscellaneous information. | |
| 32 @end menu | |
| 33 | |
| 34 @node Symbol Components | |
| 35 @section Symbol Components | |
| 36 @cindex symbol components | |
| 37 | |
| 38 Each symbol has four components (or ``cells''), each of which | |
| 39 references another object: | |
| 40 | |
| 41 @table @asis | |
| 42 @item Print name | |
| 43 @cindex print name cell | |
| 44 The @dfn{print name cell} holds a string that names the symbol for | |
| 45 reading and printing. See @code{symbol-name} in @ref{Creating Symbols}. | |
| 46 | |
| 47 @item Value | |
| 48 @cindex value cell | |
| 49 The @dfn{value cell} holds the current value of the symbol as a | |
| 50 variable. When a symbol is used as a form, the value of the form is the | |
| 51 contents of the symbol's value cell. See @code{symbol-value} in | |
| 52 @ref{Accessing Variables}. | |
| 53 | |
| 54 @item Function | |
| 55 @cindex function cell | |
| 56 The @dfn{function cell} holds the function definition of the symbol. | |
| 57 When a symbol is used as a function, its function definition is used in | |
| 58 its place. This cell is also used to make a symbol stand for a keymap | |
| 59 or a keyboard macro, for editor command execution. Because each symbol | |
| 60 has separate value and function cells, variables and function names do | |
| 61 not conflict. See @code{symbol-function} in @ref{Function Cells}. | |
| 62 | |
| 63 @item Property list | |
| 64 @cindex property list cell (symbol) | |
| 65 The @dfn{property list cell} holds the property list of the symbol. See | |
| 66 @code{symbol-plist} in @ref{Symbol Properties}. | |
| 67 @end table | |
| 68 | |
| 69 The print name cell always holds a string, and cannot be changed. The | |
| 70 other three cells can be set individually to any specified Lisp object. | |
| 71 | |
| 72 The print name cell holds the string that is the name of the symbol. | |
| 73 Since symbols are represented textually by their names, it is important | |
| 74 not to have two symbols with the same name. The Lisp reader ensures | |
| 75 this: every time it reads a symbol, it looks for an existing symbol with | |
| 76 the specified name before it creates a new one. (In XEmacs Lisp, | |
| 77 this lookup uses a hashing algorithm and an obarray; see @ref{Creating | |
| 78 Symbols}.) | |
| 79 | |
| 80 In normal usage, the function cell usually contains a function or | |
| 81 macro, as that is what the Lisp interpreter expects to see there | |
| 82 (@pxref{Evaluation}). Keyboard macros (@pxref{Keyboard Macros}), | |
| 83 keymaps (@pxref{Keymaps}) and autoload objects (@pxref{Autoloading}) are | |
| 84 also sometimes stored in the function cell of symbols. We often refer | |
| 85 to ``the function @code{foo}'' when we really mean the function stored | |
| 86 in the function cell of the symbol @code{foo}. We make the distinction | |
| 87 only when necessary. | |
| 88 | |
| 89 The property list cell normally should hold a correctly formatted | |
| 90 property list (@pxref{Property Lists}), as a number of functions expect | |
| 91 to see a property list there. | |
| 92 | |
| 93 The function cell or the value cell may be @dfn{void}, which means | |
| 94 that the cell does not reference any object. (This is not the same | |
| 95 thing as holding the symbol @code{void}, nor the same as holding the | |
| 96 symbol @code{nil}.) Examining a cell that is void results in an error, | |
| 97 such as @samp{Symbol's value as variable is void}. | |
| 98 | |
| 99 The four functions @code{symbol-name}, @code{symbol-value}, | |
| 100 @code{symbol-plist}, and @code{symbol-function} return the contents of | |
| 101 the four cells of a symbol. Here as an example we show the contents of | |
| 102 the four cells of the symbol @code{buffer-file-name}: | |
| 103 | |
| 104 @example | |
| 105 (symbol-name 'buffer-file-name) | |
| 106 @result{} "buffer-file-name" | |
| 107 (symbol-value 'buffer-file-name) | |
| 108 @result{} "/gnu/elisp/symbols.texi" | |
| 109 (symbol-plist 'buffer-file-name) | |
| 110 @result{} (variable-documentation 29529) | |
| 111 (symbol-function 'buffer-file-name) | |
| 112 @result{} #<subr buffer-file-name> | |
| 113 @end example | |
| 114 | |
| 115 @noindent | |
| 116 Because this symbol is the variable which holds the name of the file | |
| 117 being visited in the current buffer, the value cell contents we see are | |
| 446 | 118 the name of the source file of this chapter of the XEmacs Lisp Reference |
| 119 Manual. | |
| 428 | 120 The property list cell contains the list @code{(variable-documentation |
| 121 29529)} which tells the documentation functions where to find the | |
| 122 documentation string for the variable @code{buffer-file-name} in the | |
| 123 @file{DOC} file. (29529 is the offset from the beginning of the | |
| 124 @file{DOC} file to where that documentation string begins.) The | |
| 125 function cell contains the function for returning the name of the file. | |
| 126 @code{buffer-file-name} names a primitive function, which has no read | |
| 127 syntax and prints in hash notation (@pxref{Primitive Function Type}). A | |
| 128 symbol naming a function written in Lisp would have a lambda expression | |
| 129 (or a byte-code object) in this cell. | |
| 130 | |
| 131 @node Definitions | |
| 132 @section Defining Symbols | |
| 133 @cindex definition of a symbol | |
| 134 | |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
135 A @dfn{definition} in Lisp is a special operator that announces your |
| 428 | 136 intention to use a certain symbol in a particular way. In XEmacs Lisp, |
| 137 you can define a symbol as a variable, or define it as a function (or | |
| 138 macro), or both independently. | |
| 139 | |
| 140 A definition construct typically specifies a value or meaning for the | |
| 141 symbol for one kind of use, plus documentation for its meaning when used | |
| 142 in this way. Thus, when you define a symbol as a variable, you can | |
| 143 supply an initial value for the variable, plus documentation for the | |
| 144 variable. | |
| 145 | |
|
4905
755ae5b97edb
Change "special form" to "special operator" in our sources.
Aidan Kehoe <kehoea@parhasard.net>
parents:
2492
diff
changeset
|
146 @code{defvar} and @code{defconst} are special operators that define a |
| 428 | 147 symbol as a global variable. They are documented in detail in |
| 148 @ref{Defining Variables}. | |
| 149 | |
| 150 @code{defun} defines a symbol as a function, creating a lambda | |
| 151 expression and storing it in the function cell of the symbol. This | |
| 152 lambda expression thus becomes the function definition of the symbol. | |
| 153 (The term ``function definition'', meaning the contents of the function | |
| 154 cell, is derived from the idea that @code{defun} gives the symbol its | |
| 155 definition as a function.) @code{defsubst}, @code{define-function} and | |
| 156 @code{defalias} are other ways of defining a function. | |
| 2492 | 157 @xref{Functions and Commands}. |
| 428 | 158 |
| 159 @code{defmacro} defines a symbol as a macro. It creates a macro | |
| 160 object and stores it in the function cell of the symbol. Note that a | |
| 161 given symbol can be a macro or a function, but not both at once, because | |
| 162 both macro and function definitions are kept in the function cell, and | |
| 163 that cell can hold only one Lisp object at any given time. | |
| 164 @xref{Macros}. | |
| 165 | |
| 166 In XEmacs Lisp, a definition is not required in order to use a symbol | |
| 167 as a variable or function. Thus, you can make a symbol a global | |
| 168 variable with @code{setq}, whether you define it first or not. The real | |
| 169 purpose of definitions is to guide programmers and programming tools. | |
| 170 They inform programmers who read the code that certain symbols are | |
| 171 @emph{intended} to be used as variables, or as functions. In addition, | |
| 172 utilities such as @file{etags} and @file{make-docfile} recognize | |
| 173 definitions, and add appropriate information to tag tables and the | |
| 174 @file{DOC} file. @xref{Accessing Documentation}. | |
| 175 | |
| 176 @node Creating Symbols | |
| 177 @section Creating and Interning Symbols | |
| 178 @cindex reading symbols | |
| 179 | |
| 180 To understand how symbols are created in XEmacs Lisp, you must know | |
| 181 how Lisp reads them. Lisp must ensure that it finds the same symbol | |
| 182 every time it reads the same set of characters. Failure to do so would | |
| 183 cause complete confusion. | |
| 184 | |
| 185 @cindex symbol name hashing | |
| 186 @cindex hashing | |
| 187 @cindex obarray | |
| 188 @cindex bucket (in obarray) | |
| 189 When the Lisp reader encounters a symbol, it reads all the characters | |
| 190 of the name. Then it ``hashes'' those characters to find an index in a | |
| 191 table called an @dfn{obarray}. Hashing is an efficient method of | |
| 192 looking something up. For example, instead of searching a telephone | |
| 193 book cover to cover when looking up Jan Jones, you start with the J's | |
| 194 and go from there. That is a simple version of hashing. Each element | |
| 195 of the obarray is a @dfn{bucket} which holds all the symbols with a | |
| 196 given hash code; to look for a given name, it is sufficient to look | |
| 197 through all the symbols in the bucket for that name's hash code. | |
| 198 | |
| 199 @cindex interning | |
| 200 If a symbol with the desired name is found, the reader uses that | |
| 201 symbol. If the obarray does not contain a symbol with that name, the | |
| 202 reader makes a new symbol and adds it to the obarray. Finding or adding | |
| 203 a symbol with a certain name is called @dfn{interning} it, and the | |
| 204 symbol is then called an @dfn{interned symbol}. | |
| 205 | |
| 206 Interning ensures that each obarray has just one symbol with any | |
| 207 particular name. Other like-named symbols may exist, but not in the | |
| 208 same obarray. Thus, the reader gets the same symbols for the same | |
| 209 names, as long as you keep reading with the same obarray. | |
| 210 | |
| 211 @cindex symbol equality | |
| 212 @cindex uninterned symbol | |
| 213 No obarray contains all symbols; in fact, some symbols are not in any | |
| 214 obarray. They are called @dfn{uninterned symbols}. An uninterned | |
| 215 symbol has the same four cells as other symbols; however, the only way | |
| 216 to gain access to it is by finding it in some other object or as the | |
| 217 value of a variable. | |
| 218 | |
| 219 In XEmacs Lisp, an obarray is actually a vector. Each element of the | |
| 220 vector is a bucket; its value is either an interned symbol whose name | |
| 221 hashes to that bucket, or 0 if the bucket is empty. Each interned | |
| 222 symbol has an internal link (invisible to the user) to the next symbol | |
| 223 in the bucket. Because these links are invisible, there is no way to | |
| 224 find all the symbols in an obarray except using @code{mapatoms} (below). | |
| 225 The order of symbols in a bucket is not significant. | |
| 226 | |
| 227 In an empty obarray, every element is 0, and you can create an obarray | |
| 228 with @code{(make-vector @var{length} 0)}. @strong{This is the only | |
| 229 valid way to create an obarray.} Prime numbers as lengths tend | |
| 230 to result in good hashing; lengths one less than a power of two are also | |
| 231 good. | |
| 232 | |
| 233 @strong{Do not try to put symbols in an obarray yourself.} This does | |
| 234 not work---only @code{intern} can enter a symbol in an obarray properly. | |
| 235 @strong{Do not try to intern one symbol in two obarrays.} This would | |
| 236 garble both obarrays, because a symbol has just one slot to hold the | |
| 237 following symbol in the obarray bucket. The results would be | |
| 238 unpredictable. | |
| 239 | |
| 240 It is possible for two different symbols to have the same name in | |
| 241 different obarrays; these symbols are not @code{eq} or @code{equal}. | |
| 242 However, this normally happens only as part of the abbrev mechanism | |
| 243 (@pxref{Abbrevs}). | |
| 244 | |
| 245 @cindex CL note---symbol in obarrays | |
| 246 @quotation | |
| 247 @b{Common Lisp note:} In Common Lisp, a single symbol may be interned in | |
| 248 several obarrays. | |
| 249 @end quotation | |
| 250 | |
| 251 Most of the functions below take a name and sometimes an obarray as | |
| 252 arguments. A @code{wrong-type-argument} error is signaled if the name | |
| 253 is not a string, or if the obarray is not a vector. | |
| 254 | |
| 255 @defun symbol-name symbol | |
| 256 This function returns the string that is @var{symbol}'s name. For example: | |
| 257 | |
| 258 @example | |
| 259 @group | |
| 260 (symbol-name 'foo) | |
| 261 @result{} "foo" | |
| 262 @end group | |
| 263 @end example | |
| 264 | |
| 265 Changing the string by substituting characters, etc, does change the | |
| 266 name of the symbol, but fails to update the obarray, so don't do it! | |
| 267 @end defun | |
| 268 | |
| 269 @defun make-symbol name | |
| 270 This function returns a newly-allocated, uninterned symbol whose name is | |
| 271 @var{name} (which must be a string). Its value and function definition | |
| 272 are void, and its property list is @code{nil}. In the example below, | |
| 273 the value of @code{sym} is not @code{eq} to @code{foo} because it is a | |
| 274 distinct uninterned symbol whose name is also @samp{foo}. | |
| 275 | |
| 276 @example | |
| 277 (setq sym (make-symbol "foo")) | |
| 278 @result{} foo | |
| 279 (eq sym 'foo) | |
| 280 @result{} nil | |
| 281 @end example | |
| 282 @end defun | |
| 283 | |
| 284 @defun intern name &optional obarray | |
| 285 This function returns the interned symbol whose name is @var{name}. If | |
| 286 there is no such symbol in the obarray @var{obarray}, @code{intern} | |
| 287 creates a new one, adds it to the obarray, and returns it. If | |
| 288 @var{obarray} is omitted, the value of the global variable | |
| 289 @code{obarray} is used. | |
| 290 | |
| 291 @example | |
| 292 (setq sym (intern "foo")) | |
| 293 @result{} foo | |
| 294 (eq sym 'foo) | |
| 295 @result{} t | |
| 296 | |
| 297 (setq sym1 (intern "foo" other-obarray)) | |
| 298 @result{} foo | |
| 299 (eq sym 'foo) | |
| 300 @result{} nil | |
| 301 @end example | |
| 302 @end defun | |
| 303 | |
| 304 @defun intern-soft name &optional obarray | |
| 305 This function returns the symbol in @var{obarray} whose name is | |
| 306 @var{name}, or @code{nil} if @var{obarray} has no symbol with that name. | |
| 307 Therefore, you can use @code{intern-soft} to test whether a symbol with | |
| 308 a given name is already interned. If @var{obarray} is omitted, the | |
| 309 value of the global variable @code{obarray} is used. | |
| 310 | |
| 311 @smallexample | |
| 312 (intern-soft "frazzle") ; @r{No such symbol exists.} | |
| 313 @result{} nil | |
| 314 (make-symbol "frazzle") ; @r{Create an uninterned one.} | |
| 315 @result{} frazzle | |
| 316 @group | |
| 317 (intern-soft "frazzle") ; @r{That one cannot be found.} | |
| 318 @result{} nil | |
| 319 @end group | |
| 320 @group | |
| 321 (setq sym (intern "frazzle")) ; @r{Create an interned one.} | |
| 322 @result{} frazzle | |
| 323 @end group | |
| 324 @group | |
| 325 (intern-soft "frazzle") ; @r{That one can be found!} | |
| 326 @result{} frazzle | |
| 327 @end group | |
| 328 @group | |
| 329 (eq sym 'frazzle) ; @r{And it is the same one.} | |
| 330 @result{} t | |
| 331 @end group | |
| 332 @end smallexample | |
| 333 @end defun | |
| 334 | |
| 335 @defvar obarray | |
| 336 This variable is the standard obarray for use by @code{intern} and | |
| 337 @code{read}. | |
| 338 @end defvar | |
| 339 | |
| 340 @defun mapatoms function &optional obarray | |
| 341 This function calls @var{function} for each symbol in the obarray | |
| 342 @var{obarray}. It returns @code{nil}. If @var{obarray} is omitted, it | |
| 343 defaults to the value of @code{obarray}, the standard obarray for | |
| 344 ordinary symbols. | |
| 345 | |
| 346 @smallexample | |
| 347 (setq count 0) | |
| 348 @result{} 0 | |
| 349 (defun count-syms (s) | |
| 350 (setq count (1+ count))) | |
| 351 @result{} count-syms | |
| 352 (mapatoms 'count-syms) | |
| 353 @result{} nil | |
| 354 count | |
| 355 @result{} 1871 | |
| 356 @end smallexample | |
| 357 | |
| 358 See @code{documentation} in @ref{Accessing Documentation}, for another | |
| 359 example using @code{mapatoms}. | |
| 360 @end defun | |
| 361 | |
| 362 @defun unintern symbol &optional obarray | |
| 363 This function deletes @var{symbol} from the obarray @var{obarray}. If | |
| 364 @code{symbol} is not actually in the obarray, @code{unintern} does | |
| 365 nothing. If @var{obarray} is @code{nil}, the current obarray is used. | |
| 366 | |
| 367 If you provide a string instead of a symbol as @var{symbol}, it stands | |
| 368 for a symbol name. Then @code{unintern} deletes the symbol (if any) in | |
| 369 the obarray which has that name. If there is no such symbol, | |
| 370 @code{unintern} does nothing. | |
| 371 | |
| 372 If @code{unintern} does delete a symbol, it returns @code{t}. Otherwise | |
| 373 it returns @code{nil}. | |
| 374 @end defun | |
| 375 | |
| 376 @node Symbol Properties | |
| 377 @section Symbol Properties | |
| 378 @cindex property list, symbol | |
| 379 @cindex plist, symbol | |
| 380 | |
| 381 A @dfn{property list} (@dfn{plist} for short) is a list of paired | |
| 442 | 382 elements, often stored in the property list cell of a symbol. Each of |
| 383 the pairs associates a property name (usually a symbol) with a property | |
| 384 or value. Property lists are generally used to record information about | |
| 385 a symbol, such as its documentation as a variable, the name of the file | |
| 428 | 386 where it was defined, or perhaps even the grammatical class of the |
| 387 symbol (representing a word) in a language-understanding system. | |
| 388 | |
| 442 | 389 Some objects which are not symbols also have property lists associated |
| 428 | 390 with them, and XEmacs provides a full complement of functions for |
| 391 working with property lists. @xref{Property Lists}. | |
| 392 | |
| 393 The property names and values in a property list can be any Lisp | |
| 394 objects, but the names are usually symbols. They are compared using | |
| 395 @code{eq}. Here is an example of a property list, found on the symbol | |
| 396 @code{progn} when the compiler is loaded: | |
| 397 | |
| 398 @example | |
| 399 (lisp-indent-function 0 byte-compile byte-compile-progn) | |
| 400 @end example | |
| 401 | |
| 402 @noindent | |
| 403 Here @code{lisp-indent-function} and @code{byte-compile} are property | |
| 404 names, and the other two elements are the corresponding values. | |
| 405 | |
| 406 @menu | |
| 407 * Plists and Alists:: Comparison of the advantages of property | |
| 408 lists and association lists. | |
| 442 | 409 * Object Plists:: Functions to access objects' property lists. |
| 428 | 410 * Other Plists:: Accessing property lists stored elsewhere. |
| 411 @end menu | |
| 412 | |
| 413 @node Plists and Alists | |
| 414 @subsection Property Lists and Association Lists | |
| 415 | |
| 416 @cindex property lists vs association lists | |
| 417 Association lists (@pxref{Association Lists}) are very similar to | |
| 418 property lists. In contrast to association lists, the order of the | |
| 419 pairs in the property list is not significant since the property names | |
| 420 must be distinct. | |
| 421 | |
| 422 Property lists are better than association lists for attaching | |
| 423 information to various Lisp function names or variables. If all the | |
| 424 associations are recorded in one association list, the program will need | |
| 425 to search that entire list each time a function or variable is to be | |
| 426 operated on. By contrast, if the information is recorded in the | |
| 427 property lists of the function names or variables themselves, each | |
| 428 search will scan only the length of one property list, which is usually | |
| 429 short. This is why the documentation for a variable is recorded in a | |
| 430 property named @code{variable-documentation}. The byte compiler | |
| 431 likewise uses properties to record those functions needing special | |
| 432 treatment. | |
| 433 | |
| 434 However, association lists have their own advantages. Depending on | |
| 435 your application, it may be faster to add an association to the front of | |
| 436 an association list than to update a property. All properties for a | |
| 437 symbol are stored in the same property list, so there is a possibility | |
| 438 of a conflict between different uses of a property name. (For this | |
| 439 reason, it is a good idea to choose property names that are probably | |
| 440 unique, such as by including the name of the library in the property | |
| 441 name.) An association list may be used like a stack where associations | |
| 442 are pushed on the front of the list and later discarded; this is not | |
| 443 possible with a property list. | |
| 444 | |
| 442 | 445 @node Object Plists |
| 446 @subsection Property List Functions for Objects | |
| 447 | |
| 448 Once upon a time, only symbols had property lists. Now, several other | |
| 449 object types, including strings, extents, faces and glyphs also have | |
| 450 property lists. | |
| 428 | 451 |
| 452 @defun symbol-plist symbol | |
| 453 This function returns the property list of @var{symbol}. | |
| 454 @end defun | |
| 455 | |
| 442 | 456 @defun object-plist object |
| 457 This function returns the property list of @var{object}. If | |
| 458 @var{object} is a symbol, this is identical to @code{symbol-plist}. | |
| 459 @end defun | |
| 460 | |
| 428 | 461 @defun setplist symbol plist |
| 462 This function sets @var{symbol}'s property list to @var{plist}. | |
| 463 Normally, @var{plist} should be a well-formed property list, but this is | |
| 464 not enforced. | |
| 465 | |
| 466 @smallexample | |
| 467 (setplist 'foo '(a 1 b (2 3) c nil)) | |
| 468 @result{} (a 1 b (2 3) c nil) | |
| 469 (symbol-plist 'foo) | |
| 470 @result{} (a 1 b (2 3) c nil) | |
| 471 @end smallexample | |
| 472 | |
| 473 For symbols in special obarrays, which are not used for ordinary | |
| 474 purposes, it may make sense to use the property list cell in a | |
| 475 nonstandard fashion; in fact, the abbrev mechanism does so | |
| 442 | 476 (@pxref{Abbrevs}). But generally, its use is discouraged. Use |
| 477 @code{put} instead. @code{setplist} can only be used with symbols, not | |
| 478 other object types. | |
| 428 | 479 @end defun |
| 480 | |
| 442 | 481 @defun get object property &optional default |
| 428 | 482 This function finds the value of the property named @var{property} in |
| 442 | 483 @var{object}'s property list. If there is no such property, |
| 484 @code{default} (which itself defaults to @code{nil}) is returned. | |
| 428 | 485 |
| 442 | 486 @var{property} is compared with the existing properties using @code{eq}, |
| 487 so any object is a legitimate property. | |
| 428 | 488 |
| 489 See @code{put} for an example. | |
| 490 @end defun | |
| 491 | |
| 442 | 492 @defun put object property value |
| 493 This function puts @var{value} onto @var{object}'s property list under | |
| 428 | 494 the property name @var{property}, replacing any previous property value. |
| 495 The @code{put} function returns @var{value}. | |
| 496 | |
| 497 @smallexample | |
| 498 (put 'fly 'verb 'transitive) | |
| 499 @result{}'transitive | |
| 500 (put 'fly 'noun '(a buzzing little bug)) | |
| 501 @result{} (a buzzing little bug) | |
| 502 (get 'fly 'verb) | |
| 503 @result{} transitive | |
| 442 | 504 (object-plist 'fly) |
| 428 | 505 @result{} (verb transitive noun (a buzzing little bug)) |
| 506 @end smallexample | |
| 507 @end defun | |
| 508 | |
| 442 | 509 @defun remprop object property |
| 510 This function removes the entry for @var{property} from the property | |
| 511 list of @var{object}. It returns @code{t} if the property was | |
| 512 indeed found and removed, or @code{nil} if there was no such property. | |
| 513 (This function was probably omitted from Emacs originally because, | |
| 514 since @code{get} did not allow a @var{default}, it was very difficult | |
| 515 to distinguish between a missing property and a property whose value | |
| 516 was @code{nil}; thus, setting a property to @code{nil} was close | |
| 517 enough to @code{remprop} for most purposes.) | |
| 518 @end defun | |
| 519 | |
| 428 | 520 @node Other Plists |
| 442 | 521 @subsection Property Lists Not Associated with Objects |
| 428 | 522 |
| 523 These functions are useful for manipulating property lists | |
| 524 that are stored in places other than symbols: | |
| 525 | |
| 526 @defun getf plist property &optional default | |
| 527 This returns the value of the @var{property} property | |
| 528 stored in the property list @var{plist}. For example, | |
| 529 | |
| 530 @example | |
| 531 (getf '(foo 4) 'foo) | |
| 532 @result{} 4 | |
| 533 @end example | |
| 534 @end defun | |
| 535 | |
| 444 | 536 @defmac putf plist property value |
| 428 | 537 This stores @var{value} as the value of the @var{property} property in |
| 538 the property list @var{plist}. It may modify @var{plist} destructively, | |
| 539 or it may construct a new list structure without altering the old. The | |
| 540 function returns the modified property list, so you can store that back | |
| 541 in the place where you got @var{plist}. For example, | |
| 542 | |
| 543 @example | |
| 544 (setq my-plist '(bar t foo 4)) | |
| 545 @result{} (bar t foo 4) | |
| 546 (setq my-plist (putf my-plist 'foo 69)) | |
| 547 @result{} (bar t foo 69) | |
| 548 (setq my-plist (putf my-plist 'quux '(a))) | |
| 549 @result{} (quux (a) bar t foo 5) | |
| 550 @end example | |
| 444 | 551 @end defmac |
| 428 | 552 |
| 553 @defun plists-eq a b | |
| 554 This function returns non-@code{nil} if property lists @var{a} and @var{b} | |
| 555 are @code{eq}. This means that the property lists have the same values | |
| 556 for all the same properties, where comparison between values is done using | |
| 557 @code{eq}. | |
| 558 @end defun | |
| 559 | |
| 560 @defun plists-equal a b | |
| 561 This function returns non-@code{nil} if property lists @var{a} and @var{b} | |
| 562 are @code{equal}. | |
| 563 @end defun | |
| 564 | |
| 565 Both of the above functions do order-insensitive comparisons. | |
| 566 | |
| 567 @example | |
| 568 (plists-eq '(a 1 b 2 c nil) '(b 2 a 1)) | |
| 569 @result{} t | |
| 570 (plists-eq '(foo "hello" bar "goodbye") '(bar "goodbye" foo "hello")) | |
| 571 @result{} nil | |
| 572 (plists-equal '(foo "hello" bar "goodbye") '(bar "goodbye" foo "hello")) | |
| 573 @result{} t | |
| 574 @end example | |
| 575 | |
| 576 | |
| 577 |