From xemacs-m  Mon Sep 15 20:26:40 1997
Received: from jagor.srce.hr (hniksic@jagor.srce.hr [161.53.2.130])
	by xemacs.org (8.8.5/8.8.5) with ESMTP id UAA24739
	for <xemacs-beta@xemacs.org>; Mon, 15 Sep 1997 20:26:30 -0500 (CDT)
Received: (from hniksic@localhost)
	by jagor.srce.hr (8.8.7/8.8.6) id DAA04571;
	Tue, 16 Sep 1997 03:26:29 +0200 (MET DST)
To: XEmacs Developers <xemacs-beta@xemacs.org>
Subject: Re: Tirana: SPARCworks stuff broken
References: <199709160007.RAA01474@roy> <m2afheqexb.fsf@altair.xemacs.org>
X-Attribution: Hrvoje
X-Face: Mie8:rOV<\c/~z{s.X4A{!?vY7{drJ([U]0O=W/<W*SMo/Mv:58:*_y~ki>xDi&N7XG
        KV^$k0m3Oe/)'e%3=$PCR&3ITUXH,cK>]bci&<qQ>Ff%x_>1`T(+M2Gg/fgndU%k*ft
        [(7._6e0n-V%|%'[c|q:;}td$#INd+;?!-V=c8Pqf}3J
From: Hrvoje Niksic <hniksic@srce.hr>
Date: 16 Sep 1997 03:26:28 +0200
In-Reply-To: SL Baur's message of "15 Sep 1997 17:29:36 -0700"
Message-ID: <kig3en6cam3.fsf@jagor.srce.hr>
Lines: 992
X-Mailer: Gnus v5.4.65/XEmacs 20.3(beta20) - "Tirana"

SL Baur <steve@xemacs.org> writes:

> > + 	;; "cl-extra"		; These cause lossage at dump
> > + 	;; "cl-seq"		; Fix it first, if you want these dumped
> 
> Martin's patch had these two lines uncommented.  I commented them out
> because they cause conflicts at dump time.

As far as I see, the only conflict is regarding `gethash', `clrhash'
and other such, which override the builtins.  This confuses
Fsnarf_documentation because it looks at a symbol's function using
`symbol_function', instead of `indirect_function'.  So, when it finds
that symbol-function of gethash is the symbol `cl-gethash', it gets
confused and flags it as "weird" function.

The solution is to use `indirect_function' instead.  Also, most of the 
autoloads in cl-defs.el are no longer necessary.  Those for cl-macs.el 
still are, of course.

Here is the patch:

1997-09-16  Hrvoje Niksic  <hniksic@srce.hr>

	* doc.c (Fsnarf_documentation): Use `indirect_function' instead of 
	ad-hoc checking.

--- src/doc.c.orig	Tue Sep 16 03:12:19 1997
+++ src/doc.c	Tue Sep 16 03:12:20 1997
@@ -489,7 +489,7 @@
                  The type determines where the docstring is stored.  */
 	      else if (p[1] == 'F')
 		{
-                  fun = XSYMBOL (sym)->function;/*indirect_function (sym,0);*/
+                  fun = indirect_function (sym,0);
 
 		  if (CONSP (fun) && EQ (XCAR (fun), Qmacro))
 		    fun = XCDR (fun);
--- lisp/prim/dumped-lisp.el.orig	Tue Sep 16 03:23:55 1997
+++ lisp/prim/dumped-lisp.el	Tue Sep 16 03:24:00 1997
@@ -6,8 +6,8 @@
 	"replace" 		; match-string used in version.el.
 	"version.el"		; Ignore compiled-by-mistake version.elc
 	"cl"
-	;; "cl-extra"		; These cause lossage at dump
-	;; "cl-seq"		; Fix it first, if you want these dumped
+	"cl-extra"
+	"cl-seq"
 	;; "featurep"
 	"widget"
 	"custom"		; Before the world so everything can be
--- lisp/cl/cl-defs.el.orig	Tue Sep 16 03:09:11 1997
+++ lisp/cl/cl-defs.el	Tue Sep 16 03:09:12 1997
@@ -2,469 +2,469 @@
 ;;;### (autoloads (cl-macroexpand-all cl-prettyexpand cl-progv-before hash-table-count hash-table-p cl-puthash cl-hash-lookup make-hash-table cl-do-remf cl-set-getf getf get* tailp list-length nreconc revappend notevery notany every some map cl-mapcar-many concatenate random-state-p make-random-state random* signum rem* mod* round* truncate* ceiling* floor* isqrt lcm gcd cl-float-limits cl-set-frame-visible-p cl-map-overlays cl-map-intervals cl-map-keymap-recursively cl-map-keymap mapcon mapcan mapl mapc maplist equalp coerce) "cl-extra" "cl/cl-extra.el" (12636 41267))
 ;;; Generated autoloads from cl/cl-extra.el
 
-(autoload 'coerce "cl-extra" "\
-Coerce OBJECT to type TYPE.
-TYPE is a Common Lisp type specifier." nil nil)
-
-(autoload 'equalp "cl-extra" "\
-T if two Lisp objects have similar structures and contents.
-This is like `equal', except that it accepts numerically equal
-numbers of different types (float vs. integer), and also compares
-strings case-insensitively." nil nil)
-
-(autoload 'maplist "cl-extra" "\
-Map FUNC to each sublist of LIST or LISTS.
-Like `mapcar', except applies to lists and their cdr's rather than to
-the elements themselves." nil nil)
-
-(autoload 'mapc "cl-extra" "\
-Like `mapcar', but does not accumulate values returned by the function." nil nil)
-
-(autoload 'mapl "cl-extra" "\
-Like `maplist', but does not accumulate values returned by the function." nil nil)
-
-(autoload 'mapcan "cl-extra" "\
-Like `mapcar', but nconc's together the values returned by the function." nil nil)
-
-(autoload 'mapcon "cl-extra" "\
-Like `maplist', but nconc's together the values returned by the function." nil nil)
-
-(autoload 'cl-map-keymap "cl-extra" nil nil nil)
-
-(autoload 'cl-map-keymap-recursively "cl-extra" nil nil nil)
-
-(autoload 'cl-map-intervals "cl-extra" nil nil nil)
-
-(autoload 'cl-map-overlays "cl-extra" nil nil nil)
-
-(autoload 'cl-set-frame-visible-p "cl-extra" nil nil nil)
-
-(autoload 'cl-float-limits "cl-extra" nil nil nil)
-
-(autoload 'gcd "cl-extra" "\
-Return the greatest common divisor of the arguments." nil nil)
-
-(autoload 'lcm "cl-extra" "\
-Return the least common multiple of the arguments." nil nil)
-
-(autoload 'isqrt "cl-extra" "\
-Return the integer square root of the argument." nil nil)
-
-(autoload 'floor* "cl-extra" "\
-Return a list of the floor of X and the fractional part of X.
-With two arguments, return floor and remainder of their quotient." nil nil)
-
-(autoload 'ceiling* "cl-extra" "\
-Return a list of the ceiling of X and the fractional part of X.
-With two arguments, return ceiling and remainder of their quotient." nil nil)
-
-(autoload 'truncate* "cl-extra" "\
-Return a list of the integer part of X and the fractional part of X.
-With two arguments, return truncation and remainder of their quotient." nil nil)
-
-(autoload 'round* "cl-extra" "\
-Return a list of X rounded to the nearest integer and the remainder.
-With two arguments, return rounding and remainder of their quotient." nil nil)
-
-(autoload 'mod* "cl-extra" "\
-The remainder of X divided by Y, with the same sign as Y." nil nil)
-
-(autoload 'rem* "cl-extra" "\
-The remainder of X divided by Y, with the same sign as X." nil nil)
-
-(autoload 'signum "cl-extra" "\
-Return 1 if A is positive, -1 if negative, 0 if zero." nil nil)
-
-(autoload 'random* "cl-extra" "\
-Return a random nonnegative number less than LIM, an integer or float.
-Optional second arg STATE is a random-state object." nil nil)
-
-(autoload 'make-random-state "cl-extra" "\
-Return a copy of random-state STATE, or of `*random-state*' if omitted.
-If STATE is t, return a new state object seeded from the time of day." nil nil)
-
-(autoload 'random-state-p "cl-extra" "\
-Return t if OBJECT is a random-state object." nil nil)
-
-(autoload 'concatenate "cl-extra" "\
-Concatenate, into a sequence of type TYPE, the argument SEQUENCES." nil nil)
-
-(autoload 'cl-mapcar-many "cl-extra" nil nil nil)
-
-(autoload 'map "cl-extra" "\
-Map a function across one or more sequences, returning a sequence.
-TYPE is the sequence type to return, FUNC is the function, and SEQS
-are the argument sequences." nil nil)
-
-(autoload 'some "cl-extra" "\
-Return true if PREDICATE is true of any element of SEQ or SEQs.
-If so, return the true (non-nil) value returned by PREDICATE." nil nil)
-
-(autoload 'every "cl-extra" "\
-Return true if PREDICATE is true of every element of SEQ or SEQs." nil nil)
-
-(autoload 'notany "cl-extra" "\
-Return true if PREDICATE is false of every element of SEQ or SEQs." nil nil)
-
-(autoload 'notevery "cl-extra" "\
-Return true if PREDICATE is false of some element of SEQ or SEQs." nil nil)
-
-(autoload 'revappend "cl-extra" "\
-Equivalent to (append (reverse X) Y)." nil nil)
-
-(autoload 'nreconc "cl-extra" "\
-Equivalent to (nconc (nreverse X) Y)." nil nil)
-
-(autoload 'list-length "cl-extra" "\
-Return the length of a list.  Return nil if list is circular." nil nil)
-
-(autoload 'tailp "cl-extra" "\
-Return true if SUBLIST is a tail of LIST." nil nil)
-
-(autoload 'get* "cl-extra" "\
-Return the value of SYMBOL's PROPNAME property, or DEFAULT if none." nil nil)
-
-(autoload 'getf "cl-extra" "\
-Search PROPLIST for property PROPNAME; return its value or DEFAULT.
-PROPLIST is a list of the sort returned by `symbol-plist'." nil nil)
-
-(autoload 'cl-set-getf "cl-extra" nil nil nil)
-
-(autoload 'cl-do-remf "cl-extra" nil nil nil)
-
-(autoload 'make-hash-table "cl-extra" "\
-Make an empty Common Lisp-style hash-table.
-If :test is `eq', this can use Lucid Emacs built-in hash-tables.
-In non-Lucid Emacs, or with non-`eq' test, this internally uses a-lists.
-Keywords supported:  :test :size
-The Common Lisp keywords :rehash-size and :rehash-threshold are ignored." nil nil)
-
-(autoload 'cl-hash-lookup "cl-extra" nil nil nil)
-
-(autoload 'cl-puthash "cl-extra" nil nil nil)
-
-(autoload 'hash-table-p "cl-extra" "\
-Return t if OBJECT is a hash table." nil nil)
-
-(autoload 'hash-table-count "cl-extra" "\
-Return the number of entries in HASH-TABLE." nil nil)
-
-(autoload 'cl-progv-before "cl-extra" nil nil nil)
-
-(autoload 'cl-prettyexpand "cl-extra" nil nil nil)
-
-(autoload 'cl-macroexpand-all "cl-extra" "\
-Expand all macro calls through a Lisp FORM.
-This also does some trivial optimizations to make the form prettier." nil nil)
-
-;;;***
-
-;;;### (autoloads (tree-equal nsublis sublis nsubst-if-not nsubst-if nsubst subst-if-not subst-if subsetp nset-exclusive-or set-exclusive-or nset-difference set-difference nintersection intersection nunion union rassoc-if-not rassoc-if rassoc* assoc-if-not assoc-if assoc* cl-adjoin member-if-not member-if member* merge stable-sort sort* search mismatch count-if-not count-if count position-if-not position-if position find-if-not find-if find nsubstitute-if-not nsubstitute-if nsubstitute substitute-if-not substitute-if substitute delete-duplicates remove-duplicates delete-if-not delete-if delete* remove-if-not remove-if remove* remove remq replace fill reduce) "cl-seq" "cl/cl-seq.el" (12559 39909))
-;;; Generated autoloads from cl/cl-seq.el
-
-(autoload 'reduce "cl-seq" "\
-Reduce two-argument FUNCTION across SEQUENCE.
-Keywords supported:  :start :end :from-end :initial-value :key" nil nil)
-
-(autoload 'fill "cl-seq" "\
-Fill the elements of SEQ with ITEM.
-Keywords supported:  :start :end" nil nil)
-
-(autoload 'replace "cl-seq" "\
-Replace the elements of SEQ1 with the elements of SEQ2.
-SEQ1 is destructively modified, then returned.
-Keywords supported:  :start1 :end1 :start2 :end2" nil nil)
-
-(autoload 'remq "cl-seq" nil nil nil)
-
-(autoload 'remove "cl-seq" nil nil nil)
-
-(autoload 'remove* "cl-seq" "\
-Remove all occurrences of ITEM in SEQ.
-This is a non-destructive function; it makes a copy of SEQ if necessary
-to avoid corrupting the original SEQ.
-Keywords supported:  :test :test-not :key :count :start :end :from-end" nil nil)
-
-(autoload 'remove-if "cl-seq" "\
-Remove all items satisfying PREDICATE in SEQ.
-This is a non-destructive function; it makes a copy of SEQ if necessary
-to avoid corrupting the original SEQ.
-Keywords supported:  :key :count :start :end :from-end" nil nil)
-
-(autoload 'remove-if-not "cl-seq" "\
-Remove all items not satisfying PREDICATE in SEQ.
-This is a non-destructive function; it makes a copy of SEQ if necessary
-to avoid corrupting the original SEQ.
-Keywords supported:  :key :count :start :end :from-end" nil nil)
-
-(autoload 'delete* "cl-seq" "\
-Remove all occurrences of ITEM in SEQ.
-This is a destructive function; it reuses the storage of SEQ whenever possible.
-Keywords supported:  :test :test-not :key :count :start :end :from-end" nil nil)
-
-(autoload 'delete-if "cl-seq" "\
-Remove all items satisfying PREDICATE in SEQ.
-This is a destructive function; it reuses the storage of SEQ whenever possible.
-Keywords supported:  :key :count :start :end :from-end" nil nil)
-
-(autoload 'delete-if-not "cl-seq" "\
-Remove all items not satisfying PREDICATE in SEQ.
-This is a destructive function; it reuses the storage of SEQ whenever possible.
-Keywords supported:  :key :count :start :end :from-end" nil nil)
-
-(autoload 'remove-duplicates "cl-seq" "\
-Return a copy of SEQ with all duplicate elements removed.
-Keywords supported:  :test :test-not :key :start :end :from-end" nil nil)
-
-(autoload 'delete-duplicates "cl-seq" "\
-Remove all duplicate elements from SEQ (destructively).
-Keywords supported:  :test :test-not :key :start :end :from-end" nil nil)
-
-(autoload 'substitute "cl-seq" "\
-Substitute NEW for OLD in SEQ.
-This is a non-destructive function; it makes a copy of SEQ if necessary
-to avoid corrupting the original SEQ.
-Keywords supported:  :test :test-not :key :count :start :end :from-end" nil nil)
-
-(autoload 'substitute-if "cl-seq" "\
-Substitute NEW for all items satisfying PREDICATE in SEQ.
-This is a non-destructive function; it makes a copy of SEQ if necessary
-to avoid corrupting the original SEQ.
-Keywords supported:  :key :count :start :end :from-end" nil nil)
-
-(autoload 'substitute-if-not "cl-seq" "\
-Substitute NEW for all items not satisfying PREDICATE in SEQ.
-This is a non-destructive function; it makes a copy of SEQ if necessary
-to avoid corrupting the original SEQ.
-Keywords supported:  :key :count :start :end :from-end" nil nil)
-
-(autoload 'nsubstitute "cl-seq" "\
-Substitute NEW for OLD in SEQ.
-This is a destructive function; it reuses the storage of SEQ whenever possible.
-Keywords supported:  :test :test-not :key :count :start :end :from-end" nil nil)
-
-(autoload 'nsubstitute-if "cl-seq" "\
-Substitute NEW for all items satisfying PREDICATE in SEQ.
-This is a destructive function; it reuses the storage of SEQ whenever possible.
-Keywords supported:  :key :count :start :end :from-end" nil nil)
-
-(autoload 'nsubstitute-if-not "cl-seq" "\
-Substitute NEW for all items not satisfying PREDICATE in SEQ.
-This is a destructive function; it reuses the storage of SEQ whenever possible.
-Keywords supported:  :key :count :start :end :from-end" nil nil)
-
-(autoload 'find "cl-seq" "\
-Find the first occurrence of ITEM in LIST.
-Return the matching ITEM, or nil if not found.
-Keywords supported:  :test :test-not :key :start :end :from-end" nil nil)
-
-(autoload 'find-if "cl-seq" "\
-Find the first item satisfying PREDICATE in LIST.
-Return the matching ITEM, or nil if not found.
-Keywords supported:  :key :start :end :from-end" nil nil)
-
-(autoload 'find-if-not "cl-seq" "\
-Find the first item not satisfying PREDICATE in LIST.
-Return the matching ITEM, or nil if not found.
-Keywords supported:  :key :start :end :from-end" nil nil)
-
-(autoload 'position "cl-seq" "\
-Find the first occurrence of ITEM in LIST.
-Return the index of the matching item, or nil if not found.
-Keywords supported:  :test :test-not :key :start :end :from-end" nil nil)
-
-(autoload 'position-if "cl-seq" "\
-Find the first item satisfying PREDICATE in LIST.
-Return the index of the matching item, or nil if not found.
-Keywords supported:  :key :start :end :from-end" nil nil)
-
-(autoload 'position-if-not "cl-seq" "\
-Find the first item not satisfying PREDICATE in LIST.
-Return the index of the matching item, or nil if not found.
-Keywords supported:  :key :start :end :from-end" nil nil)
-
-(autoload 'count "cl-seq" "\
-Count the number of occurrences of ITEM in LIST.
-Keywords supported:  :test :test-not :key :start :end" nil nil)
-
-(autoload 'count-if "cl-seq" "\
-Count the number of items satisfying PREDICATE in LIST.
-Keywords supported:  :key :start :end" nil nil)
-
-(autoload 'count-if-not "cl-seq" "\
-Count the number of items not satisfying PREDICATE in LIST.
-Keywords supported:  :key :start :end" nil nil)
-
-(autoload 'mismatch "cl-seq" "\
-Compare SEQ1 with SEQ2, return index of first mismatching element.
-Return nil if the sequences match.  If one sequence is a prefix of the
-other, the return value indicates the end of the shorted sequence.
-Keywords supported:  :test :test-not :key :start1 :end1 :start2 :end2 :from-end" nil nil)
-
-(autoload 'search "cl-seq" "\
-Search for SEQ1 as a subsequence of SEQ2.
-Return the index of the leftmost element of the first match found;
-return nil if there are no matches.
-Keywords supported:  :test :test-not :key :start1 :end1 :start2 :end2 :from-end" nil nil)
-
-(autoload 'sort* "cl-seq" "\
-Sort the argument SEQUENCE according to PREDICATE.
-This is a destructive function; it reuses the storage of SEQUENCE if possible.
-Keywords supported:  :key" nil nil)
-
-(autoload 'stable-sort "cl-seq" "\
-Sort the argument SEQUENCE stably according to PREDICATE.
-This is a destructive function; it reuses the storage of SEQUENCE if possible.
-Keywords supported:  :key" nil nil)
-
-(autoload 'merge "cl-seq" "\
-Destructively merge the two sequences to produce a new sequence.
-TYPE is the sequence type to return, SEQ1 and SEQ2 are the two
-argument sequences, and PRED is a `less-than' predicate on the elements.
-Keywords supported:  :key" nil nil)
-
-(autoload 'member* "cl-seq" "\
-Find the first occurrence of ITEM in LIST.
-Return the sublist of LIST whose car is ITEM.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'member-if "cl-seq" "\
-Find the first item satisfying PREDICATE in LIST.
-Return the sublist of LIST whose car matches.
-Keywords supported:  :key" nil nil)
-
-(autoload 'member-if-not "cl-seq" "\
-Find the first item not satisfying PREDICATE in LIST.
-Return the sublist of LIST whose car matches.
-Keywords supported:  :key" nil nil)
-
-(autoload 'cl-adjoin "cl-seq" nil nil nil)
-
-(autoload 'assoc* "cl-seq" "\
-Find the first item whose car matches ITEM in LIST.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'assoc-if "cl-seq" "\
-Find the first item whose car satisfies PREDICATE in LIST.
-Keywords supported:  :key" nil nil)
-
-(autoload 'assoc-if-not "cl-seq" "\
-Find the first item whose car does not satisfy PREDICATE in LIST.
-Keywords supported:  :key" nil nil)
-
-(autoload 'rassoc* "cl-seq" "\
-Find the first item whose cdr matches ITEM in LIST.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'rassoc-if "cl-seq" "\
-Find the first item whose cdr satisfies PREDICATE in LIST.
-Keywords supported:  :key" nil nil)
-
-(autoload 'rassoc-if-not "cl-seq" "\
-Find the first item whose cdr does not satisfy PREDICATE in LIST.
-Keywords supported:  :key" nil nil)
-
-(autoload 'union "cl-seq" "\
-Combine LIST1 and LIST2 using a set-union operation.
-The result list contains all items that appear in either LIST1 or LIST2.
-This is a non-destructive function; it makes a copy of the data if necessary
-to avoid corrupting the original LIST1 and LIST2.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'nunion "cl-seq" "\
-Combine LIST1 and LIST2 using a set-union operation.
-The result list contains all items that appear in either LIST1 or LIST2.
-This is a destructive function; it reuses the storage of LIST1 and LIST2
-whenever possible.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'intersection "cl-seq" "\
-Combine LIST1 and LIST2 using a set-intersection operation.
-The result list contains all items that appear in both LIST1 and LIST2.
-This is a non-destructive function; it makes a copy of the data if necessary
-to avoid corrupting the original LIST1 and LIST2.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'nintersection "cl-seq" "\
-Combine LIST1 and LIST2 using a set-intersection operation.
-The result list contains all items that appear in both LIST1 and LIST2.
-This is a destructive function; it reuses the storage of LIST1 and LIST2
-whenever possible.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'set-difference "cl-seq" "\
-Combine LIST1 and LIST2 using a set-difference operation.
-The result list contains all items that appear in LIST1 but not LIST2.
-This is a non-destructive function; it makes a copy of the data if necessary
-to avoid corrupting the original LIST1 and LIST2.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'nset-difference "cl-seq" "\
-Combine LIST1 and LIST2 using a set-difference operation.
-The result list contains all items that appear in LIST1 but not LIST2.
-This is a destructive function; it reuses the storage of LIST1 and LIST2
-whenever possible.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'set-exclusive-or "cl-seq" "\
-Combine LIST1 and LIST2 using a set-exclusive-or operation.
-The result list contains all items that appear in exactly one of LIST1, LIST2.
-This is a non-destructive function; it makes a copy of the data if necessary
-to avoid corrupting the original LIST1 and LIST2.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'nset-exclusive-or "cl-seq" "\
-Combine LIST1 and LIST2 using a set-exclusive-or operation.
-The result list contains all items that appear in exactly one of LIST1, LIST2.
-This is a destructive function; it reuses the storage of LIST1 and LIST2
-whenever possible.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'subsetp "cl-seq" "\
-True if LIST1 is a subset of LIST2.
-I.e., if every element of LIST1 also appears in LIST2.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'subst-if "cl-seq" "\
-Substitute NEW for elements matching PREDICATE in TREE (non-destructively).
-Return a copy of TREE with all matching elements replaced by NEW.
-Keywords supported:  :key" nil nil)
-
-(autoload 'subst-if-not "cl-seq" "\
-Substitute NEW for elts not matching PREDICATE in TREE (non-destructively).
-Return a copy of TREE with all non-matching elements replaced by NEW.
-Keywords supported:  :key" nil nil)
-
-(autoload 'nsubst "cl-seq" "\
-Substitute NEW for OLD everywhere in TREE (destructively).
-Any element of TREE which is `eql' to OLD is changed to NEW (via a call
-to `setcar').
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'nsubst-if "cl-seq" "\
-Substitute NEW for elements matching PREDICATE in TREE (destructively).
-Any element of TREE which matches is changed to NEW (via a call to `setcar').
-Keywords supported:  :key" nil nil)
-
-(autoload 'nsubst-if-not "cl-seq" "\
-Substitute NEW for elements not matching PREDICATE in TREE (destructively).
-Any element of TREE which matches is changed to NEW (via a call to `setcar').
-Keywords supported:  :key" nil nil)
-
-(autoload 'sublis "cl-seq" "\
-Perform substitutions indicated by ALIST in TREE (non-destructively).
-Return a copy of TREE with all matching elements replaced.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'nsublis "cl-seq" "\
-Perform substitutions indicated by ALIST in TREE (destructively).
-Any matching element of TREE is changed via a call to `setcar'.
-Keywords supported:  :test :test-not :key" nil nil)
-
-(autoload 'tree-equal "cl-seq" "\
-T if trees X and Y have `eql' leaves.
-Atoms are compared by `eql'; cons cells are compared recursively.
-Keywords supported:  :test :test-not :key" nil nil)
+;(autoload 'coerce "cl-extra" "\
+;Coerce OBJECT to type TYPE.
+;TYPE is a Common Lisp type specifier." nil nil)
+
+;(autoload 'equalp "cl-extra" "\
+;T if two Lisp objects have similar structures and contents.
+;This is like `equal', except that it accepts numerically equal
+;numbers of different types (float vs. integer), and also compares
+;strings case-insensitively." nil nil)
+
+;(autoload 'maplist "cl-extra" "\
+;Map FUNC to each sublist of LIST or LISTS.
+;Like `mapcar', except applies to lists and their cdr's rather than to
+;the elements themselves." nil nil)
+
+;(autoload 'mapc "cl-extra" "\
+;Like `mapcar', but does not accumulate values returned by the function." nil nil)
+
+;(autoload 'mapl "cl-extra" "\
+;Like `maplist', but does not accumulate values returned by the function." nil nil)
+
+;(autoload 'mapcan "cl-extra" "\
+;Like `mapcar', but nconc's together the values returned by the function." nil nil)
+
+;(autoload 'mapcon "cl-extra" "\
+;Like `maplist', but nconc's together the values returned by the function." nil nil)
+
+;(autoload 'cl-map-keymap "cl-extra" nil nil nil)
+
+;(autoload 'cl-map-keymap-recursively "cl-extra" nil nil nil)
+
+;(autoload 'cl-map-intervals "cl-extra" nil nil nil)
+
+;(autoload 'cl-map-overlays "cl-extra" nil nil nil)
+
+;(autoload 'cl-set-frame-visible-p "cl-extra" nil nil nil)
+
+;(autoload 'cl-float-limits "cl-extra" nil nil nil)
+
+;(autoload 'gcd "cl-extra" "\
+;Return the greatest common divisor of the arguments." nil nil)
+
+;(autoload 'lcm "cl-extra" "\
+;Return the least common multiple of the arguments." nil nil)
+
+;(autoload 'isqrt "cl-extra" "\
+;Return the integer square root of the argument." nil nil)
+
+;(autoload 'floor* "cl-extra" "\
+;Return a list of the floor of X and the fractional part of X.
+;With two arguments, return floor and remainder of their quotient." nil nil)
+
+;(autoload 'ceiling* "cl-extra" "\
+;Return a list of the ceiling of X and the fractional part of X.
+;With two arguments, return ceiling and remainder of their quotient." nil nil)
+
+;(autoload 'truncate* "cl-extra" "\
+;Return a list of the integer part of X and the fractional part of X.
+;With two arguments, return truncation and remainder of their quotient." nil nil)
+
+;(autoload 'round* "cl-extra" "\
+;Return a list of X rounded to the nearest integer and the remainder.
+;With two arguments, return rounding and remainder of their quotient." nil nil)
+
+;(autoload 'mod* "cl-extra" "\
+;The remainder of X divided by Y, with the same sign as Y." nil nil)
+
+;(autoload 'rem* "cl-extra" "\
+;The remainder of X divided by Y, with the same sign as X." nil nil)
+
+;(autoload 'signum "cl-extra" "\
+;Return 1 if A is positive, -1 if negative, 0 if zero." nil nil)
+
+;(autoload 'random* "cl-extra" "\
+;Return a random nonnegative number less than LIM, an integer or float.
+;Optional second arg STATE is a random-state object." nil nil)
+
+;(autoload 'make-random-state "cl-extra" "\
+;Return a copy of random-state STATE, or of `*random-state*' if omitted.
+;If STATE is t, return a new state object seeded from the time of day." nil nil)
+
+;(autoload 'random-state-p "cl-extra" "\
+;Return t if OBJECT is a random-state object." nil nil)
+
+;(autoload 'concatenate "cl-extra" "\
+;Concatenate, into a sequence of type TYPE, the argument SEQUENCES." nil nil)
+
+;(autoload 'cl-mapcar-many "cl-extra" nil nil nil)
+
+;(autoload 'map "cl-extra" "\
+;Map a function across one or more sequences, returning a sequence.
+;TYPE is the sequence type to return, FUNC is the function, and SEQS
+;are the argument sequences." nil nil)
+
+;(autoload 'some "cl-extra" "\
+;Return true if PREDICATE is true of any element of SEQ or SEQs.
+;If so, return the true (non-nil) value returned by PREDICATE." nil nil)
+
+;(autoload 'every "cl-extra" "\
+;Return true if PREDICATE is true of every element of SEQ or SEQs." nil nil)
+
+;(autoload 'notany "cl-extra" "\
+;Return true if PREDICATE is false of every element of SEQ or SEQs." nil nil)
+
+;(autoload 'notevery "cl-extra" "\
+;Return true if PREDICATE is false of some element of SEQ or SEQs." nil nil)
+
+;(autoload 'revappend "cl-extra" "\
+;Equivalent to (append (reverse X) Y)." nil nil)
+
+;(autoload 'nreconc "cl-extra" "\
+;Equivalent to (nconc (nreverse X) Y)." nil nil)
+
+;(autoload 'list-length "cl-extra" "\
+;Return the length of a list.  Return nil if list is circular." nil nil)
+
+;(autoload 'tailp "cl-extra" "\
+;Return true if SUBLIST is a tail of LIST." nil nil)
+
+;(autoload 'get* "cl-extra" "\
+;Return the value of SYMBOL's PROPNAME property, or DEFAULT if none." nil nil)
+
+;(autoload 'getf "cl-extra" "\
+;Search PROPLIST for property PROPNAME; return its value or DEFAULT.
+;PROPLIST is a list of the sort returned by `symbol-plist'." nil nil)
+
+;(autoload 'cl-set-getf "cl-extra" nil nil nil)
+
+;(autoload 'cl-do-remf "cl-extra" nil nil nil)
+
+;(autoload 'make-hash-table "cl-extra" "\
+;Make an empty Common Lisp-style hash-table.
+;If :test is `eq', this can use Lucid Emacs built-in hash-tables.
+;In non-Lucid Emacs, or with non-`eq' test, this internally uses a-lists.
+;Keywords supported:  :test :size
+;The Common Lisp keywords :rehash-size and :rehash-threshold are ignored." nil nil)
+
+;(autoload 'cl-hash-lookup "cl-extra" nil nil nil)
+
+;(autoload 'cl-puthash "cl-extra" nil nil nil)
+
+;(autoload 'hash-table-p "cl-extra" "\
+;Return t if OBJECT is a hash table." nil nil)
+
+;(autoload 'hash-table-count "cl-extra" "\
+;Return the number of entries in HASH-TABLE." nil nil)
+
+;(autoload 'cl-progv-before "cl-extra" nil nil nil)
+
+;(autoload 'cl-prettyexpand "cl-extra" nil nil nil)
+
+;(autoload 'cl-macroexpand-all "cl-extra" "\
+;Expand all macro calls through a Lisp FORM.
+;This also does some trivial optimizations to make the form prettier." nil nil)
+
+;;;;***
+;
+;;;;### (autoloads (tree-equal nsublis sublis nsubst-if-not nsubst-if nsubst subst-if-not subst-if subsetp nset-exclusive-or set-exclusive-or nset-difference set-difference nintersection intersection nunion union rassoc-if-not rassoc-if rassoc* assoc-if-not assoc-if assoc* cl-adjoin member-if-not member-if member* merge stable-sort sort* search mismatch count-if-not count-if count position-if-not position-if position find-if-not find-if find nsubstitute-if-not nsubstitute-if nsubstitute substitute-if-not substitute-if substitute delete-duplicates remove-duplicates delete-if-not delete-if delete* remove-if-not remove-if remove* remove remq replace fill reduce) "cl-seq" "cl/cl-seq.el" (12559 39909))
+;;;; Generated autoloads from cl/cl-seq.el
+
+;(autoload 'reduce "cl-seq" "\
+;Reduce two-argument FUNCTION across SEQUENCE.
+;Keywords supported:  :start :end :from-end :initial-value :key" nil nil)
+
+;(autoload 'fill "cl-seq" "\
+;Fill the elements of SEQ with ITEM.
+;Keywords supported:  :start :end" nil nil)
+
+;(autoload 'replace "cl-seq" "\
+;Replace the elements of SEQ1 with the elements of SEQ2.
+;SEQ1 is destructively modified, then returned.
+;Keywords supported:  :start1 :end1 :start2 :end2" nil nil)
+
+;(autoload 'remq "cl-seq" nil nil nil)
+
+;(autoload 'remove "cl-seq" nil nil nil)
+
+;(autoload 'remove* "cl-seq" "\
+;Remove all occurrences of ITEM in SEQ.
+;This is a non-destructive function; it makes a copy of SEQ if necessary
+;to avoid corrupting the original SEQ.
+;Keywords supported:  :test :test-not :key :count :start :end :from-end" nil nil)
+
+;(autoload 'remove-if "cl-seq" "\
+;Remove all items satisfying PREDICATE in SEQ.
+;This is a non-destructive function; it makes a copy of SEQ if necessary
+;to avoid corrupting the original SEQ.
+;Keywords supported:  :key :count :start :end :from-end" nil nil)
+
+;(autoload 'remove-if-not "cl-seq" "\
+;Remove all items not satisfying PREDICATE in SEQ.
+;This is a non-destructive function; it makes a copy of SEQ if necessary
+;to avoid corrupting the original SEQ.
+;Keywords supported:  :key :count :start :end :from-end" nil nil)
+
+;(autoload 'delete* "cl-seq" "\
+;Remove all occurrences of ITEM in SEQ.
+;This is a destructive function; it reuses the storage of SEQ whenever possible.
+;Keywords supported:  :test :test-not :key :count :start :end :from-end" nil nil)
+
+;(autoload 'delete-if "cl-seq" "\
+;Remove all items satisfying PREDICATE in SEQ.
+;This is a destructive function; it reuses the storage of SEQ whenever possible.
+;Keywords supported:  :key :count :start :end :from-end" nil nil)
+
+;(autoload 'delete-if-not "cl-seq" "\
+;Remove all items not satisfying PREDICATE in SEQ.
+;This is a destructive function; it reuses the storage of SEQ whenever possible.
+;Keywords supported:  :key :count :start :end :from-end" nil nil)
+
+;(autoload 'remove-duplicates "cl-seq" "\
+;Return a copy of SEQ with all duplicate elements removed.
+;Keywords supported:  :test :test-not :key :start :end :from-end" nil nil)
+
+;(autoload 'delete-duplicates "cl-seq" "\
+;Remove all duplicate elements from SEQ (destructively).
+;Keywords supported:  :test :test-not :key :start :end :from-end" nil nil)
+
+;(autoload 'substitute "cl-seq" "\
+;Substitute NEW for OLD in SEQ.
+;This is a non-destructive function; it makes a copy of SEQ if necessary
+;to avoid corrupting the original SEQ.
+;Keywords supported:  :test :test-not :key :count :start :end :from-end" nil nil)
+
+;(autoload 'substitute-if "cl-seq" "\
+;Substitute NEW for all items satisfying PREDICATE in SEQ.
+;This is a non-destructive function; it makes a copy of SEQ if necessary
+;to avoid corrupting the original SEQ.
+;Keywords supported:  :key :count :start :end :from-end" nil nil)
+
+;(autoload 'substitute-if-not "cl-seq" "\
+;Substitute NEW for all items not satisfying PREDICATE in SEQ.
+;This is a non-destructive function; it makes a copy of SEQ if necessary
+;to avoid corrupting the original SEQ.
+;Keywords supported:  :key :count :start :end :from-end" nil nil)
+
+;(autoload 'nsubstitute "cl-seq" "\
+;Substitute NEW for OLD in SEQ.
+;This is a destructive function; it reuses the storage of SEQ whenever possible.
+;Keywords supported:  :test :test-not :key :count :start :end :from-end" nil nil)
+
+;(autoload 'nsubstitute-if "cl-seq" "\
+;Substitute NEW for all items satisfying PREDICATE in SEQ.
+;This is a destructive function; it reuses the storage of SEQ whenever possible.
+;Keywords supported:  :key :count :start :end :from-end" nil nil)
+
+;(autoload 'nsubstitute-if-not "cl-seq" "\
+;Substitute NEW for all items not satisfying PREDICATE in SEQ.
+;This is a destructive function; it reuses the storage of SEQ whenever possible.
+;Keywords supported:  :key :count :start :end :from-end" nil nil)
+
+;(autoload 'find "cl-seq" "\
+;Find the first occurrence of ITEM in LIST.
+;Return the matching ITEM, or nil if not found.
+;Keywords supported:  :test :test-not :key :start :end :from-end" nil nil)
+
+;(autoload 'find-if "cl-seq" "\
+;Find the first item satisfying PREDICATE in LIST.
+;Return the matching ITEM, or nil if not found.
+;Keywords supported:  :key :start :end :from-end" nil nil)
+
+;(autoload 'find-if-not "cl-seq" "\
+;Find the first item not satisfying PREDICATE in LIST.
+;Return the matching ITEM, or nil if not found.
+;Keywords supported:  :key :start :end :from-end" nil nil)
+
+;(autoload 'position "cl-seq" "\
+;Find the first occurrence of ITEM in LIST.
+;Return the index of the matching item, or nil if not found.
+;Keywords supported:  :test :test-not :key :start :end :from-end" nil nil)
+
+;(autoload 'position-if "cl-seq" "\
+;Find the first item satisfying PREDICATE in LIST.
+;Return the index of the matching item, or nil if not found.
+;Keywords supported:  :key :start :end :from-end" nil nil)
+
+;(autoload 'position-if-not "cl-seq" "\
+;Find the first item not satisfying PREDICATE in LIST.
+;Return the index of the matching item, or nil if not found.
+;Keywords supported:  :key :start :end :from-end" nil nil)
+
+;(autoload 'count "cl-seq" "\
+;Count the number of occurrences of ITEM in LIST.
+;Keywords supported:  :test :test-not :key :start :end" nil nil)
+
+;(autoload 'count-if "cl-seq" "\
+;Count the number of items satisfying PREDICATE in LIST.
+;Keywords supported:  :key :start :end" nil nil)
+
+;(autoload 'count-if-not "cl-seq" "\
+;Count the number of items not satisfying PREDICATE in LIST.
+;Keywords supported:  :key :start :end" nil nil)
+
+;(autoload 'mismatch "cl-seq" "\
+;Compare SEQ1 with SEQ2, return index of first mismatching element.
+;Return nil if the sequences match.  If one sequence is a prefix of the
+;other, the return value indicates the end of the shorted sequence.
+;Keywords supported:  :test :test-not :key :start1 :end1 :start2 :end2 :from-end" nil nil)
+
+;(autoload 'search "cl-seq" "\
+;Search for SEQ1 as a subsequence of SEQ2.
+;Return the index of the leftmost element of the first match found;
+;return nil if there are no matches.
+;Keywords supported:  :test :test-not :key :start1 :end1 :start2 :end2 :from-end" nil nil)
+
+;(autoload 'sort* "cl-seq" "\
+;Sort the argument SEQUENCE according to PREDICATE.
+;This is a destructive function; it reuses the storage of SEQUENCE if possible.
+;Keywords supported:  :key" nil nil)
+
+;(autoload 'stable-sort "cl-seq" "\
+;Sort the argument SEQUENCE stably according to PREDICATE.
+;This is a destructive function; it reuses the storage of SEQUENCE if possible.
+;Keywords supported:  :key" nil nil)
+
+;(autoload 'merge "cl-seq" "\
+;Destructively merge the two sequences to produce a new sequence.
+;TYPE is the sequence type to return, SEQ1 and SEQ2 are the two
+;argument sequences, and PRED is a `less-than' predicate on the elements.
+;Keywords supported:  :key" nil nil)
+
+;(autoload 'member* "cl-seq" "\
+;Find the first occurrence of ITEM in LIST.
+;Return the sublist of LIST whose car is ITEM.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'member-if "cl-seq" "\
+;Find the first item satisfying PREDICATE in LIST.
+;Return the sublist of LIST whose car matches.
+;Keywords supported:  :key" nil nil)
+
+;(autoload 'member-if-not "cl-seq" "\
+;Find the first item not satisfying PREDICATE in LIST.
+;Return the sublist of LIST whose car matches.
+;Keywords supported:  :key" nil nil)
+
+;(autoload 'cl-adjoin "cl-seq" nil nil nil)
+
+;(autoload 'assoc* "cl-seq" "\
+;Find the first item whose car matches ITEM in LIST.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'assoc-if "cl-seq" "\
+;Find the first item whose car satisfies PREDICATE in LIST.
+;Keywords supported:  :key" nil nil)
+
+;(autoload 'assoc-if-not "cl-seq" "\
+;Find the first item whose car does not satisfy PREDICATE in LIST.
+;Keywords supported:  :key" nil nil)
+
+;(autoload 'rassoc* "cl-seq" "\
+;Find the first item whose cdr matches ITEM in LIST.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'rassoc-if "cl-seq" "\
+;Find the first item whose cdr satisfies PREDICATE in LIST.
+;Keywords supported:  :key" nil nil)
+
+;(autoload 'rassoc-if-not "cl-seq" "\
+;Find the first item whose cdr does not satisfy PREDICATE in LIST.
+;Keywords supported:  :key" nil nil)
+
+;(autoload 'union "cl-seq" "\
+;Combine LIST1 and LIST2 using a set-union operation.
+;The result list contains all items that appear in either LIST1 or LIST2.
+;This is a non-destructive function; it makes a copy of the data if necessary
+;to avoid corrupting the original LIST1 and LIST2.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'nunion "cl-seq" "\
+;Combine LIST1 and LIST2 using a set-union operation.
+;The result list contains all items that appear in either LIST1 or LIST2.
+;This is a destructive function; it reuses the storage of LIST1 and LIST2
+;whenever possible.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'intersection "cl-seq" "\
+;Combine LIST1 and LIST2 using a set-intersection operation.
+;The result list contains all items that appear in both LIST1 and LIST2.
+;This is a non-destructive function; it makes a copy of the data if necessary
+;to avoid corrupting the original LIST1 and LIST2.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'nintersection "cl-seq" "\
+;Combine LIST1 and LIST2 using a set-intersection operation.
+;The result list contains all items that appear in both LIST1 and LIST2.
+;This is a destructive function; it reuses the storage of LIST1 and LIST2
+;whenever possible.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'set-difference "cl-seq" "\
+;Combine LIST1 and LIST2 using a set-difference operation.
+;The result list contains all items that appear in LIST1 but not LIST2.
+;This is a non-destructive function; it makes a copy of the data if necessary
+;to avoid corrupting the original LIST1 and LIST2.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'nset-difference "cl-seq" "\
+;Combine LIST1 and LIST2 using a set-difference operation.
+;The result list contains all items that appear in LIST1 but not LIST2.
+;This is a destructive function; it reuses the storage of LIST1 and LIST2
+;whenever possible.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'set-exclusive-or "cl-seq" "\
+;Combine LIST1 and LIST2 using a set-exclusive-or operation.
+;The result list contains all items that appear in exactly one of LIST1, LIST2.
+;This is a non-destructive function; it makes a copy of the data if necessary
+;to avoid corrupting the original LIST1 and LIST2.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'nset-exclusive-or "cl-seq" "\
+;Combine LIST1 and LIST2 using a set-exclusive-or operation.
+;The result list contains all items that appear in exactly one of LIST1, LIST2.
+;This is a destructive function; it reuses the storage of LIST1 and LIST2
+;whenever possible.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'subsetp "cl-seq" "\
+;True if LIST1 is a subset of LIST2.
+;I.e., if every element of LIST1 also appears in LIST2.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'subst-if "cl-seq" "\
+;Substitute NEW for elements matching PREDICATE in TREE (non-destructively).
+;Return a copy of TREE with all matching elements replaced by NEW.
+;Keywords supported:  :key" nil nil)
+
+;(autoload 'subst-if-not "cl-seq" "\
+;Substitute NEW for elts not matching PREDICATE in TREE (non-destructively).
+;Return a copy of TREE with all non-matching elements replaced by NEW.
+;Keywords supported:  :key" nil nil)
+
+;(autoload 'nsubst "cl-seq" "\
+;Substitute NEW for OLD everywhere in TREE (destructively).
+;Any element of TREE which is `eql' to OLD is changed to NEW (via a call
+;to `setcar').
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'nsubst-if "cl-seq" "\
+;Substitute NEW for elements matching PREDICATE in TREE (destructively).
+;Any element of TREE which matches is changed to NEW (via a call to `setcar').
+;Keywords supported:  :key" nil nil)
+
+;(autoload 'nsubst-if-not "cl-seq" "\
+;Substitute NEW for elements not matching PREDICATE in TREE (destructively).
+;Any element of TREE which matches is changed to NEW (via a call to `setcar').
+;Keywords supported:  :key" nil nil)
+
+;(autoload 'sublis "cl-seq" "\
+;Perform substitutions indicated by ALIST in TREE (non-destructively).
+;Return a copy of TREE with all matching elements replaced.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'nsublis "cl-seq" "\
+;Perform substitutions indicated by ALIST in TREE (destructively).
+;Any matching element of TREE is changed via a call to `setcar'.
+;Keywords supported:  :test :test-not :key" nil nil)
+
+;(autoload 'tree-equal "cl-seq" "\
+;T if trees X and Y have `eql' leaves.
+;Atoms are compared by `eql'; cons cells are compared recursively.
+;Keywords supported:  :test :test-not :key" nil nil)
 
 ;;;***
 


-- 
Hrvoje Niksic <hniksic@srce.hr> | Student at FER Zagreb, Croatia
--------------------------------+--------------------------------
* Q: What is an experienced Emacs user?
* A: A person who wishes that the terminal had pedals.

