| blob | a4386f3c8bbc0c2eb4afe000a0feb589f62b64b3 |
1 ;; Common-Lisp extensions for GNU Emacs Lisp.
2 ;; Copyright (C) 1987, 1988, 1989 Free Software Foundation, Inc.
4 ;; This file is part of GNU Emacs.
6 ;; GNU Emacs is distributed in the hope that it will be useful,
7 ;; but WITHOUT ANY WARRANTY. No author or distributor
8 ;; accepts responsibility to anyone for the consequences of using it
9 ;; or for whether it serves any particular purpose or works at all,
10 ;; unless he says so in writing. Refer to the GNU Emacs General Public
11 ;; License for full details.
13 ;; Everyone is granted permission to copy, modify and redistribute
14 ;; GNU Emacs, but only under the conditions described in the
15 ;; GNU Emacs General Public License. A copy of this license is
16 ;; supposed to have been given to you along with GNU Emacs so you
17 ;; can know your rights and responsibilities. It should be in a
18 ;; file named COPYING. Among other things, the copyright notice
19 ;; and this notice must be preserved on all copies.
21 ;;;;
22 ;;;; These are extensions to Emacs Lisp that provide some form of
23 ;;;; Common Lisp compatibility, beyond what is already built-in
24 ;;;; in Emacs Lisp.
25 ;;;;
26 ;;;; When developing them, I had the code spread among several files.
27 ;;;; This file 'cl.el' is a concatenation of those original files,
28 ;;;; minus some declarations that became redundant. The marks between
29 ;;;; the original files can be found easily, as they are lines that
30 ;;;; begin with four semicolons (as this does). The names of the
31 ;;;; original parts follow the four semicolons in uppercase, those
32 ;;;; names are GLOBAL, SYMBOLS, LISTS, SEQUENCES, CONDITIONALS,
33 ;;;; ITERATIONS, MULTIPLE VALUES, ARITH, SETF and DEFSTRUCT. If you
34 ;;;; add functions to this file, you might want to put them in a place
35 ;;;; that is compatible with the division above (or invent your own
36 ;;;; categories).
37 ;;;;
38 ;;;; To compile this file, make sure you load it first. This is
39 ;;;; because many things are implemented as macros and now that all
40 ;;;; the files are concatenated together one cannot ensure that
41 ;;;; declaration always precedes use.
42 ;;;;
43 ;;;; Bug reports, suggestions and comments,
44 ;;;; to quiroz@cs.rochester.edu
49 \f
50 ;;;; GLOBAL
51 ;;;; This file provides utilities and declarations that are global
52 ;;;; to Common Lisp and so might be used by more than one of the
53 ;;;; other libraries. Especially, I intend to keep here some
54 ;;;; utilities that help parsing/destructuring some difficult calls.
55 ;;;;
56 ;;;;
57 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
58 ;;;; (quiroz@cs.rochester.edu)
60 ;;; Too many pieces of the rest of this package use psetq. So it is unwise to
61 ;;; use here anything but plain Emacs Lisp! There is a neater recursive form
62 ;;; for the algorithm that deals with the bodies.
65 "(psetq {var value }...) => nil
66 Like setq, but all the values are computed before any assignment is made."
70 length))
72 '())
85 setqs))))))
86 setqs))))))
87 \f
88 ;;; utilities
89 ;;;
90 ;;; pair-with-newsyms takes a list and returns a list of lists of the
91 ;;; form (newsym form), such that a let* can then bind the evaluation
92 ;;; of the forms to the newsyms. The idea is to guarantee correct
93 ;;; order of evaluation of the subforms of a setf. It also returns a
94 ;;; list of the newsyms generated, in the corresponding order.
97 "PAIR-WITH-NEWSYMS OLDFORMS
98 The top-level components of the list oldforms are paired with fresh
99 symbols, the pairings list and the newsyms list are returned."
109 "Merge two lists EVENS and ODDS, taking elts from each list alternatingly.
110 EVENS and ODDS are two lists. ZIP-LISTS constructs a new list, whose
111 even numbered elements (0,2,...) come from EVENS and whose odd numbered
112 elements (1,3,...) come from ODDS.
113 The construction stops when the shorter list is exhausted."
125 "Extract even and odd elements of LIST into two separate lists.
126 The argument LIST is separated in two strands, the even and the odd
127 numbered elements. Numbering starts with 0, so the first element
128 belongs in EVENS. No check is made that there is an even number of
129 elements to start with."
139 \f
141 "(reassemble-argslists ARGSLISTS) => a list of lists
142 ARGSLISTS is a list of sequences. Return a list of lists, the first
143 sublist being all the entries coming from ELT 0 of the original
144 sublists, the next those coming from ELT 1 and so on, until the
145 shortest list is exhausted."
149 ;; capture all the elements at index i
152 argslists)
153 result)))))
155 \f
156 ;;; Checking that a list of symbols contains no duplicates is a common
157 ;;; task when checking the legality of some macros. The check for 'eq
158 ;;; pairs can be too expensive, as it is quadratic on the length of
159 ;;; the list. I use a 4-pass, linear, counting approach. It surely
160 ;;; loses on small lists (less than 5 elements?), but should win for
161 ;;; larger lists. The fourth pass could be eliminated.
162 ;;; 10 dec 1986. Emacs Lisp has no REMPROP, so I just eliminated the
163 ;;; 4th pass.
165 "Find all symbols appearing more than once in LIST.
166 Return a list of all such duplicates; nil if there are no duplicates."
169 )
170 ;; check validity
174 ;; pass 1: mark
177 ;; pass 2: count
180 ;; pass 3: collect
184 ;; pass 4: unmark. eliminated.
185 ;; (dolist (x list) (remprop x propname))
186 ;; return result
187 duplicates))
189 ;;;; end of cl-global.el
190 \f
191 ;;;; SYMBOLS
192 ;;;; This file provides the gentemp function, which generates fresh
193 ;;;; symbols, plus some other minor Common Lisp symbol tools.
194 ;;;;
195 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
196 ;;;; (quiroz@cs.rochester.edu)
198 ;;; Keywords. There are no packages in Emacs Lisp, so this is only a
199 ;;; kludge around to let things be "as if" a keyword package was around.
202 "Make symbol X a keyword (symbol whose value is itself).
203 Optional second arg DOCSTRING is a documentation string for it."
210 "Return t if SYM is a keyword."
212 ;; looks like one, make sure value is right
214 nil))
217 "Return a keyword that is naturally associated with symbol SYM.
218 If SYM is keyword, the value is SYM.
219 Otherwise it is a keyword whose name is `:' followed by SYM's name."
221 sym)
227 \f
228 ;;; Temporary symbols.
229 ;;;
238 "Generate a fresh interned symbol.
239 There are two optional arguments, PREFIX and OBLIST. PREFIX is the string
240 that begins the new name, OBLIST is the obarray used to search for old
241 names. The defaults are just right, YOU SHOULD NEVER NEED THESE ARGUMENTS
242 IN YOUR OWN CODE."
254 newsymbol))
255 \f
263 "Generate a fresh uninterned symbol.
264 Optional arg PREFIX is the string that begins the new name. Most people
265 take just the default, except when debugging needs suggest otherwise."
275 newsymbol))
277 ;;;; end of cl-symbols.el
278 \f
279 ;;;; CONDITIONALS
280 ;;;; This file provides some of the conditional constructs of
281 ;;;; Common Lisp. Total compatibility is again impossible, as the
282 ;;;; 'if' form is different in both languages, so only a good
283 ;;;; approximation is desired.
284 ;;;;
285 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
286 ;;;; (quiroz@cs.rochester.edu)
288 ;;; indentation info
294 ;;; WHEN and UNLESS
295 ;;; These two forms are simplified ifs, with a single branch.
298 "(when CONDITION . BODY) => evaluate BODY if CONDITION is true."
302 "(unless CONDITION . BODY) => evaluate BODY if CONDITION is false."
304 \f
305 ;;; CASE and ECASE
306 ;;; CASE selects among several clauses, based on the value (evaluated)
307 ;;; of a expression and a list of (unevaluated) key values. ECASE is
308 ;;; the same, but signals an error if no clause is activated.
311 "(case EXPR . CASES) => evals EXPR, chooses from CASES on that value.
312 EXPR -> any form
313 CASES -> list of clauses, non empty
314 CLAUSE -> HEAD . BODY
315 HEAD -> t = catch all, must be last clause
316 -> otherwise = same as t
317 -> nil = illegal
318 -> atom = activated if (eql EXPR HEAD)
319 -> list of atoms = activated if (memq EXPR HEAD)
320 BODY -> list of forms, implicit PROGN is built around it.
321 EXPR is evaluated only once."
324 ;; convert case into a cond inside a let
330 "(ecase EXPR . CASES) => like `case', but error if no case fits.
331 `t'-clauses are not allowed."
334 ;; check that no 't clause is present.
335 ;; case-clausify would put one such at the beginning of clauses
338 ;; insert error-catching clause
342 "ecase on %s = %s failed to take any branch"
345 clauses))
346 ;; generate code as usual
351 \f
353 "CASE-CLAUSIFY CASES NEWSYM => clauses for a 'cond'
354 Converts the CASES of a [e]case macro into cond clauses to be
355 evaluated inside a let that binds NEWSYM. Returns the clauses in
356 reverse order."
364 ;; construct a cond-clause according to the head
370 ;; check it is the last clause
373 ;; accept this clause as a 't' for cond
378 result)))
382 result)))
384 ;; catch-all for this parser
388 ;;;; end of cl-conditionals.el
389 \f
390 ;;;; ITERATIONS
391 ;;;; This file provides simple iterative macros (a la Common Lisp)
392 ;;;; constructed on the basis of let, let* and while, which are the
393 ;;;; primitive binding/iteration constructs of Emacs Lisp
394 ;;;;
395 ;;;; The Common Lisp iterations use to have a block named nil
396 ;;;; wrapped around them, and allow declarations at the beginning
397 ;;;; of their bodies and you can return a value using (return ...).
398 ;;;; Nothing of the sort exists in Emacs Lisp, so I haven't tried
399 ;;;; to imitate these behaviors.
400 ;;;;
401 ;;;; Other than the above, the semantics of Common Lisp are
402 ;;;; correctly reproduced to the extent this was reasonable.
403 ;;;;
404 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
405 ;;;; (quiroz@cs.rochester.edu)
407 ;;; some lisp-indentation information
415 \f
417 "(do STEPFORMS ENDFORMS . BODY): Iterate BODY, stepping some local
418 variables. STEPFORMS must be a list of symbols or lists. In the second
419 case, the lists must start with a symbol and contain up to two more forms.
420 In the STEPFORMS, a symbol is the same as a (symbol). The other two forms
421 are the initial value (def. NIL) and the form to step (def. itself).
423 The values used by initialization and stepping are computed in parallel.
424 The ENDFORMS are a list (CONDITION . ENDBODY). If the CONDITION evaluates
425 to true in any iteration, ENDBODY is evaluated and the last form in it is
426 returned.
428 The BODY (which may be empty) is evaluated at every iteration, with the
429 symbols of the STEPFORMS bound to the initial or stepped values."
431 ;; check the syntax of the macro
434 ;; construct emacs-lisp equivalent
444 \f
446 "`do*' is to `do' as `let*' is to `let'.
447 STEPFORMS must be a list of symbols or lists. In the second case, the
448 lists must start with a symbol and contain up to two more forms. In the
449 STEPFORMS, a symbol is the same as a (symbol). The other two forms are
450 the initial value (def. NIL) and the form to step (def. itself).
452 Initializations and steppings are done in the sequence they are written.
454 The ENDFORMS are a list (CONDITION . ENDBODY). If the CONDITION evaluates
455 to true in any iteration, ENDBODY is evaluated and the last form in it is
456 returned.
458 The BODY (which may be empty) is evaluated at every iteration, with
459 the symbols of the STEPFORMS bound to the initial or stepped values."
460 ;; check the syntax of the macro
463 ;; construct emacs-lisp equivalent
473 \f
474 ;;; DO and DO* share the syntax checking functions that follow.
477 "True if FORMS is a valid stepforms for the do[*] macro (q.v.)"
489 "symbol or (symbol [init [step]])"
491 forms)))
494 "True if FORMS is a valid endforms for the do[*] macro (q.v.)"
500 "Returns a list of the initializations (for do) in FORMS
501 (a stepforms, see the do macro).
502 FORMS is assumed syntactically valid."
510 forms))
512 ;;; There used to be a reason to deal with DO differently than with
513 ;;; DO*. The writing of PSETQ has made it largely unnecessary.
516 "EXTRACT-DO-STEPS FORMS => an s-expr.
517 FORMS is the stepforms part of a DO macro (q.v.). This function constructs
518 an s-expression that does the stepping at the end of an iteration."
522 "EXTRACT-DO*-STEPS FORMS => an s-expr.
523 FORMS is the stepforms part of a DO* macro (q.v.). This function constructs
524 an s-expression that does the stepping at the end of an iteration."
528 "Separate only the forms that cause stepping."
531 entry ;to explore each form in turn
532 )
538 result))))
541 \f
542 ;;; Other iterative constructs
545 "(dolist (VAR LIST [RESULTFORM]) . BODY): do BODY for each elt of LIST.
546 The RESULTFORM defaults to nil. The VAR is bound to successive elements
547 of the value of LIST and remains bound (to the nil value) when the
548 RESULTFORM is evaluated."
549 ;; check sanity
560 ;; generate code
568 listform)
571 resultform))))
574 "(dotimes (VAR COUNTFORM [RESULTFORM]) . BODY): Repeat BODY, counting in VAR.
575 The COUNTFORM should return a positive integer. The VAR is bound to
576 successive integers from 0 to COUNTFORM - 1 and the BODY is repeated for
577 each of them. At the end, the RESULTFORM is evaluated and its value
578 returned. During this last evaluation, the VAR is still bound, and its
579 value is the number of times the iteration occurred. An omitted RESULTFORM
580 defaults to nil."
581 ;; check sanity
592 ;; generate code
603 body))))
604 \f
606 "(do_symbols (VAR [OBARRAY [RESULTFORM]]) . BODY)
607 The VAR is bound to each of the symbols in OBARRAY (def. obarray) and
608 the BODY is repeatedly performed for each of those bindings. At the
609 end, RESULTFORM (def. nil) is evaluated and its value returned.
610 During this last evaluation, the VAR is still bound and its value is nil.
611 See also the function `mapatoms'."
612 ;; check sanity
623 ;; generate code
631 oblist)
634 resultform))))
638 "(do-all-symbols (VAR [RESULTFORM]) . BODY)
639 Is the same as (do-symbols (VAR obarray RESULTFORM) . BODY)."
641 'do-symbols
643 body))
644 \f
646 "(loop . BODY) repeats BODY indefinitely and does not return.
647 Normally BODY uses `throw' or `signal' to cause an exit.
648 The forms in BODY should be lists, as non-lists are reserved for new features."
649 ;; check that the body doesn't have atomic forms
652 ;; ok, it is a list, check for atomic components
657 body)
658 ;; build the infinite loop
661 ;;;; end of cl-iterations.el
662 \f
663 ;;;; LISTS
664 ;;;; This file provides some of the lists machinery of Common-Lisp
665 ;;;; in a way compatible with Emacs Lisp. Especially, see the the
666 ;;;; typical c[ad]*r functions.
667 ;;;;
668 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
669 ;;;; (quiroz@cs.rochester.edu)
685 "Generate code for (<accessor> FORM), where <accessor> is one of the named
686 list accessors: first, second, ..., tenth, rest."
709 ))))
711 ;;; Synonyms for list functions
713 "Synonym for `car'"
718 "Return the second element of the list LIST."
723 "Return the third element of the list LIST."
728 "Return the fourth element of the list LIST."
733 "Return the fifth element of the list LIST."
738 "Return the sixth element of the list LIST."
743 "Return the seventh element of the list LIST."
748 "Return the eighth element of the list LIST."
753 "Return the ninth element of the list LIST."
758 "Return the tenth element of the list LIST."
763 "Synonym for `cdr'"
766 \f
768 "t if X is nil, nil if X is a cons; error otherwise."
775 "Returns the last link in the list LIST."
783 "Returns the length of a non-circular list, or `nil' for a circular one."
799 \f
801 "Return a new list like LIST but sans the last N elements.
802 N defaults to 1. If the list doesn't have N elements, nil is returned."
807 "Return a new list containing the first arguments consed onto the last arg.
808 Thus, (list* 1 2 3 '(a b)) returns (1 2 3 a b)."
810 arg
815 front)))
818 "Return a list which contains ITEM but is otherwise like LIST.
819 If ITEM occurs in LIST, the value is LIST. Otherwise it is (cons ITEM LIST).
820 When comparing ITEM against elements, `eql' is used."
822 list
826 "Return a new list like LIST but sans SUBLIST.
827 SUBLIST must be one of the links in LIST; otherwise the value is LIST itself."
833 \f
834 ;;; The popular c[ad]*r functions and other list accessors.
836 ;;; To implement this efficiently, a new byte compile handler is used to
837 ;;; generate the minimal code, saving one function call.
840 "Generate code for a (c[ad]+r argument). This realizes the various
841 combinations of car and cdr whose names are supported in this implementation.
842 To use this functionality for a given function,just give its name a
843 'byte-compile property of 'byte-compile-ca*d*r"
850 ;; SEQ is a list of byte-car and byte-cdr in the correct order.
859 ;; the rest of this code doesn't change the stack depth!
865 "Return the car of the car of X."
870 "Return the car of the cdr of X."
875 "Return the cdr of the car of X."
880 "Return the cdr of the cdr of X."
885 "Return the car of the car of the car of X."
890 "Return the car of the car of the cdr of X."
895 "Return the car of the cdr of the car of X."
900 "Return the cdr of the car of the car of X."
905 "Return the car of the cdr of the cdr of X."
910 "Return the cdr of the car of the cdr of X."
915 "Return the cdr of the cdr of the car of X."
920 "Return the cdr of the cdr of the cdr of X."
925 "Return the car of the car of the car of the car of X."
930 "Return the car of the car of the car of the cdr of X."
935 "Return the car of the car of the cdr of the car of X."
940 "Return the car of the cdr of the car of the car of X."
945 "Return the cdr of the car of the car of the car of X."
950 "Return the car of the car of the cdr of the cdr of X."
955 "Return the car of the cdr of the car of the cdr of X."
960 "Return the cdr of the car of the car of the cdr of X."
965 "Return the car of the cdr of the cdr of the car of X."
970 "Return the cdr of the car of the cdr of the car of X."
975 "Return the cdr of the cdr of the car of the car of X."
980 "Return the car of the cdr of the cdr of the cdr of X."
985 "Return the cdr of the cdr of the car of the cdr of X."
990 "Return the cdr of the car of the cdr of the cdr of X."
995 "Return the cdr of the cdr of the cdr of the car of X."
1000 "Return the cdr of the cdr of the cdr of the cdr of X."
1003 \f
1004 ;;; some inverses of the accessors are needed for setf purposes
1007 "Set (nth N LIST) to NEWVAL. Returns NEWVAL."
1011 "(setnthcdr N LIST NEWVAL) => NEWVAL
1012 As a side effect, sets the Nth cdr of LIST to NEWVAL."
1018 newval)
1021 \f
1022 ;;; A-lists machinery
1025 "Return a new alist with KEY paired with ITEM; otherwise like ALIST.
1026 Does not copy ALIST."
1030 "Return a new alist with each elt of KEYS paired with an elt of DATA;
1031 optional 3rd arg ALIST is nconc'd at the end. KEYS and DATA must
1032 have the same length."
1044 \f
1045 ;;;; SEQUENCES
1046 ;;;; Emacs Lisp provides many of the 'sequences' functionality of
1047 ;;;; Common Lisp. This file provides a few things that were left out.
1048 ;;;;
1063 \f
1065 "Test PREDICATE on each element of SEQUENCE; is it ever non-nil?
1066 Extra args are additional sequences; PREDICATE gets one arg from each
1067 sequence and we advance down all the sequences together in lock-step.
1068 A sequence means either a list or a vector."
1084 "Test PREDICATE on each element of SEQUENCE; is it always non-nil?
1085 Extra args are additional sequences; PREDICATE gets one arg from each
1086 sequence and we advance down all the sequences together in lock-step.
1087 A sequence means either a list or a vector."
1101 \f
1103 "Test PREDICATE on each element of SEQUENCE; is it always nil?
1104 Extra args are additional sequences; PREDICATE gets one arg from each
1105 sequence and we advance down all the sequences together in lock-step.
1106 A sequence means either a list or a vector."
1122 "Test PREDICATE on each element of SEQUENCE; is it sometimes nil?
1123 Extra args are additional sequences; PREDICATE gets one arg from each
1124 sequence and we advance down all the sequences together in lock-step.
1125 A sequence means either a list or a vector."
1139 \f
1140 ;;; More sequence functions that don't need keyword arguments
1143 "(concatenate TYPE &rest SEQUENCES) => a sequence
1144 The sequence returned is of type TYPE (must be 'list, 'string, or 'vector) and
1145 contains the concatenation of the elements of all the arguments, in the order
1146 given."
1160 "(map TYPE FUNCTION &rest SEQUENCES) => a sequence
1161 The FUNCTION is called on each set of elements from the SEQUENCES \(stopping
1162 when the shortest sequence is terminated\) and the results are possibly
1163 returned in a sequence of type TYPE \(one of 'list, 'vector, 'string, or nil\)
1164 giving NIL for TYPE gets rid of the values."
1169 results)
1175 argslists))
1178 results)
1183 \f
1184 ;;; an inverse of elt is needed for setf purposes
1187 "In SEQUENCE, set the Nth element to NEWVAL. Returns NEWVAL.
1188 A sequence means either a list or a vector."
1192 ;; only two cases need be considered valid, as strings are arrays
1200 \f
1201 ;;; Testing with keyword arguments.
1202 ;;;
1203 ;;; Many of the sequence functions use keywords to denote some stylized
1204 ;;; form of selecting entries in a sequence. The involved arguments
1205 ;;; are collected with a &rest marker (as Emacs Lisp doesn't have a &key
1206 ;;; marker), then they are passed to build-klist, who
1207 ;;; constructs an association list. That association list is used to
1208 ;;; test for satisfaction and matching.
1210 ;;; DON'T USE MEMBER, NOR ANY FUNCTION THAT COULD TAKE KEYWORDS HERE!!!
1213 "Decode a keyword argument list ARGSLIST for keywords in ACCEPTABLE.
1214 ARGSLIST is a list, presumably the &rest argument of a call, whose
1215 even numbered elements must be keywords.
1216 ACCEPTABLE is a list of keywords, the only ones that are truly acceptable.
1217 The result is an alist containing the arguments named by the keywords
1218 in ACCEPTABLE, or an error is signalled, if something failed.
1219 If the third argument (an optional) is non-nil, other keys are acceptable."
1220 ;; check legality of the arguments, then destructure them
1236 keywords))
1240 nil
1242 keywords))
1252 ;; if THIS appears in auxlist, use its value
1258 "(extract-from-klist KLIST KEY [DEFAULT]) => value of KEY or DEFAULT
1259 Extract value associated with KEY in KLIST (return DEFAULT if nil)."
1264 "(keyword-argument-supplied-p KLIST KEY) => nil or something
1265 NIL if KEY (a keyword) does not appear in the KLIST."
1269 "(ADD-TO-KLIST KEY ITEM KLIST) => new KLIST
1270 Add association (KEY . ITEM) to KLIST."
1274 "(elt-satisfies-test-p ITEM ELT KLIST) => t or nil
1275 KLIST encodes a keyword-arguments test, as in CH. 14 of CLtL.
1276 True if the given ITEM and ELT satisfy the test."
1289 "(elt-satisfies-if-p ITEM KLIST) => t or nil
1290 True if an -if style function was called and ITEM satisfies the
1291 predicate under :predicate in KLIST."
1297 "(elt-satisfies-if-not-p ITEM KLIST) => t or nil
1298 KLIST encodes a keyword-arguments test, as in CH. 14 of CLtL.
1299 True if an -if-not style function was called and ITEM does not satisfy
1300 the predicate under :predicate in KLIST."
1306 "(elts-match-under-klist-p E1 E2 KLIST) => t or nil
1307 KLIST encodes a keyword-arguments test, as in CH. 14 of CLtL.
1308 True if elements E1 and E2 match under the tests encoded in KLIST."
1322 \f
1323 ;;; This macro simplifies using keyword args. It is less clumsy than using
1324 ;;; the primitives build-klist, etc... For instance, member could be written
1325 ;;; this way:
1327 ;;; (defun member (item list &rest kargs)
1328 ;;; (with-keyword-args kargs (test test-not (key 'identity))
1329 ;;; ...))
1331 ;;; Suggested by Robert Potter (potter@cs.rochester.edu, 15 Nov 1989)
1334 "(WITH-KEYWORD-ARGS KEYARGSLIST VARDEFS . BODY)
1335 KEYARGSLIST can be either a symbol or a list of one or two symbols.
1336 In the second case, the second symbol is either T or NIL, indicating whether
1337 keywords other than the mentioned ones are tolerable.
1339 VARDEFS is a list. Each entry is either a VAR (symbol) or matches
1340 \(VAR [DEFAULT [KEYWORD]]). Just giving VAR is the same as giving
1341 \(VAR nil :VAR).
1343 The BODY is executed in an environment where each VAR (a symbol) is bound to
1344 the value present in the KEYARGSLIST provided, or to the DEFAULT. The value
1345 is searched by using the keyword form of VAR (i.e., :VAR) or the optional
1346 keyword if provided.
1348 Notice that this macro doesn't distinguish between a default value given
1349 explicitly by the user and one provided by default. See also the more
1350 primitive functions build-klist, add-to-klist, extract-from-klist,
1351 keyword-argument-supplied-p, elt-satisfies-test-p, elt-satisfies-if-p,
1352 elt-satisfies-if-not-p, elts-match-under-klist-p. They provide more complete,
1353 if clumsier, control over this feature."
1358 "`%s' should be SYMBOL, (SYMBOL), or (SYMBOL t-OR-nil)"
1366 "first subform should be SYMBOL, (SYMBOL), or (SYMBOL t-OR-nil)"
1367 )))
1383 "`%s' must match (VAR [DEFAULT [KEYWORD]])"
1387 "bad variable `%s': must be non-null symbol"
1400 klistname
1401 k
1402 d))
1403 forms)))))
1404 vardefs)
1409 allow-other-keys)))
1411 body))))
1414 \f
1415 ;;; REDUCE
1416 ;;; It is here mostly as an example of how to use KLISTs.
1417 ;;;
1418 ;;; First of all, you need to declare the keywords (done elsewhere in this
1419 ;;; file):
1420 ;;; (defkeyword :from-end "syntax of sequence functions")
1421 ;;; (defkeyword :start "syntax of sequence functions")
1422 ;;; etc...
1423 ;;;
1424 ;;; Then, you capture all the possible keyword arguments with a &rest
1425 ;;; argument. You can pass that list downward again, of course, but
1426 ;;; internally you need to parse it into a KLIST (an alist, really). One uses
1427 ;;; (build-klist REST-ARGS ACCEPTABLE-KEYWORDS [ALLOW-OTHER]). You can then
1428 ;;; test for presence by using (keyword-argument-supplied-p KLIST KEY) and
1429 ;;; extract a value with (extract-from-klist KLIST KEY [DEFAULT]).
1432 "Apply FUNCTION (a function of two arguments) to succesive pairs of elements
1433 from SEQUENCE. Some keyword arguments are valid after FUNCTION and SEQUENCE:
1434 :from-end If non-nil, process the values backwards
1435 :initial-value If given, prefix it to the SEQUENCE. Suffix, if :from-end
1436 :start Restrict reduction to the subsequence from this index
1437 :end Restrict reduction to the subsequence BEFORE this index.
1438 If the sequence is empty and no :initial-value is given, the FUNCTION is
1439 called on zero (not two) arguments. Otherwise, if there is exactly one
1440 element in the combination of SEQUENCE and the initial value, that element is
1441 returned."
1454 sequence)))
1464 result))))
1467 "(cl$subseq-as-list SEQUENCE START END) => a list"
1470 result)
1476 list
1484 ;;;; end of cl-sequences.el
1485 \f
1486 ;;;; Some functions with keyword arguments
1487 ;;;;
1488 ;;;; Both list and sequence functions are considered here together. This
1489 ;;;; doesn't fit any more with the original split of functions in files.
1492 "Look for ITEM in LIST; return first tail of LIST the car of whose first
1493 cons cell tests the same as ITEM. Admits arguments :key, :test, and :test-not."
1500 ;; another workaround allegledly for speed
1508 ))
1514 ;; final hack: remove the indirection through the function names
1522 ;; ok, go for it
1537 result)))))
1538 \f
1539 ;;;; MULTIPLE VALUES
1540 ;;;; This package approximates the behavior of the multiple-values
1541 ;;;; forms of Common Lisp.
1542 ;;;;
1543 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
1544 ;;;; (quiroz@cs.rochester.edu)
1546 ;;; Lisp indentation information
1553 ;;; Global state of the package is kept here
1558 \f
1559 ;;; values is the standard multiple-value-return form. Must be the
1560 ;;; last thing evaluated inside a function. If the caller is not
1561 ;;; expecting multiple values, only the first one is passed. (values)
1562 ;;; is the same as no-values returned (unaware callers see nil). The
1563 ;;; alternative (values-list <list>) is just a convenient shorthand
1564 ;;; and complements multiple-value-list.
1567 "Produce multiple values (zero or more). Each arg is one value.
1568 See also `multiple-value-bind', which is one way to examine the
1569 multiple values produced by a form. If the containing form or caller
1570 does not check specially to see multiple values, it will see only
1571 the first value."
1577 "Produce multiple values (zero or mode). Each element of LIST is one value.
1578 This is equivalent to (apply 'values LIST)."
1585 \f
1586 ;;; Callers that want to see the multiple values use these macros.
1589 "Execute FORM and return a list of all the (multiple) values FORM produces.
1590 See `values' and `multiple-value-bind'."
1604 "Call FUNCTION on all the values produced by the remaining arguments.
1605 (multiple-value-call '+ (values 1 2) (values 3 4)) is 10."
1613 result
1618 "Bind VARS to the (multiple) values produced by FORM, then do BODY.
1619 VARS is a list of variables; each is bound to one of FORM's values.
1620 If FORM doesn't make enough values, the extra variables are bound to nil.
1621 (Ordinary forms produce only one value; to produce more, use `values'.)
1622 Extra values are ignored.
1623 BODY (zero or more forms) is executed with the variables bound,
1624 then the bindings are unwound."
1630 clauses)
1631 body)))
1632 \f
1634 "Set VARS to the (multiple) values produced by FORM.
1635 VARS is a list of variables; each is set to one of FORM's values.
1636 If FORM doesn't make enough values, the extra variables are set to nil.
1637 (Ordinary forms produce only one value; to produce more, use `values'.)
1638 Extra values are ignored."
1647 "Evaluate FORM, then BODY, then produce the same values FORM produced.
1648 Thus, (multiple-value-prog1 (values 1 2) (foobar)) produces values 1 and 2.
1649 This is like `prog1' except that `prog1' would produce only one value,
1650 which would be the first of FORM's values."
1656 ;;; utility functions
1657 ;;;
1658 ;;; mv-bind-clausify makes the pairs needed to have the variables in
1659 ;;; the variable list correspond with the values returned by the form.
1660 ;;; vals is a fresh symbol that intervenes in all the bindings.
1663 "MV-BIND-CLAUSIFY VARS VALS => Auxiliary list
1664 Forms a list of pairs `(,(nth i vars) (nth i vals)) for i from 0 to
1665 the length of VARS (a list of symbols). VALS is just a fresh symbol."
1676 ;;;; end of cl-multiple-values.el
1677 \f
1678 ;;;; ARITH
1679 ;;;; This file provides integer arithmetic extensions. Although
1680 ;;;; Emacs Lisp doesn't really support anything but integers, that
1681 ;;;; has still to be made to look more or less standard.
1682 ;;;;
1683 ;;;;
1684 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
1685 ;;;; (quiroz@cs.rochester.edu)
1689 "True if NUMBER is strictly greater than zero."
1693 "True if NUMBER is strictly less than zero."
1697 "True if INTEGER is not divisible by 2."
1701 "True if INTEGER is divisible by 2."
1705 "Return the absolute value of NUMBER."
1708 number))
1711 "Return -1, 0 or 1 according to the sign of NUMBER."
1718 \f
1720 "Return the greatest common divisor of all the arguments.
1721 The arguments must be integers. With no arguments, value is zero."
1732 ;; essentially the euclidean algorithm
1739 ;; intermediate results
1742 ;; final results
1752 "Return the least common multiple of all the arguments.
1753 The arguments must be integers and there must be at least one of them."
1757 prod ; intermediate product
1771 \f
1773 "Return the integer square root of NUMBER.
1774 NUMBER must not be negative. Result is largest integer less than or
1775 equal to the real square root of the argument."
1776 ;; The method used here is essentially the Newtonian iteration
1777 ;; x[n+1] <- (x[n] + Number/x[n]) / 2
1778 ;; suitably adapted to integer arithmetic.
1779 ;; Thanks to Philippe Schnoebelen <phs@lifia.imag.fr> for suggesting the
1780 ;; termination condition.
1783 number))
1792 approx))
1795 approx new)))))
1796 \f
1798 "Divide DIVIDEND by DIVISOR, rounding toward minus infinity.
1799 DIVISOR defaults to 1. The remainder is produced as a second value."
1819 "Divide DIVIDEND by DIVISOR, rounding toward plus infinity.
1820 DIVISOR defaults to 1. The remainder is produced as a second value."
1835 \f
1837 "Divide DIVIDEND by DIVISOR, rounding toward zero.
1838 DIVISOR defaults to 1. The remainder is produced as a second value."
1855 "Divide DIVIDEND by DIVISOR, rounding to nearest integer.
1856 DIVISOR defaults to 1. The remainder is produced as a second value."
1865 ;; adjust magnitudes first, and then signs
1871 ;; round to even is mandatory
1876 \f
1878 "Return remainder of X by Y (rounding quotient toward minus infinity).
1879 That is, the remainder goes with the quotient produced by `floor'."
1881 r))
1884 "Return remainder of X by Y (rounding quotient toward zero).
1885 That is, the remainder goes with the quotient produced by `truncate'."
1887 r))
1889 ;;; internal utilities
1890 ;;;
1891 ;;; safe-idiv performs an integer division with positive numbers only.
1892 ;;; It is known that some machines/compilers implement weird remainder
1893 ;;; computations when working with negatives, so the idea here is to
1894 ;;; make sure we know what is coming back to the caller in all cases.
1896 ;;; Signum computation fixed by mad@math.keio.JUNET (MAEDA Atusi)
1899 "SAFE-IDIV A B => Q R S
1900 Q=|A|/|B|, R is the rest, S is the sign of A/B."
1912 ;;;; end of cl-arith.el
1913 \f
1914 ;;;; SETF
1915 ;;;; This file provides the setf macro and friends. The purpose has
1916 ;;;; been modest, only the simplest defsetf forms are accepted.
1917 ;;;; Use it and enjoy.
1918 ;;;;
1919 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
1920 ;;;; (quiroz@cs.rochester.edu)
1924 "Property, its value is the function setf must invoke to update a
1925 generalized variable whose access form is a function call of the
1929 "Property of symbols that have a `defsetf' update function on them,
1931 \f
1933 "Generalized `setq' that can set things other than variable values.
1934 A use of `setf' looks like (setf {PLACE VALUE}...).
1935 The behavior of (setf PLACE VALUE) is to access the generalized variable
1936 at PLACE and store VALUE there. It returns VALUE. If there is more
1937 than one PLACE and VALUE, each PLACE is set from its VALUE before
1938 the next PLACE is evaluated."
1940 ;; check the number of subforms
1944 nil)
1946 ;; this is the recursive case
1956 result)))))
1958 ;; this is the base case (SETF PLACE VALUE)
1963 ;; dispatch on the type of the PLACE
1981 ;; this let gets new symbols to ensure adequate
1982 ;; order of evaluation of the subforms.
1984 bindings
1989 \f
1991 "Define how `setf' works on a certain kind of generalized variable.
1992 A use of `defsetf' looks like (defsetf ACCESSFN UPDATEFN [DOCSTRING]).
1993 ACCESSFN is a symbol. UPDATEFN is a function or macro which takes
1994 one more argument than ACCESSFN does. DEFSETF defines the translation
1995 of (SETF (ACCESFN . ARGS) NEWVAL) to be a form like (UPDATEFN ARGS... NEWVAL).
1996 The function UPDATEFN must return its last arg, after performing the
1997 updating called for."
1998 ;; reject ill-formed requests. too bad one can't test for functionp
1999 ;; or macrop.
2003 ;; update properties
2008 ;; any better thing to return?
2010 \f
2011 ;;; This section provides the "default" setfs for Common-Emacs-Lisp
2012 ;;; The user will not normally add anything to this, although
2013 ;;; defstruct will introduce new ones as a matter of fact.
2014 ;;;
2015 ;;; Apply is a special case. The Common Lisp
2016 ;;; standard makes the case of apply be useful when the user writes
2017 ;;; something like (apply #'name ...), Emacs Lisp doesn't have the #
2018 ;;; stuff, but it has (function ...). Notice that V18 includes a new
2019 ;;; apply: this file is compatible with V18 and pre-V18 Emacses.
2021 ;;; INCOMPATIBILITY: the SETF macro evaluates its arguments in the
2022 ;;; (correct) left to right sequence *before* checking for apply
2023 ;;; methods (which should really be an special case inside setf). Due
2024 ;;; to this, the lambda expression defsetf'd to apply will succeed in
2025 ;;; applying the right function even if the name was not quoted, but
2026 ;;; computed! That extension is not Common Lisp (nor is particularly
2027 ;;; useful, I think).
2031 ;; dissasemble the calling form
2032 ;; "(((quote fn) x1 x2 ... xn) val)" (function instead of quote, too)
2045 \f
2047 aset
2051 setnth
2055 setnthcdr
2059 setelt
2089 \f
2137 \f
2181 \f
2236 ;; how about defsetfing other Emacs forms?
2237 \f
2238 ;;; Modify macros
2239 ;;;
2240 ;;; It could be nice to implement define-modify-macro, but I don't
2241 ;;; think it really pays.
2244 "(incf REF [DELTA]) -> increment the g.v. REF by DELTA (default 1)"
2250 "(decf REF [DELTA]) -> decrement the g.v. REF by DELTA (default 1)"
2256 "(push ITEM REF) -> cons ITEM at the head of the g.v. REF (a list)"
2260 "(pushnew ITEM REF): adjoin ITEM at the head of the g.v. REF (a list)"
2264 "(pop REF) -> (prog1 (car REF) (setf REF (cdr REF)))"
2270 \f
2271 ;;; PSETF
2272 ;;;
2273 ;;; Psetf is the generalized variable equivalent of psetq. The right
2274 ;;; hand sides are evaluated and assigned (via setf) to the left hand
2275 ;;; sides. The evaluations are done in an environment where they
2276 ;;; appear to occur in parallel.
2279 "(psetf {var value }...) => nil
2280 Like setf, but all the values are computed before any assignment is made."
2284 length))
2286 '())
2299 setfs))))))
2300 setfs))))))
2301 \f
2302 ;;; SHIFTF and ROTATEF
2303 ;;;
2306 "(shiftf PLACE1 PLACE2... NEWVALUE)
2307 Set PLACE1 to PLACE2, PLACE2 to PLACE3...
2308 Each PLACE is set to the old value of the following PLACE,
2309 and the last PLACE is set to the value NEWVALUE.
2310 Returns the old value of PLACE1."
2315 ;; the places are accessed to fresh symbols
2326 "(rotatef PLACE...) sets each PLACE to the old value of the following PLACE.
2327 The last PLACE is set to the old value of the first PLACE.
2328 Thus, the values rotate through the PLACEs. Returns nil."
2330 nil
2335 'let bindings
2339 nil))))
2340 \f
2341 ;;;; STRUCTS
2342 ;;;; This file provides the structures mechanism. See the
2343 ;;;; documentation for Common-Lisp's defstruct. Mine doesn't
2344 ;;;; implement all the functionality of the standard, although some
2345 ;;;; more could be grafted if so desired. More details along with
2346 ;;;; the code.
2347 ;;;;
2348 ;;;;
2349 ;;;; Cesar Quiroz @ UofR DofCSc - Dec. 1986
2350 ;;;; (quiroz@cs.rochester.edu)
2372 \f
2374 "(defstruct NAME [DOC-STRING] . SLOTS) define NAME as structure type.
2375 NAME must be a symbol, the name of the new structure. It could also
2376 be a list (NAME . OPTIONS).
2378 Each option is either a symbol, or a list of a keyword symbol taken from the
2379 list \{:conc-name, :copier, :constructor, :predicate, :include,
2380 :print-function, :type, :initial-offset\}. The meanings of these are as in
2381 CLtL, except that no BOA-constructors are provided, and the options
2382 \{:print-fuction, :type, :initial-offset\} are ignored quietly. All these
2383 structs are named, in the sense that their names can be used for type
2384 discrimination.
2386 The DOC-STRING is established as the `structure-doc' property of NAME.
2388 The SLOTS are one or more of the following:
2389 SYMBOL -- meaning the SYMBOL is the name of a SLOT of NAME
2390 list of SYMBOL and VALUE -- meaning that VALUE is the initial value of
2391 the slot.
2392 `defstruct' defines functions `make-NAME', `NAME-p', `copy-NAME' for the
2393 structure, and functions with the same name as the slots to access
2394 them. `setf' of the accessors sets their values."
2398 ;; Names for the member functions come from the options. The
2399 ;; slots* stuff collects info about the slots declared explicitly.
2402 moreslotsn moreslots moreinits included)
2404 ;; The moreslots* stuff refers to slots gained as a consequence
2405 ;; of (:include clauses). -- Oct 89: Only one :include tolerated
2420 ;; compute properties of NAME
2425 docstring)
2427 slotsn)
2434 ;; If this definition :includes another defstruct,
2435 ;; modify both property lists.
2440 :structure-includes
2457 old
2458 :structure-included-in
2461 ;; careful with destructive
2462 ;;manipulation!
2464 'append
2466 'get
2467 old
2469 '())
2470 )))))
2473 :structure-includes
2474 '()))))
2475 ;; If this definition used to be :included in another, warn
2476 ;; that things make break. On the other hand, the redefinition
2477 ;; may be trivial, so don't call it an error.
2486 "`%s' redefined. Should redefine `%s'?"
2490 ;; Compute functions associated with NAME. This is not
2491 ;; handling BOA constructors yet, but here would be the place.
2507 'function
2517 'and
2519 typetag
2525 'memq
2526 typetag
2530 )))))
2531 ;; compute accessors for NAME's slots
2535 ;; generate returned value -- not defined by the standard
2542 ;; generate code
2545 accessors alterators returned))))))
2546 \f
2548 "(parse$defstruct$args ARGS) => NAME OPTIONS DOCSTRING SLOTSN SLOTS INITLIST
2549 NAME=symbol, OPTIONS=list of, DOCSTRING=string, SLOTSN=count of slots,
2550 SLOTS=list of their names, INITLIST=alist (keyword . initform)."
2552 options ;args=((symbol . options) ...)
2554 slotargs ;second or third cdr of args
2558 ;; extract name and options
2561 options '()))
2569 ;; is there a docstring?
2573 ;; now for the slots
2578 \f
2580 "(process$slots SLOTS) => SLOTSN SLOTSLIST INITLIST
2581 Converts a list of symbols or lists of symbol and form into the last 3
2582 values returned by PARSE$DEFSTRUCT$ARGS."
2584 slotslist ;(slot1 slot2 ...)
2597 ;; this silently ignores any slot options. bad...
2604 \f
2606 "(parse$defstruct$options name OPTIONS SLOTS) => many values
2607 A defstruct named NAME, with options list OPTIONS, has already slots SLOTS.
2608 Parse the OPTIONS and return the updated form of the struct's slots and other
2609 information. The values returned are:
2611 CONC-NAME is the string to use as prefix/suffix in the methods,
2612 CONST is the name of the official constructor,
2613 COPIER is the name of the structure copier,
2614 PRED is the name of the type predicate,
2615 MORESLOTSN is the number of slots added by :include,
2616 MORESLOTS is the list of slots added by :include,
2617 MOREINITS is the list of initialization forms added by :include,
2618 INCLUDED is nil, or the list of the symbol added by :include"
2620 ;; to build the return values
2628 ;; auxiliaries
2629 option-head ;When an option is not a plain
2630 option-second ; keyword, it must be a list of
2631 option-rest ; the form (head second . rest)
2632 these-slotsn ;When :include is found, the
2633 these-slots ; info about the included
2634 these-inits ; structure is added here.
2635 included ;NIL or (list INCLUDED)
2636 )
2637 ;; Values above are the defaults. Now we read the options themselves
2639 ;; 2 cases arise, as options must be a keyword or a list
2643 (:named
2653 (:conc-name
2657 option-second)
2663 (:copier
2668 option-second)
2672 \f
2678 option-second)
2682 (:predicate
2687 option-second)
2691 (:include
2727 ;; Return values found
2729 moreslotsn moreslots moreinits
2730 included)))
2731 \f
2733 "(simplify$inits SLOTS INITLIST) => new INITLIST
2734 Removes from INITLIST - an ALIST - any shadowed bindings."
2736 key ;from the slot
2737 )
2744 "(extract$indices INITLIST) => indices list
2745 Kludge. From a list of pairs (keyword . form) build a list of pairs
2746 of the form (keyword . position in list from 0). Useful to precompute
2747 some of the work of MAKE$STRUCTURE$INSTANCE."
2753 \f
2755 "(build$accessors$for NAME PREDICATE SLOTS SLOTSN) => FSETS DEFSETFS KWDS
2756 Generate the code for accesors and defsetfs of a structure called
2757 NAME, whose slots are SLOTS. Also, establishes the keywords for the
2758 slots names."
2778 "`%s' is not a struct %s"
2783 name))))))))
2784 accessors))
2794 "`%s' not a `%s'"
2799 name)))))))
2800 alterators))
2803 keywords))))
2804 \f
2806 "(make$structure$instance NAME ARGS) => new struct NAME
2807 A struct of type NAME is created, some slots might be initialized
2808 according to ARGS (the &rest argument of MAKE-name)."
2815 initalist ;pairlis'd on initforms
2816 initializers ;definitive initializers
2817 )
2818 ;; check sanity of the request
2826 ;; analyze the initializers provided by the call
2830 ;; check that all the arguments are introduced by keywords
2834 ;; check that all the keywords are known
2839 ;; update initforms
2849 result)))
2851 ;; compute definitive initializers
2860 ;; do real initialization
2864 ;;;; end of cl-structs.el
2865 \f
2866 ;;; For lisp-interaction mode, so that multiple values can be seen when passed
2867 ;;; back. Lies every now and then...
2881 "Evaluate sexp before point; print value\(s\) into current buffer.
2882 If the evaled form returns multiple values, they are shown one to a line.
2883 The variables -, +, ++, +++, *, **, ***, /, //, /// have their usual meaning.
2885 It clears the multiple-value passing mechanism, and does not pass back
2886 multiple values. Use this only if you are debugging cl.el and understand well
2887 how the multiple-value stuff works, because it can be fooled into believing
2888 that multiple values have been returned when they actually haven't, for
2889 instance
2890 \(identity \(values nil 1\)\)
2891 However, even when this fails, you can trust the first printed value to be
2892 \(one of\) the returned value\(s\)."
2894 ;; top level call, can reset mvalues
2908 ** *
2911 // /
2914 ++ +
2926 /)))
2929 \f
2930 ;;;; More LISTS functions
2931 ;;;;
2933 ;;; Some mapping functions on lists, commonly useful.
2934 ;;; They take no extra sequences, to go along with Emacs Lisp's MAPCAR.
2937 "(MAPC FUNCTION LIST) => LIST
2938 Apply FUNCTION to each element of LIST, return LIST.
2939 Like mapcar, but called only for effect."
2944 list)
2947 "(MAPLIST FUNCTION LIST) => list'ed results of FUNCTION on cdrs of LIST
2948 Apply FUNCTION to successive sublists of LIST, return the list of the results"
2950 results '())
2957 "(MAPL FUNCTION LIST) => LIST
2958 Apply FUNCTION to successive cdrs of LIST, return LIST.
2959 Like maplist, but called only for effect."
2964 list))
2967 "(MAPCAN FUNCTION LIST) => nconc'd results of FUNCTION on LIST
2968 Apply FUNCTION to each element of LIST, nconc the results.
2969 Beware: nconc destroys its first argument! See copy-list."
2978 "(MAPCON FUNCTION LIST) => nconc'd results of FUNCTION on cdrs of LIST
2979 Apply FUNCTION to successive sublists of LIST, nconc the results.
2980 Beware: nconc destroys its first argument! See copy-list."
2988 ;;; Copiers
2991 "Build a copy of LIST"
2995 "Build a copy of the tree of conses TREE
2996 The argument is a tree of conses, it is recursively copied down to
2997 non conses. Circularity and sharing of substructure are not
2998 necessarily preserved."
3002 tree))
3004 ;;; reversals, and destructive manipulations of a list's spine
3007 "does what (append (reverse X) Y) would, only faster"
3009 y
3013 "does (nconc (nreverse X) Y) would, only faster
3014 Destructive on X, be careful."
3016 y
3017 ;; reuse the first cons of x, making it point to y
3021 "Side-effected LIST truncated N+1 conses from the end.
3022 This is the destructive version of BUTLAST. Returns () and does not
3023 modify the LIST argument if the length of the list is not at least N."
3027 list)
3029 '())
3032 list))))
3033 \f
3034 ;;; Substitutions
3037 "NEW replaces OLD in a copy of TREE
3038 Uses eql for the test."
3042 "NEW replaces any subtree or leaf that fails TEST in a copy of TREE"
3043 ;; (subst-if new (function (lambda (x) (not (funcall test x)))) tree)
3045 new)
3047 tree)
3051 ;; If nothing changed, return originals. Else use the new
3052 ;; components to assemble a new tree.
3055 tree
3059 "NEW replaces any subtree or leaf that satisfies TEST in a copy of TREE"
3061 new)
3063 tree)
3067 ;; If nothing changed, return originals. Else use the new
3068 ;; components to assemble a new tree.
3071 tree
3075 "Use association list ALIST to modify a copy of TREE
3076 If a subtree or leaf of TREE is a key in ALIST, it is replaced by the
3077 associated value. Not exactly Common Lisp, but close in spirit and
3078 compatible with the native Emacs Lisp ASSOC, which uses EQUAL."
3083 tree)
3089 tree
3093 "PREDICATE is applied to the members of LIST. As soon as one of them
3094 returns true, that tail of the list if returned. Else NIL."
3100 nil))
3103 "PREDICATE is applied to the members of LIST. As soon as one of them
3104 returns false, that tail of the list if returned. Else NIL."
3110 nil))
3113 "(tailp SUBLIST LIST) => True if SUBLIST is a sublist of LIST."
3119 nil))
3120 \f
3121 ;;; Suggestion of phr%widow.Berkeley.EDU@lilac.berkeley.edu
3124 "Ignore a Common-Lisp declaration."
3128 "Ignore a Common-Lisp proclamation."
3132 "(the TYPE FORM) macroexpands to FORM
3133 No checking is even attempted. This is just for compatibility with
3134 Common-Lisp codes."
3135 form)
3137 ;;;; end of cl.el