| blob | b897603ab47ffe0e9a28478f981b0e04e6dc72f8 |
1 ;;; cl.el --- Common-Lisp extensions for GNU Emacs Lisp.
3 ;; Copyright (C) 1987, 1988, 1989, 1992 Free Software Foundation, Inc.
5 ;; Author: Cesar Quiroz <quiroz@cs.rochester.edu>
6 ;; Keywords: extensions
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY. No author or distributor
14 ;; accepts responsibility to anyone for the consequences of using it
15 ;; or for whether it serves any particular purpose or works at all,
16 ;; unless he says so in writing. Refer to the GNU Emacs General Public
17 ;; License for full details.
19 ;; Everyone is granted permission to copy, modify and redistribute
20 ;; GNU Emacs, but only under the conditions described in the
21 ;; GNU Emacs General Public License. A copy of this license is
22 ;; supposed to have been given to you along with GNU Emacs so you
23 ;; can know your rights and responsibilities. It should be in a
24 ;; file named COPYING. Among other things, the copyright notice
25 ;; and this notice must be preserved on all copies.
27 ;;; Commentary:
29 ;;; Notes from Rob Austein on his mods
30 ;; yaya:/usr/u/sra/cl/cl.el, 5-May-1991 16:01:34, sra
31 ;;
32 ;; Slightly hacked copy of cl.el 2.0 beta 27.
33 ;;
34 ;; Various minor performance improvements:
35 ;; a) Don't use MAPCAR when we're going to discard its results.
36 ;; b) Make various macros a little more clever about optimizing
37 ;; generated code in common cases.
38 ;; c) Fix DEFSETF to expand to the right code at compile-time.
39 ;; d) Make various macros cleverer about generating reasonable
40 ;; code when compiled, particularly forms like DEFSTRUCT which
41 ;; are usually used at top-level and thus are only compiled if
42 ;; you use Hallvard Furuseth's hacked bytecomp.el.
43 ;;
44 ;; New features: GETF, REMF, and REMPROP.
45 ;;
46 ;; Notes:
47 ;; 1) I'm sceptical about the FBOUNDP checks in SETF. Why should
48 ;; the SETF expansion fail because the SETF method isn't defined
49 ;; at compile time? Lisp is going to check for a binding at run-time
50 ;; anyway, so maybe we should just assume the user's right here.
52 ;;;; These are extensions to Emacs Lisp that provide some form of
53 ;;;; Common Lisp compatibility, beyond what is already built-in
54 ;;;; in Emacs Lisp.
55 ;;;;
56 ;;;; When developing them, I had the code spread among several files.
57 ;;;; This file 'cl.el' is a concatenation of those original files,
58 ;;;; minus some declarations that became redundant. The marks between
59 ;;;; the original files can be found easily, as they are lines that
60 ;;;; begin with four semicolons (as this does). The names of the
61 ;;;; original parts follow the four semicolons in uppercase, those
62 ;;;; names are GLOBAL, SYMBOLS, LISTS, SEQUENCES, CONDITIONALS,
63 ;;;; ITERATIONS, MULTIPLE VALUES, ARITH, SETF and DEFSTRUCT. If you
64 ;;;; add functions to this file, you might want to put them in a place
65 ;;;; that is compatible with the division above (or invent your own
66 ;;;; categories).
67 ;;;;
68 ;;;; To compile this file, make sure you load it first. This is
69 ;;;; because many things are implemented as macros and now that all
70 ;;;; the files are concatenated together one cannot ensure that
71 ;;;; declaration always precedes use.
72 ;;;;
73 ;;;; Bug reports, suggestions and comments,
74 ;;;; to quiroz@cs.rochester.edu
76 \f
77 ;;;; GLOBAL
78 ;;;; This file provides utilities and declarations that are global
79 ;;;; to Common Lisp and so might be used by more than one of the
80 ;;;; other libraries. Especially, I intend to keep here some
81 ;;;; utilities that help parsing/destructuring some difficult calls.
82 ;;;;
83 ;;;;
84 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
85 ;;;; (quiroz@cs.rochester.edu)
87 ;;; Too many pieces of the rest of this package use psetq. So it is unwise to
88 ;;; use here anything but plain Emacs Lisp! There is a neater recursive form
89 ;;; for the algorithm that deals with the bodies.
91 ;;; Code:
93 ;;; This version is due to Hallvard Furuseth (hallvard@ifi.uio.no, 6 Jul 91)
95 "(psetq {VARIABLE VALUE}...): In parallel, set each VARIABLE to its VALUE.
96 All the VALUEs are evaluated, and then all the VARIABLEs are set.
97 Aside from order of evaluation, this is the same as `setq'."
98 ;; check there is a reasonable number of forms
110 \f
111 ;;; utilities
112 ;;;
113 ;;; pair-with-newsyms takes a list and returns a list of lists of the
114 ;;; form (newsym form), such that a let* can then bind the evaluation
115 ;;; of the forms to the newsyms. The idea is to guarantee correct
116 ;;; order of evaluation of the subforms of a setf. It also returns a
117 ;;; list of the newsyms generated, in the corresponding order.
120 "PAIR-WITH-NEWSYMS OLDFORMS
121 The top-level components of the list oldforms are paired with fresh
122 symbols, the pairings list and the newsyms list are returned."
132 "Merge two lists EVENS and ODDS, taking elts from each list alternatingly.
133 EVENS and ODDS are two lists. ZIP-LISTS constructs a new list, whose
134 even numbered elements (0,2,...) come from EVENS and whose odd
135 numbered elements (1,3,...) come from ODDS.
136 The construction stops when the shorter list is exhausted."
148 "Extract even and odd elements of LIST into two separate lists.
149 The argument LIST is separated in two strands, the even and the odd
150 numbered elements. Numbering starts with 0, so the first element
151 belongs in EVENS. No check is made that there is an even number of
152 elements to start with."
162 \f
164 "(reassemble-argslists ARGSLISTS) => a list of lists
165 ARGSLISTS is a list of sequences. Return a list of lists, the first
166 sublist being all the entries coming from ELT 0 of the original
167 sublists, the next those coming from ELT 1 and so on, until the
168 shortest list is exhausted."
172 ;; capture all the elements at index i
175 argslists)
176 result)))))
178 \f
179 ;;; Checking that a list of symbols contains no duplicates is a common
180 ;;; task when checking the legality of some macros. The check for 'eq
181 ;;; pairs can be too expensive, as it is quadratic on the length of
182 ;;; the list. I use a 4-pass, linear, counting approach. It surely
183 ;;; loses on small lists (less than 5 elements?), but should win for
184 ;;; larger lists. The fourth pass could be eliminated.
185 ;;; 10 dec 1986. Emacs Lisp has no REMPROP, so I just eliminated the
186 ;;; 4th pass.
187 ;;;
188 ;;; [22 April 1991, sra] REMPROP now in library, so restored 4th pass.
190 "Find all symbols appearing more than once in LIST.
191 Return a list of all such duplicates; `nil' if there are no duplicates."
194 )
195 ;; check validity
199 ;; pass 1: mark
202 ;; pass 2: count
205 ;; pass 3: collect
209 ;; pass 4: unmark.
212 ;; return result
213 duplicates))
215 ;;;; end of cl-global.el
216 \f
217 ;;;; SYMBOLS
218 ;;;; This file provides the gentemp function, which generates fresh
219 ;;;; symbols, plus some other minor Common Lisp symbol tools.
220 ;;;;
221 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
222 ;;;; (quiroz@cs.rochester.edu)
224 ;;; Keywords. There are no packages in Emacs Lisp, so this is only a
225 ;;; kludge around to let things be "as if" a keyword package was around.
228 "Make symbol X a keyword (symbol whose value is itself).
229 Optional second argument is a documentation string for it."
236 "t if SYM is a keyword."
238 ;; looks like one, make sure value is right
240 nil))
243 "Return a keyword that is naturally associated with symbol SYM.
244 If SYM is keyword, the value is SYM.
245 Otherwise it is a keyword whose name is `:' followed by SYM's name."
247 sym)
253 \f
254 ;;; Temporary symbols.
255 ;;;
264 "Generate a fresh interned symbol.
265 There are 2 optional arguments, PREFIX and OBLIST. PREFIX is the
266 string that begins the new name, OBLIST is the obarray used to search for
267 old names. The defaults are just right, YOU SHOULD NEVER NEED THESE
268 ARGUMENTS IN YOUR OWN CODE."
280 newsymbol))
281 \f
289 "Generate a fresh uninterned symbol.
290 There is an optional argument, PREFIX. PREFIX is the
291 string that begins the new name. Most people take just the default,
292 except when debugging needs suggest otherwise."
302 newsymbol))
304 ;;;; end of cl-symbols.el
305 \f
306 ;;;; CONDITIONALS
307 ;;;; This file provides some of the conditional constructs of
308 ;;;; Common Lisp. Total compatibility is again impossible, as the
309 ;;;; 'if' form is different in both languages, so only a good
310 ;;;; approximation is desired.
311 ;;;;
312 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
313 ;;;; (quiroz@cs.rochester.edu)
315 ;;; indentation info
321 ;;; WHEN and UNLESS
322 ;;; These two forms are simplified ifs, with a single branch.
325 "(when CONDITION . BODY) => evaluate BODY if CONDITION is true."
329 "(unless CONDITION . BODY) => evaluate BODY if CONDITION is false."
331 \f
332 ;;; CASE and ECASE
333 ;;; CASE selects among several clauses, based on the value (evaluated)
334 ;;; of a expression and a list of (unevaluated) key values. ECASE is
335 ;;; the same, but signals an error if no clause is activated.
338 "(case EXPR . CASES) => evals EXPR, chooses from CASES on that value.
339 EXPR -> any form
340 CASES -> list of clauses, non empty
341 CLAUSE -> HEAD . BODY
342 HEAD -> t = catch all, must be last clause
343 -> otherwise = same as t
344 -> nil = illegal
345 -> atom = activated if (eql EXPR HEAD)
346 -> list of atoms = activated if (memq EXPR HEAD)
347 BODY -> list of forms, implicit PROGN is built around it.
348 EXPR is evaluated only once."
351 ;; convert case into a cond inside a let
357 "(ecase EXPR . CASES) => like `case', but error if no case fits.
358 `t'-clauses are not allowed."
361 ;; check that no 't clause is present.
362 ;; case-clausify would put one such at the beginning of clauses
365 ;; insert error-catching clause
369 "ecase on %s = %s failed to take any branch"
372 clauses))
373 ;; generate code as usual
378 \f
380 "CASE-CLAUSIFY CASES NEWSYM => clauses for a 'cond'
381 Converts the CASES of a [e]case macro into cond clauses to be
382 evaluated inside a let that binds NEWSYM. Returns the clauses in
383 reverse order."
391 ;; construct a cond-clause according to the head
397 ;; check it is the last clause
400 ;; accept this clause as a 't' for cond
405 result)))
409 result)))
411 ;; catch-all for this parser
415 ;;;; end of cl-conditionals.el
416 \f
417 ;;;; ITERATIONS
418 ;;;; This file provides simple iterative macros (a la Common Lisp)
419 ;;;; constructed on the basis of let, let* and while, which are the
420 ;;;; primitive binding/iteration constructs of Emacs Lisp
421 ;;;;
422 ;;;; The Common Lisp iterations use to have a block named nil
423 ;;;; wrapped around them, and allow declarations at the beginning
424 ;;;; of their bodies and you can return a value using (return ...).
425 ;;;; Nothing of the sort exists in Emacs Lisp, so I haven't tried
426 ;;;; to imitate these behaviors.
427 ;;;;
428 ;;;; Other than the above, the semantics of Common Lisp are
429 ;;;; correctly reproduced to the extent this was reasonable.
430 ;;;;
431 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
432 ;;;; (quiroz@cs.rochester.edu)
434 ;;; some lisp-indentation information
442 \f
444 "(do STEPFORMS ENDFORMS . BODY): Iterate BODY, stepping some local variables.
445 STEPFORMS must be a list of symbols or lists. In the second case, the
446 lists must start with a symbol and contain up to two more forms. In
447 the STEPFORMS, a symbol is the same as a (symbol). The other 2 forms
448 are the initial value (def. NIL) and the form to step (def. itself).
449 The values used by initialization and stepping are computed in parallel.
450 The ENDFORMS are a list (CONDITION . ENDBODY). If the CONDITION
451 evaluates to true in any iteration, ENDBODY is evaluated and the last
452 form in it is returned.
453 The BODY (which may be empty) is evaluated at every iteration, with
454 the symbols of the STEPFORMS bound to the initial or stepped values."
455 ;; check the syntax of the macro
458 ;; construct emacs-lisp equivalent
468 \f
470 "`do*' is to `do' as `let*' is to `let'.
471 STEPFORMS must be a list of symbols or lists. In the second case, the
472 lists must start with a symbol and contain up to two more forms. In
473 the STEPFORMS, a symbol is the same as a (symbol). The other 2 forms
474 are the initial value (def. NIL) and the form to step (def. itself).
475 Initializations and steppings are done in the sequence they are written.
476 The ENDFORMS are a list (CONDITION . ENDBODY). If the CONDITION
477 evaluates to true in any iteration, ENDBODY is evaluated and the last
478 form in it is returned.
479 The BODY (which may be empty) is evaluated at every iteration, with
480 the symbols of the STEPFORMS bound to the initial or stepped values."
481 ;; check the syntax of the macro
484 ;; construct emacs-lisp equivalent
494 \f
495 ;;; DO and DO* share the syntax checking functions that follow.
498 "True if FORMS is a valid stepforms for the do[*] macro (q.v.)"
510 "symbol or (symbol [init [step]])"
512 forms)))
515 "True if FORMS is a valid endforms for the do[*] macro (q.v.)"
521 "Returns a list of the initializations (for do) in FORMS
522 --a stepforms, see the do macro--. FORMS is assumed syntactically valid."
530 forms))
532 ;;; There used to be a reason to deal with DO differently than with
533 ;;; DO*. The writing of PSETQ has made it largely unnecessary.
536 "EXTRACT-DO-STEPS FORMS => an s-expr
537 FORMS is the stepforms part of a DO macro (q.v.). This function
538 constructs an s-expression that does the stepping at the end of an
539 iteration."
543 "EXTRACT-DO*-STEPS FORMS => an s-expr
544 FORMS is the stepforms part of a DO* macro (q.v.). This function
545 constructs an s-expression that does the stepping at the end of an
546 iteration."
550 "Separate only the forms that cause stepping."
553 entry ;to explore each form in turn
554 )
560 result))))
563 \f
564 ;;; Other iterative constructs
567 "(dolist (VAR LIST [RESULTFORM]) . BODY): do BODY for each elt of LIST.
568 The RESULTFORM defaults to nil. The VAR is bound to successive
569 elements of the value of LIST and remains bound (to the nil value) when the
570 RESULTFORM is evaluated."
571 ;; check sanity
582 ;; generate code
594 body))
600 "(dotimes (VAR COUNTFORM [RESULTFORM]) . BODY): Repeat BODY, counting in VAR.
601 The COUNTFORM should return a positive integer. The VAR is bound to
602 successive integers from 0 to COUNTFORM-1 and the BODY is repeated for
603 each of them. At the end, the RESULTFORM is evaluated and its value
604 returned. During this last evaluation, the VAR is still bound, and its
605 value is the number of times the iteration occurred. An omitted RESULTFORM
606 defaults to nil."
607 ;; check sanity
618 ;; generate code
630 body))
632 \f
634 "(do_symbols (VAR [OBARRAY [RESULTFORM]]) . BODY)
635 The VAR is bound to each of the symbols in OBARRAY (def. obarray) and
636 the BODY is repeatedly performed for each of those bindings. At the
637 end, RESULTFORM (def. nil) is evaluated and its value returned.
638 During this last evaluation, the VAR is still bound and its value is nil.
639 See also the function `mapatoms'."
640 ;; check sanity
651 ;; generate code
659 oblist)
662 resultform))))
666 "(do-all-symbols (VAR [RESULTFORM]) . BODY)
667 Is the same as (do-symbols (VAR obarray RESULTFORM) . BODY)."
669 'do-symbols
671 body))
672 \f
674 "(loop . BODY) repeats BODY indefinitely and does not return.
675 Normally BODY uses `throw' or `signal' to cause an exit.
676 The forms in BODY should be lists, as non-lists are reserved for new features."
677 ;; check that the body doesn't have atomic forms
680 ;; ok, it is a list, check for atomic components
685 body)
686 ;; build the infinite loop
689 ;;;; end of cl-iterations.el
690 \f
691 ;;;; LISTS
692 ;;;; This file provides some of the lists machinery of Common-Lisp
693 ;;;; in a way compatible with Emacs Lisp. Especially, see the the
694 ;;;; typical c[ad]*r functions.
695 ;;;;
696 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
697 ;;;; (quiroz@cs.rochester.edu)
699 ;;; Synonyms for list functions
701 "Synonym for `car'"
705 "Return the second element of the list LIST."
709 "Return the third element of the list LIST."
713 "Return the fourth element of the list LIST."
717 "Return the fifth element of the list LIST."
721 "Return the sixth element of the list LIST."
725 "Return the seventh element of the list LIST."
729 "Return the eighth element of the list LIST."
733 "Return the ninth element of the list LIST."
737 "Return the tenth element of the list LIST."
741 "Synonym for `cdr'"
743 \f
745 "t if X is nil, nil if X is a cons; error otherwise."
752 "Returns the last link in the list LIST."
760 "Returns the length of a non-circular list, or `nil' for a circular one."
776 \f
778 "Return a new list like LIST but sans the last N elements.
779 N defaults to 1. If the list doesn't have N elements, nil is returned."
783 ;;; This version due to Aaron Larson (alarson@src.honeywell.com, 26 Jul 91)
785 "Return a new list containing the first arguments consed onto the last arg.
786 Thus, (list* 1 2 3 '(a b)) returns (1 2 3 a b)."
788 arg
794 others)))
797 "Return a list which contains ITEM but is otherwise like LIST.
798 If ITEM occurs in LIST, the value is LIST. Otherwise it is (cons ITEM LIST).
799 When comparing ITEM against elements, `eql' is used."
801 list
805 "Return a new list like LIST but sans SUBLIST.
806 SUBLIST must be one of the links in LIST; otherwise the value is LIST itself."
812 \f
813 ;;; The popular c[ad]*r functions and other list accessors.
815 ;;; To implement this efficiently, a new byte compile handler is used to
816 ;;; generate the minimal code, saving one function call.
819 "Return the car of the car of X."
823 "Return the car of the cdr of X."
827 "Return the cdr of the car of X."
831 "Return the cdr of the cdr of X."
835 "Return the car of the car of the car of X."
839 "Return the car of the car of the cdr of X."
843 "Return the car of the cdr of the car of X."
847 "Return the cdr of the car of the car of X."
851 "Return the car of the cdr of the cdr of X."
855 "Return the cdr of the car of the cdr of X."
859 "Return the cdr of the cdr of the car of X."
863 "Return the cdr of the cdr of the cdr of X."
867 "Return the car of the car of the car of the car of X."
871 "Return the car of the car of the car of the cdr of X."
875 "Return the car of the car of the cdr of the car of X."
879 "Return the car of the cdr of the car of the car of X."
883 "Return the cdr of the car of the car of the car of X."
887 "Return the car of the car of the cdr of the cdr of X."
891 "Return the car of the cdr of the car of the cdr of X."
895 "Return the cdr of the car of the car of the cdr of X."
899 "Return the car of the cdr of the cdr of the car of X."
903 "Return the cdr of the car of the cdr of the car of X."
907 "Return the cdr of the cdr of the car of the car of X."
911 "Return the car of the cdr of the cdr of the cdr of X."
915 "Return the cdr of the cdr of the car of the cdr of X."
919 "Return the cdr of the car of the cdr of the cdr of X."
923 "Return the cdr of the cdr of the cdr of the car of X."
927 "Return the cdr of the cdr of the cdr of the cdr of X."
929 \f
930 ;;; some inverses of the accessors are needed for setf purposes
933 "Set (nth N LIST) to NEWVAL. Returns NEWVAL."
937 "(setnthcdr N LIST NEWVAL) => NEWVAL
938 As a side effect, sets the Nth cdr of LIST to NEWVAL."
944 ;; here only if (zerop n)
947 newval)
948 \f
949 ;;; A-lists machinery
952 "Return a new alist with KEY paired with ITEM; otherwise like ALIST.
953 Does not copy ALIST."
957 "Return a new alist with each elt of KEYS paired with an elt of DATA;
958 optional 3rd arg ALIST is nconc'd at the end. KEYS and DATA must
959 have the same length."
971 ;;;; end of cl-lists.el
972 \f
973 ;;;; SEQUENCES
974 ;;;; Emacs Lisp provides many of the 'sequences' functionality of
975 ;;;; Common Lisp. This file provides a few things that were left out.
976 ;;;;
992 \f
994 "Test PREDICATE on each element of SEQUENCE; is it ever non-nil?
995 Extra args are additional sequences; PREDICATE gets one arg from each
996 sequence and we advance down all the sequences together in lock-step.
997 A sequence means either a list or a vector."
1013 "Test PREDICATE on each element of SEQUENCE; is it always non-nil?
1014 Extra args are additional sequences; PREDICATE gets one arg from each
1015 sequence and we advance down all the sequences together in lock-step.
1016 A sequence means either a list or a vector."
1030 \f
1032 "Test PREDICATE on each element of SEQUENCE; is it always nil?
1033 Extra args are additional sequences; PREDICATE gets one arg from each
1034 sequence and we advance down all the sequences together in lock-step.
1035 A sequence means either a list or a vector."
1051 "Test PREDICATE on each element of SEQUENCE; is it sometimes nil?
1052 Extra args are additional sequences; PREDICATE gets one arg from each
1053 sequence and we advance down all the sequences together in lock-step.
1054 A sequence means either a list or a vector."
1068 \f
1069 ;;; More sequence functions that don't need keyword arguments
1072 "(concatenate TYPE &rest SEQUENCES) => a sequence
1073 The sequence returned is of type TYPE (must be 'list, 'string, or 'vector) and
1074 contains the concatenation of the elements of all the arguments, in the order
1075 given."
1089 "(map TYPE FUNCTION &rest SEQUENCES) => a sequence
1090 The FUNCTION is called on each set of elements from the SEQUENCES \(stopping
1091 when the shortest sequence is terminated\) and the results are possibly
1092 returned in a sequence of type TYPE \(one of 'list, 'vector, 'string, or nil\)
1093 giving NIL for TYPE gets rid of the values."
1098 results)
1104 argslists))
1107 results)
1112 \f
1113 ;;; an inverse of elt is needed for setf purposes
1116 "In SEQUENCE, set the Nth element to NEWVAL. Returns NEWVAL.
1117 A sequence means either a list or a vector."
1121 ;; only two cases need be considered valid, as strings are arrays
1129 \f
1130 ;;; Testing with keyword arguments.
1131 ;;;
1132 ;;; Many of the sequence functions use keywords to denote some stylized
1133 ;;; form of selecting entries in a sequence. The involved arguments
1134 ;;; are collected with a &rest marker (as Emacs Lisp doesn't have a &key
1135 ;;; marker), then they are passed to build-klist, who
1136 ;;; constructs an association list. That association list is used to
1137 ;;; test for satisfaction and matching.
1139 ;;; DON'T USE MEMBER, NOR ANY FUNCTION THAT COULD TAKE KEYWORDS HERE!!!
1142 "Decode a keyword argument list ARGSLIST for keywords in ACCEPTABLE.
1143 ARGSLIST is a list, presumably the &rest argument of a call, whose
1144 even numbered elements must be keywords.
1145 ACCEPTABLE is a list of keywords, the only ones that are truly acceptable.
1146 The result is an alist containing the arguments named by the keywords
1147 in ACCEPTABLE, or an error is signalled, if something failed.
1148 If the third argument (an optional) is non-nil, other keys are acceptable."
1149 ;; check legality of the arguments, then destructure them
1165 keywords))
1169 nil
1171 keywords))
1181 ;; if THIS appears in auxlist, use its value
1187 "(extract-from-klist KLIST KEY [DEFAULT]) => value of KEY or DEFAULT
1188 Extract value associated with KEY in KLIST (return DEFAULT if nil)."
1193 "(keyword-argument-supplied-p KLIST KEY) => nil or something
1194 NIL if KEY (a keyword) does not appear in the KLIST."
1198 "(ADD-TO-KLIST KEY ITEM KLIST) => new KLIST
1199 Add association (KEY . ITEM) to KLIST."
1203 "(elt-satisfies-test-p ITEM ELT KLIST) => t or nil
1204 KLIST encodes a keyword-arguments test, as in CH. 14 of CLtL.
1205 True if the given ITEM and ELT satisfy the test."
1218 "(elt-satisfies-if-p ITEM KLIST) => t or nil
1219 True if an -if style function was called and ITEM satisfies the
1220 predicate under :predicate in KLIST."
1226 "(elt-satisfies-if-not-p ITEM KLIST) => t or nil
1227 KLIST encodes a keyword-arguments test, as in CH. 14 of CLtL.
1228 True if an -if-not style function was called and ITEM does not satisfy
1229 the predicate under :predicate in KLIST."
1235 "(elts-match-under-klist-p E1 E2 KLIST) => t or nil
1236 KLIST encodes a keyword-arguments test, as in CH. 14 of CLtL.
1237 True if elements E1 and E2 match under the tests encoded in KLIST."
1251 \f
1252 ;;; This macro simplifies using keyword args. It is less clumsy than using
1253 ;;; the primitives build-klist, etc... For instance, member could be written
1254 ;;; this way:
1256 ;;; (defun member (item list &rest kargs)
1257 ;;; (with-keyword-args kargs (test test-not (key 'identity))
1258 ;;; ...))
1260 ;;; Suggested by Robert Potter (potter@cs.rochester.edu, 15 Nov 1989)
1263 "(WITH-KEYWORD-ARGS KEYARGSLIST VARDEFS . BODY)
1264 KEYARGSLIST can be either a symbol or a list of one or two symbols.
1265 In the second case, the second symbol is either T or NIL, indicating whether
1266 keywords other than the mentioned ones are tolerable.
1268 VARDEFS is a list. Each entry is either a VAR (symbol) or matches
1269 \(VAR [DEFAULT [KEYWORD]]). Just giving VAR is the same as giving
1270 \(VAR nil :VAR).
1272 The BODY is executed in an environment where each VAR (a symbol) is bound to
1273 the value present in the KEYARGSLIST provided, or to the DEFAULT. The value
1274 is searched by using the keyword form of VAR (i.e., :VAR) or the optional
1275 keyword if provided.
1277 Notice that this macro doesn't distinguish between a default value given
1278 explicitly by the user and one provided by default. See also the more
1279 primitive functions build-klist, add-to-klist, extract-from-klist,
1280 keyword-argument-supplied-p, elt-satisfies-test-p, elt-satisfies-if-p,
1281 elt-satisfies-if-not-p, elts-match-under-klist-p. They provide more complete,
1282 if clumsier, control over this feature."
1287 "`%s' should be SYMBOL, (SYMBOL), or (SYMBOL t-OR-nil)"
1295 "first subform should be SYMBOL, (SYMBOL), or (SYMBOL t-OR-nil)"
1296 )))
1312 "`%s' must match (VAR [DEFAULT [KEYWORD]])"
1316 "bad variable `%s': must be non-null symbol"
1329 klistname
1330 k
1331 d))
1332 forms)))))
1333 vardefs)
1338 allow-other-keys)))
1340 body))))
1343 \f
1344 ;;; REDUCE
1345 ;;; It is here mostly as an example of how to use KLISTs.
1346 ;;;
1347 ;;; First of all, you need to declare the keywords (done elsewhere in this
1348 ;;; file):
1349 ;;; (defkeyword :from-end "syntax of sequence functions")
1350 ;;; (defkeyword :start "syntax of sequence functions")
1351 ;;; etc...
1352 ;;;
1353 ;;; Then, you capture all the possible keyword arguments with a &rest
1354 ;;; argument. You can pass that list downward again, of course, but
1355 ;;; internally you need to parse it into a KLIST (an alist, really). One uses
1356 ;;; (build-klist REST-ARGS ACCEPTABLE-KEYWORDS [ALLOW-OTHER]). You can then
1357 ;;; test for presence by using (keyword-argument-supplied-p KLIST KEY) and
1358 ;;; extract a value with (extract-from-klist KLIST KEY [DEFAULT]).
1361 "Apply FUNCTION (a function of two arguments) to succesive pairs of elements
1362 from SEQUENCE. Some keyword arguments are valid after FUNCTION and SEQUENCE:
1363 :from-end If non-nil, process the values backwards
1364 :initial-value If given, prefix it to the SEQUENCE. Suffix, if :from-end
1365 :start Restrict reduction to the subsequence from this index
1366 :end Restrict reduction to the subsequence BEFORE this index.
1367 If the sequence is empty and no :initial-value is given, the FUNCTION is
1368 called on zero (not two) arguments. Otherwise, if there is exactly one
1369 element in the combination of SEQUENCE and the initial value, that element is
1370 returned."
1383 sequence)))
1393 result))))
1396 "(cl$subseq-as-list SEQUENCE START END) => a list"
1399 result)
1405 list
1413 ;;;; end of cl-sequences.el
1414 \f
1415 ;;;; Some functions with keyword arguments
1416 ;;;;
1417 ;;;; Both list and sequence functions are considered here together. This
1418 ;;;; doesn't fit any more with the original split of functions in files.
1421 "Look for ITEM in LIST; return first tail of LIST the car of whose first
1422 cons cell tests the same as ITEM. Admits arguments :key, :test, and
1423 :test-not."
1430 ;; another workaround allegedly for speed, BLAH
1438 ))
1444 ;; final hack: remove the indirection through the function names
1452 ;; ok, go for it
1467 result)))))
1468 \f
1469 ;;;; MULTIPLE VALUES
1470 ;;;; This package approximates the behavior of the multiple-values
1471 ;;;; forms of Common Lisp.
1472 ;;;;
1473 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
1474 ;;;; (quiroz@cs.rochester.edu)
1476 ;;; Lisp indentation information
1483 ;;; Global state of the package is kept here
1488 \f
1489 ;;; values is the standard multiple-value-return form. Must be the
1490 ;;; last thing evaluated inside a function. If the caller is not
1491 ;;; expecting multiple values, only the first one is passed. (values)
1492 ;;; is the same as no-values returned (unaware callers see nil). The
1493 ;;; alternative (values-list <list>) is just a convenient shorthand
1494 ;;; and complements multiple-value-list.
1497 "Produce multiple values (zero or more). Each arg is one value.
1498 See also `multiple-value-bind', which is one way to examine the
1499 multiple values produced by a form. If the containing form or caller
1500 does not check specially to see multiple values, it will see only
1501 the first value."
1507 "Produce multiple values (zero or more). Each element of LIST is one value.
1508 This is equivalent to (apply 'values LIST)."
1515 \f
1516 ;;; Callers that want to see the multiple values use these macros.
1519 "Execute FORM and return a list of all the (multiple) values FORM produces.
1520 See `values' and `multiple-value-bind'."
1534 "Call FUNCTION on all the values produced by the remaining arguments.
1535 (multiple-value-call '+ (values 1 2) (values 3 4)) is 10."
1543 result
1548 "Bind VARS to the (multiple) values produced by FORM, then do BODY.
1549 VARS is a list of variables; each is bound to one of FORM's values.
1550 If FORM doesn't make enough values, the extra variables are bound to nil.
1551 (Ordinary forms produce only one value; to produce more, use `values'.)
1552 Extra values are ignored.
1553 BODY (zero or more forms) is executed with the variables bound,
1554 then the bindings are unwound."
1560 clauses)
1561 body)))
1562 \f
1564 "Set VARS to the (multiple) values produced by FORM.
1565 VARS is a list of variables; each is set to one of FORM's values.
1566 If FORM doesn't make enough values, the extra variables are set to nil.
1567 (Ordinary forms produce only one value; to produce more, use `values'.)
1568 Extra values are ignored."
1577 "Evaluate FORM, then BODY, then produce the same values FORM produced.
1578 Thus, (multiple-value-prog1 (values 1 2) (foobar)) produces values 1 and 2.
1579 This is like `prog1' except that `prog1' would produce only one value,
1580 which would be the first of FORM's values."
1586 ;;; utility functions
1587 ;;;
1588 ;;; mv-bind-clausify makes the pairs needed to have the variables in
1589 ;;; the variable list correspond with the values returned by the form.
1590 ;;; vals is a fresh symbol that intervenes in all the bindings.
1593 "MV-BIND-CLAUSIFY VARS VALS => Auxiliary list
1594 Forms a list of pairs `(,(nth i vars) (nth i vals)) for i from 0 to
1595 the length of VARS (a list of symbols). VALS is just a fresh symbol."
1606 ;;;; end of cl-multiple-values.el
1607 \f
1608 ;;;; ARITH
1609 ;;;; This file provides integer arithmetic extensions. Although
1610 ;;;; Emacs Lisp doesn't really support anything but integers, that
1611 ;;;; has still to be made to look more or less standard.
1612 ;;;;
1613 ;;;;
1614 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
1615 ;;;; (quiroz@cs.rochester.edu)
1619 "True if NUMBER is strictly greater than zero."
1623 "True if NUMBER is strictly less than zero."
1627 "True if INTEGER is not divisible by 2."
1631 "True if INTEGER is divisible by 2."
1635 "Return the absolute value of NUMBER."
1638 number))
1641 "Return -1, 0 or 1 according to the sign of NUMBER."
1648 \f
1650 "Return the greatest common divisor of all the arguments.
1651 The arguments must be integers. With no arguments, value is zero."
1662 ;; essentially the euclidean algorithm
1669 ;; intermediate results
1672 ;; final results
1682 "Return the least common multiple of all the arguments.
1683 The arguments must be integers and there must be at least one of them."
1687 prod ; intermediate product
1701 \f
1703 "Return the integer square root of NUMBER.
1704 NUMBER must not be negative. Result is largest integer less than or
1705 equal to the real square root of the argument."
1706 ;; The method used here is essentially the Newtonian iteration
1707 ;; x[n+1] <- (x[n] + Number/x[n]) / 2
1708 ;; suitably adapted to integer arithmetic.
1709 ;; Thanks to Philippe Schnoebelen <phs@lifia.imag.fr> for suggesting the
1710 ;; termination condition.
1713 number))
1722 approx))
1725 approx new)))))
1726 \f
1728 "Divide DIVIDEND by DIVISOR, rounding toward minus infinity.
1729 DIVISOR defaults to 1. The remainder is produced as a second value."
1748 "Divide DIVIDEND by DIVISOR, rounding toward plus infinity.
1749 DIVISOR defaults to 1. The remainder is produced as a second value."
1763 \f
1765 "Divide DIVIDEND by DIVISOR, rounding toward zero.
1766 DIVISOR defaults to 1. The remainder is produced as a second value."
1782 "Divide DIVIDEND by DIVISOR, rounding to nearest integer.
1783 DIVISOR defaults to 1. The remainder is produced as a second value."
1792 ;; adjust magnitudes first, and then signs
1798 ;; round to even is mandatory
1803 \f
1804 ;;; These two functions access the implementation-dependent representation of
1805 ;;; the multiple value returns.
1808 "Return remainder of X by Y (rounding quotient toward minus infinity).
1809 That is, the remainder goes with the quotient produced by `floor'.
1810 Emacs Lisp hint:
1811 If you know that both arguments are positive, use `%' instead for speed."
1816 "Return remainder of X by Y (rounding quotient toward zero).
1817 That is, the remainder goes with the quotient produced by `truncate'.
1818 Emacs Lisp hint:
1819 If you know that both arguments are positive, use `%' instead for speed."
1822 \f
1823 ;;; internal utilities
1824 ;;;
1825 ;;; safe-idiv performs an integer division with positive numbers only.
1826 ;;; It is known that some machines/compilers implement weird remainder
1827 ;;; computations when working with negatives, so the idea here is to
1828 ;;; make sure we know what is coming back to the caller in all cases.
1830 ;;; Signum computation fixed by mad@math.keio.JUNET (MAEDA Atusi)
1833 "SAFE-IDIV A B => Q R S
1834 Q=|A|/|B|, S is the sign of A/B, R is the rest A - S*Q*B."
1835 ;; (unless (and (numberp a) (numberp b))
1836 ;; (error "arguments to `safe-idiv' must be numbers"))
1837 ;; (when (zerop b)
1838 ;; (error "cannot divide %d by zero" a))
1844 ;;;; end of cl-arith.el
1845 \f
1846 ;;;; SETF
1847 ;;;; This file provides the setf macro and friends. The purpose has
1848 ;;;; been modest, only the simplest defsetf forms are accepted.
1849 ;;;; Use it and enjoy.
1850 ;;;;
1851 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
1852 ;;;; (quiroz@cs.rochester.edu)
1856 "Property, its value is the function setf must invoke to update a
1857 generalized variable whose access form is a function call of the
1861 "Property of symbols that have a `defsetf' update function on them,
1863 \f
1865 "Generalized `setq' that can set things other than variable values.
1866 A use of `setf' looks like (setf {PLACE VALUE}...).
1867 The behavior of (setf PLACE VALUE) is to access the generalized variable
1868 at PLACE and store VALUE there. It returns VALUE. If there is more
1869 than one PLACE and VALUE, each PLACE is set from its VALUE before
1870 the next PLACE is evaluated."
1872 ;; check the number of subforms
1876 nil)
1878 ;; this is the recursive case
1888 result)))))
1890 ;; this is the base case (SETF PLACE VALUE)
1895 ;; dispatch on the type of the PLACE
1902 ;; dispatch on the type of update function
1920 ;; this let gets new symbols to ensure adequate
1921 ;; order of evaluation of the subforms.
1923 bindings
1928 \f
1930 "Define how `setf' works on a certain kind of generalized variable.
1931 A use of `defsetf' looks like (defsetf ACCESSFN UPDATEFN [DOCSTRING]).
1932 ACCESSFN is a symbol. UPDATEFN is a function or macro which takes
1933 one more argument than ACCESSFN does. DEFSETF defines the translation
1934 of (SETF (ACCESFN . ARGS) NEWVAL) to be a form like (UPDATEFN ARGS... NEWVAL).
1935 The function UPDATEFN must return its last arg, after performing the
1936 updating called for."
1937 ;; reject ill-formed requests. too bad one can't test for functionp
1938 ;; or macrop.
1942 ;; update properties
1948 ;; any better thing to return?
1950 \f
1951 ;;; This section provides the "default" setfs for Common-Emacs-Lisp
1952 ;;; The user will not normally add anything to this, although
1953 ;;; defstruct will introduce new ones as a matter of fact.
1954 ;;;
1955 ;;; Apply is a special case. The Common Lisp
1956 ;;; standard makes the case of apply be useful when the user writes
1957 ;;; something like (apply #'name ...), Emacs Lisp doesn't have the #
1958 ;;; stuff, but it has (function ...). Notice that V18 includes a new
1959 ;;; apply: this file is compatible with V18 and pre-V18 Emacses.
1961 ;;; INCOMPATIBILITY: the SETF macro evaluates its arguments in the
1962 ;;; (correct) left to right sequence *before* checking for apply
1963 ;;; methods (which should really be an special case inside setf). Due
1964 ;;; to this, the lambda expression defsetf'd to apply will succeed in
1965 ;;; applying the right function even if the name was not quoted, but
1966 ;;; computed! That extension is not Common Lisp (nor is particularly
1967 ;;; useful, I think).
1971 ;; dissasemble the calling form
1972 ;; "(((quote fn) x1 x2 ... xn) val)" (function instead of quote, too)
1985 \f
1987 aset
1991 setnth
1995 setnthcdr
1999 setelt
2029 \f
2077 \f
2121 \f
2176 ;; how about defsetfing other Emacs forms?
2177 \f
2178 ;;; Modify macros
2179 ;;;
2180 ;;; It could be nice to implement define-modify-macro, but I don't
2181 ;;; think it really pays.
2184 "(incf REF [DELTA]) -> increment the g.v. REF by DELTA (default 1)"
2190 "(decf REF [DELTA]) -> decrement the g.v. REF by DELTA (default 1)"
2196 "(push ITEM REF) -> cons ITEM at the head of the g.v. REF (a list)"
2200 "(pushnew ITEM REF): adjoin ITEM at the head of the g.v. REF (a list)"
2204 "(pop REF) -> (prog1 (car REF) (setf REF (cdr REF)))"
2210 \f
2211 ;;; PSETF
2212 ;;;
2213 ;;; Psetf is the generalized variable equivalent of psetq. The right
2214 ;;; hand sides are evaluated and assigned (via setf) to the left hand
2215 ;;; sides. The evaluations are done in an environment where they
2216 ;;; appear to occur in parallel.
2219 "(psetf {var value }...) => nil
2220 Like setf, but all the values are computed before any assignment is made."
2224 length))
2226 '())
2239 setfs))))))
2240 setfs))))))
2241 \f
2242 ;;; SHIFTF and ROTATEF
2243 ;;;
2246 "(shiftf PLACE1 PLACE2... NEWVALUE)
2247 Set PLACE1 to PLACE2, PLACE2 to PLACE3...
2248 Each PLACE is set to the old value of the following PLACE,
2249 and the last PLACE is set to the value NEWVALUE.
2250 Returns the old value of PLACE1."
2255 ;; the places are accessed to fresh symbols
2266 "(rotatef PLACE...) sets each PLACE to the old value of the following PLACE.
2267 The last PLACE is set to the old value of the first PLACE.
2268 Thus, the values rotate through the PLACEs. Returns nil."
2270 nil
2275 'let bindings
2279 nil))))
2280 \f
2281 ;;; GETF, REMF, and REMPROP
2282 ;;;
2285 "Return PLACE's PROPNAME property, or DEFAULT if not present."
2290 default))
2293 "SETF method for GETF. Not for public use."
2311 vsym)))
2314 getf$setf$method)
2317 "Remove from the property list at PLACE its PROPNAME property.
2318 Returns non-nil if and only if the property existed."
2324 t)
2331 isym)))
2338 t)))))))
2341 "Remove SYMBOL's PROPNAME property, returning non-nil if it was present."
2344 \f
2345 ;;;; STRUCTS
2346 ;;;; This file provides the structures mechanism. See the
2347 ;;;; documentation for Common-Lisp's defstruct. Mine doesn't
2348 ;;;; implement all the functionality of the standard, although some
2349 ;;;; more could be grafted if so desired. More details along with
2350 ;;;; the code.
2351 ;;;;
2352 ;;;;
2353 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
2354 ;;;; (quiroz@cs.rochester.edu)
2376 \f
2378 "(defstruct NAME [DOC-STRING] . SLOTS) define NAME as structure type.
2379 NAME must be a symbol, the name of the new structure. It could also
2380 be a list (NAME . OPTIONS).
2382 Each option is either a symbol, or a list of a keyword symbol taken from the
2383 list \{:conc-name, :copier, :constructor, :predicate, :include,
2384 :print-function, :type, :initial-offset\}. The meanings of these are as in
2385 CLtL, except that no BOA-constructors are provided, and the options
2386 \{:print-fuction, :type, :initial-offset\} are ignored quietly. All these
2387 structs are named, in the sense that their names can be used for type
2388 discrimination.
2390 The DOC-STRING is established as the `structure-doc' property of NAME.
2392 The SLOTS are one or more of the following:
2393 SYMBOL -- meaning the SYMBOL is the name of a SLOT of NAME
2394 list of SYMBOL and VALUE -- meaning that VALUE is the initial value of
2395 the slot.
2396 `defstruct' defines functions `make-NAME', `NAME-p', `copy-NAME' for the
2397 structure, and functions with the same name as the slots to access
2398 them. `setf' of the accessors sets their values."
2402 ;; Names for the member functions come from the options. The
2403 ;; slots* stuff collects info about the slots declared explicitly.
2406 moreslotsn moreslots moreinits included)
2408 ;; The moreslots* stuff refers to slots gained as a consequence
2409 ;; of (:include clauses). -- Oct 89: Only one :include tolerated
2424 ;; compute properties of NAME
2429 docstring)
2431 slotsn)
2438 ;; If this definition :includes another defstruct,
2439 ;; modify both property lists.
2444 :structure-includes
2461 old
2462 :structure-included-in
2465 ;; careful with destructive
2466 ;;manipulation!
2468 'append
2470 'get
2471 old
2473 '())
2474 )))))
2477 :structure-includes
2478 '()))))
2479 ;; If this definition used to be :included in another, warn
2480 ;; that things make break. On the other hand, the redefinition
2481 ;; may be trivial, so don't call it an error.
2490 "`%s' redefined. Should redefine `%s'?"
2494 ;; Compute functions associated with NAME. This is not
2495 ;; handling BOA constructors yet, but here would be the place.
2509 'function
2519 'and
2521 typetag
2527 'memq
2528 typetag
2532 )))))
2533 ;; compute accessors for NAME's slots
2537 ;; generate returned value -- not defined by the standard
2544 ;; generate code
2547 accessors alterators returned))))))
2548 \f
2550 "(parse$defstruct$args ARGS) => NAME OPTIONS DOCSTRING SLOTSN SLOTS INITLIST
2551 NAME=symbol, OPTIONS=list of, DOCSTRING=string, SLOTSN=count of slots,
2552 SLOTS=list of their names, INITLIST=alist (keyword . initform)."
2554 options ;args=((symbol . options) ...)
2556 slotargs ;second or third cdr of args
2560 ;; extract name and options
2563 options '()))
2571 ;; is there a docstring?
2575 ;; now for the slots
2580 \f
2582 "(process$slots SLOTS) => SLOTSN SLOTSLIST INITLIST
2583 Converts a list of symbols or lists of symbol and form into the last 3
2584 values returned by PARSE$DEFSTRUCT$ARGS."
2586 slotslist ;(slot1 slot2 ...)
2599 ;; this silently ignores any slot options. bad...
2606 \f
2608 "(parse$defstruct$options name OPTIONS SLOTS) => many values
2609 A defstruct named NAME, with options list OPTIONS, has already slots SLOTS.
2610 Parse the OPTIONS and return the updated form of the struct's slots and other
2611 information. The values returned are:
2613 CONC-NAME is the string to use as prefix/suffix in the methods,
2614 CONST is the name of the official constructor,
2615 COPIER is the name of the structure copier,
2616 PRED is the name of the type predicate,
2617 MORESLOTSN is the number of slots added by :include,
2618 MORESLOTS is the list of slots added by :include,
2619 MOREINITS is the list of initialization forms added by :include,
2620 INCLUDED is nil, or the list of the symbol added by :include"
2622 ;; to build the return values
2630 ;; auxiliaries
2631 option-head ;When an option is not a plain
2632 option-second ; keyword, it must be a list of
2633 option-rest ; the form (head second . rest)
2634 these-slotsn ;When :include is found, the
2635 these-slots ; info about the included
2636 these-inits ; structure is added here.
2637 included ;NIL or (list INCLUDED)
2638 )
2639 ;; Values above are the defaults. Now we read the options themselves
2641 ;; 2 cases arise, as options must be a keyword or a list
2645 (:named
2655 (:conc-name
2659 option-second)
2665 (:copier
2670 option-second)
2674 \f
2680 option-second)
2684 (:predicate
2689 option-second)
2693 (:include
2729 ;; Return values found
2731 moreslotsn moreslots moreinits
2732 included)))
2733 \f
2735 "(simplify$inits SLOTS INITLIST) => new INITLIST
2736 Removes from INITLIST - an ALIST - any shadowed bindings."
2738 key ;from the slot
2739 )
2746 "(extract$indices INITLIST) => indices list
2747 Kludge. From a list of pairs (keyword . form) build a list of pairs
2748 of the form (keyword . position in list from 0). Useful to precompute
2749 some of the work of MAKE$STRUCTURE$INSTANCE."
2755 \f
2757 "(build$accessors$for NAME PREDICATE SLOTS SLOTSN) => FSETS DEFSETFS KWDS
2758 Generate the code for accesors and defsetfs of a structure called
2759 NAME, whose slots are SLOTS. Also, establishes the keywords for the
2760 slots names."
2780 "`%s' is not a struct %s"
2785 name))))))))
2786 accessors))
2796 "`%s' not a `%s'"
2801 name)))))))
2802 alterators))
2805 keywords))))
2806 \f
2808 "(make$structure$instance NAME ARGS) => new struct NAME
2809 A struct of type NAME is created, some slots might be initialized
2810 according to ARGS (the &rest argument of MAKE-name)."
2817 initalist ;pairlis'd on initforms
2818 initializers ;definitive initializers
2819 )
2820 ;; check sanity of the request
2828 ;; analyze the initializers provided by the call
2832 ;; check that all the arguments are introduced by keywords
2836 ;; check that all the keywords are known
2841 ;; update initforms
2851 result)))
2853 ;; compute definitive initializers
2862 ;; do real initialization
2866 ;;;; end of cl-structs.el
2867 \f
2868 ;;; For lisp-interaction mode, so that multiple values can be seen when passed
2869 ;;; back. Lies every now and then...
2883 "Evaluate sexp before point; print value\(s\) into current buffer.
2884 If the evaled form returns multiple values, they are shown one to a line.
2885 The variables -, +, ++, +++, *, **, ***, /, //, /// have their usual meaning.
2887 It clears the multiple-value passing mechanism, and does not pass back
2888 multiple values. Use this only if you are debugging cl.el and understand well
2889 how the multiple-value stuff works, because it can be fooled into believing
2890 that multiple values have been returned when they actually haven't, for
2891 instance
2892 \(identity \(values nil 1\)\)
2893 However, even when this fails, you can trust the first printed value to be
2894 \(one of\) the returned value\(s\)."
2896 ;; top level call, can reset mvalues
2910 ** *
2913 // /
2916 ++ +
2928 /)))
2931 \f
2932 ;;;; More LISTS functions
2933 ;;;;
2935 ;;; Some mapping functions on lists, commonly useful.
2936 ;;; They take no extra sequences, to go along with Emacs Lisp's MAPCAR.
2939 "(MAPC FUNCTION LIST) => LIST
2940 Apply FUNCTION to each element of LIST, return LIST.
2941 Like mapcar, but called only for effect."
2946 list)
2949 "(MAPLIST FUNCTION LIST) => list'ed results of FUNCTION on cdrs of LIST
2950 Apply FUNCTION to successive sublists of LIST, return the list of the results"
2952 results '())
2959 "(MAPL FUNCTION LIST) => LIST
2960 Apply FUNCTION to successive cdrs of LIST, return LIST.
2961 Like maplist, but called only for effect."
2966 list))
2969 "(MAPCAN FUNCTION LIST) => nconc'd results of FUNCTION on LIST
2970 Apply FUNCTION to each element of LIST, nconc the results.
2971 Beware: nconc destroys its first argument! See copy-list."
2980 "(MAPCON FUNCTION LIST) => nconc'd results of FUNCTION on cdrs of LIST
2981 Apply FUNCTION to successive sublists of LIST, nconc the results.
2982 Beware: nconc destroys its first argument! See copy-list."
2990 ;;; Copiers
2993 "Build a copy of LIST"
2997 "Build a copy of the tree of conses TREE
2998 The argument is a tree of conses, it is recursively copied down to
2999 non conses. Circularity and sharing of substructure are not
3000 necessarily preserved."
3004 tree))
3006 ;;; reversals, and destructive manipulations of a list's spine
3009 "does what (append (reverse X) Y) would, only faster"
3011 y
3015 "does (nconc (nreverse X) Y) would, only faster
3016 Destructive on X, be careful."
3018 y
3019 ;; reuse the first cons of x, making it point to y
3023 "Side-effected LIST truncated N+1 conses from the end.
3024 This is the destructive version of BUTLAST. Returns () and does not
3025 modify the LIST argument if the length of the list is not at least N."
3029 list)
3031 '())
3034 list))))
3035 \f
3036 ;;; Substitutions
3039 "NEW replaces OLD in a copy of TREE
3040 Uses eql for the test."
3044 "NEW replaces any subtree or leaf that fails TEST in a copy of TREE"
3045 ;; (subst-if new (function (lambda (x) (not (funcall test x)))) tree)
3047 new)
3049 tree)
3053 ;; If nothing changed, return originals. Else use the new
3054 ;; components to assemble a new tree.
3057 tree
3061 "NEW replaces any subtree or leaf that satisfies TEST in a copy of TREE"
3063 new)
3065 tree)
3069 ;; If nothing changed, return originals. Else use the new
3070 ;; components to assemble a new tree.
3073 tree
3077 "Use association list ALIST to modify a copy of TREE
3078 If a subtree or leaf of TREE is a key in ALIST, it is replaced by the
3079 associated value. Not exactly Common Lisp, but close in spirit and
3080 compatible with the native Emacs Lisp ASSOC, which uses EQUAL."
3085 tree)
3091 tree
3095 "PREDICATE is applied to the members of LIST. As soon as one of them
3096 returns true, that tail of the list if returned. Else NIL."
3102 nil))
3105 "PREDICATE is applied to the members of LIST. As soon as one of them
3106 returns false, that tail of the list if returned. Else NIL."
3112 nil))
3115 "(tailp SUBLIST LIST) => True if SUBLIST is a sublist of LIST."
3121 nil))
3122 \f
3123 ;;; Suggestion of phr%widow.Berkeley.EDU@lilac.berkeley.edu
3126 "Ignore a Common-Lisp declaration."
3130 "Ignore a Common-Lisp proclamation."
3134 "(the TYPE FORM) macroexpands to FORM
3135 No checking is even attempted. This is just for compatibility with
3136 Common-Lisp codes."
3137 form)
3138 \f
3139 ;;; Due to Aaron Larson (alarson@src.honeywell.com, 26 Jul 91)
3142 "progv vars vals &body forms
3143 bind vars to vals then execute forms.
3144 If there are more vars than vals, the extra vars are unbound, if
3145 there are more vals than vars, the extra vals are just ignored."
3148 ;;; To do this efficiently, it really needs to be a special form...
3162 ;;;; end of cl.el