From 9fb94aba052316f54c0c9c35aa0de6c1ab6ea10e Mon Sep 17 00:00:00 2001 From: Miles Bader Date: Mon, 30 Jul 2007 05:36:39 +0000 Subject: [PATCH 1/9] Remove lisp/erc/erc-nicklist.el Patches applied: * emacs@sv.gnu.org/emacs--devo--0--patch-832 Remove lisp/erc/erc-nicklist.el Revision: emacs@sv.gnu.org/emacs--rel--22--patch-76 Creator: Michael Olson --- lisp/erc/ChangeLog | 6 + lisp/erc/erc-nicklist.el | 414 --------------------------------------- 2 files changed, 6 insertions(+), 414 deletions(-) delete mode 100644 lisp/erc/erc-nicklist.el diff --git a/lisp/erc/ChangeLog b/lisp/erc/ChangeLog index ead40c1e01e..9baafe61257 100644 --- a/lisp/erc/ChangeLog +++ b/lisp/erc/ChangeLog @@ -1,3 +1,9 @@ +2007-07-30 Michael Olson + + * erc-nicklist.el: Remove from the Emacs source tree. This file + is not release quality, and relies heavily on a module which + cannot be distributed with ERC due to licensing reasons. + 2007-07-25 Glenn Morris * Relicense all FSF files to GPLv3 or later. diff --git a/lisp/erc/erc-nicklist.el b/lisp/erc/erc-nicklist.el deleted file mode 100644 index b542c2a5e1d..00000000000 --- a/lisp/erc/erc-nicklist.el +++ /dev/null @@ -1,414 +0,0 @@ -;;; erc-nicklist.el --- Display channel nicknames in a side buffer. - -;; Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc. - -;; Filename: erc-nicklist.el -;; Author: Lawrence Mitchell -;; Created: 2004-04-30 -;; Keywords: IRC chat client Internet - -;; This file is part of GNU Emacs. - -;; GNU Emacs is free software; you can redistribute it and/or modify -;; it under the terms of the GNU General Public License as published by -;; the Free Software Foundation; either version 3, or (at your option) -;; any later version. - -;; GNU Emacs is distributed in the hope that it will be useful, -;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;; GNU General Public License for more details. - -;; You should have received a copy of the GNU General Public License -;; along with GNU Emacs; see the file COPYING. If not, write to the -;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, -;; Boston, MA 02110-1301, USA. - -;;; Commentary: -;; -;; This provides a minimal mIRC style nicklist buffer for ERC. To -;; activate, do M-x erc-nicklist RET in the channel buffer you want -;; the nicklist to appear for. To close and quit the nicklist -;; buffer, do M-x erc-nicklist-quit RET from within the nicklist buffer. -;; -;; TODO: -;; o Somehow associate nicklist windows with channel windows so they -;; appear together, and if one gets buried, then the other does. -;; -;; o Make "Query" and "Message" work. -;; -;; o Prettify the actual list of nicks in some way. -;; -;; o Add a proper erc-module that people can turn on and off, figure -;; out a way of creating the nicklist window at an appropriate time -;; --- probably in `erc-join-hook'. -;; -;; o Ensure XEmacs compatibility --- the mouse-menu support is likely -;; broken. -;; -;; o Add option to display in a separate frame --- will again need to -;; be able to associate the nicklist with the currently active -;; channel buffer or something similar. -;; -;; o Allow toggling of visibility of nicklist via ERC commands. - -;;; History: -;; - -;; Changes by Edgar Gonçalves -;; Jun 25 2005: -;; - images are changed to a standard set of names. -;; - /images now contain gaim's status icons. -;; May 31 2005: -;; - tooltips are improved. they try to access bbdb for a nice nick! -;; Apr 26 2005: -;; - erc-nicklist-channel-users-info was fixed (sorting bug) -;; - Away names don't need parenthesis when using icons -;; Apr 26 2005: -;; - nicks can display icons of their connection type (msn, icq, for now) -;; Mar 15 2005: -;; - nicks now are different for unvoiced and op users -;; - nicks now have tooltips displaying more info -;; Mar 18 2005: -;; - queries now work ok, both on menu and keyb shortcut RET. -;; - nicklist is now sorted ignoring the case. Voiced nicks will -;; appear according to `erc-nicklist-voiced-position'. - -;;; Code: - -(require 'erc) -(condition-case nil - (require 'erc-bbdb) - (error nil)) -(eval-when-compile (require 'cl)) - -(defgroup erc-nicklist nil - "Display a list of nicknames in a separate window." - :group 'erc) - -(defcustom erc-nicklist-use-icons t - "*If non-nil, display an icon instead of the name of the chat medium. -By \"chat medium\", we mean IRC, AOL, MSN, ICQ, etc." - :group 'erc-nicklist - :type 'boolean) - -(defcustom erc-nicklist-icons-directory - (concat default-directory "images/") - "*Directory of the PNG files for chat icons. -Icons are displayed if `erc-nicklist-use-icons' is non-nil." - :group 'erc-nicklist - :type 'directory) - -(defcustom erc-nicklist-voiced-position 'bottom - "*Position of voiced nicks in the nicklist. -The value can be `top', `bottom' or nil (don't sort)." - :group 'erc-nicklist - :type '(choice - (const :tag "Top" 'top) - (const :tag "Bottom" 'bottom) - (const :tag "Mixed" nil))) - -(defcustom erc-nicklist-window-size 20.0 - "*The size of the nicklist window. - -This specifies a percentage of the channel window width. - -A negative value means the nicklist window appears on the left of the -channel window, and vice versa." - :group 'erc-nicklist - :type 'float) - - -(defun erc-nicklist-buffer-name (&optional buffer) - "Return the buffer name for a nicklist associated with BUFFER. - -If BUFFER is nil, use the value of `current-buffer'." - (format " *%s-nicklist*" (buffer-name (or buffer (current-buffer))))) - -(defun erc-nicklist-make-window () - "Create an ERC nicklist window. - -See also `erc-nicklist-window-size'." - (let ((width (floor (* (window-width) (/ erc-nicklist-window-size 100.0)))) - (buffer (erc-nicklist-buffer-name)) - window) - (split-window-horizontally (- width)) - (setq window (next-window)) - (set-window-buffer window (get-buffer-create buffer)) - (with-current-buffer buffer - (set-window-dedicated-p window t)))) - - -(defvar erc-nicklist-images-alist '() - "Alist that maps a connection type to an icon.") - -(defun erc-nicklist-insert-medium-name-or-icon (host channel is-away) - "Inserts an icon or a string identifying the current host type. -This is configured using `erc-nicklist-use-icons' and -`erc-nicklist-icons-directory'." - ;; identify the network (for bitlebee usage): - (let ((bitlbee-p (save-match-data - (string-match "\\`&bitlbee\\b" - (buffer-name channel))))) - (cond ((and bitlbee-p - (string= "login.icq.com" host)) - (if erc-nicklist-use-icons - (if is-away - (insert-image (cdr (assoc 'icq-away - erc-nicklist-images-alist))) - (insert-image (cdr (assoc 'icq - erc-nicklist-images-alist)))) - (insert "ICQ"))) - (bitlbee-p - (if erc-nicklist-use-icons - (if is-away - (insert-image (cdr (assoc 'msn-away - erc-nicklist-images-alist))) - (insert-image (cdr (assoc 'msn - erc-nicklist-images-alist)))) - (insert "MSN"))) - (t - (if erc-nicklist-use-icons - (if is-away - (insert-image (cdr (assoc 'irc-away - erc-nicklist-images-alist))) - (insert-image (cdr (assoc 'irc - erc-nicklist-images-alist)))) - (insert "IRC")))) - (insert " "))) - -(defun erc-nicklist-search-for-nick (finger-host) - "Return the bitlbee-nick field for this contact given FINGER-HOST. -Seach for the BBDB record of this contact. If not found, return nil." - (when (boundp 'erc-bbdb-bitlbee-name-field) - (let ((record (car - (erc-member-if - #'(lambda (r) - (let ((fingers (bbdb-record-finger-host r))) - (when fingers - (string-match finger-host - (car (bbdb-record-finger-host r)))))) - (bbdb-records))))) - (when record - (bbdb-get-field record erc-bbdb-bitlbee-name-field))))) - -(defun erc-nicklist-insert-contents (channel) - "Insert the nicklist contents, with text properties and the optional images." - (setq buffer-read-only nil) - (erase-buffer) - (dolist (u (erc-nicklist-channel-users-info channel)) - (let* ((server-user (car u)) - (channel-user (cdr u)) - (nick (erc-server-user-nickname server-user)) - (host (erc-server-user-host server-user)) - (login (erc-server-user-login server-user)) - (full-name(erc-server-user-full-name server-user)) - (info (erc-server-user-info server-user)) - (channels (erc-server-user-buffers server-user)) - (op (erc-channel-user-op channel-user)) - (voice (erc-channel-user-voice channel-user)) - (bbdb-nick (or (erc-nicklist-search-for-nick - (concat login "@" host)) - "")) - (away-status (if voice "" "\n(Away)")) - (balloon-text (concat bbdb-nick (if (string= "" bbdb-nick) - "" "\n") - "Login: " login "@" host - away-status))) - (erc-nicklist-insert-medium-name-or-icon host channel (not voice)) - (unless (or voice erc-nicklist-use-icons) - (setq nick (concat "(" nick ")"))) - (when op - (setq nick (concat nick " (OP)"))) - (insert (erc-propertize nick - 'erc-nicklist-nick nick - 'mouse-face 'highlight - 'erc-nicklist-channel channel - 'help-echo balloon-text) - "\n"))) - (erc-nicklist-mode)) - - -(defun erc-nicklist () - "Create an ERC nicklist buffer." - (interactive) - (let ((channel (current-buffer))) - (unless (or (not erc-nicklist-use-icons) - erc-nicklist-images-alist) - (setq erc-nicklist-images-alist - `((msn . ,(create-image (concat erc-nicklist-icons-directory - "msn-online.png"))) - (msn-away . ,(create-image (concat erc-nicklist-icons-directory - "msn-offline.png"))) - (irc . ,(create-image (concat erc-nicklist-icons-directory - "irc-online.png"))) - (irc-away . ,(create-image (concat erc-nicklist-icons-directory - "irc-offline.png"))) - (icq . ,(create-image (concat erc-nicklist-icons-directory - "icq-online.png"))) - (icq-away . ,(create-image (concat erc-nicklist-icons-directory - "icq-offline.png")))))) - (erc-nicklist-make-window) - (with-current-buffer (get-buffer (erc-nicklist-buffer-name channel)) - (erc-nicklist-insert-contents channel))) - (add-hook 'erc-channel-members-changed-hook #'erc-nicklist-update)) - -(defun erc-nicklist-update () - "Update the ERC nicklist buffer." - (let ((b (get-buffer (erc-nicklist-buffer-name))) - (channel (current-buffer))) - (when b - (with-current-buffer b - (erc-nicklist-insert-contents channel))))) - -(defvar erc-nicklist-mode-map - (let ((map (make-sparse-keymap))) - (define-key map (kbd "") 'erc-nicklist-menu) - (define-key map "\C-j" 'erc-nicklist-kbd-menu) - (define-key map "q" 'erc-nicklist-quit) - (define-key map (kbd "RET") 'erc-nicklist-kbd-cmd-QUERY) - map) - "Keymap for `erc-nicklist-mode'.") - -(define-derived-mode erc-nicklist-mode fundamental-mode - "Nicklist" - "Major mode for the ERC nicklist buffer." - (setq buffer-read-only t)) - -(defun erc-nicklist-call-erc-command (command point buffer window) - "Call an ERC COMMAND. - -Depending on what COMMAND is, it's called with one of POINT, BUFFER, -or WINDOW as arguments." - (when command - (let* ((p (text-properties-at point)) - (b (plist-get p 'erc-nicklist-channel))) - (if (memq command '(erc-nicklist-quit ignore)) - (funcall command window) - ;; EEEK! Horrble, but it's the only way we can ensure the - ;; response goes to the correct buffer. - (erc-set-active-buffer b) - (switch-to-buffer-other-window b) - (funcall command (plist-get p 'erc-nicklist-nick)))))) - -(defun erc-nicklist-cmd-QUERY (user &optional server) - "Opens a query buffer with USER." - ;; FIXME: find a way to switch to that buffer afterwards... - (let ((send (if server - (format "QUERY %s %s" user server) - (format "QUERY %s" user)))) - (erc-cmd-QUERY user) - t)) - -(defun erc-nicklist-kbd-cmd-QUERY (&optional window) - (interactive) - (let* ((p (text-properties-at (point))) - (server (plist-get p 'erc-nicklist-channel)) - (nick (plist-get p 'erc-nicklist-nick)) - (nick (or (and (string-match "(\\(.*\\))" nick) - (match-string 1 nick)) - nick)) - (nick (or (and (string-match "\\+\\(.*\\)" nick) - (match-string 1 nick)) - nick)) - (send (format "QUERY %s %s" nick server))) - (switch-to-buffer-other-window server) - (erc-cmd-QUERY nick))) - - -(defvar erc-nicklist-menu - (let ((map (make-sparse-keymap "Action"))) - (define-key map [erc-cmd-WHOIS] - '("Whois" . erc-cmd-WHOIS)) - (define-key map [erc-cmd-DEOP] - '("Deop" . erc-cmd-DEOP)) - (define-key map [erc-cmd-MSG] - '("Message" . erc-cmd-MSG)) ;; TODO! - (define-key map [erc-nicklist-cmd-QUERY] - '("Query" . erc-nicklist-kbd-cmd-QUERY)) - (define-key map [ignore] - '("Cancel" . ignore)) - (define-key map [erc-nicklist-quit] - '("Close nicklist" . erc-nicklist-quit)) - map) - "Menu keymap for the ERC nicklist.") - -(defun erc-nicklist-quit (&optional window) - "Delete the ERC nicklist. - -Deletes WINDOW and stops updating the nicklist buffer." - (interactive) - (let ((b (window-buffer window))) - (with-current-buffer b - (set-buffer-modified-p nil) - (kill-this-buffer) - (remove-hook 'erc-channel-members-changed-hook 'erc-nicklist-update)))) - - -(defun erc-nicklist-kbd-menu () - "Show the ERC nicklist menu." - (interactive) - (let* ((point (point)) - (window (selected-window)) - (buffer (current-buffer))) - (with-current-buffer buffer - (erc-nicklist-call-erc-command - (car (x-popup-menu point - erc-nicklist-menu)) - point - buffer - window)))) - -(defun erc-nicklist-menu (&optional arg) - "Show the ERC nicklist menu. - -ARG is a parametrized event (see `interactive')." - (interactive "e") - (let* ((point (nth 1 (cadr arg))) - (window (car (cadr arg))) - (buffer (window-buffer window))) - (with-current-buffer buffer - (erc-nicklist-call-erc-command - (car (x-popup-menu arg - erc-nicklist-menu)) - point - buffer - window)))) - - -(defun erc-nicklist-channel-users-info (channel) - "Return a nick-sorted list of all users on CHANNEL. -Result are elements in the form (SERVER-USER . CHANNEL-USER). The -list has all the voiced users according to -`erc-nicklist-voiced-position'." - (let* ((nicks (erc-sort-channel-users-alphabetically - (with-current-buffer channel (erc-get-channel-user-list))))) - (if erc-nicklist-voiced-position - (let ((voiced-nicks (erc-remove-if-not - #'(lambda (x) - (null (erc-channel-user-voice (cdr x)))) - nicks)) - (devoiced-nicks (erc-remove-if-not - #'(lambda (x) - (erc-channel-user-voice - (cdr x))) - nicks))) - (cond ((eq erc-nicklist-voiced-position 'top) - (append devoiced-nicks voiced-nicks)) - ((eq erc-nicklist-voiced-position 'bottom) - (append voiced-nicks devoiced-nicks)))) - nicks))) - - - -(provide 'erc-nicklist) - -;;; erc-nicklist.el ends here -;; -;; Local Variables: -;; indent-tabs-mode: t -;; tab-width: 8 -;; coding: utf-8 -;; End: - -;; arch-tag: db37a256-87a7-4544-bd90-e5f16c9f5ca5 From 8f069875eb386abee5463cffd35fffe78a5e2049 Mon Sep 17 00:00:00 2001 From: Miles Bader Date: Mon, 30 Jul 2007 05:36:46 +0000 Subject: [PATCH 2/9] Update some .arch-inventory files Revision: emacs@sv.gnu.org/emacs--rel--22--patch-77 Creator: Michael Olson --- lib-src/.arch-inventory | 2 +- lisp/emacs-lisp/.arch-inventory | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) create mode 100644 lisp/emacs-lisp/.arch-inventory diff --git a/lib-src/.arch-inventory b/lib-src/.arch-inventory index 362f3aebf63..1b0b3aec45a 100644 --- a/lib-src/.arch-inventory +++ b/lib-src/.arch-inventory @@ -1,5 +1,5 @@ # Ignore binaries -backup ^(test-distrib|make-docfile|profile|digest-doc|movemail|cvtmail|fakemail|yow|emacsserver|hexl|update-game-score|etags|ctags|emacsclient|b2m|ebrowse|sorted-doc)$ +backup ^(test-distrib|make-docfile|profile|digest-doc|movemail|cvtmail|fakemail|blessmail|yow|emacsserver|hexl|update-game-score|etags|ctags|emacsclient|b2m|ebrowse|sorted-doc)$ # Building actually makes a copy/link of the source file precious ^(ctags\.c)$ diff --git a/lisp/emacs-lisp/.arch-inventory b/lisp/emacs-lisp/.arch-inventory new file mode 100644 index 00000000000..328861b72fc --- /dev/null +++ b/lisp/emacs-lisp/.arch-inventory @@ -0,0 +1,4 @@ +# Auto-generated lisp files, which we ignore +precious ^(cl-loaddefs)\.el$ + +# arch-tag: d6986671-2713-4fed-ae51-7758ae0d4c10 From 791869eb88a410f5cb8a176c081e7a675a7f2c5e Mon Sep 17 00:00:00 2001 From: Dan Nicolaescu Date: Mon, 30 Jul 2007 17:12:10 +0000 Subject: [PATCH 3/9] * vc-hg.el (vc-hg-registered): Set the vc-state property. --- lisp/ChangeLog | 1 + lisp/vc-hg.el | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/lisp/ChangeLog b/lisp/ChangeLog index dfa662b791c..4d5f051cf33 100644 --- a/lisp/ChangeLog +++ b/lisp/ChangeLog @@ -9,6 +9,7 @@ * vc.el (vc-directory-exclusion-list): Add .git and .hg. * vc-hg.el (vc-hg-revision-completion-table): Re-enable. + (vc-hg-registered): Set the vc-state property. * diff-mode.el (diff-mode-menu): New entries. diff --git a/lisp/vc-hg.el b/lisp/vc-hg.el index 972adeed675..c9a69a7e5ea 100644 --- a/lisp/vc-hg.el +++ b/lisp/vc-hg.el @@ -138,7 +138,7 @@ (defun vc-hg-registered (file) "Return non-nil if FILE is registered with hg." (when (vc-hg-root file) ; short cut - (vc-hg-state file))) ; expensive + (vc-file-setprop file 'vc-state (vc-hg-state file)))) ; expensive (defun vc-hg-state (file) "Hg-specific version of `vc-state'." From f8d25b6d2c679fc9a3ec13d720944ddfee8daf48 Mon Sep 17 00:00:00 2001 From: "Richard M. Stallman" Date: Mon, 30 Jul 2007 19:48:16 +0000 Subject: [PATCH 4/9] *** empty log message *** --- admin/FOR-RELEASE | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/admin/FOR-RELEASE b/admin/FOR-RELEASE index 0f8bd0c4420..8c0eca3fb47 100644 --- a/admin/FOR-RELEASE +++ b/admin/FOR-RELEASE @@ -36,6 +36,10 @@ to the hack introduced on 2005-07-01 to fix some other Cleartype problem. * BUGS +** davby@ida.liu.se, 6 July: Bug in pos-visible-in-window-p + +** dak@gnu.org, 30 May: Redraw problem with overlapping frames + * FIXES FOR EMACS 22.2 Here we list small fixes that arrived too late for Emacs 22.1, but @@ -43,8 +47,6 @@ that should be installed on the release branch after 22.1 is released. ** viper should not load cl at run time. -** yamaoka@jpl.org's patch for mail-extract-address-components problem. - * DOCUMENTATION ** Check the Emacs Tutorial. From 982240c54bdde2e9baa40d07c31f923d22bed0f0 Mon Sep 17 00:00:00 2001 From: "Richard M. Stallman" Date: Mon, 30 Jul 2007 20:10:53 +0000 Subject: [PATCH 5/9] *** empty log message *** --- admin/FOR-RELEASE | 2 ++ 1 file changed, 2 insertions(+) diff --git a/admin/FOR-RELEASE b/admin/FOR-RELEASE index 8c0eca3fb47..51da5c9b735 100644 --- a/admin/FOR-RELEASE +++ b/admin/FOR-RELEASE @@ -40,6 +40,8 @@ to the hack introduced on 2005-07-01 to fix some other Cleartype problem. ** dak@gnu.org, 30 May: Redraw problem with overlapping frames +** dksw@eircom.net, 3 Jul: Telnet mode (rsh/ssh) + * FIXES FOR EMACS 22.2 Here we list small fixes that arrived too late for Emacs 22.1, but From 183e368a055a9084d6ad9d5f78fd4aadf3083ea5 Mon Sep 17 00:00:00 2001 From: "Richard M. Stallman" Date: Tue, 31 Jul 2007 04:14:07 +0000 Subject: [PATCH 6/9] *** empty log message *** --- admin/FOR-RELEASE | 2 -- 1 file changed, 2 deletions(-) diff --git a/admin/FOR-RELEASE b/admin/FOR-RELEASE index 51da5c9b735..c707ac7a754 100644 --- a/admin/FOR-RELEASE +++ b/admin/FOR-RELEASE @@ -47,8 +47,6 @@ to the hack introduced on 2005-07-01 to fix some other Cleartype problem. Here we list small fixes that arrived too late for Emacs 22.1, but that should be installed on the release branch after 22.1 is released. -** viper should not load cl at run time. - * DOCUMENTATION ** Check the Emacs Tutorial. From fa4488bd964cc3e3b9cee8c83b2d7834bd1cf611 Mon Sep 17 00:00:00 2001 From: Miles Bader Date: Tue, 31 Jul 2007 04:20:12 +0000 Subject: [PATCH 7/9] Changes from arch/CVS synchronization --- lisp/ChangeLog | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lisp/ChangeLog b/lisp/ChangeLog index 4d5f051cf33..78d0aca39f0 100644 --- a/lisp/ChangeLog +++ b/lisp/ChangeLog @@ -3,7 +3,7 @@ * vc-git.el: (vc-directory-exclusion-list, vc-handled-backends): Remove. (vc-git-revision-completion-table): Enable. - + * vc-hooks.el (vc-handled-backends): Add GIT and HG. * vc.el (vc-directory-exclusion-list): Add .git and .hg. From 2f62a04420ba8990a8f5372329ee63b82d8b6a51 Mon Sep 17 00:00:00 2001 From: Miles Bader Date: Tue, 31 Jul 2007 05:04:20 +0000 Subject: [PATCH 8/9] Merge from gnus--rel--5.10 Patches applied: * emacs--devo--0 (patch 806, 811-812, 823) - Merge from emacs--rel--22 - Update from CVS * gnus--rel--5.10 (patch 239-241) - Merge from emacs--devo--0 - Update from CVS 2007-07-24 Katsumi Yamaoka * lisp/gnus/gnus-msg.el (gnus-summary-supersede-article) (gnus-summary-resend-message-edit): Add Gcc header. (gnus-summary-resend-bounced-mail): Ditto; search whole body for parent article's Message-ID; refer parent article in summary buffer. * lisp/gnus/message.el (message-bounce): Call mime-to-mml. 2007-07-14 David Kastrup * lisp/gnus/gnus-art.el (gnus-mime-delete-part): Don't go through article-edit finishing actions if we did not edit the article. Revision: emacs@sv.gnu.org/emacs--rel--22--patch-82 --- lisp/gnus/ChangeLog | 14 ++++++++++++++ lisp/gnus/gnus-art.el | 10 +++++----- lisp/gnus/gnus-msg.el | 38 +++++++++++++++++++++++++++++--------- lisp/gnus/message.el | 2 +- man/emacs-mime.texi | 1 + 5 files changed, 50 insertions(+), 15 deletions(-) diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog index a39d64994b0..83ca62ca0de 100644 --- a/lisp/gnus/ChangeLog +++ b/lisp/gnus/ChangeLog @@ -2,6 +2,15 @@ * Relicense all FSF files to GPLv3 or later. +2007-07-24 Katsumi Yamaoka + + * gnus-msg.el (gnus-summary-supersede-article) + (gnus-summary-resend-message-edit): Add Gcc header. + (gnus-summary-resend-bounced-mail): Ditto; search whole body for parent + article's Message-ID; refer parent article in summary buffer. + + * message.el (message-bounce): Call mime-to-mml. + 2007-07-21 Reiner Steib * mm-uu.el (mm-uu-type-alist): Refer to mm-uu-configure-list in doc @@ -11,6 +20,11 @@ * gnus-srvr.el (gnus-server-font-lock-keywords): Quote faces. +2007-07-14 David Kastrup + + * gnus-art.el (gnus-mime-delete-part): Don't go through article-edit + finishing actions if we did not edit the article. + 2007-07-13 Katsumi Yamaoka * gnus-srvr.el (gnus-server-agent-face, gnus-server-opened-face) diff --git a/lisp/gnus/gnus-art.el b/lisp/gnus/gnus-art.el index 2d5672ff78a..40de10187f3 100644 --- a/lisp/gnus/gnus-art.el +++ b/lisp/gnus/gnus-art.el @@ -4408,11 +4408,11 @@ Deleting parts may malfunction or destroy the article; continue? ") (gnus-summary-edit-article-done ,(or (mail-header-references gnus-current-headers) "") ,(gnus-group-read-only-p) - ,gnus-summary-buffer no-highlight))))) - ;; Not in `gnus-mime-save-part-and-strip': - (gnus-article-edit-done) - (gnus-summary-expand-window) - (gnus-summary-show-article)) + ,gnus-summary-buffer no-highlight)))) + ;; Not in `gnus-mime-save-part-and-strip': + (gnus-article-edit-done) + (gnus-summary-expand-window) + (gnus-summary-show-article))) (defun gnus-mime-save-part () "Save the MIME part under point." diff --git a/lisp/gnus/gnus-msg.el b/lisp/gnus/gnus-msg.el index 0789e25bc68..c9aedab7019 100644 --- a/lisp/gnus/gnus-msg.el +++ b/lisp/gnus/gnus-msg.el @@ -815,7 +815,10 @@ header line with the old Message-ID." (set-buffer ,gnus-summary-buffer) (gnus-cache-possibly-remove-article ,article nil nil nil t) (gnus-summary-mark-as-read ,article gnus-canceled-mark))))) - message-send-actions)))) + message-send-actions) + ;; Add Gcc header. + (gnus-inews-insert-archive-gcc) + (gnus-inews-insert-gcc)))) @@ -1280,10 +1283,13 @@ composing a new message." (message-narrow-to-head-1) ;; Gnus will generate a new one when sending. (message-remove-header "Message-ID") - (message-remove-header message-ignored-resent-headers t) ;; Remove unwanted headers. + (message-remove-header message-ignored-resent-headers t) (goto-char (point-max)) (insert mail-header-separator) + ;; Add Gcc header. + (gnus-inews-insert-archive-gcc) + (gnus-inews-insert-gcc) (goto-char (point-min)) (when (re-search-forward "^To:\\|^Newsgroups:" nil 'move) (forward-char 1)) @@ -1557,15 +1563,29 @@ If FETCH, try to fetch the article that this is a reply to, if indeed this is a reply." (interactive "P") (gnus-summary-select-article t) - (set-buffer gnus-original-article-buffer) - (gnus-setup-message 'compose-bounce - (let* ((references (mail-fetch-field "references")) - (parent (and references (gnus-parent-id references)))) + (let (summary-buffer parent) + (if fetch + (progn + (setq summary-buffer (current-buffer)) + (set-buffer gnus-original-article-buffer) + (article-goto-body) + (when (re-search-forward "^References:\n?" nil t) + (while (memq (char-after) '(?\t ? )) + (forward-line 1)) + (skip-chars-backward "\t\n ") + (setq parent + (gnus-parent-id (buffer-substring (match-end 0) (point)))))) + (set-buffer gnus-original-article-buffer)) + (gnus-setup-message 'compose-bounce (message-bounce) + ;; Add Gcc header. + (gnus-inews-insert-archive-gcc) + (gnus-inews-insert-gcc) ;; If there are references, we fetch the article we answered to. - (and fetch parent - (gnus-summary-refer-article parent) - (gnus-summary-show-all-headers))))) + (when parent + (with-current-buffer summary-buffer + (gnus-summary-refer-article parent) + (gnus-summary-show-all-headers)))))) ;;; Gcc handling. diff --git a/lisp/gnus/message.el b/lisp/gnus/message.el index b98c4eb5366..419fd07727c 100644 --- a/lisp/gnus/message.el +++ b/lisp/gnus/message.el @@ -6697,7 +6697,7 @@ you." (goto-char boundary) (when (re-search-backward "^.?From .*\n" nil t) (delete-region (match-beginning 0) (match-end 0))))) - (mm-enable-multibyte) + (mime-to-mml) (save-restriction (message-narrow-to-head-1) (message-remove-header message-ignored-bounced-headers t) diff --git a/man/emacs-mime.texi b/man/emacs-mime.texi index 5cf17e7d54b..0f3c141c792 100644 --- a/man/emacs-mime.texi +++ b/man/emacs-mime.texi @@ -32,6 +32,7 @@ license to the document, as described in section 6 of the license. @end quotation @end copying +@c Node ``Interface Functions'' uses Latin-1 characters @documentencoding ISO-8859-1 @dircategory Emacs From bd53d37c664e18c3417da079de4bb999533886af Mon Sep 17 00:00:00 2001 From: Miles Bader Date: Tue, 31 Jul 2007 05:04:29 +0000 Subject: [PATCH 9/9] Restore lisp/emacs-lisp/cl-loaddefs.el ... and remove lisp/emacs-lisp/.arch-inventory Revision: emacs@sv.gnu.org/emacs--rel--22--patch-83 --- lisp/emacs-lisp/.arch-inventory | 4 - lisp/emacs-lisp/cl-loaddefs.el | 1234 +++++++++++++++++++++++++++++++ 2 files changed, 1234 insertions(+), 4 deletions(-) delete mode 100644 lisp/emacs-lisp/.arch-inventory create mode 100644 lisp/emacs-lisp/cl-loaddefs.el diff --git a/lisp/emacs-lisp/.arch-inventory b/lisp/emacs-lisp/.arch-inventory deleted file mode 100644 index 328861b72fc..00000000000 --- a/lisp/emacs-lisp/.arch-inventory +++ /dev/null @@ -1,4 +0,0 @@ -# Auto-generated lisp files, which we ignore -precious ^(cl-loaddefs)\.el$ - -# arch-tag: d6986671-2713-4fed-ae51-7758ae0d4c10 diff --git a/lisp/emacs-lisp/cl-loaddefs.el b/lisp/emacs-lisp/cl-loaddefs.el new file mode 100644 index 00000000000..1589e19cbb2 --- /dev/null +++ b/lisp/emacs-lisp/cl-loaddefs.el @@ -0,0 +1,1234 @@ +;;; cl-loaddefs.el --- automatically extracted autoloads +;; +;;; Code: + + +;;;### (autoloads (cl-prettyexpand cl-macroexpand-all cl-remprop +;;;;;; cl-do-remf cl-set-getf getf get* tailp list-length nreconc +;;;;;; revappend concatenate subseq cl-float-limits random-state-p +;;;;;; make-random-state random* signum rem* mod* round* truncate* +;;;;;; ceiling* floor* isqrt lcm gcd cl-progv-before cl-set-frame-visible-p +;;;;;; cl-map-overlays cl-map-intervals cl-map-keymap-recursively +;;;;;; notevery notany every some mapcon mapcan mapl maplist map +;;;;;; cl-mapcar-many equalp coerce) "cl-extra" "cl-extra.el" "47c92504dda976a632c2c10bedd4b6a4") +;;; Generated autoloads from cl-extra.el + +(autoload (quote coerce) "cl-extra" "\ +Coerce OBJECT to type TYPE. +TYPE is a Common Lisp type specifier. + +\(fn OBJECT TYPE)" nil nil) + +(autoload (quote equalp) "cl-extra" "\ +Return 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. + +\(fn X Y)" nil nil) + +(autoload (quote cl-mapcar-many) "cl-extra" "\ +Not documented + +\(fn CL-FUNC CL-SEQS)" nil nil) + +(autoload (quote map) "cl-extra" "\ +Map a FUNCTION across one or more SEQUENCEs, returning a sequence. +TYPE is the sequence type to return. + +\(fn TYPE FUNCTION SEQUENCE...)" nil nil) + +(autoload (quote maplist) "cl-extra" "\ +Map FUNCTION to each sublist of LIST or LISTs. +Like `mapcar', except applies to lists and their cdr's rather than to +the elements themselves. + +\(fn FUNCTION LIST...)" nil nil) + +(autoload (quote mapl) "cl-extra" "\ +Like `maplist', but does not accumulate values returned by the function. + +\(fn FUNCTION LIST...)" nil nil) + +(autoload (quote mapcan) "cl-extra" "\ +Like `mapcar', but nconc's together the values returned by the function. + +\(fn FUNCTION SEQUENCE...)" nil nil) + +(autoload (quote mapcon) "cl-extra" "\ +Like `maplist', but nconc's together the values returned by the function. + +\(fn FUNCTION LIST...)" nil nil) + +(autoload (quote 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. + +\(fn PREDICATE SEQ...)" nil nil) + +(autoload (quote every) "cl-extra" "\ +Return true if PREDICATE is true of every element of SEQ or SEQs. + +\(fn PREDICATE SEQ...)" nil nil) + +(autoload (quote notany) "cl-extra" "\ +Return true if PREDICATE is false of every element of SEQ or SEQs. + +\(fn PREDICATE SEQ...)" nil nil) + +(autoload (quote notevery) "cl-extra" "\ +Return true if PREDICATE is false of some element of SEQ or SEQs. + +\(fn PREDICATE SEQ...)" nil nil) + +(defalias (quote cl-map-keymap) (quote map-keymap)) + +(autoload (quote cl-map-keymap-recursively) "cl-extra" "\ +Not documented + +\(fn CL-FUNC-REC CL-MAP &optional CL-BASE)" nil nil) + +(autoload (quote cl-map-intervals) "cl-extra" "\ +Not documented + +\(fn CL-FUNC &optional CL-WHAT CL-PROP CL-START CL-END)" nil nil) + +(autoload (quote cl-map-overlays) "cl-extra" "\ +Not documented + +\(fn CL-FUNC &optional CL-BUFFER CL-START CL-END CL-ARG)" nil nil) + +(autoload (quote cl-set-frame-visible-p) "cl-extra" "\ +Not documented + +\(fn FRAME VAL)" nil nil) + +(autoload (quote cl-progv-before) "cl-extra" "\ +Not documented + +\(fn SYMS VALUES)" nil nil) + +(autoload (quote gcd) "cl-extra" "\ +Return the greatest common divisor of the arguments. + +\(fn &rest ARGS)" nil nil) + +(autoload (quote lcm) "cl-extra" "\ +Return the least common multiple of the arguments. + +\(fn &rest ARGS)" nil nil) + +(autoload (quote isqrt) "cl-extra" "\ +Return the integer square root of the argument. + +\(fn X)" nil nil) + +(autoload (quote 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. + +\(fn X &optional Y)" nil nil) + +(autoload (quote 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. + +\(fn X &optional Y)" nil nil) + +(autoload (quote 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. + +\(fn X &optional Y)" nil nil) + +(autoload (quote 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. + +\(fn X &optional Y)" nil nil) + +(autoload (quote mod*) "cl-extra" "\ +The remainder of X divided by Y, with the same sign as Y. + +\(fn X Y)" nil nil) + +(autoload (quote rem*) "cl-extra" "\ +The remainder of X divided by Y, with the same sign as X. + +\(fn X Y)" nil nil) + +(autoload (quote signum) "cl-extra" "\ +Return 1 if X is positive, -1 if negative, 0 if zero. + +\(fn X)" nil nil) + +(autoload (quote random*) "cl-extra" "\ +Return a random nonnegative number less than LIM, an integer or float. +Optional second arg STATE is a random-state object. + +\(fn LIM &optional STATE)" nil nil) + +(autoload (quote 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. + +\(fn &optional STATE)" nil nil) + +(autoload (quote random-state-p) "cl-extra" "\ +Return t if OBJECT is a random-state object. + +\(fn OBJECT)" nil nil) + +(autoload (quote cl-float-limits) "cl-extra" "\ +Not documented + +\(fn)" nil nil) + +(autoload (quote subseq) "cl-extra" "\ +Return the subsequence of SEQ from START to END. +If END is omitted, it defaults to the length of the sequence. +If START or END is negative, it counts from the end. + +\(fn SEQ START &optional END)" nil nil) + +(autoload (quote concatenate) "cl-extra" "\ +Concatenate, into a sequence of type TYPE, the argument SEQUENCEs. + +\(fn TYPE SEQUENCE...)" nil nil) + +(autoload (quote revappend) "cl-extra" "\ +Equivalent to (append (reverse X) Y). + +\(fn X Y)" nil nil) + +(autoload (quote nreconc) "cl-extra" "\ +Equivalent to (nconc (nreverse X) Y). + +\(fn X Y)" nil nil) + +(autoload (quote list-length) "cl-extra" "\ +Return the length of list X. Return nil if list is circular. + +\(fn X)" nil nil) + +(autoload (quote tailp) "cl-extra" "\ +Return true if SUBLIST is a tail of LIST. + +\(fn SUBLIST LIST)" nil nil) + +(autoload (quote get*) "cl-extra" "\ +Return the value of SYMBOL's PROPNAME property, or DEFAULT if none. + +\(fn SYMBOL PROPNAME &optional DEFAULT)" nil nil) + +(autoload (quote getf) "cl-extra" "\ +Search PROPLIST for property PROPNAME; return its value or DEFAULT. +PROPLIST is a list of the sort returned by `symbol-plist'. + +\(fn PROPLIST PROPNAME &optional DEFAULT)" nil nil) + +(autoload (quote cl-set-getf) "cl-extra" "\ +Not documented + +\(fn PLIST TAG VAL)" nil nil) + +(autoload (quote cl-do-remf) "cl-extra" "\ +Not documented + +\(fn PLIST TAG)" nil nil) + +(autoload (quote cl-remprop) "cl-extra" "\ +Remove from SYMBOL's plist the property PROPNAME and its value. + +\(fn SYMBOL PROPNAME)" nil nil) + +(defalias (quote remprop) (quote cl-remprop)) + +(defalias (quote cl-gethash) (quote gethash)) + +(defalias (quote cl-puthash) (quote puthash)) + +(defalias (quote cl-remhash) (quote remhash)) + +(defalias (quote cl-clrhash) (quote clrhash)) + +(defalias (quote cl-maphash) (quote maphash)) + +(defalias (quote cl-make-hash-table) (quote make-hash-table)) + +(defalias (quote cl-hash-table-p) (quote hash-table-p)) + +(defalias (quote cl-hash-table-count) (quote hash-table-count)) + +(autoload (quote cl-macroexpand-all) "cl-extra" "\ +Expand all macro calls through a Lisp FORM. +This also does some trivial optimizations to make the form prettier. + +\(fn FORM &optional ENV)" nil nil) + +(autoload (quote cl-prettyexpand) "cl-extra" "\ +Not documented + +\(fn FORM &optional FULL)" nil nil) + +;;;*** + +;;;### (autoloads (compiler-macroexpand define-compiler-macro ignore-errors +;;;;;; assert check-type typep cl-struct-setf-expander defstruct +;;;;;; define-modify-macro callf2 callf letf* letf rotatef shiftf +;;;;;; remf cl-do-pop psetf setf get-setf-method defsetf define-setf-method +;;;;;; declare the locally multiple-value-setq multiple-value-bind +;;;;;; lexical-let* lexical-let symbol-macrolet macrolet labels +;;;;;; flet progv psetq do-all-symbols do-symbols dotimes dolist +;;;;;; do* do loop return-from return block etypecase typecase ecase +;;;;;; case load-time-value eval-when destructuring-bind function* +;;;;;; defmacro* defun* gentemp gensym cl-compile-time-init) "cl-macs" +;;;;;; "cl-macs.el" "7ccc827d272482ca276937ca18a7895a") +;;; Generated autoloads from cl-macs.el + +(autoload (quote cl-compile-time-init) "cl-macs" "\ +Not documented + +\(fn)" nil nil) + +(autoload (quote gensym) "cl-macs" "\ +Generate a new uninterned symbol. +The name is made by appending a number to PREFIX, default \"G\". + +\(fn &optional PREFIX)" nil nil) + +(autoload (quote gentemp) "cl-macs" "\ +Generate a new interned symbol with a unique name. +The name is made by appending a number to PREFIX, default \"G\". + +\(fn &optional PREFIX)" nil nil) + +(autoload (quote defun*) "cl-macs" "\ +Define NAME as a function. +Like normal `defun', except ARGLIST allows full Common Lisp conventions, +and BODY is implicitly surrounded by (block NAME ...). + +\(fn NAME ARGLIST [DOCSTRING] BODY...)" nil (quote macro)) + +(autoload (quote defmacro*) "cl-macs" "\ +Define NAME as a macro. +Like normal `defmacro', except ARGLIST allows full Common Lisp conventions, +and BODY is implicitly surrounded by (block NAME ...). + +\(fn NAME ARGLIST [DOCSTRING] BODY...)" nil (quote macro)) + +(autoload (quote function*) "cl-macs" "\ +Introduce a function. +Like normal `function', except that if argument is a lambda form, +its argument list allows full Common Lisp conventions. + +\(fn FUNC)" nil (quote macro)) + +(autoload (quote destructuring-bind) "cl-macs" "\ +Not documented + +\(fn ARGS EXPR &rest BODY)" nil (quote macro)) + +(autoload (quote eval-when) "cl-macs" "\ +Control when BODY is evaluated. +If `compile' is in WHEN, BODY is evaluated when compiled at top-level. +If `load' is in WHEN, BODY is evaluated when loaded after top-level compile. +If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level. + +\(fn (WHEN...) BODY...)" nil (quote macro)) + +(autoload (quote load-time-value) "cl-macs" "\ +Like `progn', but evaluates the body at load time. +The result of the body appears to the compiler as a quoted constant. + +\(fn FORM &optional READ-ONLY)" nil (quote macro)) + +(autoload (quote case) "cl-macs" "\ +Eval EXPR and choose among clauses on that value. +Each clause looks like (KEYLIST BODY...). EXPR is evaluated and compared +against each key in each KEYLIST; the corresponding BODY is evaluated. +If no clause succeeds, case returns nil. A single atom may be used in +place of a KEYLIST of one atom. A KEYLIST of t or `otherwise' is +allowed only in the final clause, and matches if no other keys match. +Key values are compared by `eql'. + +\(fn EXPR (KEYLIST BODY...)...)" nil (quote macro)) + +(autoload (quote ecase) "cl-macs" "\ +Like `case', but error if no case fits. +`otherwise'-clauses are not allowed. + +\(fn EXPR (KEYLIST BODY...)...)" nil (quote macro)) + +(autoload (quote typecase) "cl-macs" "\ +Evals EXPR, chooses among clauses on that value. +Each clause looks like (TYPE BODY...). EXPR is evaluated and, if it +satisfies TYPE, the corresponding BODY is evaluated. If no clause succeeds, +typecase returns nil. A TYPE of t or `otherwise' is allowed only in the +final clause, and matches if no other keys match. + +\(fn EXPR (TYPE BODY...)...)" nil (quote macro)) + +(autoload (quote etypecase) "cl-macs" "\ +Like `typecase', but error if no case fits. +`otherwise'-clauses are not allowed. + +\(fn EXPR (TYPE BODY...)...)" nil (quote macro)) + +(autoload (quote block) "cl-macs" "\ +Define a lexically-scoped block named NAME. +NAME may be any symbol. Code inside the BODY forms can call `return-from' +to jump prematurely out of the block. This differs from `catch' and `throw' +in two respects: First, the NAME is an unevaluated symbol rather than a +quoted symbol or other form; and second, NAME is lexically rather than +dynamically scoped: Only references to it within BODY will work. These +references may appear inside macro expansions, but not inside functions +called from BODY. + +\(fn NAME &rest BODY)" nil (quote macro)) + +(autoload (quote return) "cl-macs" "\ +Return from the block named nil. +This is equivalent to `(return-from nil RESULT)'. + +\(fn &optional RESULT)" nil (quote macro)) + +(autoload (quote return-from) "cl-macs" "\ +Return from the block named NAME. +This jump out to the innermost enclosing `(block NAME ...)' form, +returning RESULT from that form (or nil if RESULT is omitted). +This is compatible with Common Lisp, but note that `defun' and +`defmacro' do not create implicit blocks as they do in Common Lisp. + +\(fn NAME &optional RESULT)" nil (quote macro)) + +(autoload (quote loop) "cl-macs" "\ +The Common Lisp `loop' macro. +Valid clauses are: + for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM, + for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR, + for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND, + always COND, never COND, thereis COND, collect EXPR into VAR, + append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR, + count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR, + if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...], + unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...], + do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR, + finally return EXPR, named NAME. + +\(fn CLAUSE...)" nil (quote macro)) + +(autoload (quote do) "cl-macs" "\ +The Common Lisp `do' loop. + +\(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil (quote macro)) + +(autoload (quote do*) "cl-macs" "\ +The Common Lisp `do*' loop. + +\(fn ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil (quote macro)) + +(autoload (quote dolist) "cl-macs" "\ +Loop over a list. +Evaluate BODY with VAR bound to each `car' from LIST, in turn. +Then evaluate RESULT to get return value, default nil. + +\(fn (VAR LIST [RESULT]) BODY...)" nil (quote macro)) + +(autoload (quote dotimes) "cl-macs" "\ +Loop a certain number of times. +Evaluate BODY with VAR bound to successive integers from 0, inclusive, +to COUNT, exclusive. Then evaluate RESULT to get return value, default +nil. + +\(fn (VAR COUNT [RESULT]) BODY...)" nil (quote macro)) + +(autoload (quote do-symbols) "cl-macs" "\ +Loop over all symbols. +Evaluate BODY with VAR bound to each interned symbol, or to each symbol +from OBARRAY. + +\(fn (VAR [OBARRAY [RESULT]]) BODY...)" nil (quote macro)) + +(autoload (quote do-all-symbols) "cl-macs" "\ +Not documented + +\(fn SPEC &rest BODY)" nil (quote macro)) + +(autoload (quote psetq) "cl-macs" "\ +Set SYMs to the values VALs in parallel. +This is like `setq', except that all VAL forms are evaluated (in order) +before assigning any symbols SYM to the corresponding values. + +\(fn SYM VAL SYM VAL ...)" nil (quote macro)) + +(autoload (quote progv) "cl-macs" "\ +Bind SYMBOLS to VALUES dynamically in BODY. +The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists. +Each symbol in the first list is bound to the corresponding value in the +second list (or made unbound if VALUES is shorter than SYMBOLS); then the +BODY forms are executed and their result is returned. This is much like +a `let' form, except that the list of symbols can be computed at run-time. + +\(fn SYMBOLS VALUES &rest BODY)" nil (quote macro)) + +(autoload (quote flet) "cl-macs" "\ +Make temporary function definitions. +This is an analogue of `let' that operates on the function cell of FUNC +rather than its value cell. The FORMs are evaluated with the specified +function definitions in place, then the definitions are undone (the FUNCs +go back to their previous definitions, or lack thereof). + +\(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil (quote macro)) + +(autoload (quote labels) "cl-macs" "\ +Make temporary function bindings. +This is like `flet', except the bindings are lexical instead of dynamic. +Unlike `flet', this macro is fully compliant with the Common Lisp standard. + +\(fn ((FUNC ARGLIST BODY...) ...) FORM...)" nil (quote macro)) + +(autoload (quote macrolet) "cl-macs" "\ +Make temporary macro definitions. +This is like `flet', but for macros instead of functions. + +\(fn ((NAME ARGLIST BODY...) ...) FORM...)" nil (quote macro)) + +(autoload (quote symbol-macrolet) "cl-macs" "\ +Make symbol macro definitions. +Within the body FORMs, references to the variable NAME will be replaced +by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...). + +\(fn ((NAME EXPANSION) ...) FORM...)" nil (quote macro)) + +(autoload (quote lexical-let) "cl-macs" "\ +Like `let', but lexically scoped. +The main visible difference is that lambdas inside BODY will create +lexical closures as in Common Lisp. + +\(fn VARLIST BODY)" nil (quote macro)) + +(autoload (quote lexical-let*) "cl-macs" "\ +Like `let*', but lexically scoped. +The main visible difference is that lambdas inside BODY will create +lexical closures as in Common Lisp. + +\(fn VARLIST BODY)" nil (quote macro)) + +(autoload (quote multiple-value-bind) "cl-macs" "\ +Collect multiple return values. +FORM must return a list; the BODY is then executed with the first N elements +of this list bound (`let'-style) to each of the symbols SYM in turn. This +is analogous to the Common Lisp `multiple-value-bind' macro, using lists to +simulate true multiple return values. For compatibility, (values A B C) is +a synonym for (list A B C). + +\(fn (SYM...) FORM BODY)" nil (quote macro)) + +(autoload (quote multiple-value-setq) "cl-macs" "\ +Collect multiple return values. +FORM must return a list; the first N elements of this list are stored in +each of the symbols SYM in turn. This is analogous to the Common Lisp +`multiple-value-setq' macro, using lists to simulate true multiple return +values. For compatibility, (values A B C) is a synonym for (list A B C). + +\(fn (SYM...) FORM)" nil (quote macro)) + +(autoload (quote locally) "cl-macs" "\ +Not documented + +\(fn &rest BODY)" nil (quote macro)) + +(autoload (quote the) "cl-macs" "\ +Not documented + +\(fn TYPE FORM)" nil (quote macro)) + +(autoload (quote declare) "cl-macs" "\ +Not documented + +\(fn &rest SPECS)" nil (quote macro)) + +(autoload (quote define-setf-method) "cl-macs" "\ +Define a `setf' method. +This method shows how to handle `setf's to places of the form (NAME ARGS...). +The argument forms ARGS are bound according to ARGLIST, as if NAME were +going to be expanded as a macro, then the BODY forms are executed and must +return a list of five elements: a temporary-variables list, a value-forms +list, a store-variables list (of length one), a store-form, and an access- +form. See `defsetf' for a simpler way to define most setf-methods. + +\(fn NAME ARGLIST BODY...)" nil (quote macro)) + +(autoload (quote defsetf) "cl-macs" "\ +Define a `setf' method. +This macro is an easy-to-use substitute for `define-setf-method' that works +well for simple place forms. In the simple `defsetf' form, `setf's of +the form (setf (NAME ARGS...) VAL) are transformed to function or macro +calls of the form (FUNC ARGS... VAL). Example: + + (defsetf aref aset) + +Alternate form: (defsetf NAME ARGLIST (STORE) BODY...). +Here, the above `setf' call is expanded by binding the argument forms ARGS +according to ARGLIST, binding the value form VAL to STORE, then executing +BODY, which must return a Lisp form that does the necessary `setf' operation. +Actually, ARGLIST and STORE may be bound to temporary variables which are +introduced automatically to preserve proper execution order of the arguments. +Example: + + (defsetf nth (n x) (v) (list 'setcar (list 'nthcdr n x) v)) + +\(fn NAME [FUNC | ARGLIST (STORE) BODY...])" nil (quote macro)) + +(autoload (quote get-setf-method) "cl-macs" "\ +Return a list of five values describing the setf-method for PLACE. +PLACE may be any Lisp form which can appear as the PLACE argument to +a macro like `setf' or `incf'. + +\(fn PLACE &optional ENV)" nil nil) + +(autoload (quote setf) "cl-macs" "\ +Set each PLACE to the value of its VAL. +This is a generalized version of `setq'; the PLACEs may be symbolic +references such as (car x) or (aref x i), as well as plain symbols. +For example, (setf (cadar x) y) is equivalent to (setcar (cdar x) y). +The return value is the last VAL in the list. + +\(fn PLACE VAL PLACE VAL ...)" nil (quote macro)) + +(autoload (quote psetf) "cl-macs" "\ +Set PLACEs to the values VALs in parallel. +This is like `setf', except that all VAL forms are evaluated (in order) +before assigning any PLACEs to the corresponding values. + +\(fn PLACE VAL PLACE VAL ...)" nil (quote macro)) + +(autoload (quote cl-do-pop) "cl-macs" "\ +Not documented + +\(fn PLACE)" nil nil) + +(autoload (quote remf) "cl-macs" "\ +Remove TAG from property list PLACE. +PLACE may be a symbol, or any generalized variable allowed by `setf'. +The form returns true if TAG was found and removed, nil otherwise. + +\(fn PLACE TAG)" nil (quote macro)) + +(autoload (quote shiftf) "cl-macs" "\ +Shift left among PLACEs. +Example: (shiftf A B C) sets A to B, B to C, and returns the old A. +Each PLACE may be a symbol, or any generalized variable allowed by `setf'. + +\(fn PLACE... VAL)" nil (quote macro)) + +(autoload (quote rotatef) "cl-macs" "\ +Rotate left among PLACEs. +Example: (rotatef A B C) sets A to B, B to C, and C to A. It returns nil. +Each PLACE may be a symbol, or any generalized variable allowed by `setf'. + +\(fn PLACE...)" nil (quote macro)) + +(autoload (quote letf) "cl-macs" "\ +Temporarily bind to PLACEs. +This is the analogue of `let', but with generalized variables (in the +sense of `setf') for the PLACEs. Each PLACE is set to the corresponding +VALUE, then the BODY forms are executed. On exit, either normally or +because of a `throw' or error, the PLACEs are set back to their original +values. Note that this macro is *not* available in Common Lisp. +As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)', +the PLACE is not modified before executing BODY. + +\(fn ((PLACE VALUE) ...) BODY...)" nil (quote macro)) + +(autoload (quote letf*) "cl-macs" "\ +Temporarily bind to PLACEs. +This is the analogue of `let*', but with generalized variables (in the +sense of `setf') for the PLACEs. Each PLACE is set to the corresponding +VALUE, then the BODY forms are executed. On exit, either normally or +because of a `throw' or error, the PLACEs are set back to their original +values. Note that this macro is *not* available in Common Lisp. +As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)', +the PLACE is not modified before executing BODY. + +\(fn ((PLACE VALUE) ...) BODY...)" nil (quote macro)) + +(autoload (quote callf) "cl-macs" "\ +Set PLACE to (FUNC PLACE ARGS...). +FUNC should be an unquoted function name. PLACE may be a symbol, +or any generalized variable allowed by `setf'. + +\(fn FUNC PLACE ARGS...)" nil (quote macro)) + +(autoload (quote callf2) "cl-macs" "\ +Set PLACE to (FUNC ARG1 PLACE ARGS...). +Like `callf', but PLACE is the second argument of FUNC, not the first. + +\(fn FUNC ARG1 PLACE ARGS...)" nil (quote macro)) + +(autoload (quote define-modify-macro) "cl-macs" "\ +Define a `setf'-like modify macro. +If NAME is called, it combines its PLACE argument with the other arguments +from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +) + +\(fn NAME ARGLIST FUNC &optional DOC)" nil (quote macro)) + +(autoload (quote defstruct) "cl-macs" "\ +Define a struct type. +This macro defines a new Lisp data type called NAME, which contains data +stored in SLOTs. This defines a `make-NAME' constructor, a `copy-NAME' +copier, a `NAME-p' predicate, and setf-able `NAME-SLOT' accessors. + +\(fn (NAME OPTIONS...) (SLOT SLOT-OPTS...)...)" nil (quote macro)) + +(autoload (quote cl-struct-setf-expander) "cl-macs" "\ +Not documented + +\(fn X NAME ACCESSOR PRED-FORM POS)" nil nil) + +(autoload (quote typep) "cl-macs" "\ +Check that OBJECT is of type TYPE. +TYPE is a Common Lisp-style type specifier. + +\(fn OBJECT TYPE)" nil nil) + +(autoload (quote check-type) "cl-macs" "\ +Verify that FORM is of type TYPE; signal an error if not. +STRING is an optional description of the desired type. + +\(fn FORM TYPE &optional STRING)" nil (quote macro)) + +(autoload (quote assert) "cl-macs" "\ +Verify that FORM returns non-nil; signal an error if not. +Second arg SHOW-ARGS means to include arguments of FORM in message. +Other args STRING and ARGS... are arguments to be passed to `error'. +They are not evaluated unless the assertion fails. If STRING is +omitted, a default message listing FORM itself is used. + +\(fn FORM &optional SHOW-ARGS STRING &rest ARGS)" nil (quote macro)) + +(autoload (quote ignore-errors) "cl-macs" "\ +Execute BODY; if an error occurs, return nil. +Otherwise, return result of last form in BODY. + +\(fn &rest BODY)" nil (quote macro)) + +(autoload (quote define-compiler-macro) "cl-macs" "\ +Define a compiler-only macro. +This is like `defmacro', but macro expansion occurs only if the call to +FUNC is compiled (i.e., not interpreted). Compiler macros should be used +for optimizing the way calls to FUNC are compiled; the form returned by +BODY should do the same thing as a call to the normal function called +FUNC, though possibly more efficiently. Note that, like regular macros, +compiler macros are expanded repeatedly until no further expansions are +possible. Unlike regular macros, BODY can decide to \"punt\" and leave the +original function call alone by declaring an initial `&whole foo' parameter +and then returning foo. + +\(fn FUNC ARGS &rest BODY)" nil (quote macro)) + +(autoload (quote compiler-macroexpand) "cl-macs" "\ +Not documented + +\(fn FORM)" 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* +;;;;;; replace fill reduce) "cl-seq" "cl-seq.el" "8805f76626399794931f5db36ddf855f") +;;; Generated autoloads from cl-seq.el + +(autoload (quote reduce) "cl-seq" "\ +Reduce two-argument FUNCTION across SEQ. + +Keywords supported: :start :end :from-end :initial-value :key + +\(fn FUNCTION SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote fill) "cl-seq" "\ +Fill the elements of SEQ with ITEM. + +Keywords supported: :start :end + +\(fn SEQ ITEM [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote remove-duplicates) "cl-seq" "\ +Return a copy of SEQ with all duplicate elements removed. + +Keywords supported: :test :test-not :key :start :end :from-end + +\(fn SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote delete-duplicates) "cl-seq" "\ +Remove all duplicate elements from SEQ (destructively). + +Keywords supported: :test :test-not :key :start :end :from-end + +\(fn SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn NEW OLD SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote find) "cl-seq" "\ +Find the first occurrence of ITEM in SEQ. +Return the matching ITEM, or nil if not found. + +Keywords supported: :test :test-not :key :start :end :from-end + +\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote find-if) "cl-seq" "\ +Find the first item satisfying PREDICATE in SEQ. +Return the matching item, or nil if not found. + +Keywords supported: :key :start :end :from-end + +\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote find-if-not) "cl-seq" "\ +Find the first item not satisfying PREDICATE in SEQ. +Return the matching item, or nil if not found. + +Keywords supported: :key :start :end :from-end + +\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote position) "cl-seq" "\ +Find the first occurrence of ITEM in SEQ. +Return the index of the matching item, or nil if not found. + +Keywords supported: :test :test-not :key :start :end :from-end + +\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote position-if) "cl-seq" "\ +Find the first item satisfying PREDICATE in SEQ. +Return the index of the matching item, or nil if not found. + +Keywords supported: :key :start :end :from-end + +\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote position-if-not) "cl-seq" "\ +Find the first item not satisfying PREDICATE in SEQ. +Return the index of the matching item, or nil if not found. + +Keywords supported: :key :start :end :from-end + +\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote count) "cl-seq" "\ +Count the number of occurrences of ITEM in SEQ. + +Keywords supported: :test :test-not :key :start :end + +\(fn ITEM SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote count-if) "cl-seq" "\ +Count the number of items satisfying PREDICATE in SEQ. + +Keywords supported: :key :start :end + +\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote count-if-not) "cl-seq" "\ +Count the number of items not satisfying PREDICATE in SEQ. + +Keywords supported: :key :start :end + +\(fn PREDICATE SEQ [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 shorter sequence. + +Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end + +\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn SEQ1 SEQ2 [KEYWORD VALUE]...)" nil nil) + +(autoload (quote sort*) "cl-seq" "\ +Sort the argument SEQ according to PREDICATE. +This is a destructive function; it reuses the storage of SEQ if possible. + +Keywords supported: :key + +\(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil) + +(autoload (quote stable-sort) "cl-seq" "\ +Sort the argument SEQ stably according to PREDICATE. +This is a destructive function; it reuses the storage of SEQ if possible. + +Keywords supported: :key + +\(fn SEQ PREDICATE [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 PREDICATE is a `less-than' predicate on the elements. + +Keywords supported: :key + +\(fn TYPE SEQ1 SEQ2 PREDICATE [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil) + +(autoload (quote member-if) "cl-seq" "\ +Find the first item satisfying PREDICATE in LIST. +Return the sublist of LIST whose car matches. + +Keywords supported: :key + +\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil) + +(autoload (quote cl-adjoin) "cl-seq" "\ +Not documented + +\(fn CL-ITEM CL-LIST &rest CL-KEYS)" nil nil) + +(autoload (quote assoc*) "cl-seq" "\ +Find the first item whose car matches ITEM in LIST. + +Keywords supported: :test :test-not :key + +\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil) + +(autoload (quote assoc-if) "cl-seq" "\ +Find the first item whose car satisfies PREDICATE in LIST. + +Keywords supported: :key + +\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil) + +(autoload (quote assoc-if-not) "cl-seq" "\ +Find the first item whose car does not satisfy PREDICATE in LIST. + +Keywords supported: :key + +\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil) + +(autoload (quote rassoc*) "cl-seq" "\ +Find the first item whose cdr matches ITEM in LIST. + +Keywords supported: :test :test-not :key + +\(fn ITEM LIST [KEYWORD VALUE]...)" nil nil) + +(autoload (quote rassoc-if) "cl-seq" "\ +Find the first item whose cdr satisfies PREDICATE in LIST. + +Keywords supported: :key + +\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil) + +(autoload (quote rassoc-if-not) "cl-seq" "\ +Find the first item whose cdr does not satisfy PREDICATE in LIST. + +Keywords supported: :key + +\(fn PREDICATE LIST [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) + +(autoload (quote subsetp) "cl-seq" "\ +Return 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 + +\(fn LIST1 LIST2 [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn NEW OLD TREE [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn NEW PREDICATE TREE [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn ALIST TREE [KEYWORD VALUE]...)" nil nil) + +(autoload (quote 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 + +\(fn ALIST TREE [KEYWORD VALUE]...)" nil nil) + +(autoload (quote tree-equal) "cl-seq" "\ +Return t if trees TREE1 and TREE2 have `eql' leaves. +Atoms are compared by `eql'; cons cells are compared recursively. + +Keywords supported: :test :test-not :key + +\(fn TREE1 TREE2 [KEYWORD VALUE]...)" nil nil) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; End: + +;; arch-tag: 08cc5aab-e992-47f6-992e-12a7428c1a0e +;;; cl-loaddefs.el ends here