Mercurial > hg > xemacs-beta
annotate man/lispref/symbols.texi @ 5044:e84a30b0e4a2
remove duplicative code in change_frame_size()
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-02-15 Ben Wing <ben@xemacs.org>
* frame.c (change_frame_size_1):
Simplify the logic in this function.
(1) Don't allow 0 as the value of height or width. The old code
that tried to allow this was totally broken, anyway, so obviously
this never happens any more.
(2) Don't duplicate the code in frame_conversion_internal() that
converts displayable pixel size to total pixel size -- just call
that function.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Mon, 15 Feb 2010 22:58:10 -0600 |
| 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 |