mirror/emacs
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/emacs.git synced 2025-01-01 11:14:55 +00:00
Code Issues Releases Activity

Merged from miles@gnu.org--gnu-2005 (patch 70-73, 320-331)

Browse Source 
Patches applied:

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-320
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-321
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-322
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-323
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-324
   Merge from gnus--rel--5.10

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-325
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-326
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-327
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-328
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-329
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-330
   Merge from gnus--rel--5.10

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-331
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-70
   Update from CVS

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-71
   Merge from emacs--cvs-trunk--0

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-72
   Merge from emacs--cvs-trunk--0

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-73
   Update from CVS

git-archimport-id: lorentey@elte.hu--2004/emacs--multi-tty--0--patch-348
This commit is contained in:
Karoly Lorentey 2005-05-28 21:04:38 +00:00
commit 93d7a36692
216 changed files with 3339 additions and 1433 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
admin/FOR-RELEASE
View File

@ -88,23 +88,26 @@ is encountered.
** Add missing years in copyright notices of all files.
Policy document admin/notes/years must be updated before
making further progress on this task!!!
Please record your name here and say which part of the distribution
you're going to handle.
DIRECTORY STATUS IN CHARGE
--------- ------ ---------
leim working Kenichi Handa
lisp/calc done Thien-Thi Nguyen
lisp/calc working Thien-Thi Nguyen
lisp/calendar working Glenn Morris
lisp/emulation done Thien-Thi Nguyen
lisp/emulation working Thien-Thi Nguyen
lisp/eshell working Thien-Thi Nguyen
lisp/international done Kenichi Handa
lisp/languages done Kenichi Handa
lisp/mh-e done Thien-Thi Nguyen
lisp/net done Thien-Thi Nguyen
lisp/play done Thien-Thi Nguyen
lisp/term done Thien-Thi Nguyen
lisp/toolbar done Thien-Thi Nguyen
lisp/mh-e working Thien-Thi Nguyen
lisp/net working Thien-Thi Nguyen
lisp/play working Thien-Thi Nguyen
lisp/term working Thien-Thi Nguyen
lisp/toolbar working Thien-Thi Nguyen
lisp/url working Thien-Thi Nguyen
** Update AUTHORS.
@ -132,7 +135,7 @@ man/commands.texi "Luc Teirlinck" Chong Yidong
man/custom.texi Chong Yidong
man/dired.texi Chong Yidong joakim@verona.se
man/display.texi "Luc Teirlinck" Chong Yidong
man/emacs.texi "Luc Teirlinck"
man/emacs.texi "Luc Teirlinck" Lute Kamstra
man/entering.texi "Luc Teirlinck" Chong Yidong
man/files.texi "Luc Teirlinck" Chong Yidong
man/fixit.texi "Luc Teirlinck" Chong Yidong

7
admin/notes/years
View File

@ -1,3 +1,10 @@
THIS DOCUMENT IS UNDER REVIEW.
DO NOT FOLLOW THESE INSTRUCTIONS -- THEY ARE NOT CORRECT.
How to Maintain Copyright Years for GNU Emacs

18
etc/NEWS
View File

@ -732,7 +732,7 @@ this variable is found in `default-indicate-buffer-boundaries'.
If value is `left' or `right', both angle and arrow bitmaps are
displayed in the left or right fringe, resp.
The value can also be an alist which specifies the presense and
The value can also be an alist which specifies the presence and
position of each bitmap individually.
For example, ((top . left) (t . right)) places the top angle bitmap
@ -2994,6 +2994,10 @@ any customizations.
* Incompatible Lisp Changes in Emacs 22.1
---
** The variables post-command-idle-hook and post-command-idle-delay have
been removed. Use run-with-idle-timer instead.
+++
** `suppress-keymap' now works by remapping `self-insert-command' to
the command `undefined'. (In earlier Emacs versions, it used
@ -3012,10 +3016,6 @@ the command `undefined'. (In earlier Emacs versions, it used
** General Lisp changes:
---
*** The variables post-command-idle-hook and post-command-idle-delay have
been removed. Use run-with-idle-timer instead.
+++
*** The function `eql' is now available without requiring the CL package.
@ -3630,6 +3630,7 @@ sure saved files have the current year in any copyright headers.
`save-some-buffers' will always save that buffer without asking (if
it's modified).
+++
*** New function `locate-file' searches for a file in a list of directories.
`locate-file' accepts a name of a file to search (a string), and two
lists: a list of directories to search in and a list of suffixes to
@ -4770,6 +4771,11 @@ used to add text properties to mode-line elements.
to display the size of the accessible part of the buffer on the mode
line.
*** Mouse-face on mode-line (and header-line) is now supported.
`mode-line-highlight' is the standard face indicating mouse sensitive
elements on mode-line (and header-line) like `highlight' face on text
areas.
** Menu manipulation changes:
---
@ -14247,7 +14253,7 @@ select one of those items.
----------------------------------------------------------------------
Copyright information:
Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
Permission is granted to anyone to make or distribute verbatim copies
of this document as received, in any medium, provided that the

5
lib-src/ChangeLog
View File

@ -1,3 +1,8 @@
2005-05-25 Thien-Thi Nguyen <ttn@gnu.org>
* yow.c (setup_yow): Use EXIT_FAILURE in case no separators found.
(yow): Use EXIT_FAILURE in case of memory error.
2005-05-13 YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
* make-docfile.c (DIRECTORY_SEP): New macro.

6
lib-src/yow.c
View File

@ -104,7 +104,7 @@ setup_yow(fp)
while ((c = getc(fp)) != SEP) {
if (c == EOF) {
fprintf(stderr, "yow: file contains no separators\n");
exit(2);
exit(EXIT_FAILURE);
}
}
header_len = ftell(fp);
@ -157,7 +157,7 @@ yow (fp)
buf = (char *) malloc(bufsize);
if (buf == (char *)0) {
fprintf(stderr, "yow: virtual memory exhausted\n");
exit (3);
exit (EXIT_FAILURE);
}
buf[i++] = c;
@ -170,7 +170,7 @@ yow (fp)
buf = (char *) realloc(buf, bufsize);
if (buf == (char *)0) {
fprintf(stderr, "yow: virtual memory exhausted\n");
exit (3);
exit (EXIT_FAILURE);
}
}
}

596
lisp/ChangeLog
View File

@ -1,5 +1,538 @@
2005-05-28 Nick Roberts <nickrob@snap.net.nz>
* progmodes/gdb-ui.el (gdb-all-registers): New variable.
(gdb-registers-buffer, toggle-gdb-all-registers):
Toggle display of floating point registers.
(gdb-registers-mode-map): Bind SPC to toggle-gdb-all-registers.
* progmodes/gud.el (gud-goto-info): Use info. Don't use require.
(toggle-gud-tooltip-dereference):
Rename from gud-toggle-tooltip-dereference.
2005-05-27 Stefan Monnier <monnier@iro.umontreal.ca>
* info.el (Info-goto-node): Revert autoload addition (2004-06-12).
2005-05-27 Jay Belanger <belanger@truman.edu>
* calc/calc-prog.el (calc-kbd-report): Remove.
(calc-kbd-query): Rewrite.
2005-05-27 Juanma Barranquero <lekktu@gmail.com>
* image.el (image-library-alist): Move to image.c.
(image-type-available-p): Doc fix.
2005-05-27 Lute Kamstra <lute@gnu.org>
* calc/calc.el (calc):
* outline.el (outline-1, outline-2, outline-3, outline-4)
(outline-5, outline-6, outline-7, outline-8):
* textmodes/dns-mode.el (dns-mode):
* textmodes/sgml-mode.el (sgml-namespace-face):
* textmodes/tex-mode.el (superscript, subscript, tex-math-face)
(tex-verbatim-face, tex-use-reftex):
* textmodes/texinfo.el (texinfo-heading-face):
Specify customization group.
* longlines.el: Don't require easy-mmode.
(longlines-visible-face): Specify customization group.
2005-05-27 Kenichi Handa <handa@m17n.org>
* language/cyrillic.el: Add cyrillic-iso8859-5 characters in the
encoding table of windows-1251.
* international/ucs-tables.el (ucs-set-table-for-input):
If translation-table-for-input of a coding system is a symbol, get
its translation-table property.
* international/code-pages.el: Don't register a coding system into
non-iso-charset-alist more than once.
(cp-make-coding-system): Likewise.
2005-05-26 John Wiegley <johnw@newartisans.com>
* eshell/esh-cmd.el (eshell-eval-command): If the return value of
`eshell-resume-eval' is wrapped in a list, it indicates that the
command was run asynchronously. In that case, unwrap the value
before checking the delimiter value.
* eshell/em-cmpl.el (eshell-complete-parse-arguments): If the
character before a space at the end of a line is \, assume the space
is part of the last argument rather than a final argument separator.
* eshell/esh-io.el (eshell-get-target): If `eshell-buffer-shorthand'
is in use, and the target is `t' or `nil' (which are the most common
values), don't assume that the symbol target is a buffer.
2005-05-26 Luc Teirlinck <teirllm@auburn.edu>
* calendar/calendar.el (calendar-mode-line-format):
Use mode-line-highlight as mouse-face.
* time.el (display-time-string-forms, display-time-update):
Use mode-line-highlight as mouse-face.
2005-05-26 Jay Belanger <belanger@truman.edu>
* calc/calc.el (calc-language-alist): Remove extra defvar.
2005-05-26 Lute Kamstra <lute@gnu.org>
* arc-mode.el (archive-mode):
* bookmark.el (bookmark-read-annotation-mode)
(bookmark-edit-annotation-mode, bookmark-bmenu-mode):
* bs.el (bs-mode):
* calc/calc-yank.el (calc-edit-mode):
* calc/calc.el (calc-mode, calc-trail-mode):
* calculator.el (calculator-mode):
* chistory.el (command-history-mode):
* comint.el:
* cus-edit.el (custom-mode):
* descr-text.el (describe-text-mode):
* ebuff-menu.el (Electric-buffer-menu-mode):
* ediff-util.el (ediff-mode):
* emacs-lisp/re-builder.el (reb-mode):
* emulation/vi.el (vi-mode-setup):
* emulation/ws-mode.el (wordstar-mode):
* eshell/esh-mode.el (eshell-mode):
* forms.el (forms-mode):
* help-mode.el (help-mode):
* hexl.el (hexl-mode):
* ibuffer.el (ibuffer-mode):
* ielm.el (inferior-emacs-lisp-mode):
* info.el (Info-mode, Info-edit-mode):
* international/swedish.el:
* ledit.el (ledit-from-lisp-mode):
* locate.el (locate-mode):
* mail/rmail.el (rmail-mode):
* mail/rmailedit.el (rmail-edit-mode):
* mail/rmailsum.el (rmail-summary-mode):
* mail/supercite.el (sc-electric-mode):
* net/eudc.el (eudc-mode):
* net/quickurl.el (quickurl-list-mode):
* net/snmp-mode.el (snmp-mode, snmpv2-mode):
* obsolete/ooutline.el (outline-mode):
* obsolete/options.el (Edit-options-mode):
* obsolete/rnews.el (news-mode):
* obsolete/rnewspost.el (news-reply-mode):
* play/5x5.el (5x5-mode):
* play/decipher.el (decipher-mode, decipher-stats-mode):
* play/gomoku.el (gomoku-mode):
* play/snake.el (snake-mode):
* play/solitaire.el (solitaire-mode):
* play/tetris.el (tetris-mode):
* progmodes/ada-mode.el (ada-mode):
* progmodes/antlr-mode.el (antlr-mode):
* progmodes/autoconf.el (autoconf-mode):
* progmodes/dcl-mode.el (dcl-mode):
* progmodes/delphi.el (delphi-mode):
* progmodes/ebrowse.el (ebrowse-tree-mode)
(ebrowse-electric-list-mode, ebrowse-member-mode)
(ebrowse-electric-position-mode):
* progmodes/f90.el (f90-mode):
* progmodes/fortran.el (fortran-mode):
* progmodes/icon.el (icon-mode):
* progmodes/idlw-help.el (idlwave-help-mode):
* progmodes/idlw-shell.el (idlwave-shell-mode):
* progmodes/idlwave.el (idlwave-mode):
* progmodes/inf-lisp.el (inferior-lisp-mode):
* progmodes/m4-mode.el (m4-mode):
* progmodes/meta-mode.el (metafont-mode, metapost-mode):
* progmodes/modula2.el (modula-2-mode):
* progmodes/octave-inf.el (inferior-octave-mode):
* progmodes/octave-mod.el (octave-mode):
* progmodes/pascal.el (pascal-mode):
* progmodes/sh-script.el (sh-mode):
* progmodes/sql.el (sql-mode, sql-interactive-mode):
* progmodes/vhdl-mode.el (vhdl-mode):
* progmodes/xscheme.el (scheme-interaction-mode):
* replace.el (occur-mode):
* ses.el (ses-mode):
* simple.el (completion-list-mode):
* skeleton.el:
* speedbar.el (speedbar-mode):
* term.el (term-mode):
* terminal.el (terminal-edit-mode):
* textmodes/reftex-index.el (reftex-index-mode)
(reftex-index-phrases-mode):
* textmodes/reftex-sel.el (reftex-select-label-mode)
(reftex-select-bib-mode):
* textmodes/reftex-toc.el (reftex-toc-mode):
* wdired.el (wdired-change-to-wdired-mode):
* wid-browse.el (widget-browse-mode):
Use run-mode-hooks.
* array.el (array-mode):
* calendar/todo-mode.el (todo-mode):
* man.el (Man-mode):
* play/landmark.el (lm-mode):
* play/mpuz.el (mpuz-mode):
Use kill-all-local-variables and run-mode-hooks.
* subr.el (delay-mode-hooks): Specify indentation.
2005-05-26 Mark A. Hershberger <mah@everybody.org>
* xml.el (xml-substitute-special): Don't die for undefined xml entities.
2005-05-26 Jay Belanger <belanger@truman.edu>
* calc/calc-prog.el (calc-user-define-edit): Don't find substring
of nil.
2005-05-27 Nick Roberts <nickrob@snap.net.nz>
* progmodes/gdb-ui.el (gdb-frame-address):
Rename from gdb-current-address.
(gdb-previous-frame-address): Rename from gdb-previous-address.
(gdb-selected-frame): Rename from gdb-current-frame.
(gdb-get-selected-frame): Rename from gdb-get-current-frame.
(gdb-frame-number): Rename from gdb-current-stack-level.
(gdb-ann3): Match new mode-name for disassembly buffer.
Extend initialisation of variables.
(gdb-post-prompt): Update disassembly from gdb-frame-handler.
(gdb-memory-mode): Use mouse-face in header line.
(gdb-assembler-buffer-name): Call it disassembly and give frame
in mode line.
(gdb-source-spec-regexp, gdb-assembler-custom)
(gdb-invalidate-assembler, gdb-frame-handler):
Make robust to leading zeroes in address format.
2005-05-26 Carsten Dominik <dominik@science.uva.nl>
* textmodes/org.el (org-mode): Use `define-derived-mode' to
define `org-mode'.
(org-agenda-mode): Use `run-mode-hooks' instead of `run-hooks'.
2005-05-26 Stefan Monnier <monnier@iro.umontreal.ca>
* log-edit.el (log-edit-changelog-entries): Distinguish between
filenames like xfns.c and fns.c.
2005-05-25 Luc Teirlinck <teirllm@auburn.edu>
* buff-menu.el (Buffer-menu-revert-function): Improve handling of
point after reverting.
(Buffer-menu-make-sort-button): Handle the case where
`Buffer-menu-use-header-line' is nil.
2005-05-25 Thien-Thi Nguyen <ttn@gnu.org>
* vms-patch.el (vms-magic-right-square-brace, vms-magic-colon):
New funcs. In minibuffer-local-completion-map bind `]', `/'
and `:' to them.
2005-05-25 Stefan Monnier <monnier@iro.umontreal.ca>
* startup.el (normal-top-level): Allow modification of load-path while
we're iterating over it.
2005-05-25 Juanma Barranquero <lekktu@gmail.com>
* thumbs.el (thumbs-thumbsdir-max-size, thumbs-temp-file)
(thumbs-cleanup-thumbsdir, thumbs-call-convert)
(thumbs-resize-interactive, thumbs-insert-image)
(thumbs-insert-thumb, thumbs-dired-show-marked)
(thumbs-find-image-at-point, thumbs-delete-images)
(thumbs-rename-images, thumbs-next-image, thumbs-dired-setroot)
(thumbs-increment-image-size, thumbs-decrement-image-size):
Fix typos in docstrings.
2005-05-24 Andre Spiegel <spiegel@gnu.org>
* progmodes/cperl-mode.el (cperl-vc-header-alist): Obsolete.
(cperl-vc-rcs-header, cperl-vc-sccs-header): New user options.
(cperl-mode): Use them.
2005-05-24 Juanma Barranquero <lekktu@gmail.com>
* window.el (quit-window, shrink-window-if-larger-than-buffer):
Doc fixes.
2005-05-24 Nick Roberts <nickrob@snap.net.nz>
* progmodes/gdb-ui.el (gdb-inferior-io-mode-map):
Bind C-d to gdb-inferior-io-eof.
* dired.el (dired-dnd-popup-notice): Use message-box.
2005-05-23 Masatake YAMATO <jet@gyve.org>
* bindings.el (mode-line-major-mode-keymap):
Bind [mode-line down-mouse-1] to `mouse-major-mode-menu'.
* faces.el (mode-line-highlight): New face.
* ruler-mode.el (ruler-mode-ruler): Use mode-line-highlight
as mouse-face.
* bindings.el (top-level, help-echo, mode-line-modified)
(mode-line-mule-info, mode-line-eol-desc): Use mode-line-highlight
as mouse-face.
2005-05-23 Juanma Barranquero <lekktu@gmail.com>
* progmodes/cc-engine.el (c-guess-basic-syntax):
Remove spurious call to `zerop'.
* emacs-lisp/cl.el (acons, pairlis): Add docstring.
2005-05-23 Martin Stjernholm <bug-cc-mode@gnu.org>
CC Mode update to 5.30.10:
* cc-fonts.el (c-font-lock-declarators): Fix bug where the point
could go past the limit in decoration level 2, thereby causing
errors during interactive fontification.
* cc-mode.el (c-make-inherited-keymap): Fix cc-bytecomp bug when
the file is evaluated interactively.
* cc-engine.el (c-guess-basic-syntax): Handle operator
declarations somewhat better in C++.
* cc-styles.el, cc-mode.el (c-run-mode-hooks): New helper macro to
make use of `run-mode-hooks' which has been added in Emacs 21.1.
(c-mode, c++-mode, objc-mode, java-mode, idl-mode, pike-mode)
(awk-mode): Use it.
(make-local-hook): Suppress warning about obsoleteness.
* cc-engine.el, cc-align.el, cc-cmds.el
(c-append-backslashes-forward, c-delete-backslashes-forward)
(c-find-decl-spots, c-semi&comma-no-newlines-before-nonblanks):
Compensate for return value from `forward-line' when it has moved
but not to a different line due to eob.
* cc-engine.el (c-guess-basic-syntax): Fix anchoring in
`objc-method-intro' and `objc-method-args-cont'.
2005-05-23 Alan Mackenzie <bug-cc-mode@gnu.org>
CC Mode update to 5.30.10:
* cc-mode.el, cc-engine.el, cc-align.el: Change the FSF's address
in the copyright statement. Incidentally, change "along with GNU
Emacs" to "along with this program" where it occurs.
* cc-mode.el: Add a fourth parameter `t' to the awk-mode autoload,
so that it is interactive, hence can be found by M-x awk-mode
whilst cc-mode is yet to be loaded. Reported by Glenn Morris
<gmorris+emacs@ast.cam.ac.uk>.
* cc-awk.el: Add character classes (e.g. "[:alpha:]") into AWK
Mode's regexps.
2005-05-23 Kevin Ryde <user42@zip.com.au>
* cc-align.el (c-lineup-argcont): Ignore conses for {} pairs from
c-parse-state, to avoid a lisp error (on bad code).
2005-05-23 Lute Kamstra <lute@gnu.org>
* subr.el (font-lock-defaults): Remove defvar as it's already
defined in font-core.el.
* font-lock.el (font-lock-beginning-of-syntax-function): Fix docstring.
2005-05-23 Nick Roberts <nickrob@snap.net.nz>
* progmodes/gdb-ui.el (gdb-info-locals-handler): Make regexps
more general and work when GDB variable "print pretty" is on,
as with Emacs, for example.
2005-05-22 Luc Teirlinck <teirllm@auburn.edu>
* font-core.el: Update comment.
* emacs-lisp/easy-mmode.el (define-global-minor-mode):
Use `after-change-major-mode-hook' instead of `find-file-hook'.
* buff-menu.el (Buffer-menu-mode): Use `run-mode-hooks'.
2005-05-22 Eli Zaretskii <eliz@gnu.org>
* simple.el (yank, yank-pop): Mention `yank-excluded-properties'
and `yank-handler' in the doc strings.
2005-05-22 Stefan Monnier <monnier@iro.umontreal.ca>
* emacs-lisp/cl.el (eql): Remove. It's a builtin already.
2005-05-22 Richard M. Stallman <rms@gnu.org>
* help.el (describe-key): Move print-help-return-message call
out of conditional.
* progmodes/etags.el (list-tags): Use with-no-warnings.
* mail/smtpmail.el (smtpmail-open-stream): Use with-no-warnings.
(smtpmail-send-queued-mail): Avoid beginning-of-buffer.
(starttls-extra-args, starttls-extra-arguments): Add defvars.
* mail/mailalias.el (mail-get-names): Avoid beginning-of-buffer.
* language/viet-util.el (viet-viscii-nonascii-translation-table):
Add defvar.
* emulation/viper-ex.el (viper-ex-work-buf, viper-ex-print-buf):
Use defvar, not defconst.
* hexl.el (hexl-follow-line): Use with-no-warnings.
* emulation/tpu-extras.el: Use write-file-functions instead of
write-file-hooks.
* dired.el (dired-font-lock-keywords): Fontify files with junk
extensions even if marked by -F.
2005-05-22 Juanma Barranquero <lekktu@gmail.com>
* emacs-lisp/cl.el (pushnew, cl-macroexpand, floatp-safe, plusp)
(minusp, oddp, evenp, mapcar*, list*, copy-list, adjoin, subst):
* emacs-lisp/cl-extra.el (coerce, map, maplist, cl-mapc, mapl)
(mapcan, mapcon, some, every, notany, notevery, signum, isqrt)
(concatenate, list-length, get*, getf, cl-remprop):
* emacs-lisp/cl-macs.el (function*, case, ecase, typecase)
(etypecase, progv, lexical-let, lexical-let*)
(multiple-value-bind, multiple-value-setq, shiftf):
Improve argument/docstring consistency.
* subr.el (focus-frame, unfocus-frame):
Revert deletion on 2005-05-01.
2005-05-22 Andre Spiegel <spiegel@gnu.org>
* vc-cvs.el (vc-cvs-checkout-model): Handle the case where FILE
doesn't exist.
* vc.el (vc-trunk-p): Add autoload cookie. The function is used in
vc-rcs.el when vc-mistrust-permissions is t, which is not the default.
2005-05-22 Nick Roberts <nickrob@snap.net.nz>
* emacs-lisp/bytecomp.el: Remove make-obsolete-variable for
already deleted variables: auto-fill-hook, blink-paren-hook,
lisp-indent-hook, inhibit-local-variables, unread-command-event
suspend-hooks, comment-indent-hook, meta-flag,
before-change-function, after-change-function,
font-lock-doc-string-face.
2005-05-21 Luc Teirlinck <teirllm@auburn.edu>
* emacs-lisp/derived.el (define-derived-mode): Doc fix.
2005-05-21 Eli Zaretskii <eliz@gnu.org>
* mail/rmail.el (rmail-reply): Filter the list in reply-to through
rmail-dont-reply-to.
2005-05-21 Frederik Fouvry <fouvry@CoLi.Uni-SB.DE>
* mail/sendmail.el (mail-send): Use [[:space:]] instead of a
literal blank when splitting new-header-values.
2005-05-21 Matt Hodges <MPHodges@member.fsf.org>
* calendar/cal-menu.el (cal-menu-update): Add separator as a
string so that tmm doesn't create a completion entry for it.
* textmodes/table.el (table-disable-menu): Ditto.
2005-05-21 Richard M. Stallman <rms@gnu.org>
* progmodes/idlwave.el (idlwave-doc-header): Use insert-file-contents.
* progmodes/flymake.el (flymake-makehash): Use with-no-warnings.
* net/rcompile.el (remote-compile): Use compilation-start.
* tmm.el (tmm-shortcut): Avoid using beginning-of-buffer.
2005-05-21 Daniel Pfeiffer <occitan@esperanto.org>
* files.el (auto-mode-alist): Check GNUmakefile before makefile.
Default to makefile-bsdmake-mode on BSD systems.
* imenu.el (imenu-generic-expression, imenu--generic-function'):
REGEXP may also be a search function now. The part of doc-string
for describing the structure was 95% identical to that of
`imenu--generic-function'. Unify it there.
* progmodes/make-mode.el (makefile-imenu-generic-expression):
Use function to find dependencies, because regexp alone is so complex,
it easily goes into an endless loop.
(makefile-makepp-mode): Also add submenu for Perl functions
defined in the makefile.
(makefile-bsdmake-mode): Special imenu-generic-expression no
longer needed, due to function call.
(makefile-match-dependency): Take BOUND into account when checking
if we're through.
2005-05-20 Jay Belanger <belanger@truman.edu>
* calc/calc-units.el (calc-invalidate-units-table):
Use inhibit-read-only.
(math-build-units-table-buffer): Use view-mode.
2005-05-20 David Kastrup <dak@gnu.org>
* emacs-lisp/easymenu.el (easy-menu-add): Correct docstring since
easy-menu-add is not a nop on Emacs; and clarify when to call it.
2005-05-20 Lute Kamstra <lute@gnu.org>
* diff-mode.el (diff-header-face, diff-file-header-face)
(diff-index-face, diff-hunk-header-face, diff-removed-face)
(diff-added-face, diff-changed-face, diff-function-face)
(diff-context-face, diff-nonexistent-face): Put them in the
diff-mode customization group.
2005-05-20 Stefan Monnier <monnier@iro.umontreal.ca>
* progmodes/vhdl-mode.el (vhdl-font-lock-match-item): Simplify regexp.
* progmodes/sh-script.el (sh-mode, sh-get-word): Minor regexp fixes.
* font-lock.el (lisp-font-lock-keywords-2): Don't error.
Minor regexp-optimization.
2005-05-20 Carsten Dominik <dominik@science.uva.nl>
* textmodes/org.el (org-agenda-toggle-time-grid): New command.
(org-agenda-use-time-grid, org-agenda-time-grid): New options.
(org-agenda-add-time-grid-maybe): New function.
(org-agenda): Call `org-agenda-add-time-grid-maybe'.
(org-table-create): `dotimes' instead of `mapcar'.
(org-xor): Simplify implementation.
(org-agenda): `inhibit-redisplay' turned on.
(org-agenda-change-all-lines): Use `org-format-agenda-item' to get
a consistent line after a state change.
(org-agenda-remove-times-when-in-prefix): New option.
(org-prefix-has-time): New variable.
(org-parse-time-string): Optional argument NODEFAULT.
(org-format-agenda-item): Parse items for time-of-day
specifications and move these into the prefix if possible.
(org-agenda-priority): Get current heading, not previous heading
during agenda remote editing.
2005-05-20 Juanma Barranquero <lekktu@gmail.com>
* emacs-lisp/cl-seq.el (reduce, fill, replace, remove*)
(remove-if, remove-if-not, delete*, delete-if, delete-if-not)
(remove-duplicates, delete-duplicates, substitute)
(substitute-if, substitute-if-not, nsubstitute, nsubstitute-if)
(nsubstitute-if-not, find, find-if, find-if-not, position)
(position-if, position-if-not, count, count-if, count-if-not)
(mismatch, search, sort*, stable-sort, merge, member*)
(member-if, member-if-not, assoc*, assoc-if, assoc-if-not)
(rassoc*, rassoc-if, rassoc-if-not, union, nunion)
(intersection, nintersection, set-difference, nset-difference)
(set-exclusive-or, nset-exclusive-or, subsetp, subst-if)
(subst-if-not, nsubst, nsubst-if, nsubst-if-not, sublis)
(nsublis, tree-equal): Improve argument/docstring consistency.
* subr.el (send-string, send-region):
Remove obsolescence declaration.
(window-dot, set-window-dot, read-input, show-buffer)
@ -68,6 +601,7 @@
(left-fringe-p): Function deleted.
* buff-menu.el (Buffer-menu-buffer-face): In group Buffer-menu.
(list-buffers-noselect): Set `font-lock-face' property, not `face'.
* dired-aux.el (dired-copy-file-recursive): Handle symlinks
in recursive copy.
@ -89,7 +623,7 @@
2005-05-19 Carsten Dominik <dominik@science.uva.nl>
* textmodes/reftex.el (reftex-isearch-minor-mode): Moved the
* textmodes/reftex.el (reftex-isearch-minor-mode): Move the
definition of this variable from reftex-global.el to reftex.el,
because it is needed in the menu.
@ -112,8 +646,8 @@
(makefile-add-this-line-macro): Simplify and integrate into
`makefile-pickup-macros.
(makefile-pickup-filenames-as-targets): Simplify.
(makefile-previous-dependency, makefile-match-dependency): Don't
stumble over `::'.
(makefile-previous-dependency, makefile-match-dependency):
Don't stumble over `::'.
2005-05-19 Nick Roberts <nickrob@snap.net.nz>
@ -127,8 +661,8 @@
* help-fns.el (describe-variable): Remove hyperlinks in a
variable's value as these are quite frequently inappropriate.
* follow.el (follow-submit-feedback, follow-mode): Remove
references to post-command-idle-hook.
* follow.el (follow-submit-feedback, follow-mode):
Remove references to post-command-idle-hook.
2005-05-18 Daniel Pfeiffer <occitan@esperanto.org>
@ -138,8 +672,8 @@
2005-05-18 Jay Belanger <belanger@truman.edu>
* calc/calc-help.el (calc-s-prefix-help): Add
`calc-copy-special-constant' to help string.
* calc/calc-help.el (calc-s-prefix-help):
Add `calc-copy-special-constant' to help string.
2005-05-18 Luc Teirlinck <teirllm@auburn.edu>
@ -152,8 +686,8 @@
2005-05-18 Carsten Dominik <dominik@science.uva.nl>
* textmodes/reftex-vars.el (reftex-cite-format-builtin): Support
for jurabib.
* textmodes/reftex-vars.el (reftex-cite-format-builtin):
Support for jurabib.
* textmodes/reftex.el (featurep): Define aliases for overlay
commands, for XEmacs compatibility, and use these aliases in
@ -164,8 +698,8 @@
(reftex-access-search-path): Use `reftex-uniquify' instead of
`reftex-uniq'
* textmodes/reftex-sel.el (reftex-select-unmark): Overlay
`before-string' property modification enables for Emacs as well.
* textmodes/reftex-sel.el (reftex-select-unmark):
Overlay `before-string' property modification enables for Emacs as well.
(reftex-select-item): Use `reftex-delete-overlay'.
(reftex-select-mark): Use `reftex-make-overlay' and
`reftex-overlay-put'.
@ -200,8 +734,7 @@
* progmodes/prolog.el (inferior-prolog-mode): Doc fix.
(prolog-consult-region): Replace `send-string' by
`process-send-string'; replace `send-region' by
`process-send-region'.
`process-send-string'; replace `send-region' by `process-send-region'.
* progmodes/delphi.el (delphi-log-msg):
Replace `set-window-dot' by `set-window-point'.
@ -232,8 +765,8 @@
loop. It should also be more efficient, because first it only
searches for `:', instead of applying the very complex regexp.
(makefile-mode): Cancel `font-lock-support-mode', because blocks
to be fontified in one piece can be too long for JIT. Makefiles
are never *that* big.
to be fontified in one piece can be too long for JIT.
Makefiles are never *that* big.
2005-05-17 Reiner Steib <Reiner.Steib@gmx.de>
@ -259,8 +792,8 @@
2005-05-16 Daniel Pfeiffer <occitan@esperanto.org>
* font-lock.el (lisp-font-lock-keywords-1): Set
`font-lock-negation-char-face' for [^...] char group.
* font-lock.el (lisp-font-lock-keywords-1):
Set `font-lock-negation-char-face' for [^...] char group.
(lisp-font-lock-keywords-2): Highlight regexp's \\( \\| \\).
* progmodes/make-mode.el (makefile-dependency-regex): Turn it into
@ -274,11 +807,10 @@
might be the same one to be skipped by the initial [^$], leading
to an overlooked variable use.
(makefile-make-font-lock-keywords): Remove two parameters, which
are now variables that some of the modes set locally. Handle
dependency and rule action matching through functions, because
are now variables that some of the modes set locally.
Handle dependency and rule action matching through functions, because
regexps alone match too often. Dependency matching now comes
last, so it can check, whether a colon already matched something
else.
last, so it can check, whether a colon already matched something else.
(makefile-mode): Inform that font-lock improves makefile parsing
capabilities.
(makefile-match-dependency, makefile-match-action): New functions.
@ -363,8 +895,8 @@
(reftex-bib-sort-year-reverse, reftex-format-citation):
* textmodes/reftex-parse.el (reftex-init-section-numbers)
(reftex-section-number):
* textmodes/texinfmt.el (texinfo-paragraphindent): Replace
`string-to-int' by `string-to-number'.
* textmodes/texinfmt.el (texinfo-paragraphindent):
Replace `string-to-int' by `string-to-number'.
* international/latexenc.el: Add page marker to force the "Local
Variables:" string out of the last page.
@ -472,23 +1004,22 @@
(tramp-pre-connection): Add parameter CHUNKSIZE. Make local
variable `tramp-chunksize'. Change callees.
(tramp-open-connection-setup-interactive-shell): Check remote host
for buggy `send-process-string' implementation. Set
`tramp-chunksize' if found. Reported by Michael Kifer
for buggy `send-process-string' implementation.
Set `tramp-chunksize' if found. Reported by Michael Kifer
<kifer@cs.sunysb.edu> (and a lot of other people all the years).
(tramp-handle-shell-command): `insert-buffer' cannot be used
because the contents of the Tramp buffer is changed before
insertion (`expand-file' and alike). Reported by Fr,Ai(Bd,Ai(Bric Bothamy
<frederic.bothamy@free.fr>.
(tramp-set-auto-save): Actions should be done for Tramp file name
handler only. Ange-FTP has its own auto-save mechanism. Reported
by Richard G. Bielawski <Richard.G.Bielawski@wellsfargo.com>.
handler only. Ange-FTP has its own auto-save mechanism.
Reported by Richard G. Bielawski <Richard.G.Bielawski@wellsfargo.com>.
(tramp-set-auto-save-file-modes): Set file modes of
`buffer-auto-save-file-name' to ?\600 as fallback solution.
Reported by Ferenc Wagner <wferi@tba.elte.hu>.
(tramp-bug): Remove obsolete variable.
(tramp-append-tramp-buffers): Rewrite partly. More suitable check
for presence of `mml-mode'. Make it running for older Emacsen as
well.
for presence of `mml-mode'. Make it running for older Emacsen as well.
2005-05-14 John Paul Wallington <jpw@pobox.com>
@ -540,15 +1071,14 @@
2005-05-13 Matt Hodges <MPHodges@member.fsf.org>
* tmm.el (tmm-get-keymap): Include only active menus and menu
items.
* tmm.el (tmm-get-keymap): Include only active menus and menu items.
* emacs-lisp/easymenu.el (easy-menu-define): Doc fixes.
2005-05-13 Jan Dj,Ad(Brv <jan.h.d@swipnet.se>
* dired.el (dired-mode): make-variable-buffer-local =>
make-local-variable
make-local-variable.
2005-05-13 YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
@ -9597,7 +10127,7 @@
(Info-build-toc): Don't check for special Info file names.
Set main-file to nil if Info-find-file returns a symbol.
2004-10-05 Emilio C. Lopes <eclig@gmx.net>:
2004-10-05 Emilio C. Lopes <eclig@gmx.net>
* calendar/calendar.el (calendar-goto-iso-week): Add autoload.
(calendar-mode-map): Add binding for `calendar-goto-iso-week'.

2
lisp/arc-mode.el
View File

@ -672,7 +672,7 @@ archive.
(setq major-mode 'archive-mode)
(setq mode-name (concat typename "-Archive"))
;; Run archive-foo-mode-hook and archive-mode-hook
(run-hooks (archive-name "mode-hook") 'archive-mode-hook)
(run-mode-hooks (archive-name "mode-hook") 'archive-mode-hook)
(use-local-map archive-mode-map))
(make-local-variable 'archive-proper-file-start)

3
lisp/array.el
View File

@ -872,6 +872,7 @@ take a numeric prefix argument):
Entering array mode calls the function `array-mode-hook'."
(interactive)
(kill-all-local-variables)
;; Number of rows in the array.
(make-local-variable 'array-max-row)
;; Number of columns in the array.
@ -907,7 +908,7 @@ Entering array mode calls the function `array-mode-hook'."
(setq truncate-lines t)
(setq overwrite-mode 'overwrite-mode-textual)
(use-local-map array-mode-map)
(run-hooks 'array-mode-hook))
(run-mode-hooks 'array-mode-hook))

20
lisp/bindings.el
View File

@ -165,7 +165,8 @@ corresponding to the mode line clicked."
(eval-when-compile
(let ((map (make-sparse-keymap)))
(define-key map [mode-line mouse-3] 'mode-line-change-eol)
map))))
map))
'mouse-face 'mode-line-highlight))
(push (cons eol (cons mnemonic desc)) mode-line-eol-desc-cache)
desc)))
@ -177,7 +178,8 @@ corresponding to the mode line clicked."
"Input method: "
current-input-method
". mouse-2: disable, mouse-3: describe")
local-map ,mode-line-input-method-map))
local-map ,mode-line-input-method-map
mouse-face mode-line-highlight))
,(propertize
"%z"
'help-echo
@ -191,6 +193,7 @@ corresponding to the mode line clicked."
" buffer; mouse-3: describe coding system")
(concat "Unibyte " (symbol-name buffer-file-coding-system)
" buffer")))))
'mouse-face 'mode-line-highlight
'local-map mode-line-coding-system-map)
(:eval (mode-line-eol-desc)))
"Mode-line control for displaying information of multilingual environment.
@ -235,7 +238,8 @@ Normally nil in most modes, since there is no process to display.")
"Not r")))))
'local-map (purecopy (make-mode-line-mouse-map
'mouse-3
#'mode-line-toggle-read-only)))
#'mode-line-toggle-read-only))
'mouse-face 'mode-line-highlight)
(propertize
"%1+"
'help-echo (purecopy (lambda (window object point)
@ -246,7 +250,8 @@ Normally nil in most modes, since there is no process to display.")
"M"
"Not m")))))
'local-map (purecopy (make-mode-line-mouse-map
'mouse-3 #'mode-line-toggle-modified))))
'mouse-3 #'mode-line-toggle-modified))
'mouse-face 'mode-line-highlight))
"Mode-line control for displaying whether current buffer is modified.")
(make-variable-buffer-local 'mode-line-modified)
@ -262,6 +267,7 @@ buffer size, the line number and the column number.")
(defvar mode-line-major-mode-keymap
(let ((map (make-sparse-keymap)))
(define-key map [mode-line down-mouse-1] 'mouse-major-mode-menu)
(define-key map [mode-line mouse-2] 'describe-mode)
(define-key map [mode-line down-mouse-3] 'mode-line-mode-menu-1)
map) "\
@ -303,13 +309,16 @@ Keymap to display on minor modes.")
(list
(propertize "%[(" 'help-echo help-echo)
`(:propertize ("" mode-name)
help-echo "mouse-2: help for current major mode"
help-echo "mouse-1: major-mode-menu mouse-2: help for current major mode"
mouse-face mode-line-highlight
local-map ,mode-line-major-mode-keymap)
'("" mode-line-process)
`(:propertize ("" minor-mode-alist)
mouse-face mode-line-highlight
help-echo "mouse-2: help for minor modes, mouse-3: minor mode menu"
local-map ,mode-line-minor-mode-keymap)
(propertize "%n" 'help-echo "mouse-2: widen"
'mouse-face 'mode-line-highlight
'local-map (make-mode-line-mouse-map
'mouse-2 #'mode-line-widen))
(propertize ")%]--" 'help-echo help-echo)))
@ -465,6 +474,7 @@ text properties for face, help-echo, and local-map to it."
'face 'Buffer-menu-buffer-face
'help-echo
(purecopy "mouse-1: previous buffer, mouse-3: next buffer")
'mouse-face 'mode-line-highlight
'local-map mode-line-buffer-identification-keymap)))
(setq-default mode-line-buffer-identification

6
lisp/bookmark.el
View File

@ -866,7 +866,7 @@ the annotation.
(use-local-map bookmark-read-annotation-mode-map)
(setq major-mode 'bookmark-read-annotation-mode)
(insert (funcall bookmark-read-annotation-text-func bookmark))
(run-hooks 'text-mode-hook))
(run-mode-hooks 'text-mode-hook))
(defun bookmark-read-annotation (parg bookmark)
@ -903,7 +903,7 @@ When you have finished composing, type \\[bookmark-send-annotation].
(let ((annotation (bookmark-get-annotation bookmark)))
(if (and annotation (not (string-equal annotation "")))
(insert annotation)))
(run-hooks 'text-mode-hook))
(run-mode-hooks 'text-mode-hook))
(defun bookmark-send-edited-annotation ()
@ -1618,7 +1618,7 @@ Bookmark names preceded by a \"*\" have annotations.
(setq buffer-read-only t)
(setq major-mode 'bookmark-bmenu-mode)
(setq mode-name "Bookmark Menu")
(run-hooks 'bookmark-bmenu-mode-hook))
(run-mode-hooks 'bookmark-bmenu-mode-hook))
(defun bookmark-bmenu-toggle-filenames (&optional show)

2
lisp/bs.el
View File

@ -656,7 +656,7 @@ to show always.
truncate-lines t
font-lock-defaults '(bs-mode-font-lock-keywords t)
font-lock-verbose nil)
(run-hooks 'bs-mode-hook))
(run-mode-hooks 'bs-mode-hook))
(defun bs-kill ()
"Let buffer disappear and reset window-configuration."

44
lisp/buff-menu.el
View File

@ -1,7 +1,7 @@
;;; buff-menu.el --- buffer menu main function and support functions -*- coding:utf-8 -*-
;; Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 2000, 2001, 2002, 2003,
;; 2004 Free Software Foundation, Inc.
;; 2004, 2005 Free Software Foundation, Inc.
;; Maintainer: FSF
;; Keywords: convenience
@ -190,7 +190,7 @@ Letters do not insert themselves; instead, they are commands.
#'(lambda (&optional noconfirm) 'fast))
(setq truncate-lines t)
(setq buffer-read-only t)
(run-hooks 'buffer-menu-mode-hook))
(run-mode-hooks 'buffer-menu-mode-hook))
;; This function exists so we can make the doc string of Buffer-menu-mode
;; look nice.
@ -203,17 +203,21 @@ Letters do not insert themselves; instead, they are commands.
(or (eq buffer-undo-list t)
(setq buffer-undo-list nil))
;; We can not use save-excursion here. The buffer gets erased.
(let ((ocol (current-column))
(let ((opoint (point))
(eobp (eobp))
(ocol (current-column))
(oline (progn (move-to-column 4)
(get-text-property (point) 'buffer)))
(prop (point-min))
;; do not make undo records for the reversion.
(buffer-undo-list t))
(list-buffers-noselect Buffer-menu-files-only)
(while (setq prop (next-single-property-change prop 'buffer))
(when (eq (get-text-property prop 'buffer) oline)
(goto-char prop)
(move-to-column ocol)))))
(if oline
(while (setq prop (next-single-property-change prop 'buffer))
(when (eq (get-text-property prop 'buffer) oline)
(goto-char prop)
(move-to-column ocol)))
(goto-char (if eobp (point-max) opoint)))))
(defun Buffer-menu-toggle-files-only (arg)
"Toggle whether the current buffer-menu displays only file buffers.
@ -633,15 +637,29 @@ For more information, see the function `buffer-menu'."
(if (equal column Buffer-menu-sort-column) (setq column nil))
(propertize name
'help-echo (if column
(concat "mouse-2: sort by " (downcase name))
"mouse-2: sort by visited order")
(if Buffer-menu-use-header-line
(concat "mouse-2: sort by " (downcase name))
(concat "mouse-2, RET: sort by "
(downcase name)))
(if Buffer-menu-use-header-line
"mouse-2: sort by visited order"
"mouse-2, RET: sort by visited order"))
'mouse-face 'highlight
'keymap (let ((map (make-sparse-keymap)))
(define-key map [header-line mouse-2]
`(lambda (e)
(interactive "e")
(save-window-excursion
(if Buffer-menu-use-header-line
(define-key map [header-line mouse-2]
`(lambda (e)
(interactive "e")
(save-window-excursion
(if e (mouse-select-window e))
(Buffer-menu-sort ,column))))
(define-key map [mouse-2]
`(lambda (e)
(interactive "e")
(if e (mouse-select-window e))
(Buffer-menu-sort ,column)))
(define-key map "\C-m"
`(lambda () (interactive)
(Buffer-menu-sort ,column))))
map)))

25
lisp/calc/calc-prog.el
View File

@ -702,7 +702,7 @@
(get func 'calc-user-defn)))
(kys (concat "z" (char-to-string (car def))))
(intcmd (symbol-name (cdr def)))
(algcmd (substring (symbol-name func) 9)))
(algcmd (if func (substring (symbol-name func) 9) "")))
(if (and defn (calc-valid-formula-func func))
(let ((niceexpr (math-format-nice-expr defn (frame-width))))
(calc-wrapper
@ -1446,15 +1446,22 @@ Redefine the corresponding command."
(error "Unbalanced Z' in keyboard macro")))
(defun calc-kbd-report (msg)
(interactive "sMessage: ")
(calc-wrapper
(math-working msg (calc-top-n 1))))
;; (defun calc-kbd-report (msg)
;; (interactive "sMessage: ")
;; (calc-wrapper
;; (math-working msg (calc-top-n 1))))
(defun calc-kbd-query (msg)
(interactive "sPrompt: ")
(calc-wrapper
(calc-alg-entry nil (and (not (equal msg "")) msg))))
(defun calc-kbd-query ()
(interactive)
(let ((defining-kbd-macro nil)
(executing-kbd-macro nil)
(msg (calc-top 1)))
(if (not (eq (car-safe msg) 'vec))
(error "No prompt string provided")
(setq msg (math-vector-to-string msg))
(calc-wrapper
(calc-pop-stack 1)
(calc-alg-entry nil (and (not (equal msg "")) msg))))))
;;;; Logical operations.

120
lisp/calc/calc-units.el
View File

@ -555,7 +555,7 @@ Entries are (SYMBOL EXPR DOC-STRING TEMP-TYPE BASE-UNITS).")
(save-excursion
(goto-char (point-min))
(if (looking-at "Calculator Units Table")
(let ((buffer-read-only nil))
(let ((inhibit-read-only t))
(insert "(Obsolete) "))))))))
(defun calc-get-unit-definition (uname)
@ -1310,65 +1310,65 @@ Entries are (SYMBOL EXPR DOC-STRING TEMP-TYPE BASE-UNITS).")
(save-excursion
(message "Formatting units table...")
(set-buffer buf)
(setq buffer-read-only nil)
(erase-buffer)
(insert "Calculator Units Table:\n\n")
(insert "Unit Type Definition Description\n\n")
(while uptr
(setq u (car uptr)
name (nth 2 u))
(when (eq (car u) 'm)
(setq std t))
(setq shadowed (and std (assq (car u) math-additional-units)))
(when (and name
(> (length name) 1)
(eq (aref name 0) ?\*))
(unless (eq uptr math-units-table)
(insert "\n"))
(setq name (substring name 1)))
(insert " ")
(and shadowed (insert "("))
(insert (symbol-name (car u)))
(and shadowed (insert ")"))
(if (nth 3 u)
(progn
(indent-to 10)
(insert (symbol-name (nth 3 u))))
(or std
(progn
(indent-to 10)
(insert "U"))))
(indent-to 14)
(and shadowed (insert "("))
(if (nth 1 u)
(insert (math-format-value (nth 1 u) 80))
(insert (symbol-name (car u))))
(and shadowed (insert ")"))
(indent-to 41)
(insert " ")
(when name
(insert name))
(if shadowed
(insert " (redefined above)")
(unless (nth 1 u)
(insert " (base unit)")))
(insert "\n")
(setq uptr (cdr uptr)))
(insert "\n\nUnit Prefix Table:\n\n")
(setq uptr math-unit-prefixes)
(while uptr
(setq u (car uptr))
(insert " " (char-to-string (car u)))
(if (equal (nth 1 u) (nth 1 (nth 1 uptr)))
(insert " " (char-to-string (car (car (setq uptr (cdr uptr)))))
" ")
(insert " "))
(insert "10^" (int-to-string (nth 2 (nth 1 u))))
(indent-to 15)
(insert " " (nth 2 u) "\n")
(while (eq (car (car (setq uptr (cdr uptr)))) 0)))
(insert "\n")
(setq buffer-read-only t)
(let ((inhibit-read-only t))
(erase-buffer)
(insert "Calculator Units Table:\n\n")
(insert "Unit Type Definition Description\n\n")
(while uptr
(setq u (car uptr)
name (nth 2 u))
(when (eq (car u) 'm)
(setq std t))
(setq shadowed (and std (assq (car u) math-additional-units)))
(when (and name
(> (length name) 1)
(eq (aref name 0) ?\*))
(unless (eq uptr math-units-table)
(insert "\n"))
(setq name (substring name 1)))
(insert " ")
(and shadowed (insert "("))
(insert (symbol-name (car u)))
(and shadowed (insert ")"))
(if (nth 3 u)
(progn
(indent-to 10)
(insert (symbol-name (nth 3 u))))
(or std
(progn
(indent-to 10)
(insert "U"))))
(indent-to 14)
(and shadowed (insert "("))
(if (nth 1 u)
(insert (math-format-value (nth 1 u) 80))
(insert (symbol-name (car u))))
(and shadowed (insert ")"))
(indent-to 41)
(insert " ")
(when name
(insert name))
(if shadowed
(insert " (redefined above)")
(unless (nth 1 u)
(insert " (base unit)")))
(insert "\n")
(setq uptr (cdr uptr)))
(insert "\n\nUnit Prefix Table:\n\n")
(setq uptr math-unit-prefixes)
(while uptr
(setq u (car uptr))
(insert " " (char-to-string (car u)))
(if (equal (nth 1 u) (nth 1 (nth 1 uptr)))
(insert " " (char-to-string (car (car (setq uptr (cdr uptr)))))
" ")
(insert " "))
(insert "10^" (int-to-string (nth 2 (nth 1 u))))
(indent-to 15)
(insert " " (nth 2 u) "\n")
(while (eq (car (car (setq uptr (cdr uptr)))) 0)))
(insert "\n"))
(view-mode)
(message "Formatting units table...done"))
(setq math-units-table-buffer-valid t)
(let ((oldbuf (current-buffer)))

2
lisp/calc/calc-yank.el
View File

@ -447,7 +447,7 @@ To cancel the edit, simply kill the *Calc Edit* buffer."
(setq truncate-lines nil)
(setq major-mode 'calc-edit-mode)
(setq mode-name "Calc Edit")
(run-hooks 'calc-edit-mode-hook)
(run-mode-hooks 'calc-edit-mode-hook)
(make-local-variable 'calc-original-buffer)
(setq calc-original-buffer oldbuf)
(make-local-variable 'calc-return-buffer)

21
lisp/calc/calc.el
View File

@ -209,7 +209,8 @@
(defgroup calc nil
"GNU Calc"
:prefix "calc-"
:tag "Calc")
:tag "Calc"
:group 'applications)
;;;###autoload
(defcustom calc-settings-file
@ -830,20 +831,6 @@ If nil, selections displayed but ignored.")
(defvar var-gamma '(special-const (math-gamma-const)))
(defvar var-Modes '(special-const (math-get-modes-vec)))
(defvar calc-language-alist
'((latex-mode . latex)
(tex-mode . tex)
(plain-tex-mode . tex)
(context-mode . tex)
(nroff-mode . eqn)
(pascal-mode . pascal)
(c-mode . c)
(c++-mode . c)
(fortran-mode . fortran)
(f90-mode . fortran))
"Alist of major modes with appropriate Calc languages.")
(mapcar (lambda (v) (or (boundp v) (set v nil)))
calc-local-var-list)
@ -1131,7 +1118,7 @@ Notations: 3.14e6 3.14 * 10^6
(string-match "full" (nth 1 p))
(setq calc-standalone-flag t))
(setq p (cdr p))))
(run-hooks 'calc-mode-hook)
(run-mode-hooks 'calc-mode-hook)
(calc-refresh t)
(calc-set-mode-line)
(calc-check-defines))
@ -1181,7 +1168,7 @@ commands given here will actually operate on the *Calculator* stack."
(insert (propertize (concat "Emacs Calculator v" calc-version
" by Dave Gillespie\n")
'font-lock-face 'italic))))
(run-hooks 'calc-trail-mode-hook))
(run-mode-hooks 'calc-trail-mode-hook))
(defun calc-create-buffer ()
(set-buffer (get-buffer-create "*Calculator*"))

4
lisp/calculator.el
View File

@ -4,7 +4,7 @@
;; Author: Eli Barzilay <eli@barzilay.org>
;; Keywords: tools, convenience
;; Time-stamp: <2002-07-13 01:14:35 eli>
;; Time-stamp: <26 May 2005, 14:32:34, Lute Kamstra, pijl>
;; This file is part of GNU Emacs.
@ -680,7 +680,7 @@ more information.
(setq major-mode 'calculator-mode)
(setq mode-name "Calculator")
(use-local-map calculator-mode-map)
(run-hooks 'calculator-mode-hook))
(run-mode-hooks 'calculator-mode-hook))
(eval-when-compile (require 'electric) (require 'ehelp))

2
lisp/calendar/cal-menu.el
View File

@ -221,7 +221,7 @@ not available."
l)))
(setq l (cons ["Mark Holidays" mark-calendar-holidays t]
(cons ["Unmark Calendar" calendar-unmark t]
(cons ["--" '("--") t] l))))
(cons "--" l))))
(define-key calendar-mode-map [menu-bar Holidays]
(cons "Holidays" (easy-menu-create-menu "Holidays" (nreverse l))))
(define-key calendar-mode-map [menu-bar Holidays separator]

5
lisp/calendar/calendar.el
View File

@ -2335,6 +2335,7 @@ movement commands will not work correctly."
(propertize (substitute-command-keys
"\\<calendar-mode-map>\\[scroll-calendar-left]")
'help-echo "mouse-2: scroll left"
'mouse-face 'mode-line-highlight
'keymap (make-mode-line-mouse-map 'mouse-2
'mouse-scroll-calendar-left))
"Calendar"
@ -2343,12 +2344,14 @@ movement commands will not work correctly."
(substitute-command-keys
"\\<calendar-mode-map>\\[calendar-goto-info-node] info")
'help-echo "mouse-2: read Info on Calendar"
'mouse-face 'mode-line-highlight
'keymap (make-mode-line-mouse-map 'mouse-2 'calendar-goto-info-node))
"/"
(propertize
(substitute-command-keys
"\\<calendar-mode-map>\\[calendar-other-month] other")
'help-echo "mouse-2: choose another month"
'mouse-face 'mode-line-highlight
'keymap (make-mode-line-mouse-map
'mouse-2 'mouse-calendar-other-month))
"/"
@ -2356,11 +2359,13 @@ movement commands will not work correctly."
(substitute-command-keys
"\\<calendar-mode-map>\\[calendar-goto-today] today")
'help-echo "mouse-2: go to today's date"
'mouse-face 'mode-line-highlight
'keymap (make-mode-line-mouse-map 'mouse-2 #'calendar-goto-today)))
'(calendar-date-string (calendar-current-date) t)
(propertize (substitute-command-keys
"\\<calendar-mode-map>\\[scroll-calendar-right]")
'help-echo "mouse-2: scroll right"
'mouse-face 'mode-line-highlight
'keymap (make-mode-line-mouse-map
'mouse-2 'mouse-scroll-calendar-right)))
"The mode line of the calendar buffer.

3
lisp/calendar/todo-mode.el
View File

@ -904,11 +904,12 @@ Number of entries for each category is given by `todo-print-priorities'."
\\{todo-mode-map}"
(interactive)
(kill-all-local-variables)
(setq major-mode 'todo-mode)
(setq mode-name "TODO")
(use-local-map todo-mode-map)
(easy-menu-add todo-menu)
(run-hooks 'todo-mode-hook))
(run-mode-hooks 'todo-mode-hook))
(eval-when-compile
(defvar date)

2
lisp/chistory.el
View File

@ -145,7 +145,7 @@ Keybindings:
(setq major-mode 'command-history-mode)
(setq mode-name "Command History")
(use-local-map command-history-map)
(run-hooks 'command-history-mode-hook))
(run-mode-hooks 'command-history-mode-hook))
(defun Command-history-setup ()
(kill-all-local-variables)

2
lisp/comint.el
View File

@ -3437,7 +3437,7 @@ REGEXP-GROUP is the regular expression group in REGEXP to use."
;; (make-local-variable 'shell-directory-stack)
;; (setq shell-directory-stack nil)
;; (add-hook 'comint-input-filter-functions 'shell-directory-tracker)
;; (run-hooks 'shell-mode-hook))
;; (run-mode-hooks 'shell-mode-hook))
;;
;;
;; Completion for comint-mode users

2
lisp/cus-edit.el
View File

@ -4276,7 +4276,7 @@ if that value is non-nil."
(set (make-local-variable 'widget-link-prefix) "")
(set (make-local-variable 'widget-link-suffix) ""))
(add-hook 'widget-edit-functions 'custom-state-buffer-message nil t)
(run-hooks 'custom-mode-hook))
(run-mode-hooks 'custom-mode-hook))
(put 'custom-mode 'mode-class 'special)

2
lisp/descr-text.el
View File

@ -61,7 +61,7 @@ if that value is non-nil."
(use-local-map describe-text-mode-map)
(widget-setup)
(add-hook 'change-major-mode-hook 'font-lock-defontify nil t)
(run-hooks 'describe-text-mode-hook))
(run-mode-hooks 'describe-text-mode-hook))
;;; Describe-Text Utilities.

30
lisp/diff-mode.el
View File

@ -185,7 +185,8 @@ when editing big diffs)."
(((class color) (background dark))
:foreground "green" :weight bold)
(t :weight bold))
"`diff-mode' face inherited by hunk and index header faces.")
"`diff-mode' face inherited by hunk and index header faces."
:group 'diff-mode)
(defvar diff-header-face 'diff-header-face)
(defface diff-file-header-face
@ -198,27 +199,32 @@ when editing big diffs)."
(((class color) (background dark))
:foreground "cyan" :weight bold)
(t :weight bold)) ; :height 1.3
"`diff-mode' face used to highlight file header lines.")
"`diff-mode' face used to highlight file header lines."
:group 'diff-mode)
(defvar diff-file-header-face 'diff-file-header-face)
(defface diff-index-face
'((t :inherit diff-file-header-face))
"`diff-mode' face used to highlight index header lines.")
"`diff-mode' face used to highlight index header lines."
:group 'diff-mode)
(defvar diff-index-face 'diff-index-face)
(defface diff-hunk-header-face
'((t :inherit diff-header-face))
"`diff-mode' face used to highlight hunk header lines.")
"`diff-mode' face used to highlight hunk header lines."
:group 'diff-mode)
(defvar diff-hunk-header-face 'diff-hunk-header-face)
(defface diff-removed-face
'((t :inherit diff-changed-face))
"`diff-mode' face used to highlight removed lines.")
"`diff-mode' face used to highlight removed lines."
:group 'diff-mode)
(defvar diff-removed-face 'diff-removed-face)
(defface diff-added-face
'((t :inherit diff-changed-face))
"`diff-mode' face used to highlight added lines.")
"`diff-mode' face used to highlight added lines."
:group 'diff-mode)
(defvar diff-added-face 'diff-added-face)
(defface diff-changed-face
@ -226,12 +232,14 @@ when editing big diffs)."
:foreground "magenta" :weight bold :slant italic)
(((type tty pc) (class color) (background dark))
:foreground "yellow" :weight bold :slant italic))
"`diff-mode' face used to highlight changed lines.")
"`diff-mode' face used to highlight changed lines."
:group 'diff-mode)
(defvar diff-changed-face 'diff-changed-face)
(defface diff-function-face
'((t :inherit diff-context-face))
"`diff-mode' face used to highlight function names produced by \"diff -p\".")
"`diff-mode' face used to highlight function names produced by \"diff -p\"."
:group 'diff-mode)
(defvar diff-function-face 'diff-function-face)
(defface diff-context-face
@ -239,12 +247,14 @@ when editing big diffs)."
:foreground "grey50")
(((class color) (background dark))
:foreground "grey70"))
"`diff-mode' face used to highlight context and other side-information.")
"`diff-mode' face used to highlight context and other side-information."
:group 'diff-mode)
(defvar diff-context-face 'diff-context-face)
(defface diff-nonexistent-face
'((t :inherit diff-file-header-face))
"`diff-mode' face used to highlight nonexistent files in recursive diffs.")
"`diff-mode' face used to highlight nonexistent files in recursive diffs."
:group 'diff-mode)
(defvar diff-nonexistent-face 'diff-nonexistent-face)
(defconst diff-yank-handler '(diff-yank-function))

25
lisp/dired.el
View File

@ -418,7 +418,24 @@ Subexpression 2 must end right before the \\n or \\r.")
;; It is quicker to first find just an extension, then go back to the
;; start of that file name. So we do this complex MATCH-ANCHORED form.
(list (concat "\\(" (regexp-opt completion-ignored-extensions) "\\|#\\)$")
'(".+" (dired-move-to-filename) nil (0 dired-ignored-face)))))
'(".+" (dired-move-to-filename) nil (0 dired-ignored-face))))
;;
;; Files suffixed with `completion-ignored-extensions'
;; plus a character put in by -F.
'(eval .
(list (concat "\\(" (regexp-opt completion-ignored-extensions)
"\\|#\\)[*=|]$")
'(".+" (progn
(end-of-line)
;; If the last character is not part of the filename,
;; move back to the start of the filename
;; so it can be fontified.
;; Otherwise, leave point at the end of the line;
;; that way, nothing is fontified.
(unless (get-text-property (1- (point)) 'mouse-face)
(dired-move-to-filename)))
nil (0 dired-ignored-face))))
)
"Additional expressions to highlight in Dired mode.")
;;; Macros must be defined before they are used, for the byte compiler.
@ -3163,10 +3180,8 @@ Anything else means ask for each directory."
:group 'dired)
(defun dired-dnd-popup-notice ()
(x-popup-dialog
t
'("Recursive copies not enabled.\nSee variable dired-recursive-copies."
("Ok" . nil))))
(message-box
"Recursive copies not enabled.\nSee variable dired-recursive-copies."))
(defun dired-dnd-do-ask-action (uri)

2
lisp/ebuff-menu.el
View File

@ -162,7 +162,7 @@ Entry to this mode via command `electric-buffer-list' calls the value of
(setq major-mode 'Electric-buffer-menu-mode)
(goto-char (point-min))
(if (search-forward "\n." nil t) (forward-char -1))
(run-hooks 'electric-buffer-menu-mode-hook))
(run-mode-hooks 'electric-buffer-menu-mode-hook))
;; generally the same as Buffer-menu-mode-map
;; (except we don't indirect to global-map)

5
lisp/ediff-util.el
View File

@ -1,6 +1,7 @@
;;; ediff-util.el --- the core commands and utilities of ediff
;; Copyright (C) 1994, 95, 96, 97, 98, 99, 2000, 01, 02, 04 Free Software Foundation, Inc.
;; Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
;; 2004 Free Software Foundation, Inc.
;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
@ -116,7 +117,7 @@ Commands:
(kill-all-local-variables)
(setq major-mode 'ediff-mode)
(setq mode-name "Ediff")
(run-hooks 'ediff-mode-hook))
(run-mode-hooks 'ediff-mode-hook))

21
lisp/emacs-lisp/bytecomp.el
View File

@ -4055,27 +4055,6 @@ For example, invoke `emacs -batch -f batch-byte-recompile-directory .'."
(setq command-line-args-left (cdr command-line-args-left)))
(kill-emacs 0))
(make-obsolete-variable 'auto-fill-hook 'auto-fill-function "before 19.15")
(make-obsolete-variable 'blink-paren-hook 'blink-paren-function "before 19.15")
(make-obsolete-variable 'lisp-indent-hook 'lisp-indent-function "before 19.15")
(make-obsolete-variable 'inhibit-local-variables
"use enable-local-variables (with the reversed sense)."
"before 19.15")
(make-obsolete-variable 'unread-command-event
"use unread-command-events; which is a list of events rather than a single event."
"before 19.15")
(make-obsolete-variable 'suspend-hooks 'suspend-hook "before 19.15")
(make-obsolete-variable 'comment-indent-hook 'comment-indent-function "before 19.15")
(make-obsolete-variable 'meta-flag "use the set-input-mode function instead." "before 19.34")
(make-obsolete-variable 'before-change-function
"use before-change-functions; which is a list of functions rather than a single function."
"before 19.34")
(make-obsolete-variable 'after-change-function
"use after-change-functions; which is a list of functions rather than a single function."
"before 19.34")
(make-obsolete-variable 'font-lock-doc-string-face 'font-lock-string-face "before 19.34")
(provide 'byte-compile)
(provide 'bytecomp)

70
lisp/emacs-lisp/cl-extra.el
View File

@ -46,7 +46,8 @@
(defun coerce (x type)
"Coerce OBJECT to type TYPE.
TYPE is a Common Lisp type specifier."
TYPE is a Common Lisp type specifier.
\n(fn OBJECT TYPE)"
(cond ((eq type 'list) (if (listp x) x (append x nil)))
((eq type 'vector) (if (vectorp x) x (vconcat x)))
((eq type 'string) (if (stringp x) x (concat x)))
@ -120,16 +121,17 @@ strings case-insensitively."
(nreverse cl-res))))
(defun map (cl-type cl-func cl-seq &rest cl-rest)
"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."
"Map a FUNCTION across one or more SEQUENCEs, returning a sequence.
TYPE is the sequence type to return.
\n(fn TYPE FUNCTION SEQUENCE...)"
(let ((cl-res (apply 'mapcar* cl-func cl-seq cl-rest)))
(and cl-type (coerce cl-res cl-type))))
(defun maplist (cl-func cl-list &rest cl-rest)
"Map FUNC to each sublist of LIST or LISTS.
"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."
the elements themselves.
\n(fn FUNCTION LIST...)"
(if cl-rest
(let ((cl-res nil)
(cl-args (cons cl-list (copy-sequence cl-rest)))
@ -146,14 +148,16 @@ the elements themselves."
(nreverse cl-res))))
(defun cl-mapc (cl-func cl-seq &rest cl-rest)
"Like `mapcar', but does not accumulate values returned by the function."
"Like `mapcar', but does not accumulate values returned by the function.
\n(fn FUNCTION SEQUENCE...)"
(if cl-rest
(progn (apply 'map nil cl-func cl-seq cl-rest)
cl-seq)
(mapc cl-func cl-seq)))
(defun mapl (cl-func cl-list &rest cl-rest)
"Like `maplist', but does not accumulate values returned by the function."
"Like `maplist', but does not accumulate values returned by the function.
\n(fn FUNCTION LIST...)"
(if cl-rest
(apply 'maplist cl-func cl-list cl-rest)
(let ((cl-p cl-list))
@ -161,16 +165,19 @@ the elements themselves."
cl-list)
(defun mapcan (cl-func cl-seq &rest cl-rest)
"Like `mapcar', but nconc's together the values returned by the function."
"Like `mapcar', but nconc's together the values returned by the function.
\n(fn FUNCTION SEQUENCE...)"
(apply 'nconc (apply 'mapcar* cl-func cl-seq cl-rest)))
(defun mapcon (cl-func cl-list &rest cl-rest)
"Like `maplist', but nconc's together the values returned by the function."
"Like `maplist', but nconc's together the values returned by the function.
\n(fn FUNCTION LIST...)"
(apply 'nconc (apply 'maplist cl-func cl-list cl-rest)))
(defun some (cl-pred cl-seq &rest cl-rest)
"Return true if PREDICATE is true of any element of SEQ or SEQs.
If so, return the true (non-nil) value returned by PREDICATE."
If so, return the true (non-nil) value returned by PREDICATE.
\n(fn PREDICATE SEQ...)"
(if (or cl-rest (nlistp cl-seq))
(catch 'cl-some
(apply 'map nil
@ -183,7 +190,8 @@ If so, return the true (non-nil) value returned by PREDICATE."
cl-x)))
(defun every (cl-pred cl-seq &rest cl-rest)
"Return true if PREDICATE is true of every element of SEQ or SEQs."
"Return true if PREDICATE is true of every element of SEQ or SEQs.
\n(fn PREDICATE SEQ...)"
(if (or cl-rest (nlistp cl-seq))
(catch 'cl-every
(apply 'map nil
@ -195,11 +203,13 @@ If so, return the true (non-nil) value returned by PREDICATE."
(null cl-seq)))
(defun notany (cl-pred cl-seq &rest cl-rest)
"Return true if PREDICATE is false of every element of SEQ or SEQs."
"Return true if PREDICATE is false of every element of SEQ or SEQs.
\n(fn PREDICATE SEQ...)"
(not (apply 'some cl-pred cl-seq cl-rest)))
(defun notevery (cl-pred cl-seq &rest cl-rest)
"Return true if PREDICATE is false of some element of SEQ or SEQs."
"Return true if PREDICATE is false of some element of SEQ or SEQs.
\n(fn PREDICATE SEQ...)"
(not (apply 'every cl-pred cl-seq cl-rest)))
;;; Support for `loop'.
@ -332,16 +342,16 @@ If so, return the true (non-nil) value returned by PREDICATE."
(setq a (* (/ a (gcd a b)) b))))
a)))
(defun isqrt (a)
(defun isqrt (x)
"Return the integer square root of the argument."
(if (and (integerp a) (> a 0))
(let ((g (cond ((<= a 100) 10) ((<= a 10000) 100)
((<= a 1000000) 1000) (t a)))
(if (and (integerp x) (> x 0))
(let ((g (cond ((<= x 100) 10) ((<= x 10000) 100)
((<= x 1000000) 1000) (t x)))
g2)
(while (< (setq g2 (/ (+ g (/ a g)) 2)) g)
(while (< (setq g2 (/ (+ g (/ x g)) 2)) g)
(setq g g2))
g)
(if (eq a 0) 0 (signal 'arith-error nil))))
(if (eq x 0) 0 (signal 'arith-error nil))))
(defun floor* (x &optional y)
"Return a list of the floor of X and the fractional part of X.
@ -388,9 +398,9 @@ With two arguments, return rounding and remainder of their quotient."
"The remainder of X divided by Y, with the same sign as X."
(nth 1 (truncate* x y)))
(defun signum (a)
"Return 1 if A is positive, -1 if negative, 0 if zero."
(cond ((> a 0) 1) ((< a 0) -1) (t 0)))
(defun signum (x)
"Return 1 if X is positive, -1 if negative, 0 if zero."
(cond ((> x 0) 1) ((< x 0) -1) (t 0)))
;; Random numbers.
@ -514,7 +524,8 @@ If START or END is negative, it counts from the end."
res))))))
(defun concatenate (type &rest seqs)
"Concatenate, into a sequence of type TYPE, the argument SEQUENCES."
"Concatenate, into a sequence of type TYPE, the argument SEQUENCEs.
\n(fn TYPE SEQUENCE...)"
(cond ((eq type 'vector) (apply 'vconcat seqs))
((eq type 'string) (apply 'concat seqs))
((eq type 'list) (apply 'append (append seqs '(nil))))
@ -532,7 +543,7 @@ If START or END is negative, it counts from the end."
(nconc (nreverse x) y))
(defun list-length (x)
"Return the length of a list. Return nil if list is circular."
"Return the length of list X. Return nil if list is circular."
(let ((n 0) (fast x) (slow x))
(while (and (cdr fast) (not (and (eq fast slow) (> n 0))))
(setq n (+ n 2) fast (cdr (cdr fast)) slow (cdr slow)))
@ -550,7 +561,8 @@ If START or END is negative, it counts from the end."
;;; Property lists.
(defun get* (sym tag &optional def) ; See compiler macro in cl-macs.el
"Return the value of SYMBOL's PROPNAME property, or DEFAULT if none."
"Return the value of SYMBOL's PROPNAME property, or DEFAULT if none.
\n(fn SYMBOL PROPNAME &optional DEFAULT)"
(or (get sym tag)
(and def
(let ((plist (symbol-plist sym)))
@ -560,7 +572,8 @@ If START or END is negative, it counts from the end."
(defun getf (plist tag &optional def)
"Search PROPLIST for property PROPNAME; return its value or DEFAULT.
PROPLIST is a list of the sort returned by `symbol-plist'."
PROPLIST is a list of the sort returned by `symbol-plist'.
\n(fn PROPLIST PROPNAME &optional DEFAULT)"
(setplist '--cl-getf-symbol-- plist)
(or (get '--cl-getf-symbol-- tag)
;; Originally we called get* here,
@ -582,7 +595,8 @@ PROPLIST is a list of the sort returned by `symbol-plist'."
(and (cdr p) (progn (setcdr p (cdr (cdr (cdr p)))) t))))
(defun cl-remprop (sym tag)
"Remove from SYMBOL's plist the property PROP and its value."
"Remove from SYMBOL's plist the property PROPNAME and its value.
\n(fn SYMBOL PROPNAME)"
(let ((plist (symbol-plist sym)))
(if (and plist (eq tag (car plist)))
(progn (setplist sym (cdr (cdr plist))) t)

38
lisp/emacs-lisp/cl-macs.el
View File

@ -207,8 +207,8 @@ and BODY is implicitly surrounded by (block NAME ...).
(defmacro function* (func)
"Introduce a function.
Like normal `function', except that if argument is a lambda form, its
ARGLIST allows full Common Lisp conventions."
Like normal `function', except that if argument is a lambda form,
its argument list allows full Common Lisp conventions."
(if (eq (car-safe func) 'lambda)
(let* ((res (cl-transform-lambda (cdr func) 'cl-none))
(form (list 'function (cons 'lambda (cdr res)))))
@ -488,13 +488,14 @@ The result of the body appears to the compiler as a quoted constant."
;;; Conditional control structures.
(defmacro case (expr &rest clauses)
"Eval EXPR and choose from CLAUSES on that value.
"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'."
Key values are compared by `eql'.
\n(fn EXPR (KEYLIST BODY...)...)"
(let* ((temp (if (cl-simple-expr-p expr 3) expr (make-symbol "--cl-var--")))
(head-list nil)
(body (cons
@ -522,15 +523,17 @@ Key values are compared by `eql'."
(defmacro ecase (expr &rest clauses)
"Like `case', but error if no case fits.
`otherwise'-clauses are not allowed."
`otherwise'-clauses are not allowed.
\n(fn EXPR (KEYLIST BODY...)...)"
(list* 'case expr (append clauses '((ecase-error-flag)))))
(defmacro typecase (expr &rest clauses)
"Evals EXPR, chooses from CLAUSES on that value.
"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."
final clause, and matches if no other keys match.
\n(fn EXPR (TYPE BODY...)...)"
(let* ((temp (if (cl-simple-expr-p expr 3) expr (make-symbol "--cl-var--")))
(type-list nil)
(body (cons
@ -552,7 +555,8 @@ final clause, and matches if no other keys match."
(defmacro etypecase (expr &rest clauses)
"Like `typecase', but error if no case fits.
`otherwise'-clauses are not allowed."
`otherwise'-clauses are not allowed.
\n(fn EXPR (TYPE BODY...)...)"
(list* 'typecase expr (append clauses '((ecase-error-flag)))))
@ -1273,7 +1277,7 @@ before assigning any symbols SYM to the corresponding values.
(defmacro progv (symbols values &rest body)
"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
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."
@ -1284,7 +1288,7 @@ a `let' form, except that the list of symbols can be computed at run-time."
;;; This should really have some way to shadow 'byte-compile properties, etc.
(defmacro flet (bindings &rest body)
"Make temporary function defns.
"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
@ -1311,7 +1315,7 @@ go back to their previous definitions, or lack thereof).
body))
(defmacro labels (bindings &rest body)
"Make temporary func bindings.
"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.
@ -1369,7 +1373,8 @@ by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...).
(defmacro lexical-let (bindings &rest body)
"Like `let', but lexically scoped.
The main visible difference is that lambdas inside BODY will create
lexical closures as in Common Lisp."
lexical closures as in Common Lisp.
\n(fn VARLIST BODY)"
(let* ((cl-closure-vars cl-closure-vars)
(vars (mapcar (function
(lambda (x)
@ -1411,7 +1416,8 @@ lexical closures as in Common Lisp."
(defmacro lexical-let* (bindings &rest body)
"Like `let*', but lexically scoped.
The main visible difference is that lambdas inside BODY will create
lexical closures as in Common Lisp."
lexical closures as in Common Lisp.
\n(fn VARLIST BODY)"
(if (null bindings) (cons 'progn body)
(setq bindings (reverse bindings))
(while bindings
@ -1435,7 +1441,7 @@ 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 SYM...) FORM BODY)"
\(fn (SYM...) FORM BODY)"
(let ((temp (make-symbol "--cl-var--")) (n -1))
(list* 'let* (cons (list temp form)
(mapcar (function
@ -1451,7 +1457,7 @@ 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 SYM...) FORM)"
\(fn (SYM...) FORM)"
(cond ((null vars) (list 'progn form nil))
((null (cdr vars)) (list 'setq (car vars) (list 'car form)))
(t
@ -1967,7 +1973,7 @@ The form returns true if TAG was found and removed, nil otherwise."
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 PLACE... VAL)"
\(fn PLACE... VAL)"
(cond
((null args) place)
((symbolp place) `(prog1 ,place (setq ,place (shiftf ,@args))))

209
lisp/emacs-lisp/cl-seq.el
View File

@ -125,8 +125,9 @@
(defun reduce (cl-func cl-seq &rest cl-keys)
"Reduce two-argument FUNCTION across SEQUENCE.
Keywords supported: :start :end :from-end :initial-value :key"
"Reduce two-argument FUNCTION across SEQ.
\nKeywords supported: :start :end :from-end :initial-value :key
\n(fn FUNCTION SEQ [KEYWORD VALUE]...)"
(cl-parsing-keywords (:from-end (:start 0) :end :initial-value :key) ()
(or (listp cl-seq) (setq cl-seq (append cl-seq nil)))
(setq cl-seq (subseq cl-seq cl-start cl-end))
@ -145,7 +146,8 @@ Keywords supported: :start :end :from-end :initial-value :key"
(defun fill (seq item &rest cl-keys)
"Fill the elements of SEQ with ITEM.
Keywords supported: :start :end"
\nKeywords supported: :start :end
\n(fn SEQ ITEM [KEYWORD VALUE]...)"
(cl-parsing-keywords ((:start 0) :end) ()
(if (listp seq)
(let ((p (nthcdr cl-start seq))
@ -164,7 +166,8 @@ Keywords supported: :start :end"
(defun replace (cl-seq1 cl-seq2 &rest cl-keys)
"Replace the elements of SEQ1 with the elements of SEQ2.
SEQ1 is destructively modified, then returned.
Keywords supported: :start1 :end1 :start2 :end2"
\nKeywords supported: :start1 :end1 :start2 :end2
\n(fn SEQ1 SEQ2 [KEYWORD VALUE]...)"
(cl-parsing-keywords ((:start1 0) :end1 (:start2 0) :end2) ()
(if (and (eq cl-seq1 cl-seq2) (<= cl-start2 cl-start1))
(or (= cl-start1 cl-start2)
@ -206,7 +209,8 @@ Keywords supported: :start1 :end1 :start2 :end2"
"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"
\nKeywords supported: :test :test-not :key :count :start :end :from-end
\n(fn ITEM SEQ [KEYWORD VALUE]...)"
(cl-parsing-keywords (:test :test-not :key :if :if-not :count :from-end
(:start 0) :end) ()
(if (<= (or cl-count (setq cl-count 8000000)) 0)
@ -250,20 +254,23 @@ Keywords supported: :test :test-not :key :count :start :end :from-end"
"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"
\nKeywords supported: :key :count :start :end :from-end
\n(fn PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'remove* nil cl-list :if cl-pred cl-keys))
(defun remove-if-not (cl-pred cl-list &rest cl-keys)
"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"
\nKeywords supported: :key :count :start :end :from-end
\n(fn PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'remove* nil cl-list :if-not cl-pred cl-keys))
(defun delete* (cl-item cl-seq &rest cl-keys)
"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"
\nKeywords supported: :test :test-not :key :count :start :end :from-end
\n(fn ITEM SEQ [KEYWORD VALUE]...)"
(cl-parsing-keywords (:test :test-not :key :if :if-not :count :from-end
(:start 0) :end) ()
(if (<= (or cl-count (setq cl-count 8000000)) 0)
@ -305,23 +312,27 @@ Keywords supported: :test :test-not :key :count :start :end :from-end"
(defun delete-if (cl-pred cl-list &rest cl-keys)
"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"
\nKeywords supported: :key :count :start :end :from-end
\n(fn PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'delete* nil cl-list :if cl-pred cl-keys))
(defun delete-if-not (cl-pred cl-list &rest cl-keys)
"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"
\nKeywords supported: :key :count :start :end :from-end
\n(fn PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'delete* nil cl-list :if-not cl-pred cl-keys))
(defun remove-duplicates (cl-seq &rest cl-keys)
"Return a copy of SEQ with all duplicate elements removed.
Keywords supported: :test :test-not :key :start :end :from-end"
\nKeywords supported: :test :test-not :key :start :end :from-end
\n(fn SEQ [KEYWORD VALUE]...)"
(cl-delete-duplicates cl-seq cl-keys t))
(defun delete-duplicates (cl-seq &rest cl-keys)
"Remove all duplicate elements from SEQ (destructively).
Keywords supported: :test :test-not :key :start :end :from-end"
\nKeywords supported: :test :test-not :key :start :end :from-end
\n(fn SEQ [KEYWORD VALUE]...)"
(cl-delete-duplicates cl-seq cl-keys nil))
(defun cl-delete-duplicates (cl-seq cl-keys cl-copy)
@ -368,7 +379,8 @@ Keywords supported: :test :test-not :key :start :end :from-end"
"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"
\nKeywords supported: :test :test-not :key :count :start :end :from-end
\n(fn NEW OLD SEQ [KEYWORD VALUE]...)"
(cl-parsing-keywords (:test :test-not :key :if :if-not :count
(:start 0) :end :from-end) ()
(if (or (eq cl-old cl-new)
@ -388,20 +400,23 @@ Keywords supported: :test :test-not :key :count :start :end :from-end"
"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"
\nKeywords supported: :key :count :start :end :from-end
\n(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'substitute cl-new nil cl-list :if cl-pred cl-keys))
(defun substitute-if-not (cl-new cl-pred cl-list &rest cl-keys)
"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"
\nKeywords supported: :key :count :start :end :from-end
\n(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'substitute cl-new nil cl-list :if-not cl-pred cl-keys))
(defun nsubstitute (cl-new cl-old cl-seq &rest cl-keys)
"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"
\nKeywords supported: :test :test-not :key :count :start :end :from-end
\n(fn NEW OLD SEQ [KEYWORD VALUE]...)"
(cl-parsing-keywords (:test :test-not :key :if :if-not :count
(:start 0) :end :from-end) ()
(or (eq cl-old cl-new) (<= (or cl-count (setq cl-count 8000000)) 0)
@ -433,38 +448,44 @@ Keywords supported: :test :test-not :key :count :start :end :from-end"
(defun nsubstitute-if (cl-new cl-pred cl-list &rest cl-keys)
"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"
\nKeywords supported: :key :count :start :end :from-end
\n(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'nsubstitute cl-new nil cl-list :if cl-pred cl-keys))
(defun nsubstitute-if-not (cl-new cl-pred cl-list &rest cl-keys)
"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"
\nKeywords supported: :key :count :start :end :from-end
\n(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'nsubstitute cl-new nil cl-list :if-not cl-pred cl-keys))
(defun find (cl-item cl-seq &rest cl-keys)
"Find the first occurrence of ITEM in LIST.
"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"
\nKeywords supported: :test :test-not :key :start :end :from-end
\n(fn ITEM SEQ [KEYWORD VALUE]...)"
(let ((cl-pos (apply 'position cl-item cl-seq cl-keys)))
(and cl-pos (elt cl-seq cl-pos))))
(defun find-if (cl-pred cl-list &rest cl-keys)
"Find the first item satisfying PREDICATE in LIST.
Return the matching ITEM, or nil if not found.
Keywords supported: :key :start :end :from-end"
"Find the first item satisfying PREDICATE in SEQ.
Return the matching item, or nil if not found.
\nKeywords supported: :key :start :end :from-end
\n(fn PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'find nil cl-list :if cl-pred cl-keys))
(defun find-if-not (cl-pred cl-list &rest cl-keys)
"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"
"Find the first item not satisfying PREDICATE in SEQ.
Return the matching item, or nil if not found.
\nKeywords supported: :key :start :end :from-end
\n(fn PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'find nil cl-list :if-not cl-pred cl-keys))
(defun position (cl-item cl-seq &rest cl-keys)
"Find the first occurrence of ITEM in LIST.
"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"
\nKeywords supported: :test :test-not :key :start :end :from-end
\n(fn ITEM SEQ [KEYWORD VALUE]...)"
(cl-parsing-keywords (:test :test-not :key :if :if-not
(:start 0) :end :from-end) ()
(cl-position cl-item cl-seq cl-start cl-end cl-from-end)))
@ -491,20 +512,23 @@ Keywords supported: :test :test-not :key :start :end :from-end"
(and (< cl-start cl-end) cl-start))))
(defun position-if (cl-pred cl-list &rest cl-keys)
"Find the first item satisfying PREDICATE in LIST.
"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"
\nKeywords supported: :key :start :end :from-end
\n(fn PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'position nil cl-list :if cl-pred cl-keys))
(defun position-if-not (cl-pred cl-list &rest cl-keys)
"Find the first item not satisfying PREDICATE in LIST.
"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"
\nKeywords supported: :key :start :end :from-end
\n(fn PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'position nil cl-list :if-not cl-pred cl-keys))
(defun count (cl-item cl-seq &rest cl-keys)
"Count the number of occurrences of ITEM in LIST.
Keywords supported: :test :test-not :key :start :end"
"Count the number of occurrences of ITEM in SEQ.
\nKeywords supported: :test :test-not :key :start :end
\n(fn ITEM SEQ [KEYWORD VALUE]...)"
(cl-parsing-keywords (:test :test-not :key :if :if-not (:start 0) :end) ()
(let ((cl-count 0) cl-x)
(or cl-end (setq cl-end (length cl-seq)))
@ -516,20 +540,23 @@ Keywords supported: :test :test-not :key :start :end"
cl-count)))
(defun count-if (cl-pred cl-list &rest cl-keys)
"Count the number of items satisfying PREDICATE in LIST.
Keywords supported: :key :start :end"
"Count the number of items satisfying PREDICATE in SEQ.
\nKeywords supported: :key :start :end
\n(fn PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'count nil cl-list :if cl-pred cl-keys))
(defun count-if-not (cl-pred cl-list &rest cl-keys)
"Count the number of items not satisfying PREDICATE in LIST.
Keywords supported: :key :start :end"
"Count the number of items not satisfying PREDICATE in SEQ.
\nKeywords supported: :key :start :end
\n(fn PREDICATE SEQ [KEYWORD VALUE]...)"
(apply 'count nil cl-list :if-not cl-pred cl-keys))
(defun mismatch (cl-seq1 cl-seq2 &rest cl-keys)
"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"
\nKeywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end
\n(fn SEQ1 SEQ2 [KEYWORD VALUE]...)"
(cl-parsing-keywords (:test :test-not :key :from-end
(:start1 0) :end1 (:start2 0) :end2) ()
(or cl-end1 (setq cl-end1 (length cl-seq1)))
@ -558,7 +585,8 @@ Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end"
"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"
\nKeywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end
\n(fn SEQ1 SEQ2 [KEYWORD VALUE]...)"
(cl-parsing-keywords (:test :test-not :key :from-end
(:start1 0) :end1 (:start2 0) :end2) ()
(or cl-end1 (setq cl-end1 (length cl-seq1)))
@ -580,9 +608,10 @@ Keywords supported: :test :test-not :key :start1 :end1 :start2 :end2 :from-end"
(and (< cl-start2 cl-end2) cl-pos)))))
(defun sort* (cl-seq cl-pred &rest cl-keys)
"Sort the argument SEQUENCE according to PREDICATE.
This is a destructive function; it reuses the storage of SEQUENCE if possible.
Keywords supported: :key"
"Sort the argument SEQ according to PREDICATE.
This is a destructive function; it reuses the storage of SEQ if possible.
\nKeywords supported: :key
\n(fn SEQ PREDICATE [KEYWORD VALUE]...)"
(if (nlistp cl-seq)
(replace cl-seq (apply 'sort* (append cl-seq nil) cl-pred cl-keys))
(cl-parsing-keywords (:key) ()
@ -593,16 +622,18 @@ Keywords supported: :key"
(funcall cl-key cl-y)))))))))
(defun stable-sort (cl-seq cl-pred &rest cl-keys)
"Sort the argument SEQUENCE stably according to PREDICATE.
This is a destructive function; it reuses the storage of SEQUENCE if possible.
Keywords supported: :key"
"Sort the argument SEQ stably according to PREDICATE.
This is a destructive function; it reuses the storage of SEQ if possible.
\nKeywords supported: :key
\n(fn SEQ PREDICATE [KEYWORD VALUE]...)"
(apply 'sort* cl-seq cl-pred cl-keys))
(defun merge (cl-type cl-seq1 cl-seq2 cl-pred &rest cl-keys)
"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"
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.
\nKeywords supported: :key
\n(fn TYPE SEQ1 SEQ2 PREDICATE [KEYWORD VALUE]...)"
(or (listp cl-seq1) (setq cl-seq1 (append cl-seq1 nil)))
(or (listp cl-seq2) (setq cl-seq2 (append cl-seq2 nil)))
(cl-parsing-keywords (:key) ()
@ -618,7 +649,8 @@ Keywords supported: :key"
(defun member* (cl-item cl-list &rest cl-keys)
"Find the first occurrence of ITEM in LIST.
Return the sublist of LIST whose car is ITEM.
Keywords supported: :test :test-not :key"
\nKeywords supported: :test :test-not :key
\n(fn ITEM LIST [KEYWORD VALUE]...)"
(if cl-keys
(cl-parsing-keywords (:test :test-not :key :if :if-not) ()
(while (and cl-list (not (cl-check-test cl-item (car cl-list))))
@ -631,13 +663,15 @@ Keywords supported: :test :test-not :key"
(defun member-if (cl-pred cl-list &rest cl-keys)
"Find the first item satisfying PREDICATE in LIST.
Return the sublist of LIST whose car matches.
Keywords supported: :key"
\nKeywords supported: :key
\n(fn PREDICATE LIST [KEYWORD VALUE]...)"
(apply 'member* nil cl-list :if cl-pred cl-keys))
(defun member-if-not (cl-pred cl-list &rest cl-keys)
"Find the first item not satisfying PREDICATE in LIST.
Return the sublist of LIST whose car matches.
Keywords supported: :key"
\nKeywords supported: :key
\n(fn PREDICATE LIST [KEYWORD VALUE]...)"
(apply 'member* nil cl-list :if-not cl-pred cl-keys))
(defun cl-adjoin (cl-item cl-list &rest cl-keys)
@ -649,7 +683,8 @@ Keywords supported: :key"
;;; See compiler macro in cl-macs.el
(defun assoc* (cl-item cl-alist &rest cl-keys)
"Find the first item whose car matches ITEM in LIST.
Keywords supported: :test :test-not :key"
\nKeywords supported: :test :test-not :key
\n(fn ITEM LIST [KEYWORD VALUE]...)"
(if cl-keys
(cl-parsing-keywords (:test :test-not :key :if :if-not) ()
(while (and cl-alist
@ -663,17 +698,20 @@ Keywords supported: :test :test-not :key"
(defun assoc-if (cl-pred cl-list &rest cl-keys)
"Find the first item whose car satisfies PREDICATE in LIST.
Keywords supported: :key"
\nKeywords supported: :key
\n(fn PREDICATE LIST [KEYWORD VALUE]...)"
(apply 'assoc* nil cl-list :if cl-pred cl-keys))
(defun assoc-if-not (cl-pred cl-list &rest cl-keys)
"Find the first item whose car does not satisfy PREDICATE in LIST.
Keywords supported: :key"
\nKeywords supported: :key
\n(fn PREDICATE LIST [KEYWORD VALUE]...)"
(apply 'assoc* nil cl-list :if-not cl-pred cl-keys))
(defun rassoc* (cl-item cl-alist &rest cl-keys)
"Find the first item whose cdr matches ITEM in LIST.
Keywords supported: :test :test-not :key"
\nKeywords supported: :test :test-not :key
\n(fn ITEM LIST [KEYWORD VALUE]...)"
(if (or cl-keys (numberp cl-item))
(cl-parsing-keywords (:test :test-not :key :if :if-not) ()
(while (and cl-alist
@ -685,12 +723,14 @@ Keywords supported: :test :test-not :key"
(defun rassoc-if (cl-pred cl-list &rest cl-keys)
"Find the first item whose cdr satisfies PREDICATE in LIST.
Keywords supported: :key"
\nKeywords supported: :key
\n(fn PREDICATE LIST [KEYWORD VALUE]...)"
(apply 'rassoc* nil cl-list :if cl-pred cl-keys))
(defun rassoc-if-not (cl-pred cl-list &rest cl-keys)
"Find the first item whose cdr does not satisfy PREDICATE in LIST.
Keywords supported: :key"
\nKeywords supported: :key
\n(fn PREDICATE LIST [KEYWORD VALUE]...)"
(apply 'rassoc* nil cl-list :if-not cl-pred cl-keys))
(defun union (cl-list1 cl-list2 &rest cl-keys)
@ -698,7 +738,8 @@ Keywords supported: :key"
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"
\nKeywords supported: :test :test-not :key
\n(fn LIST1 LIST2 [KEYWORD VALUE]...)"
(cond ((null cl-list1) cl-list2) ((null cl-list2) cl-list1)
((equal cl-list1 cl-list2) cl-list1)
(t
@ -717,7 +758,8 @@ Keywords supported: :test :test-not :key"
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"
\nKeywords supported: :test :test-not :key
\n(fn LIST1 LIST2 [KEYWORD VALUE]...)"
(cond ((null cl-list1) cl-list2) ((null cl-list2) cl-list1)
(t (apply 'union cl-list1 cl-list2 cl-keys))))
@ -726,7 +768,8 @@ Keywords supported: :test :test-not :key"
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"
\nKeywords supported: :test :test-not :key
\n(fn LIST1 LIST2 [KEYWORD VALUE]...)"
(and cl-list1 cl-list2
(if (equal cl-list1 cl-list2) cl-list1
(cl-parsing-keywords (:key) (:test :test-not)
@ -747,7 +790,8 @@ Keywords supported: :test :test-not :key"
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"
\nKeywords supported: :test :test-not :key
\n(fn LIST1 LIST2 [KEYWORD VALUE]...)"
(and cl-list1 cl-list2 (apply 'intersection cl-list1 cl-list2 cl-keys)))
(defun set-difference (cl-list1 cl-list2 &rest cl-keys)
@ -755,7 +799,8 @@ Keywords supported: :test :test-not :key"
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"
\nKeywords supported: :test :test-not :key
\n(fn LIST1 LIST2 [KEYWORD VALUE]...)"
(if (or (null cl-list1) (null cl-list2)) cl-list1
(cl-parsing-keywords (:key) (:test :test-not)
(let ((cl-res nil))
@ -773,7 +818,8 @@ Keywords supported: :test :test-not :key"
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"
\nKeywords supported: :test :test-not :key
\n(fn LIST1 LIST2 [KEYWORD VALUE]...)"
(if (or (null cl-list1) (null cl-list2)) cl-list1
(apply 'set-difference cl-list1 cl-list2 cl-keys)))
@ -782,7 +828,8 @@ Keywords supported: :test :test-not :key"
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"
\nKeywords supported: :test :test-not :key
\n(fn LIST1 LIST2 [KEYWORD VALUE]...)"
(cond ((null cl-list1) cl-list2) ((null cl-list2) cl-list1)
((equal cl-list1 cl-list2) nil)
(t (append (apply 'set-difference cl-list1 cl-list2 cl-keys)
@ -793,7 +840,8 @@ Keywords supported: :test :test-not :key"
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"
\nKeywords supported: :test :test-not :key
\n(fn LIST1 LIST2 [KEYWORD VALUE]...)"
(cond ((null cl-list1) cl-list2) ((null cl-list2) cl-list1)
((equal cl-list1 cl-list2) nil)
(t (nconc (apply 'nset-difference cl-list1 cl-list2 cl-keys)
@ -802,7 +850,8 @@ Keywords supported: :test :test-not :key"
(defun subsetp (cl-list1 cl-list2 &rest cl-keys)
"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"
\nKeywords supported: :test :test-not :key
\n(fn LIST1 LIST2 [KEYWORD VALUE]...)"
(cond ((null cl-list1) t) ((null cl-list2) nil)
((equal cl-list1 cl-list2) t)
(t (cl-parsing-keywords (:key) (:test :test-not)
@ -815,38 +864,44 @@ Keywords supported: :test :test-not :key"
(defun subst-if (cl-new cl-pred cl-tree &rest cl-keys)
"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"
\nKeywords supported: :key
\n(fn NEW PREDICATE TREE [KEYWORD VALUE]...)"
(apply 'sublis (list (cons nil cl-new)) cl-tree :if cl-pred cl-keys))
(defun subst-if-not (cl-new cl-pred cl-tree &rest cl-keys)
"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"
\nKeywords supported: :key
\n(fn NEW PREDICATE TREE [KEYWORD VALUE]...)"
(apply 'sublis (list (cons nil cl-new)) cl-tree :if-not cl-pred cl-keys))
(defun nsubst (cl-new cl-old cl-tree &rest cl-keys)
"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"
\nKeywords supported: :test :test-not :key
\n(fn NEW OLD TREE [KEYWORD VALUE]...)"
(apply 'nsublis (list (cons cl-old cl-new)) cl-tree cl-keys))
(defun nsubst-if (cl-new cl-pred cl-tree &rest cl-keys)
"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"
\nKeywords supported: :key
\n(fn NEW PREDICATE TREE [KEYWORD VALUE]...)"
(apply 'nsublis (list (cons nil cl-new)) cl-tree :if cl-pred cl-keys))
(defun nsubst-if-not (cl-new cl-pred cl-tree &rest cl-keys)
"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"
\nKeywords supported: :key
\n(fn NEW PREDICATE TREE [KEYWORD VALUE]...)"
(apply 'nsublis (list (cons nil cl-new)) cl-tree :if-not cl-pred cl-keys))
(defun sublis (cl-alist cl-tree &rest cl-keys)
"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"
\nKeywords supported: :test :test-not :key
\n(fn ALIST TREE [KEYWORD VALUE]...)"
(cl-parsing-keywords (:test :test-not :key :if :if-not) ()
(cl-sublis-rec cl-tree)))
@ -867,7 +922,8 @@ Keywords supported: :test :test-not :key"
(defun nsublis (cl-alist cl-tree &rest cl-keys)
"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"
\nKeywords supported: :test :test-not :key
\n(fn ALIST TREE [KEYWORD VALUE]...)"
(cl-parsing-keywords (:test :test-not :key :if :if-not) ()
(let ((cl-hold (list cl-tree)))
(cl-nsublis-rec cl-hold)
@ -888,9 +944,10 @@ Keywords supported: :test :test-not :key"
(setq cl-tree (cdr cl-tree))))))
(defun tree-equal (cl-x cl-y &rest cl-keys)
"Return t if trees X and Y have `eql' leaves.
"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"
\nKeywords supported: :test :test-not :key
\n(fn TREE1 TREE2 [KEYWORD VALUE]...)"
(cl-parsing-keywords (:test :test-not :key) ()
(cl-tree-equal-rec cl-x cl-y)))

69
lisp/emacs-lisp/cl.el
View File

@ -112,16 +112,6 @@ a future Emacs interpreter will be able to use it.")
(defun cl-cannot-unload ()
(error "Cannot unload the feature `cl'"))
;;; Predicates.
(defun eql (a b) ; See compiler macro in cl-macs.el
"Return t if the two args are the same Lisp object.
Floating-point numbers of equal value are `eql', but they may not be `eq'."
(if (numberp a)
(equal a b)
(eq a b)))
;;; Generalized variables. These macros are defined here so that they
;;; can safely be used in .emacs files.
@ -162,7 +152,8 @@ be a symbol, or any generalized variable allowed by `setf'."
"(pushnew X PLACE): insert X at the head of the list if not already there.
Like (push X PLACE), except that the list is unmodified if X is `eql' to
an element already on the list.
Keywords supported: :test :test-not :key"
\nKeywords supported: :test :test-not :key
\n(fn X PLACE [KEYWORD VALUE]...)"
(if (symbolp place) (list 'setq place (list* 'adjoin x place keys))
(list* 'callf2 'adjoin x place keys)))
@ -256,7 +247,8 @@ Otherwise, the macro is expanded and the expansion is considered
in place of FORM. When a non-macro-call results, it is returned.
The second optional arg ENVIRONMENT specifies an environment of macro
definitions to shadow the loaded ones for use in file byte-compilation."
definitions to shadow the loaded ones for use in file byte-compilation.
\n(fn FORM &optional ENVIRONMENT)"
(let ((cl-macro-environment cl-env))
(while (progn (setq cl-macro (funcall cl-old-macroexpand cl-macro cl-env))
(and (symbolp cl-macro)
@ -300,27 +292,27 @@ definitions to shadow the loaded ones for use in file byte-compilation."
;;; Numbers.
(defun floatp-safe (x)
(defun floatp-safe (object)
"Return t if OBJECT is a floating point number.
On Emacs versions that lack floating-point support, this function
always returns nil."
(and (numberp x) (not (integerp x))))
(and (numberp object) (not (integerp object))))
(defun plusp (x)
(defun plusp (number)
"Return t if NUMBER is positive."
(> x 0))
(> number 0))
(defun minusp (x)
(defun minusp (number)
"Return t if NUMBER is negative."
(< x 0))
(< number 0))
(defun oddp (x)
(defun oddp (integer)
"Return t if INTEGER is odd."
(eq (logand x 1) 1))
(eq (logand integer 1) 1))
(defun evenp (x)
(defun evenp (integer)
"Return t if INTEGER is even."
(eq (logand x 1) 0))
(eq (logand integer 1) 0))
(defvar *random-state* (vector 'cl-random-state-tag -1 30 (cl-random-time)))
@ -344,7 +336,8 @@ always returns nil."
If there are several SEQs, FUNCTION is called with that many arguments,
and mapping stops as soon as the shortest list runs out. With just one
SEQ, this is like `mapcar'. With several, it is like the Common Lisp
`mapcar' function extended to arbitrary sequence types."
`mapcar' function extended to arbitrary sequence types.
\n(fn FUNCTION SEQ...)"
(if cl-rest
(if (or (cdr cl-rest) (nlistp cl-x) (nlistp (car cl-rest)))
(cl-mapcar-many cl-func (cons cl-x cl-rest))
@ -503,9 +496,10 @@ SEQ, this is like `mapcar'. With several, it is like the Common Lisp
;; x))
(defun list* (arg &rest rest) ; See compiler macro in cl-macs.el
"Return a new list with specified args as elements, consed to last arg.
"Return a new list with specified ARGs as elements, consed to last ARG.
Thus, `(list* A B C D)' is equivalent to `(nconc (list A B C) D)', or to
`(cons A (cons B (cons C D)))'."
`(cons A (cons B (cons C D)))'.
\n(fn ARG...)"
(cond ((not rest) arg)
((not (cdr rest)) (cons arg (car rest)))
(t (let* ((n (length rest))
@ -522,8 +516,8 @@ Thus, `(list* A B C D)' is equivalent to `(nconc (list A B C) D)', or to
(nreverse res)))
(defun copy-list (list)
"Return a copy of a list, which may be a dotted list.
The elements of the list are not copied, just the list structure itself."
"Return a copy of LIST, which may be a dotted list.
The elements of LIST are not copied, just the list structure itself."
(if (consp list)
(let ((res nil))
(while (consp list) (push (pop list) res))
@ -544,7 +538,8 @@ The elements of the list are not copied, just the list structure itself."
(defun adjoin (cl-item cl-list &rest cl-keys) ; See compiler macro in cl-macs
"Return ITEM consed onto the front of LIST only if it's not already there.
Otherwise, return LIST unmodified.
Keywords supported: :test :test-not :key"
\nKeywords supported: :test :test-not :key
\n(fn ITEM LIST [KEYWORD VALUE]...)"
(cond ((or (equal cl-keys '(:test eq))
(and (null cl-keys) (not (numberp cl-item))))
(if (memq cl-item cl-list) cl-list (cons cl-item cl-list)))
@ -555,7 +550,8 @@ Keywords supported: :test :test-not :key"
(defun subst (cl-new cl-old cl-tree &rest cl-keys)
"Substitute NEW for OLD everywhere in TREE (non-destructively).
Return a copy of TREE with all elements `eql' to OLD replaced by NEW.
Keywords supported: :test :test-not :key"
\nKeywords supported: :test :test-not :key
\n(fn NEW OLD TREE [KEYWORD VALUE]...)"
(if (or cl-keys (and (numberp cl-old) (not (integerp cl-old))))
(apply 'sublis (list (cons cl-old cl-new)) cl-tree cl-keys)
(cl-do-subst cl-new cl-old cl-tree)))
@ -569,8 +565,17 @@ Keywords supported: :test :test-not :key"
cl-tree (cons a d))))
(t cl-tree)))
(defun acons (a b c) (cons (cons a b) c))
(defun pairlis (a b &optional c) (nconc (mapcar* 'cons a b) c))
(defun acons (key value alist)
"Add KEY and VALUE to ALIST.
Return a new list with (cons KEY VALUE) as car and ALIST as cdr."
(cons (cons key value) alist))
(defun pairlis (keys values &optional alist)
"Make an alist from KEYS and VALUES.
Return a new alist composed by associating KEYS to corresponding VALUES;
the process stops as soon as KEYS or VALUES run out.
If ALIST is non-nil, the new pairs are prepended to it."
(nconc (mapcar* 'cons keys values) alist))
;;; Miscellaneous.
@ -699,5 +704,5 @@ Keywords supported: :test :test-not :key"
(run-hooks 'cl-load-hook)
;;; arch-tag: 5f07fa74-f153-4524-9303-21f5be125851
;; arch-tag: 5f07fa74-f153-4524-9303-21f5be125851
;;; cl.el ends here

1
lisp/emacs-lisp/derived.el
View File

@ -132,6 +132,7 @@ BODY can start with a bunch of keyword arguments. The following keyword
arguments are currently understood:
:group GROUP
Declare the customization group that corresponds to this mode.
The command `customize-mode' uses this.
:syntax-table TABLE
Use TABLE instead of the default.
A nil value means to simply use the same syntax-table as the parent.

6
lisp/emacs-lisp/easy-mmode.el
View File

@ -172,7 +172,7 @@ For example, you could write
(setq group
`(:group ',(intern (replace-regexp-in-string
"-mode\\'" "" mode-name)))))
`(progn
;; Define the variable to enable or disable the mode.
,(if (not globalp)
@ -306,9 +306,9 @@ in which `%s' turns it on."
;; Setup hook to handle future mode changes and new buffers.
(if ,global-mode
(progn
(add-hook 'find-file-hook ',buffers)
(add-hook 'after-change-major-mode-hook ',buffers)
(add-hook 'change-major-mode-hook ',cmmh))
(remove-hook 'find-file-hook ',buffers)
(remove-hook 'after-change-major-mode-hook ',buffers)
(remove-hook 'change-major-mode-hook ',cmmh))
;; Go through existing buffers.

14
lisp/emacs-lisp/easymenu.el
View File

@ -471,11 +471,15 @@ Contrary to XEmacs, this is a nop on Emacs since menus are automatically
(defun easy-menu-add (menu &optional map)
"Add the menu to the menubar.
This is a nop on Emacs since menus are automatically activated when the
corresponding keymap is activated. On XEmacs this is needed to actually
add the menu to the current menubar.
Maybe precalculate equivalent key bindings.
Do it only if `easy-menu-precalculate-equivalent-keybindings' is on."
On Emacs, menus are already automatically activated when the
corresponding keymap is activated. On XEmacs this is needed to
actually add the menu to the current menubar.
This also precalculates equivalent key bindings when
`easy-menu-precalculate-equivalent-keybindings' is on.
You should call this once the menu and keybindings are set up
completely and menu filter functions can be expected to work."
(when easy-menu-precalculate-equivalent-keybindings
(if (and (symbolp menu) (not (keymapp menu)) (boundp menu))
(setq menu (symbol-value menu)))

2
lisp/emacs-lisp/re-builder.el
View File

@ -254,7 +254,7 @@ Except for Lisp syntax this is the same as `reb-regexp'.")
mode-name "RE Builder")
(use-local-map reb-mode-map)
(reb-mode-common)
(run-hooks 'reb-mode-hook))
(run-mode-hooks 'reb-mode-hook))
(define-derived-mode reb-lisp-mode
emacs-lisp-mode "RE Builder Lisp"

6
lisp/emulation/tpu-extras.el
View File

@ -144,9 +144,9 @@ the previous line when starting from a line beginning."
"Eliminate whitespace at ends of lines, if the cursor is free."
(if (and (buffer-modified-p) tpu-cursor-free) (tpu-trim-line-ends)))
(or (memq 'tpu-write-file-hook write-file-hooks)
(setq write-file-hooks
(cons 'tpu-write-file-hook write-file-hooks)))
(or (memq 'tpu-write-file-hook write-file-functions)
(setq write-file-functions
(cons 'tpu-write-file-hook write-file-functions)))
;;; Utility routines for implementing scroll margins

2
lisp/emulation/vi.el
View File

@ -403,7 +403,7 @@ form that is ready to be `apply'ed.")
(make-local-variable 'vi-mode-old-mode-name)
(make-local-variable 'vi-mode-old-major-mode)
(make-local-variable 'vi-mode-old-case-fold)
(run-hooks 'vi-mode-hook))
(run-mode-hooks 'vi-mode-hook))
;;;###autoload
(defun vi-mode ()

4
lisp/emulation/viper-ex.el
View File

@ -67,10 +67,10 @@
;;; Variables
(defconst viper-ex-work-buf-name " *ex-working-space*")
(defconst viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
(defvar viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
(defconst viper-ex-tmp-buf-name " *ex-tmp*")
(defconst viper-ex-print-buf-name " *ex-print*")
(defconst viper-ex-print-buf (get-buffer-create viper-ex-print-buf-name))
(defvar viper-ex-print-buf (get-buffer-create viper-ex-print-buf-name))
;;; ex-commands...

2
lisp/emulation/ws-mode.el
View File

@ -294,7 +294,7 @@ The key bindings are:
(use-local-map wordstar-mode-map)
(setq mode-name "WordStar")
(setq major-mode 'wordstar-mode)
(run-hooks 'wordstar-mode-hook))
(run-mode-hooks 'wordstar-mode-hook))
(defun wordstar-center-paragraph ()

3
lisp/eshell/em-cmpl.el
View File

@ -370,7 +370,8 @@ to writing a completion function."
(setq args (nthcdr (1+ l) args)
posns (nthcdr (1+ l) posns))))
(assert (= (length args) (length posns)))
(when (and args (eq (char-syntax (char-before end)) ? ))
(when (and args (eq (char-syntax (char-before end)) ? )
(not (eq (char-before (1- end)) ?\\)))
(nconc args (list ""))
(nconc posns (list (point))))
(cons (mapcar

9
lisp/eshell/esh-cmd.el
View File

@ -757,7 +757,7 @@ nil)' if none)."
(defmacro eshell-do-subjob (object)
"Evaluate a command OBJECT as a subjob.
We indicate thet the process was run in the background by returned it
We indicate that the process was run in the background by returning it
ensconced in a list."
`(let ((eshell-current-subjob-p t))
,object))
@ -1006,11 +1006,10 @@ at the moment are:
(eshell-resume-eval))))
;; On systems that don't support async subprocesses, eshell-resume
;; can return t. Don't treat that as an error.
(if (listp delim)
(setq delim (car delim)))
(if (and delim (not (eq delim t)))
(error "Unmatched delimiter: %c"
(if (listp delim)
(car delim)
delim))))))
(error "Unmatched delimiter: %c" delim)))))
(defun eshell-resume-command (proc status)
"Resume the current command when a process ends."

3
lisp/eshell/esh-io.el
View File

@ -353,7 +353,8 @@ it defaults to `insert'."
((or (bufferp target)
(and (boundp 'eshell-buffer-shorthand)
(symbol-value 'eshell-buffer-shorthand)
(symbolp target)))
(symbolp target)
(not (memq target '(t nil)))))
(let ((buf (if (bufferp target)
target
(get-buffer-create

2
lisp/eshell/esh-mode.el
View File

@ -435,7 +435,7 @@ This is used by `eshell-watch-for-password-prompt'."
(if eshell-first-time-p
(run-hooks 'eshell-first-time-mode-hook))
(run-hooks 'eshell-mode-hook)
(run-mode-hooks 'eshell-mode-hook)
(run-hooks 'eshell-post-command-hook))
(put 'eshell-mode 'mode-class 'special)

13
lisp/faces.el
View File

@ -1874,9 +1874,22 @@ created."
:group 'modeline
:group 'basic-faces)
(defface mode-line-highlight
'((((class color) (min-colors 88) (background light))
:background "RoyalBlue4" :foreground "white")
(((class color) (min-colors 88) (background dark))
:background "light sky blue" :foreground "black")
(t
:inverse-video t))
"Basic mode line face for highlighting."
:version "22.1"
:group 'modeline
:group 'basic-faces)
;; Make `modeline' an alias for `mode-line', for compatibility.
(put 'modeline 'face-alias 'mode-line)
(put 'modeline-inactive 'face-alias 'mode-line-inactive)
(put 'modeline-higilight 'face-alias 'mode-line-highlight)
(defface header-line
'((default

9
lisp/files.el
View File

@ -1744,7 +1744,7 @@ in that case, this function acts as if `enable-local-variables' were t."
(mapc
(lambda (elt)
(cons (purecopy (car elt)) (cdr elt)))
'(;; do this first, so that .html.pl is Polish html, not Perl
`(;; do this first, so that .html.pl is Polish html, not Perl
("\\.s?html?\\(\\.[a-zA-Z_]+\\)?\\'" . html-mode)
("\\.te?xt\\'" . text-mode)
("\\.[tT]e[xX]\\'" . tex-mode)
@ -1762,9 +1762,12 @@ in that case, this function acts as if `enable-local-variables' were t."
("\\.ad[abs]\\'" . ada-mode)
("\\.ad[bs].dg\\'" . ada-mode)
("\\.\\([pP]\\([Llm]\\|erl\\|od\\)\\|al\\)\\'" . perl-mode)
("\\.mk\\'" . makefile-gmake-mode) ; Might be any make, give Gnu the host advantage
("[Mm]akefile\\'" . makefile-mode)
("GNUmakefile\\'" . makefile-gmake-mode)
,@(if (memq system-type '(berkeley-unix next-mach darwin))
'(("\\.mk\\'" . makefile-bsdmake-mode)
("[Mm]akefile\\'" . makefile-bsdmake-mode))
'(("\\.mk\\'" . makefile-gmake-mode) ; Might be any make, give Gnu the host advantage
("[Mm]akefile\\'" . makefile-mode)))
("Makeppfile\\'" . makefile-makepp-mode)
("\\.am\\'" . makefile-automake-mode)
;; Less common extensions come here

24
lisp/font-core.el
View File

@ -231,24 +231,20 @@ this function onto `change-major-mode-hook'."
;; hook is run, the major mode is in the process of being changed and we do not
;; know what the final major mode will be. So, `font-lock-change-major-mode'
;; only (a) notes the name of the current buffer, and (b) adds our function
;; `turn-on-font-lock-if-enabled' to the hook variables `find-file-hook' and
;; `post-command-hook' (for buffers that are not visiting files). By the time
;; `turn-on-font-lock-if-enabled' to the hook variables
;; `after-change-major-mode-hook' and `post-command-hook' (for modes
;; that do not yet run `after-change-major-mode-hook'). By the time
;; the functions on the first of these hooks to be run are run, the new major
;; mode is assumed to be in place. This way we get a Font Lock function run
;; when a major mode is turned on, without knowing major modes or their hooks.
;;
;; Naturally this requires that (a) major modes run `kill-all-local-variables',
;; as they are supposed to do, and (b) the major mode is in place after the
;; file is visited or the command that ran `kill-all-local-variables' has
;; finished, whichever the sooner. Arguably, any major mode that does not
;; follow the convension (a) is broken, and I can't think of any reason why (b)
;; would not be met (except `gnudoit' on non-files). However, it is not clean.
;;
;; Probably the cleanest solution is to have each major mode function run some
;; hook, e.g., `major-mode-hook', but maybe implementing that change is
;; impractical. I am personally against making `setq' a macro or be advised,
;; or have a special function such as `set-major-mode', but maybe someone can
;; come up with another solution?
;; Naturally this requires that major modes run `kill-all-local-variables'
;; and `after-change-major-mode-hook', as they are supposed to. For modes
;; that do not run `after-change-major-mode-hook' yet, `post-command-hook'
;; takes care of things if the mode is set directly or indirectly by
;; an interactive command; however, problems can occur if the mode is
;; set by a timer or process: in that case, proper handling of Font Lock mode
;; may be delayed until the next interactive command.
;; User interface.
;;

25
lisp/font-lock.el
View File

@ -563,11 +563,11 @@ is not in a string or comment and not within any bracket-pairs (or else,
a place such that any bracket-pairs outside it can be ignored for Emacs
syntax analysis and fontification).
If this is nil, the beginning of the buffer is used, which is
always correct but tends to be slow.
This is normally set via `font-lock-defaults'.
This variable is semi-obsolete; we recommend setting
`syntax-begin-function' instead.")
If this is nil, Font Lock uses `syntax-begin-function' to move back
outside of any comment, string, or sexp. This variable is semi-obsolete;
we recommend setting `syntax-begin-function' instead.
This is normally set via `font-lock-defaults'.")
(defvar font-lock-mark-block-function nil
"*Non-nil means use this function to mark a block of text.
@ -2053,19 +2053,22 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item."
("\\<:\\sw+\\>" 0 font-lock-builtin-face)
;; ELisp and CLisp `&' keywords as types.
("\\&\\sw+\\>" . font-lock-type-face)
;; Make regexp grouping constructs bold, so they stand out, but only in strings.
;; Make regexp grouping constructs bold, so they stand out, but only
;; in strings.
((lambda (bound)
(if (re-search-forward "\\([\\][\\]\\)\\([(|)]\\)\\(\\?:\\)?" bound)
(if (re-search-forward "\\(\\\\\\\\\\)\\([(|)]\\)\\(\\?:\\)?" bound t)
(let ((face (get-text-property (1- (point)) 'face)))
(if (listp face)
(memq 'font-lock-string-face face)
(eq 'font-lock-string-face face)))))
(1 font-lock-comment-face prepend) ; Should we introduce a lowlight face for this?
; Ideally that would retain the color, dimmed 50%.
;; Should we introduce a lowlight face for this?
;; Ideally that would retain the color, dimmed.
(1 font-lock-comment-face prepend)
(2 'bold prepend)
(3 font-lock-type-face prepend t))
;; Underline innermost grouping, so that you can more easily see what belongs together.
;; 2005-05-12: Font-lock can go into an unbreakable endless loop on this -- something's broken.
;; Underline innermost grouping, so that you can more easily see what
;; belongs together. 2005-05-12: Font-lock can go into an
;; unbreakable endless loop on this -- something's broken.
;;("[\\][\\][(]\\(?:\\?:\\)?\\(\\(?:[^\\\"]+\\|[\\]\\(?:[^\\]\\|[\\][^(]\\)\\)+?\\)[\\][\\][)]"
;;1 'underline prepend)
;;; This is too general -- rms.

2
lisp/forms.el
View File

@ -713,7 +713,7 @@ Commands: Equivalent keys in read-only mode:
;; user customising
;;(message "forms: proceeding setup (user hooks)...")
(run-hooks 'forms-mode-hook 'forms-mode-hooks)
(run-mode-hooks 'forms-mode-hook 'forms-mode-hooks)
;;(message "forms: setting up... done.")
;; be helpful

82
lisp/gnus/ChangeLog
View File

@ -1,3 +1,85 @@
2005-05-27 Katsumi Yamaoka <yamaoka@jpl.org>
* gnus-util.el (gnus-run-mode-hooks): New function.
* score-mode.el (gnus-score-mode): Use gnus-run-mode-hooks.
2005-05-26 Luc Teirlinck <teirllm@auburn.edu>
* gnus-agent.el (gnus-agent-make-mode-line-string):
Use mode-line-highlight as mouse-face.
2005-05-17 Katsumi Yamaoka <yamaoka@jpl.org>
* canlock.el (canlock): Change the parent group to news.
* deuglify.el (gnus-outlook-deuglify): Add :group.
* dig.el (dig): Add :group.
* gnus-art.el (gnus-inhibit-mime-unbuttonizing): Add :group.
* gnus-cite.el (gnus-cite-attribution-face): Add :group.
(gnus-cite-face-1, gnus-cite-face-2, gnus-cite-face-3): Ditto.
(gnus-cite-face-4, gnus-cite-face-5, gnus-cite-face-6): Ditto.
(gnus-cite-face-7, gnus-cite-face-8, gnus-cite-face-9): Ditto.
(gnus-cite-face-10, gnus-cite-face-11): Ditto.
* gnus-diary.el (gnus-diary): Add :group.
* gnus.el (gnus-group-news-1-face): Add :group.
(gnus-group-news-1-empty-face): Ditto.
(gnus-group-news-2-face, gnus-group-news-2-empty-face): Ditto.
(gnus-group-news-3-face, gnus-group-news-3-empty-face): Ditto.
(gnus-group-news-4-face, gnus-group-news-4-empty-face): Ditto.
(gnus-group-news-5-face, gnus-group-news-5-empty-face): Ditto.
(gnus-group-news-6-face, gnus-group-news-6-empty-face): Ditto.
(gnus-group-news-low-face, gnus-group-news-low-empty-face): Ditto.
(gnus-group-mail-1-face, gnus-group-mail-1-empty-face): Ditto.
(gnus-group-mail-2-face, gnus-group-mail-2-empty-face): Ditto.
(gnus-group-mail-3-face, gnus-group-mail-3-empty-face): Ditto.
(gnus-group-mail-low-face, gnus-group-mail-low-empty-face): Ditto.
(gnus-summary-selected-face, gnus-summary-cancelled-face): Ditto.
(gnus-summary-high-ticked-face): Ditto.
(gnus-summary-low-ticked-face): Ditto.
(gnus-summary-normal-ticked-face): Ditto.
(gnus-summary-high-ancient-face): Ditto.
(gnus-summary-low-ancient-face): Ditto.
(gnus-summary-normal-ancient-face): Ditto.
(gnus-summary-high-undownloaded-face): Ditto.
(gnus-summary-low-undownloaded-face): Ditto.
(gnus-summary-normal-undownloaded-face): Ditto.
(gnus-summary-high-unread-face): Ditto.
(gnus-summary-low-unread-face): Ditto.
(gnus-summary-normal-unread-face): Ditto.
(gnus-summary-high-read-face, gnus-summary-low-read-face): Diito
(gnus-summary-normal-read-face, gnus-splash-face): Ditto.
* message.el (message-minibuffer-local-map): Add :group.
* sieve-manage.el (sieve-manage-log): Add :group.
(sieve-manage-default-user): Diito.
(sieve-manage-server-eol, sieve-manage-client-eol): Ditto.
(sieve-manage-streams, sieve-manage-stream-alist): Ditto.
(sieve-manage-authenticators): Ditto.
(sieve-manage-authenticator-alist): Ditto
(sieve-manage-default-port): Ditto.
* sieve-mode.el (sieve-control-commands-face): Add :group.
(sieve-action-commands-face): Ditto.
(sieve-test-commands-face): Ditto.
(sieve-tagged-arguments-face): Ditto.
* smime.el (smime): Add :group.
* spam-report.el (spam-report): Add :group.
* spam.el (spam, spam-face): Add :group.
2005-05-26 Lute Kamstra <lute@gnu.org>
* score-mode.el (gnus-score-mode): Use run-mode-hooks.
2005-05-16 Katsumi Yamaoka <yamaoka@jpl.org>
* gnus-art.el: Don't autoload mail-extract-address-components.

4
lisp/gnus/canlock.el
View File

@ -1,6 +1,6 @@
;;; canlock.el --- functions for Cancel-Lock feature
;; Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004
;; Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004, 2005
;; Free Software Foundation, Inc.
;; Author: Katsumi Yamaoka <yamaoka@jpl.org>
@ -50,7 +50,7 @@
(defgroup canlock nil
"The Cancel-Lock feature."
:group 'applications)
:group 'news)
(defcustom canlock-password nil
"Password to use when signing a Cancel-Lock or a Cancel-Key header."

5
lisp/gnus/deuglify.el
View File

@ -1,6 +1,6 @@
;;; deuglify.el --- deuglify broken Outlook (Express) articles
;; Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
;; Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
;; Copyright (C) 2001, 2002 Raymond Scholz
;; Author: Raymond Scholz <rscholz@zonix.de>
@ -231,7 +231,8 @@
(defgroup gnus-outlook-deuglify nil
"Deuglify articles generated by broken user agents like MS Outlook (Express)."
:version "22.1")
:version "22.1"
:group 'gnus)
;;;###autoload
(defcustom gnus-outlook-deuglify-unwrap-min 45

5
lisp/gnus/dig.el
View File

@ -1,5 +1,5 @@
;;; dig.el --- Domain Name System dig interface
;; Copyright (c) 2000, 2001, 2003 Free Software Foundation, Inc.
;; Copyright (c) 2000, 2001, 2003, 2005 Free Software Foundation, Inc.
;; Author: Simon Josefsson <simon@josefsson.org>
;; Keywords: DNS BIND dig
@ -40,7 +40,8 @@
(eval-when-compile (require 'cl))
(defgroup dig nil
"Dig configuration.")
"Dig configuration."
:group 'comm)
(defcustom dig-program "dig"
"Name of dig (domain information groper) binary."

3
lisp/gnus/gnus-agent.el
View File

@ -561,7 +561,8 @@ manipulated as follows:
(if (and (fboundp 'propertize)
(fboundp 'make-mode-line-mouse-map))
(propertize string 'local-map
(make-mode-line-mouse-map mouse-button mouse-func))
(make-mode-line-mouse-map mouse-button mouse-func)
'mouse-face 'mode-line-highlight)
string))
(defun gnus-agent-toggle-plugged (set-to)

1
lisp/gnus/gnus-art.el
View File

@ -814,6 +814,7 @@ When nil (the default value), then some MIME parts do not get buttons,
as described by the variables `gnus-buttonized-mime-types' and
`gnus-unbuttonized-mime-types'."
:version "22.1"
:group 'gnus-article-mime
:type 'boolean)
(defcustom gnus-body-boundary-delimiter "_"

39
lisp/gnus/gnus-cite.el
View File

@ -1,6 +1,7 @@
;;; gnus-cite.el --- parse citations in articles for Gnus
;; Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
;; Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
;; 2005
;; Free Software Foundation, Inc.
;; Author: Per Abhiddenware
@ -138,7 +139,8 @@ the envelope From line."
(defface gnus-cite-attribution-face '((t
(:italic t)))
"Face used for attribution lines.")
"Face used for attribution lines."
:group 'gnus-cite)
(defcustom gnus-cite-attribution-face 'gnus-cite-attribution-face
"Face used for attribution lines.
@ -155,7 +157,8 @@ It is merged with the face for the cited text belonging to the attribution."
(:foreground "MidnightBlue"))
(t
(:italic t)))
"Citation face.")
"Citation face."
:group 'gnus-cite)
(defface gnus-cite-face-2 '((((class color)
(background dark))
@ -165,7 +168,8 @@ It is merged with the face for the cited text belonging to the attribution."
(:foreground "firebrick"))
(t
(:italic t)))
"Citation face.")
"Citation face."
:group 'gnus-cite)
(defface gnus-cite-face-3 '((((class color)
(background dark))
@ -175,7 +179,8 @@ It is merged with the face for the cited text belonging to the attribution."
(:foreground "dark green"))
(t
(:italic t)))
"Citation face.")
"Citation face."
:group 'gnus-cite)
(defface gnus-cite-face-4 '((((class color)
(background dark))
@ -185,7 +190,8 @@ It is merged with the face for the cited text belonging to the attribution."
(:foreground "OrangeRed"))
(t
(:italic t)))
"Citation face.")
"Citation face."
:group 'gnus-cite)
(defface gnus-cite-face-5 '((((class color)
(background dark))
@ -195,7 +201,8 @@ It is merged with the face for the cited text belonging to the attribution."
(:foreground "dark khaki"))
(t
(:italic t)))
"Citation face.")
"Citation face."
:group 'gnus-cite)
(defface gnus-cite-face-6 '((((class color)
(background dark))
@ -205,7 +212,8 @@ It is merged with the face for the cited text belonging to the attribution."
(:foreground "dark violet"))
(t
(:italic t)))
"Citation face.")
"Citation face."
:group 'gnus-cite)
(defface gnus-cite-face-7 '((((class color)
(background dark))
@ -215,7 +223,8 @@ It is merged with the face for the cited text belonging to the attribution."
(:foreground "SteelBlue4"))
(t
(:italic t)))
"Citation face.")
"Citation face."
:group 'gnus-cite)
(defface gnus-cite-face-8 '((((class color)
(background dark))
@ -225,7 +234,8 @@ It is merged with the face for the cited text belonging to the attribution."
(:foreground "magenta"))
(t
(:italic t)))
"Citation face.")
"Citation face."
:group 'gnus-cite)
(defface gnus-cite-face-9 '((((class color)
(background dark))
@ -235,7 +245,8 @@ It is merged with the face for the cited text belonging to the attribution."
(:foreground "violet"))
(t
(:italic t)))
"Citation face.")
"Citation face."
:group 'gnus-cite)
(defface gnus-cite-face-10 '((((class color)
(background dark))
@ -245,7 +256,8 @@ It is merged with the face for the cited text belonging to the attribution."
(:foreground "medium purple"))
(t
(:italic t)))
"Citation face.")
"Citation face."
:group 'gnus-cite)
(defface gnus-cite-face-11 '((((class color)
(background dark))
@ -255,7 +267,8 @@ It is merged with the face for the cited text belonging to the attribution."
(:foreground "turquoise"))
(t
(:italic t)))
"Citation face.")
"Citation face."
:group 'gnus-cite)
(defcustom gnus-cite-face-list
'(gnus-cite-face-1 gnus-cite-face-2 gnus-cite-face-3 gnus-cite-face-4

5
lisp/gnus/gnus-diary.el
View File

@ -1,6 +1,6 @@
;;; gnus-diary.el --- Wrapper around the NNDiary Gnus backend
;; Copyright (c) 2001, 2002, 2003 Free Software Foundation, Inc.
;; Copyright (c) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
;; Copyright (C) 1999, 2000, 2001 Didier Verna.
;; Author: Didier Verna <didier@xemacs.org>
@ -103,7 +103,8 @@
(defgroup gnus-diary nil
"Utilities on top of the nndiary backend for Gnus."
:version "22.1")
:version "22.1"
:group 'gnus)
(defcustom gnus-diary-summary-line-format "%U%R%z %uD: %(%s%) (%ud)\n"
"*Summary line format for nndiary groups."

6
lisp/gnus/gnus-util.el
View File

@ -1015,6 +1015,12 @@ ARG is passed to the first function."
(save-current-buffer
(apply 'run-hooks funcs)))
(defun gnus-run-mode-hooks (&rest funcs)
"Run `run-mode-hooks' if it is available. Otherwise run `run-hooks'."
(if (fboundp 'run-mode-hooks)
(apply 'run-mode-hooks funcs)
(apply 'run-hooks funcs)))
;;; Various
(defvar gnus-group-buffer) ; Compiler directive

120
lisp/gnus/gnus.el
View File

@ -366,7 +366,8 @@ be set in `.emacs' instead."
(:foreground "ForestGreen" :bold t))
(t
()))
"Level 1 newsgroup face.")
"Level 1 newsgroup face."
:group 'gnus-group)
(defface gnus-group-news-1-empty-face
'((((class color)
@ -377,7 +378,8 @@ be set in `.emacs' instead."
(:foreground "ForestGreen"))
(t
()))
"Level 1 empty newsgroup face.")
"Level 1 empty newsgroup face."
:group 'gnus-group)
(defface gnus-group-news-2-face
'((((class color)
@ -388,7 +390,8 @@ be set in `.emacs' instead."
(:foreground "CadetBlue4" :bold t))
(t
()))
"Level 2 newsgroup face.")
"Level 2 newsgroup face."
:group 'gnus-group)
(defface gnus-group-news-2-empty-face
'((((class color)
@ -399,7 +402,8 @@ be set in `.emacs' instead."
(:foreground "CadetBlue4"))
(t
()))
"Level 2 empty newsgroup face.")
"Level 2 empty newsgroup face."
:group 'gnus-group)
(defface gnus-group-news-3-face
'((((class color)
@ -410,7 +414,8 @@ be set in `.emacs' instead."
(:bold t))
(t
()))
"Level 3 newsgroup face.")
"Level 3 newsgroup face."
:group 'gnus-group)
(defface gnus-group-news-3-empty-face
'((((class color)
@ -421,7 +426,8 @@ be set in `.emacs' instead."
())
(t
()))
"Level 3 empty newsgroup face.")
"Level 3 empty newsgroup face."
:group 'gnus-group)
(defface gnus-group-news-4-face
'((((class color)
@ -432,7 +438,8 @@ be set in `.emacs' instead."
(:bold t))
(t
()))
"Level 4 newsgroup face.")
"Level 4 newsgroup face."
:group 'gnus-group)
(defface gnus-group-news-4-empty-face
'((((class color)
@ -443,7 +450,8 @@ be set in `.emacs' instead."
())
(t
()))
"Level 4 empty newsgroup face.")
"Level 4 empty newsgroup face."
:group 'gnus-group)
(defface gnus-group-news-5-face
'((((class color)
@ -454,7 +462,8 @@ be set in `.emacs' instead."
(:bold t))
(t
()))
"Level 5 newsgroup face.")
"Level 5 newsgroup face."
:group 'gnus-group)
(defface gnus-group-news-5-empty-face
'((((class color)
@ -465,7 +474,8 @@ be set in `.emacs' instead."
())
(t
()))
"Level 5 empty newsgroup face.")
"Level 5 empty newsgroup face."
:group 'gnus-group)
(defface gnus-group-news-6-face
'((((class color)
@ -476,7 +486,8 @@ be set in `.emacs' instead."
(:bold t))
(t
()))
"Level 6 newsgroup face.")
"Level 6 newsgroup face."
:group 'gnus-group)
(defface gnus-group-news-6-empty-face
'((((class color)
@ -487,7 +498,8 @@ be set in `.emacs' instead."
())
(t
()))
"Level 6 empty newsgroup face.")
"Level 6 empty newsgroup face."
:group 'gnus-group)
(defface gnus-group-news-low-face
'((((class color)
@ -498,7 +510,8 @@ be set in `.emacs' instead."
(:foreground "DarkGreen" :bold t))
(t
()))
"Low level newsgroup face.")
"Low level newsgroup face."
:group 'gnus-group)
(defface gnus-group-news-low-empty-face
'((((class color)
@ -509,7 +522,8 @@ be set in `.emacs' instead."
(:foreground "DarkGreen"))
(t
()))
"Low level empty newsgroup face.")
"Low level empty newsgroup face."
:group 'gnus-group)
(defface gnus-group-mail-1-face
'((((class color)
@ -520,7 +534,8 @@ be set in `.emacs' instead."
(:foreground "DeepPink3" :bold t))
(t
(:bold t)))
"Level 1 mailgroup face.")
"Level 1 mailgroup face."
:group 'gnus-group)
(defface gnus-group-mail-1-empty-face
'((((class color)
@ -531,7 +546,8 @@ be set in `.emacs' instead."
(:foreground "DeepPink3"))
(t
(:italic t :bold t)))
"Level 1 empty mailgroup face.")
"Level 1 empty mailgroup face."
:group 'gnus-group)
(defface gnus-group-mail-2-face
'((((class color)
@ -542,7 +558,8 @@ be set in `.emacs' instead."
(:foreground "HotPink3" :bold t))
(t
(:bold t)))
"Level 2 mailgroup face.")
"Level 2 mailgroup face."
:group 'gnus-group)
(defface gnus-group-mail-2-empty-face
'((((class color)
@ -553,7 +570,8 @@ be set in `.emacs' instead."
(:foreground "HotPink3"))
(t
(:bold t)))
"Level 2 empty mailgroup face.")
"Level 2 empty mailgroup face."
:group 'gnus-group)
(defface gnus-group-mail-3-face
'((((class color)
@ -564,7 +582,8 @@ be set in `.emacs' instead."
(:foreground "magenta4" :bold t))
(t
(:bold t)))
"Level 3 mailgroup face.")
"Level 3 mailgroup face."
:group 'gnus-group)
(defface gnus-group-mail-3-empty-face
'((((class color)
@ -575,7 +594,8 @@ be set in `.emacs' instead."
(:foreground "magenta4"))
(t
()))
"Level 3 empty mailgroup face.")
"Level 3 empty mailgroup face."
:group 'gnus-group)
(defface gnus-group-mail-low-face
'((((class color)
@ -586,7 +606,8 @@ be set in `.emacs' instead."
(:foreground "DeepPink4" :bold t))
(t
(:bold t)))
"Low level mailgroup face.")
"Low level mailgroup face."
:group 'gnus-group)
(defface gnus-group-mail-low-empty-face
'((((class color)
@ -597,18 +618,21 @@ be set in `.emacs' instead."
(:foreground "DeepPink4"))
(t
(:bold t)))
"Low level empty mailgroup face.")
"Low level empty mailgroup face."
:group 'gnus-group)
;; Summary mode faces.
(defface gnus-summary-selected-face '((t
(:underline t)))
"Face used for selected articles.")
"Face used for selected articles."
:group 'gnus-summary)
(defface gnus-summary-cancelled-face
'((((class color))
(:foreground "yellow" :background "black")))
"Face used for cancelled articles.")
"Face used for cancelled articles."
:group 'gnus-summary)
(defface gnus-summary-high-ticked-face
'((((class color)
@ -619,7 +643,8 @@ be set in `.emacs' instead."
(:foreground "firebrick" :bold t))
(t
(:bold t)))
"Face used for high interest ticked articles.")
"Face used for high interest ticked articles."
:group 'gnus-summary)
(defface gnus-summary-low-ticked-face
'((((class color)
@ -630,7 +655,8 @@ be set in `.emacs' instead."
(:foreground "firebrick" :italic t))
(t
(:italic t)))
"Face used for low interest ticked articles.")
"Face used for low interest ticked articles."
:group 'gnus-summary)
(defface gnus-summary-normal-ticked-face
'((((class color)
@ -641,7 +667,8 @@ be set in `.emacs' instead."
(:foreground "firebrick"))
(t
()))
"Face used for normal interest ticked articles.")
"Face used for normal interest ticked articles."
:group 'gnus-summary)
(defface gnus-summary-high-ancient-face
'((((class color)
@ -652,7 +679,8 @@ be set in `.emacs' instead."
(:foreground "RoyalBlue" :bold t))
(t
(:bold t)))
"Face used for high interest ancient articles.")
"Face used for high interest ancient articles."
:group 'gnus-summary)
(defface gnus-summary-low-ancient-face
'((((class color)
@ -663,7 +691,8 @@ be set in `.emacs' instead."
(:foreground "RoyalBlue" :italic t))
(t
(:italic t)))
"Face used for low interest ancient articles.")
"Face used for low interest ancient articles."
:group 'gnus-summary)
(defface gnus-summary-normal-ancient-face
'((((class color)
@ -674,7 +703,8 @@ be set in `.emacs' instead."
(:foreground "RoyalBlue"))
(t
()))
"Face used for normal interest ancient articles.")
"Face used for normal interest ancient articles."
:group 'gnus-summary)
(defface gnus-summary-high-undownloaded-face
'((((class color)
@ -683,7 +713,8 @@ be set in `.emacs' instead."
(((class color) (background dark))
(:bold t :foreground "LightGray"))
(t (:inverse-video t :bold t)))
"Face used for high interest uncached articles.")
"Face used for high interest uncached articles."
:group 'gnus-summary)
(defface gnus-summary-low-undownloaded-face
'((((class color)
@ -692,7 +723,8 @@ be set in `.emacs' instead."
(((class color) (background dark))
(:italic t :foreground "LightGray" :bold nil))
(t (:inverse-video t :italic t)))
"Face used for low interest uncached articles.")
"Face used for low interest uncached articles."
:group 'gnus-summary)
(defface gnus-summary-normal-undownloaded-face
'((((class color)
@ -701,22 +733,26 @@ be set in `.emacs' instead."
(((class color) (background dark))
(:foreground "LightGray" :bold nil))
(t (:inverse-video t)))
"Face used for normal interest uncached articles.")
"Face used for normal interest uncached articles."
:group 'gnus-summary)
(defface gnus-summary-high-unread-face
'((t
(:bold t)))
"Face used for high interest unread articles.")
"Face used for high interest unread articles."
:group 'gnus-summary)
(defface gnus-summary-low-unread-face
'((t
(:italic t)))
"Face used for low interest unread articles.")
"Face used for low interest unread articles."
:group 'gnus-summary)
(defface gnus-summary-normal-unread-face
'((t
()))
"Face used for normal interest unread articles.")
"Face used for normal interest unread articles."
:group 'gnus-summary)
(defface gnus-summary-high-read-face
'((((class color)
@ -729,7 +765,8 @@ be set in `.emacs' instead."
:bold t))
(t
(:bold t)))
"Face used for high interest read articles.")
"Face used for high interest read articles."
:group 'gnus-summary)
(defface gnus-summary-low-read-face
'((((class color)
@ -742,7 +779,8 @@ be set in `.emacs' instead."
:italic t))
(t
(:italic t)))
"Face used for low interest read articles.")
"Face used for low interest read articles."
:group 'gnus-summary)
(defface gnus-summary-normal-read-face
'((((class color)
@ -753,7 +791,8 @@ be set in `.emacs' instead."
(:foreground "DarkGreen"))
(t
()))
"Face used for normal interest read articles.")
"Face used for normal interest read articles."
:group 'gnus-summary)
;;;
@ -806,7 +845,8 @@ be set in `.emacs' instead."
(:foreground "#888888"))
(t
()))
"Face for the splash screen.")
"Face for the splash screen."
:group 'gnus)
(defun gnus-splash ()
(save-excursion

3
lisp/gnus/message.el
View File

@ -842,7 +842,8 @@ the signature is inserted."
(set-keymap-parent map minibuffer-local-map)
map)
"Keymap for `message-read-from-minibuffer'."
:version "22.1")
:version "22.1"
:group 'message-various)
;;;###autoload
(defcustom message-citation-line-function 'message-insert-citation-line

6
lisp/gnus/score-mode.el
View File

@ -1,6 +1,6 @@
;;; score-mode.el --- mode for editing Gnus score files
;; Copyright (C) 1996, 2001, 2004 Free Software Foundation, Inc.
;; Copyright (C) 1996, 2001, 2004, 2005 Free Software Foundation, Inc.
;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
;; Keywords: news, mail
@ -28,7 +28,7 @@
(eval-when-compile (require 'cl))
(require 'mm-util) ; for mm-universal-coding-system
(require 'gnus-util) ; for gnus-pp
(require 'gnus-util) ; for gnus-pp, gnus-run-mode-hooks
(defvar gnus-score-mode-hook nil
"*Hook run in score mode buffers.")
@ -71,7 +71,7 @@ This mode is an extended emacs-lisp mode.
(setq mode-name "Score")
(lisp-mode-variables nil)
(make-local-variable 'gnus-score-edit-exit-function)
(run-hooks 'emacs-lisp-mode-hook 'gnus-score-mode-hook))
(gnus-run-mode-hooks 'emacs-lisp-mode-hook 'gnus-score-mode-hook))
(defun gnus-score-make-menu-bar ()
(unless (boundp 'gnus-score-menu)

27
lisp/gnus/sieve-manage.el
View File

@ -86,22 +86,27 @@
(defcustom sieve-manage-log "*sieve-manage-log*"
"Name of buffer for managesieve session trace."
:type 'string)
:type 'string
:group 'sieve-manage)
(defcustom sieve-manage-default-user (user-login-name)
"Default username to use."
:type 'string)
:type 'string
:group 'sieve-manage)
(defcustom sieve-manage-server-eol "\r\n"
"The EOL string sent from the server."
:type 'string)
:type 'string
:group 'sieve-manage)
(defcustom sieve-manage-client-eol "\r\n"
"The EOL string we send to the server."
:type 'string)
:type 'string
:group 'sieve-manage)
(defcustom sieve-manage-streams '(network starttls shell)
"Priority of streams to consider when opening connection to server.")
"Priority of streams to consider when opening connection to server."
:group 'sieve-manage)
(defcustom sieve-manage-stream-alist
'((network sieve-manage-network-p sieve-manage-network-open)
@ -113,10 +118,12 @@
NAME names the stream, CHECK is a function returning non-nil if the
server support the stream and OPEN is a function for opening the
stream.")
stream."
:group 'sieve-manage)
(defcustom sieve-manage-authenticators '(cram-md5 plain)
"Priority of authenticators to consider when authenticating to server.")
"Priority of authenticators to consider when authenticating to server."
:group 'sieve-manage)
(defcustom sieve-manage-authenticator-alist
'((cram-md5 sieve-manage-cram-md5-p sieve-manage-cram-md5-auth)
@ -127,11 +134,13 @@ stream.")
NAME names the authenticator. CHECK is a function returning non-nil if
the server support the authenticator and AUTHENTICATE is a function
for doing the actual authentication.")
for doing the actual authentication."
:group 'sieve-manage)
(defcustom sieve-manage-default-port 2000
"Default port number for managesieve protocol."
:type 'integer)
:type 'integer
:group 'sieve-manage)
;; Internal variables:

14
lisp/gnus/sieve-mode.el
View File

@ -1,5 +1,5 @@
;;; sieve-mode.el --- Sieve code editing commands for Emacs
;; Copyright (C) 2001, 2003 Free Software Foundation, Inc.
;; Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
;; Author: Simon Josefsson <simon@josefsson.org>
@ -75,7 +75,8 @@
(((class color) (background light)) (:foreground "Orchid"))
(((class color) (background dark)) (:foreground "LightSteelBlue"))
(t (:bold t)))
"Face used for Sieve Control Commands.")
"Face used for Sieve Control Commands."
:group 'sieve)
(defvar sieve-action-commands-face 'sieve-action-commands-face
"Face name used for Sieve Action Commands.")
@ -85,7 +86,8 @@
(((class color) (background light)) (:foreground "Blue"))
(((class color) (background dark)) (:foreground "LightSkyBlue"))
(t (:inverse-video t :bold t)))
"Face used for Sieve Action Commands.")
"Face used for Sieve Action Commands."
:group 'sieve)
(defvar sieve-test-commands-face 'sieve-test-commands-face
"Face name used for Sieve Test Commands.")
@ -99,7 +101,8 @@
(((class color) (background light)) (:foreground "CadetBlue"))
(((class color) (background dark)) (:foreground "Aquamarine"))
(t (:bold t :underline t)))
"Face used for Sieve Test Commands.")
"Face used for Sieve Test Commands."
:group 'sieve)
(defvar sieve-tagged-arguments-face 'sieve-tagged-arguments-face
"Face name used for Sieve Tagged Arguments.")
@ -111,7 +114,8 @@
(((class color) (background light)) (:foreground "Purple"))
(((class color) (background dark)) (:foreground "Cyan"))
(t (:bold t)))
"Face used for Sieve Tagged Arguments.")
"Face used for Sieve Tagged Arguments."
:group 'sieve)
(defconst sieve-font-lock-keywords

3
lisp/gnus/smime.el
View File

@ -122,7 +122,8 @@
(eval-when-compile (require 'cl))
(defgroup smime nil
"S/MIME configuration.")
"S/MIME configuration."
:group 'mime)
(defcustom smime-keys nil
"*Map mail addresses to a file containing Certificate (and private key).

6
lisp/gnus/spam-report.el
View File

@ -1,5 +1,5 @@
;;; spam-report.el --- Reporting spam
;; Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
;; Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
;; Author: Teodor Zlatanov <tzz@lifelogs.com>
;; Keywords: network
@ -35,7 +35,9 @@
(autoload 'mm-url-insert "mm-url"))
(defgroup spam-report nil
"Spam reporting configuration.")
"Spam reporting configuration."
:group 'mail
:group 'news)
(defcustom spam-report-gmane-regex nil
"Regexp matching Gmane newsgroups, e.g. \"^nntp\\+.*:gmane\\.\"

9
lisp/gnus/spam.el
View File

@ -1,5 +1,5 @@
;;; spam.el --- Identifying spam
;; Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
;; Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
;; Keywords: network
@ -77,7 +77,9 @@
(defgroup spam nil
"Spam configuration."
:version "22.1")
:version "22.1"
:group 'mail
:group 'news)
(defcustom spam-directory (nnheader-concat gnus-directory "spam/")
"Directory for spam whitelists and blacklists."
@ -308,7 +310,8 @@ All unmarked article in such group receive the spam mark on group entry."
(((class color) (background light))
(:foreground "ivory4"))
(t :inverse-video t))
"Face for spam-marked articles.")
"Face for spam-marked articles."
:group 'spam)
(defcustom spam-face 'spam-face
"Face for spam-marked articles."

2
lisp/help-mode.el
View File

@ -196,7 +196,7 @@ Commands:
(view-mode)
(make-local-variable 'view-no-disable-on-exit)
(setq view-no-disable-on-exit t)
(run-hooks 'help-mode-hook))
(run-mode-hooks 'help-mode-hook))
;;;###autoload
(defun help-mode-setup ()

4
lisp/help.el
View File

@ -698,8 +698,8 @@ the last key hit are used."
(princ " runs the command ")
(prin1 defn)
(princ "\n which is ")
(describe-function-1 defn))))
(print-help-return-message))))))))
(describe-function-1 defn)))))
(print-help-return-message)))))))
(defun describe-mode (&optional buffer)

11
lisp/hexl.el
View File

@ -291,7 +291,7 @@ You can use \\[hexl-find-file] to visit a file in Hexl mode.
"hexl-current-address")
(if hexl-follow-ascii (hexl-follow-ascii 1)))
(run-hooks 'hexl-mode-hook))
(run-mode-hooks 'hexl-mode-hook))
(defun hexl-isearch-search-function ()
@ -926,10 +926,11 @@ Customize the variable `hexl-follow-ascii' to disable this feature."
"Activate `hl-line-mode'"
(require 'frame)
(require 'hl-line)
(set (make-local-variable 'hl-line-range-function)
'hexl-highlight-line-range)
(set (make-local-variable 'hl-line-face)
'highlight)
(with-no-warnings
(set (make-local-variable 'hl-line-range-function)
'hexl-highlight-line-range)
(set (make-local-variable 'hl-line-face)
'highlight))
(hl-line-mode 1))
(defun hexl-highlight-line-range ()

2
lisp/ibuffer.el
View File

@ -2511,7 +2511,7 @@ will be inserted before the group at point."
(when ibuffer-default-directory
(setq default-directory ibuffer-default-directory))
(add-hook 'change-major-mode-hook 'font-lock-defontify nil t)
(run-hooks 'ibuffer-mode-hook)
(run-mode-hooks 'ibuffer-mode-hook)
;; called after mode hooks to allow the user to add filters
(ibuffer-update-mode-name))

2
lisp/ielm.el
View File

@ -548,7 +548,7 @@ Customized bindings may be defined in `ielm-map', which currently contains:
(set-marker comint-last-input-start (ielm-pm))
(set-process-filter (get-buffer-process (current-buffer)) 'comint-output-filter))
(run-hooks 'ielm-mode-hook))
(run-mode-hooks 'ielm-mode-hook))
(defun ielm-get-old-input nil
;; Return the previous input surrounding point

16
lisp/image.el
View File

@ -48,20 +48,6 @@ IMAGE-TYPE must be a pair (PREDICATE . TYPE). PREDICATE is called
with one argument, a string containing the image data. If PREDICATE returns
a non-nil value, TYPE is the image's type.")
;;;###autoload
(defvar image-library-alist nil
"Alist of image types vs external libraries needed to display them.
Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
representing a supported image type, and the rest are strings giving
alternate filenames for the corresponding external libraries.
Emacs tries to load the libraries in the order they appear on the
list; if none is loaded, the running session of Emacs won't
support the image type. Types 'pbm and 'xbm don't need to be
listed; they're always supported.")
;;;###autoload (put 'image-library-alist 'risky-local-variable t)
(defun image-jpeg-p (data)
"Value is non-nil if DATA, a string, consists of JFIF image data.
We accept the tag Exif because that is the same format."
@ -122,7 +108,7 @@ be determined."
;;;###autoload
(defun image-type-available-p (type)
"Value is non-nil if image type TYPE is available.
"Return non-nil if image type TYPE is available.
Image types are symbols like `xbm' or `jpeg'."
(and (fboundp 'init-image-library)
(init-image-library type image-library-alist)))

65
lisp/imenu.el
View File

@ -192,32 +192,9 @@ with name concatenation."
(defvar imenu-generic-expression nil
"The regex pattern to use for creating a buffer index.
If non-nil this pattern is passed to `imenu--generic-function'
to create a buffer index.
The value should be an alist with elements that look like this:
(MENU-TITLE REGEXP INDEX)
or like this:
(MENU-TITLE REGEXP INDEX FUNCTION ARGUMENTS...)
with zero or more ARGUMENTS. The former format creates a simple element in
the index alist when it matches; the latter creates a special element
of the form (NAME POSITION-MARKER FUNCTION ARGUMENTS...)
with FUNCTION and ARGUMENTS copied from `imenu-generic-expression'.
MENU-TITLE is a string used as the title for the submenu or nil if the
entries are not nested.
REGEXP is a regexp that should match a construct in the buffer that is
to be displayed in the menu; i.e., function or variable definitions,
etc. It contains a substring which is the name to appear in the
menu. See the info section on Regexps for more information.
INDEX points to the substring in REGEXP that contains the name (of the
function, variable or type) that is to appear in the menu.
The variable `imenu-case-fold-search' determines whether or not the
regexp matches are case sensitive, and `imenu-syntax-alist' can be
used to alter the syntax table for the search.
If non-nil this pattern is passed to `imenu--generic-function' to
create a buffer index. Look there for the documentation of this
pattern's structure.
For example, see the value of `fortran-imenu-generic-expression' used by
`fortran-mode' with `imenu-syntax-alist' set locally to give the
@ -750,21 +727,33 @@ for modes which use `imenu--generic-function'. If it is not set, but
"Return an index of the current buffer as an alist.
PATTERNS is an alist with elements that look like this:
(MENU-TITLE REGEXP INDEX).
(MENU-TITLE REGEXP INDEX)
or like this:
(MENU-TITLE REGEXP INDEX FUNCTION ARGUMENTS...)
with zero or more ARGUMENTS.
with zero or more ARGUMENTS. The former format creates a simple
element in the index alist when it matches; the latter creates a
special element of the form (NAME POSITION-MARKER FUNCTION
ARGUMENTS...) with FUNCTION and ARGUMENTS copied from
`imenu-generic-expression'.
MENU-TITLE is a string used as the title for the submenu or nil if the
entries are not nested.
MENU-TITLE is a string used as the title for the submenu or nil
if the entries are not nested.
REGEXP is a regexp that should match a construct in the buffer that is
to be displayed in the menu; i.e., function or variable definitions,
etc. It contains a substring which is the name to appear in the
menu. See the info section on Regexps for more information.
REGEXP is a regexp that should match a construct in the buffer
that is to be displayed in the menu; i.e., function or variable
definitions, etc. It contains a substring which is the name to
appear in the menu. See the info section on Regexps for more
information. REGEXP may also be a function, called without
arguments. It is expected to search backwards. It shall return
true and set `match-data' iff it finds another element.
INDEX points to the substring in REGEXP that contains the name (of the
function, variable or type) that is to appear in the menu.
INDEX points to the substring in REGEXP that contains the
name (of the function, variable or type) that is to appear in the
menu.
The variable `imenu-case-fold-search' determines whether or not the
regexp matches are case sensitive, and `imenu-syntax-alist' can be
used to alter the syntax table for the search.
See `lisp-imenu-generic-expression' for an example of PATTERNS.
@ -811,7 +800,9 @@ depending on PATTERNS."
start beg)
;; Go backwards for convenience of adding items in order.
(goto-char (point-max))
(while (and (re-search-backward regexp nil t)
(while (and (if (functionp regexp)
(funcall regexp)
(re-search-backward regexp nil t))
;; Exit the loop if we get an empty match,
;; because it means a bad regexp was specified.
(not (= (match-beginning 0) (match-end 0))))

21
lisp/info.el
View File

@ -1,7 +1,7 @@
;;; info.el --- info package for Emacs
;; Copyright (C) 1985,86,92,93,94,95,96,97,98,99,2000,01,02,03,04,2005
;; Free Software Foundation, Inc.
;; Copyright (C) 1985, 1986, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
;; 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
;; Maintainer: FSF
;; Keywords: help
@ -515,9 +515,10 @@ in all the directories in that path."
;; since the argument will then be parsed improperly. This also
;; has the added benefit of allowing node names to be included
;; following the parenthesized filename.
(if (and (stringp file) (string-match "(.*)" file))
(Info-goto-node file)
(Info-goto-node (concat "(" file ")")))
(Info-goto-node
(if (and (stringp file) (string-match "(.*)" file))
file
(concat "(" file ")")))
(if (zerop (buffer-size))
(Info-directory))))
@ -1344,7 +1345,9 @@ any double quotes or backslashes must be escaped (\\\",\\\\)."
;; Go to an info node specified with a filename-and-nodename string
;; of the sort that is found in pointers in nodes.
;;;###autoload
;; Don't autoload this function: the correct entry point for other packages
;; to use is `info'. --Stef
;; ;;;###autoload
(defun Info-goto-node (nodename &optional fork)
"Go to info node named NODENAME. Give just NODENAME or (FILENAME)NODENAME.
If NODENAME is of the form (FILENAME)NODENAME, the node is in the Info file
@ -3259,7 +3262,7 @@ Advanced commands:
(set (make-local-variable 'search-whitespace-regexp)
Info-search-whitespace-regexp)
(Info-set-mode-line)
(run-hooks 'Info-mode-hook))
(run-mode-hooks 'Info-mode-hook))
;; When an Info buffer is killed, make sure the associated tags buffer
;; is killed too.
@ -3301,7 +3304,7 @@ which returns to Info mode for browsing.
(setq buffer-read-only nil)
(force-mode-line-update)
(buffer-enable-undo (current-buffer))
(run-hooks 'Info-edit-mode-hook))
(run-mode-hooks 'Info-edit-mode-hook))
(defun Info-edit ()
"Edit the contents of this Info node.
@ -4127,5 +4130,5 @@ BUFFER is the buffer speedbar is requesting buttons for."
(provide 'info)
;;; arch-tag: f2480fe2-2139-40c1-a49b-6314991164ac
;; arch-tag: f2480fe2-2139-40c1-a49b-6314991164ac
;;; info.el ends here

34
lisp/international/code-pages.el
View File

@ -193,15 +193,18 @@ Return an updated `non-iso-charset-alist'."
;; a separate table that only translates the coding
;; system's safe-chars.
(cons 'translation-table-for-input 'ucs-mule-to-mule-unicode)))
(push (list ',name
nil ; charset list
',decoder
(let (l) ; code range
(dolist (elt (reverse codes))
(push (cdr elt) l)
(push (car elt) l))
(list l)))
non-iso-charset-alist))))
(let ((slot (assq ',name non-iso-charset-alist))
(elt (list nil ; charset list
',decoder
(let (l) ; code range
(dolist (elt (reverse codes))
(push (cdr elt) l)
(push (car elt) l))
(list l)))))
(if (not slot)
(push (cons ',name elt) non-iso-charset-alist)
(setcdr slot elt)
non-iso-charset-alist)))))
(eval-when-compile (defvar non-iso-charset-alist))
@ -4502,11 +4505,14 @@ Return an updated `non-iso-charset-alist'."
;; Define cp125* as aliases for all windows-125*, so on Windows
;; we can just concat "cp" to the ANSI codepage we get from the system
;; and not have to worry about whether it should be "cp" or "windows-".
(if (coding-system-p w)
(define-coding-system-alias c w))
;; Compatibility with codepage.el, though cp... are not the
;; canonical names.
(push (assoc w non-iso-charset-alist) non-iso-charset-alist)))
(when (coding-system-p w)
(define-coding-system-alias c w)
;; Compatibility with codepage.el, though cp... are not the
;; canonical names.
(if (not (assq c non-iso-charset-alist))
(let ((slot (assq w non-iso-charset-alist)))
(if slot
(push (cons c (cdr slot)) non-iso-charset-alist)))))))
(provide 'code-pages)

4
lisp/international/swedish.el
View File

@ -131,7 +131,7 @@ Leaves point just after the word that looks Swedish."
; (setq major-mode 'swedish-mode)
; (setq local-abbrev-table swedish-mode-abbrev-table)
; (set-syntax-table text-mode-syntax-table)
; (run-hooks 'text-mode-hook))
; (run-mode-hooks 'text-mode-hook))
;(defun indented-swedish-mode ()
; "Major mode for editing indented Swedish text intended for
@ -149,7 +149,7 @@ Leaves point just after the word that looks Swedish."
; (use-local-map indented-text-mode-map)
; (setq mode-name "Indented Swedish")
; (setq major-mode 'indented-swedish-mode)
; (run-hooks 'text-mode-hook))
; (run-mode-hooks 'text-mode-hook))
(provide 'swedish)

4
lisp/international/ucs-tables.el
View File

@ -2517,7 +2517,9 @@ This function is automatically called directly at the end of `get-buffer-create'
(if (and table (symbolp table))
(setq table (get table 'translation-table)))
(unless (char-table-p table)
(setq table (coding-system-get cs 'translation-table-for-input)))
(setq table (coding-system-get cs 'translation-table-for-input))
(if (and table (symbolp table))
(setq table (get table 'translation-table))))
(when (char-table-p table)
(if buffer
(with-current-buffer buffer

17
lisp/language/cyrillic.el
View File

@ -475,6 +475,23 @@ Support for Russian using koi8-r and the russian-computer input method.")
?\$,1(V(B ?\$,1(W(B ?\$,1(X(B ?\$,1(Y(B ?\$,1(Z(B ?\$,1([(B ?\$,1(\(B ?\$,1(](B ?\$,1(^(B ?\$,1(_(B ?\$,1(`(B ?\$,1(a(B ?\$,1(b(B ?\$,1(c(B ?\$,1(d(B ?\$,1(e(B ?\$,1(f(B
?\$,1(g(B ?\$,1(h(B ?\$,1(i(B ?\$,1(j(B ?\$,1(k(B ?\$,1(l(B ?\$,1(m(B ?\$,1(n(B ?\$,1(o(B] nil ?b)))
;; Register cyrillic-iso8859-5 characters in the encode table of
;; windows-1251.
(let ((table (get 'encode-windows-1251 'translation-table))
;; Nth element is a cyrillic-iso8859-5 character encoded to a
;; code (128 + N), or nil.
(vec [?\,L"(B ?\,L#(B nil ?\,Ls(B nil nil nil nil nil nil ?\,L)(B nil ?\,L*(B ?\,L,(B ?\,L+(B ?\,L/(B
?\,Lr(B nil nil nil nil nil nil nil nil nil ?\,Ly(B nil ?\,Lz(B ?\,L|(B ?\,L{(B ?\,L(B
nil ?\,L.(B ?\,L~(B ?\,L((B nil nil nil nil ?\,L!(B nil ?\,L$(B nil nil nil nil ?\,L'(B
nil nil ?\,L&(B ?\,Lv(B nil nil nil nil ?\,Lq(B ?\,Lp(B ?\,Lt(B nil ?\,Lx(B ?\,L%(B ?\,Lu(B ?\,Lw(B
?\,L0(B ?\,L1(B ?\,L2(B ?\,L3(B ?\,L4(B ?\,L5(B ?\,L6(B ?\,L7(B ?\,L8(B ?\,L9(B ?\,L:(B ?\,L;(B ?\,L<(B ?\,L=(B ?\,L>(B ?\,L?(B
?\,L@(B ?\,LA(B ?\,LB(B ?\,LC(B ?\,LD(B ?\,LE(B ?\,LF(B ?\,LG(B ?\,LH(B ?\,LI(B ?\,LJ(B ?\,LK(B ?\,LL(B ?\,LM(B ?\,LN(B ?\,LO(B
?\,LP(B ?\,LQ(B ?\,LR(B ?\,LS(B ?\,LT(B ?\,LU(B ?\,LV(B ?\,LW(B ?\,LX(B ?\,LY(B ?\,LZ(B ?\,L[(B ?\,L\(B ?\,L](B ?\,L^(B ?\,L_(B
?\,L`(B ?\,La(B ?\,Lb(B ?\,Lc(B ?\,Ld(B ?\,Le(B ?\,Lf(B ?\,Lg(B ?\,Lh(B ?\,Li(B ?\,Lj(B ?\,Lk(B ?\,Ll(B ?\,Lm(B ?\,Ln(B ?\,Lo(B]))
(dotimes (i (length vec))
(if (aref vec i)
(aset table (aref vec i) (+ 128 i)))))
(define-coding-system-alias 'cp1251 'windows-1251)
(let ((elt `("microsoft-cp1251" windows-1251 1

2
lisp/language/viet-util.el
View File

@ -38,6 +38,8 @@
;;; Code:
(defvar viet-viscii-nonascii-translation-table)
;;;###autoload
(defun viet-encode-viscii-char (char)
"Return VISCII character code of CHAR if appropriate."

2
lisp/ledit.el
View File

@ -152,7 +152,7 @@ do (setq lisp-mode-hook 'ledit-from-lisp-mode)"
(use-local-map ledit-mode-map)
(setq mode-name "Ledit")
(setq major-mode 'ledit-mode)
(run-hooks 'ledit-mode-hook))
(run-mode-hooks 'ledit-mode-hook))
(provide 'ledit)

2
lisp/locate.el
View File

@ -393,7 +393,7 @@ do not work in subdirectories.
(make-local-variable 'revert-buffer-function)
(setq revert-buffer-function 'locate-update)
(set (make-local-variable 'page-delimiter) "\n\n")
(run-hooks 'locate-mode-hook))
(run-mode-hooks 'locate-mode-hook))
(defun locate-do-setup (search-string)
(goto-char (point-min))

8
lisp/log-edit.el
View File

@ -607,8 +607,12 @@ where LOGBUFFER is the name of the ChangeLog buffer, and each
(search-forward pattern nil t))))
(setq pattern (file-name-nondirectory file)))
(setq pattern (concat "\\(^\\|[^[:alnum:]]\\)"
pattern
"\\($\\|[^[:alnum:]]\\)"))
(let (texts)
(while (search-forward pattern nil t)
(while (re-search-forward pattern nil t)
(let ((entry (log-edit-changelog-entry)))
(push entry texts)
(goto-char (elt entry 1))))
@ -646,5 +650,5 @@ Sort REGIONS front-to-back first."
(provide 'log-edit)
;;; arch-tag: 8089b39c-983b-4e83-93cd-ed0a64c7fdcc
;; arch-tag: 8089b39c-983b-4e83-93cd-ed0a64c7fdcc
;;; log-edit.el ends here

5
lisp/longlines.el
View File

@ -39,8 +39,6 @@
;;; Code:
(require 'easy-mmode)
(defgroup longlines nil
"Automatic wrapping of long lines when loading files."
:group 'fill)
@ -157,7 +155,8 @@ major mode changes."
(defface longlines-visible-face
'((t (:background "red")))
"Face used to make hard newlines visible in `longlines-mode'.")
"Face used to make hard newlines visible in `longlines-mode'."
:group 'longlines)
(defun longlines-show-hard-newlines (&optional arg)
"Make hard newlines visible by adding a face.

2
lisp/mail/mailalias.el
View File

@ -435,7 +435,7 @@ PATTERN is the string we want to complete."
(if mail-passwd-command
(call-process shell-file-name nil t nil
shell-command-switch mail-passwd-command))
(beginning-of-buffer)
(goto-char (point-min))
(setq mail-local-names nil)
(while (not (eobp))
;;Recognize lines like

8
lisp/mail/rmail.el
View File

@ -1156,7 +1156,7 @@ Instead, these commands are available:
(when rmail-display-summary
(rmail-summary))
(rmail-construct-io-menu))
(run-hooks 'rmail-mode-hook)))
(run-mode-hooks 'rmail-mode-hook)))
(defun rmail-mode-2 ()
(kill-all-local-variables)
@ -3444,7 +3444,11 @@ use \\[mail-yank-original] to yank the original message into it."
;; I don't know whether there are other mailers that still
;; need the names to be stripped.
;;; (mail-strip-quoted-names reply-to)
reply-to
;; Remove unwanted names from reply-to, since Mail-Followup-To
;; header causes all the names in it to wind up in reply-to, not
;; in cc. But if what's left is an empty list, use the original.
(let* ((reply-to-list (rmail-dont-reply-to reply-to)))
(if (string= reply-to-list "") reply-to reply-to-list))
subject
(rmail-make-in-reply-to-field from date message-id)
(if just-sender

2
lisp/mail/rmailedit.el
View File

@ -68,7 +68,7 @@ This functions runs the normal hook `rmail-edit-mode-hook'.
(save-excursion
(set-buffer rmail-summary-buffer)
(rmail-summary-disable)))
(run-hooks 'rmail-edit-mode-hook))
(run-mode-hooks 'rmail-edit-mode-hook))
(defvar rmail-old-pruned nil)
(put 'rmail-old-pruned 'permanent-local t)

2
lisp/mail/rmailsum.el
View File

@ -760,7 +760,7 @@ Commands for sorting the summary:
(make-local-variable 'font-lock-defaults)
(setq font-lock-defaults '(rmail-summary-font-lock-keywords t))
(rmail-summary-enable)
(run-hooks 'rmail-summary-mode-hook))
(run-mode-hooks 'rmail-summary-mode-hook))
;; Summary features need to be disabled during edit mode.
(defun rmail-summary-disable ()

3
lisp/mail/sendmail.el
View File

@ -810,7 +810,8 @@ the user from the mailer."
'(lambda (e)
(unless (member e l)
(push e l)))
(split-string new-header-values ", +" t))
(split-string new-header-values
",[[:space:]]+" t))
(mapconcat 'identity l ", "))
"\n"))
;; Add Mail-Reply-To if none yet

7
lisp/mail/smtpmail.el
View File

@ -396,7 +396,7 @@ This is relative to `smtpmail-queue-dir'.")
;;; mail, send it, etc...
(let ((file-msg ""))
(insert-file-contents smtpmail-queue-index)
(beginning-of-buffer)
(goto-char (point-min))
(while (not (eobp))
(setq file-msg (buffer-substring (point) (line-end-position)))
(load file-msg)
@ -465,11 +465,14 @@ This is relative to `smtpmail-queue-dir'.")
(push el2 result)))
(nreverse result)))
(defvar starttls-extra-args)
(defvar starttls-extra-arguments)
(defun smtpmail-open-stream (process-buffer host port)
(let ((cred (smtpmail-find-credentials
smtpmail-starttls-credentials host port)))
(if (null (and cred (condition-case ()
(progn
(with-no-warnings
(require 'starttls)
(call-process (if starttls-use-gnutls
starttls-gnutls-program

2
lisp/mail/supercite.el
View File

@ -1667,7 +1667,7 @@ header style to use, unless not supplied or invalid, in which case
(major-mode 'sc-electric-mode))
(use-local-map sc-electric-mode-map)
(sc-eref-show sc-eref-style)
(run-hooks 'sc-electric-mode-hook)
(run-mode-hooks 'sc-electric-mode-hook)
(recursive-edit)
)))

5
lisp/man.el
View File

@ -1061,6 +1061,7 @@ The following variables may be of some use. Try
The following key bindings are currently in effect in the buffer:
\\{Man-mode-map}"
(interactive)
(kill-all-local-variables)
(setq major-mode 'Man-mode
mode-name "Man"
buffer-auto-save-file-name nil
@ -1069,7 +1070,7 @@ The following key bindings are currently in effect in the buffer:
" {" 'Man-page-mode-string "}")
truncate-lines t
buffer-read-only t)
(buffer-disable-undo (current-buffer))
(buffer-disable-undo)
(auto-fill-mode -1)
(use-local-map Man-mode-map)
(set-syntax-table man-mode-syntax-table)
@ -1080,7 +1081,7 @@ The following key bindings are currently in effect in the buffer:
(Man-strip-page-headers)
(Man-unindent)
(Man-goto-page 1)
(run-hooks 'Man-mode-hook))
(run-mode-hooks 'Man-mode-hook))
(defsubst Man-build-section-alist ()
"Build the association list of manpage sections."

5
lisp/mh-e/ChangeLog
View File

@ -1,3 +1,8 @@
2005-05-26 Lute Kamstra <lute@gnu.org>
* mh-utils.el (mh-show-mode):
* mh-pick.el (mh-pick-mode): Remove spurious run-hooks.
2005-04-08 Dan Nicolaescu <dann@ics.uci.edu>
* mh-customize.el (mh-speedbar-selected-folder-face): Special case

3
lisp/mh-e/mh-pick.el
View File

@ -140,8 +140,7 @@ with no arguments, upon entry to this mode.
(make-local-variable 'mh-searching-function)
(make-local-variable 'mh-help-messages)
(easy-menu-add mh-pick-menu)
(setq mh-help-messages mh-pick-mode-help-messages)
(run-hooks 'mh-pick-mode-hook))
(setq mh-help-messages mh-pick-mode-help-messages))
;;;###mh-autoload
(defun mh-pick-do-search ()

3
lisp/mh-e/mh-utils.el
View File

@ -1129,8 +1129,7 @@ See also `mh-folder-mode'.
(make-local-variable 'mh-show-folder-buffer)
(buffer-disable-undo)
(setq buffer-read-only t)
(use-local-map mh-show-mode-map)
(run-hooks 'mh-show-mode-hook))
(use-local-map mh-show-mode-map))
(defun mh-show-addr ()
"Use `goto-address'."

3
lisp/net/eudc.el
View File

@ -670,8 +670,7 @@ These are the special commands of EUDC mode:
(if eudc-emacs-p
(easy-menu-define eudc-emacs-menu eudc-mode-map "" (eudc-menu))
(setq mode-popup-menu (eudc-menu)))
(run-hooks 'eudc-mode-hook)
)
(run-mode-hooks 'eudc-mode-hook))
;;}}}

2
lisp/net/quickurl.el
View File

@ -458,7 +458,7 @@ The key bindings for `quickurl-list-mode' are:
(use-local-map quickurl-list-mode-map)
(setq major-mode 'quickurl-list-mode
mode-name "quickurl list")
(run-hooks 'quickurl-list-mode-hook)
(run-mode-hooks 'quickurl-list-mode-hook)
(setq buffer-read-only t
truncate-lines t))

2
lisp/net/rcompile.el
View File

@ -168,7 +168,7 @@ See \\[compile]."
compile-command)))
(setq remote-compile-host host)
(save-some-buffers nil nil)
(compile-internal compile-command "No more errors")
(compilation-start compile-command)
;; Set comint-file-name-prefix in the compilation buffer so
;; compilation-parse-errors will find referenced files by ange-ftp.
(with-current-buffer compilation-last-buffer

6
lisp/net/snmp-mode.el
View File

@ -393,8 +393,7 @@ Turning on snmp-mode runs the hooks in `snmp-common-mode-hook', then
(setq snmp-mode-status-list snmp-rfc1212-status)
;; Run hooks
(run-hooks 'snmp-common-mode-hook)
(run-hooks 'snmp-mode-hook))
(run-mode-hooks 'snmp-common-mode-hook 'snmp-mode-hook))
;;;###autoload
@ -429,8 +428,7 @@ then `snmpv2-mode-hook'."
(setq snmp-mode-status-list snmp-rfc1902-status)
;; Run hooks
(run-hooks 'snmp-common-mode-hook)
(run-hooks 'snmpv2-mode-hook))
(run-mode-hooks 'snmp-common-mode-hook 'snmpv2-mode-hook))
;;;----------------------------------------------------------------------------

2
lisp/obsolete/ooutline.el
View File

@ -224,7 +224,7 @@ Turning on outline mode calls the value of `text-mode-hook' and then of
(setq font-lock-defaults '(outline-font-lock-keywords t))
(make-local-variable 'change-major-mode-hook)
(add-hook 'change-major-mode-hook 'show-all)
(run-hooks 'text-mode-hook 'outline-mode-hook))
(run-mode-hooks 'text-mode-hook 'outline-mode-hook))
(defcustom outline-minor-mode-prefix "\C-c@"
"*Prefix key to use for Outline commands in Outline minor mode.

Some files were not shown because too many files have changed in this diff Show More