# HG changeset patch
# User Gerd Moellmann <gerd@gnu.org>
# Date 965251776 0
# Node ID 338238ca63cee840738d6cb8c1f4bc7d0ad3e2e6
# Parent  a363ab77020cb8131c353586567b1d610fa9f5da
*** empty log message ***

diff -r a363ab77020c -r 338238ca63ce etc/NEWS
--- a/etc/NEWS	Wed Aug 02 20:23:23 2000 +0000
+++ b/etc/NEWS	Wed Aug 02 21:29:36 2000 +0000
@@ -1083,6 +1083,22 @@
 
 ** New modes and packages
 
+*** THe new package hi-lock.el, text matching interactively entered
+regexp's can be highlighted.  For example, 
+
+  M-x highlight-regexp RET clearly RET RET 
+
+will highlight all occurrences of `clearly' using a yellow background
+face.  New occurrences of `clearly' will be highlighted as they are
+typed.  `M-x unhighlight-regexp RET' will remove the highlighting.
+Any existing face can be used for highlighting and a set of
+appropriate faces is provided.  The regexps can be written into the
+current buffer in a form that will be recognized the next time the
+corresponding file is read.
+
+*** The new package zone.el plays games with Emacs' display when 
+Emacs is idle.
+
 *** The new package xml.el provides a simple but generic XML
 parser. It doesn't parse the DTDs however.
 
diff -r a363ab77020c -r 338238ca63ce lisp-elc.tgz
Binary file lisp-elc.tgz has changed
diff -r a363ab77020c -r 338238ca63ce lisp/ChangeLog
--- a/lisp/ChangeLog	Wed Aug 02 20:23:23 2000 +0000
+++ b/lisp/ChangeLog	Wed Aug 02 21:29:36 2000 +0000
@@ -1,5 +1,9 @@
 2000-08-02  Gerd Moellmann  <gerd@gnu.org>
 
+	* hi-lock.el: New file.
+
+	* play/zone.el: New file.
+
 	* replace.el (occur): Set tab-width in the *Occur* buffer to the
 	value of tab-width in the original buffer.  Choose a line number
 	format that's a multiple of the original buffer's tab width, so
diff -r a363ab77020c -r 338238ca63ce lisp/cus-load.el
--- a/lisp/cus-load.el	Wed Aug 02 20:23:23 2000 +0000
+++ b/lisp/cus-load.el	Wed Aug 02 21:29:36 2000 +0000
@@ -6,6 +6,7 @@
 (put 'SQL 'custom-loads '("sql"))
 (put 'refbib 'custom-loads '("refbib"))
 (put 'elp 'custom-loads '("elp"))
+(put 'eshell-ext 'custom-loads '("esh-ext"))
 (put 'ffap 'custom-loads '("ffap"))
 (put 'shell 'custom-loads '("dirtrack" "shell" "terminal"))
 (put 'locate 'custom-loads '("locate"))
@@ -15,11 +16,14 @@
 (put 'shell-directories 'custom-loads '("shell"))
 (put 'idlwave-documentation 'custom-loads '("idlwave"))
 (put 'footnote 'custom-loads '("footnote"))
+(put 'pcomplete 'custom-loads '("pcmpl-cvs" "pcmpl-gnu" "pcmpl-linux" "pcmpl-rpm" "pcomplete" "em-cmpl"))
 (put 'calendar-tex 'custom-loads '("cal-tex"))
+(put 'hi-lock-interactive-text-highlighting 'custom-loads '("hi-lock"))
 (put 'mail-hist 'custom-loads '("mail-hist"))
 (put 'gnus-article-emphasis 'custom-loads '("gnus-art"))
 (put 'dunnet 'custom-loads '("dunnet"))
 (put 'fortran 'custom-loads '("fortran"))
+(put 'eshell-script 'custom-loads '("em-script"))
 (put 'feedmail-header 'custom-loads '("feedmail"))
 (put 'reftex-table-of-contents-browser 'custom-loads '("reftex-vars"))
 (put 'mspools 'custom-loads '("mspools"))
@@ -38,6 +42,7 @@
 (put 'icon 'custom-loads '("icon"))
 (put 'nnmail-procmail 'custom-loads '("nnmail"))
 (put 'desktop 'custom-loads '("desktop"))
+(put 'eshell-cmpl 'custom-loads '("em-cmpl"))
 (put 'cperl-help-system 'custom-loads '("cperl-mode"))
 (put 'ps-print-miscellany 'custom-loads '("ps-print"))
 (put 'comint-completion 'custom-loads '("comint"))
@@ -75,6 +80,7 @@
 (put 'mpuz 'custom-loads '("mpuz"))
 (put 'find-file 'custom-loads '("files" "find-file"))
 (put 'fortran-comment 'custom-loads '("fortran"))
+(put 'idlwave-online-help 'custom-loads '("idlwave"))
 (put 'viper 'custom-loads '("viper-ex" "viper-init" "viper-keym" "viper-macs" "viper-mous" "viper"))
 (put 'ps-print-page 'custom-loads '("ps-print"))
 (put 'postscript 'custom-loads '("ps-print" "ebnf2ps"))
@@ -108,11 +114,13 @@
 (put 'feedmail 'custom-loads '("feedmail"))
 (put 'gnus-agent 'custom-loads '("gnus-agent"))
 (put 'message-news 'custom-loads '("message"))
+(put 'eshell 'custom-loads '("esh-arg" "esh-cmd" "esh-ext" "esh-io" "esh-mode" "esh-module" "esh-opt" "esh-proc" "esh-test" "esh-util" "esh-var" "eshell"))
 (put 'bib 'custom-loads '("bib-mode"))
 (put 'vhdl-align 'custom-loads '("vhdl-mode"))
 (put 'iswitchb 'custom-loads '("iswitchb"))
 (put 'custom-buffer 'custom-loads '("cus-edit"))
 (put 'vhdl-header 'custom-loads '("vhdl-mode"))
+(put 'eshell-cmd 'custom-loads '("esh-cmd"))
 (put 'tex-run 'custom-loads '("tex-mode"))
 (put 'reftex-finding-files 'custom-loads '("reftex-vars"))
 (put 'iso-acc 'custom-loads '("iso-acc"))
@@ -138,6 +146,7 @@
 (put 'speedbar-faces 'custom-loads '("speedbar" "vhdl-mode"))
 (put 'rmail 'custom-loads '("paths" "rmail" "undigest"))
 (put 'ps-print-n-up 'custom-loads '("ps-print"))
+(put 'eshell-arg 'custom-loads '("esh-arg"))
 (put 'ps-print-printer 'custom-loads '("ps-print"))
 (put 'message-various 'custom-loads '("message"))
 (put 'term 'custom-loads '("terminal" "term"))
@@ -165,6 +174,7 @@
 (put 'gnus-score 'custom-loads '("gnus-nocem" "gnus"))
 (put 'gnus-group-select 'custom-loads '("gnus-sum" "gnus"))
 (put 'archive-lzh 'custom-loads '("arc-mode"))
+(put 'eshell-prompt 'custom-loads '("em-prompt"))
 (put 'vhdl-sequential-process 'custom-loads '("vhdl-mode"))
 (put 'simula 'custom-loads '("simula"))
 (put 'bs-appearence 'custom-loads '("bs"))
@@ -174,6 +184,7 @@
 (put 'generic 'custom-loads '("generic-x" "generic"))
 (put 'docs 'custom-loads '("info" "makeinfo" "texinfo"))
 (put 'indent 'custom-loads '("indent"))
+(put 'eshell-alias 'custom-loads '("em-alias"))
 (put 'enriched 'custom-loads '("enriched"))
 (put 'gnus-threading 'custom-loads '("gnus-sum"))
 (put 'hide-ifdef 'custom-loads '("hideif"))
@@ -186,9 +197,10 @@
 (put 'idlwave-shell-initial-commands 'custom-loads '("idlw-shell"))
 (put 'tildify 'custom-loads '("tildify"))
 (put 'cperl-autoinsert-details 'custom-loads '("cperl-mode"))
-(put 'help 'custom-loads '("help" "apropos" "cus-edit" "help-macro" "info-look" "info" "man" "tooltip" "woman"))
+(put 'help 'custom-loads '("help-macro" "help" "apropos" "cus-edit" "info-look" "info" "man" "tooltip" "woman"))
 (put 'forms 'custom-loads '("forms"))
 (put 'widget-documentation 'custom-loads '("wid-edit"))
+(put 'eshell-banner 'custom-loads '("em-banner"))
 (put 'gnus-score-various 'custom-loads '("gnus-score" "gnus"))
 (put 'cperl-faces 'custom-loads '("cperl-mode"))
 (put 'goto-address 'custom-loads '("goto-addr"))
@@ -224,7 +236,9 @@
 (put 'mail-extr 'custom-loads '("mail-extr"))
 (put 'double 'custom-loads '("double"))
 (put 'imenu 'custom-loads '("imenu"))
+(put 'eshell-var 'custom-loads '("esh-var"))
 (put 'scribe 'custom-loads '("scribe"))
+(put 'eshell-smart 'custom-loads '("em-smart"))
 (put 'server 'custom-loads '("server"))
 (put 'idlwave-shell-highlighting-and-faces 'custom-loads '("idlw-shell"))
 (put 'tcl 'custom-loads '("tcl"))
@@ -242,6 +256,7 @@
 (put 'nnmail-duplicate 'custom-loads '("nnmail"))
 (put 'handwrite 'custom-loads '("handwrite"))
 (put 'tags 'custom-loads '("speedbar"))
+(put 'eshell-proc 'custom-loads '("esh-proc"))
 (put 'custom-browse 'custom-loads '("cus-edit"))
 (put 'generic-x 'custom-loads '("generic-x"))
 (put 'partial-completion 'custom-loads '("complete"))
@@ -270,20 +285,23 @@
 (put 'ebnf-optimization 'custom-loads '("ebnf2ps"))
 (put 'apropos 'custom-loads '("apropos"))
 (put 'gomoku 'custom-loads '("gomoku"))
+(put 'eshell-pred 'custom-loads '("em-pred"))
 (put 'tools 'custom-loads '("add-log" "calculator" "compare-w" "diff-mode" "diff" "ediff" "elide-head" "emerge" "gud" "pcvs-defs" "smerge-mode" "speedbar" "tempo" "tooltip" "vc" "which-func" "copyright" "compile" "ebrowse" "etags" "glasses" "make-mode" "rcompile"))
 (put 'gnus-topic 'custom-loads '("gnus-topic"))
 (put 'sgml 'custom-loads '("sgml-mode"))
 (put 'keyboard 'custom-loads '("simple" "chistory" "type-break"))
+(put 'eshell-hist 'custom-loads '("em-hist"))
 (put 'viper-mouse 'custom-loads '("viper-mous"))
 (put 'ps-print-horizontal 'custom-loads '("ps-print"))
 (put 'woman 'custom-loads '("woman"))
 (put 'decipher 'custom-loads '("decipher"))
+(put 'pcmpl-gnu 'custom-loads '("pcmpl-gnu"))
 (put 'ps-print-face 'custom-loads '("ps-print"))
 (put 'rmail-summary 'custom-loads '("rmail" "rmailsum"))
 (put 'metamail 'custom-loads '("metamail"))
 (put 'winner 'custom-loads '("winner"))
 (put 'ebrowse-faces 'custom-loads '("ebrowse"))
-(put 'wp 'custom-loads '("cus-edit" "enriched" "lpr" "ps-print" "view" "ebnf2ps" "bib-mode" "nroff-mode" "refbib" "refer" "scribe" "tildify"))
+(put 'wp 'custom-loads '("view" "cus-edit" "enriched" "lpr" "ps-print" "ebnf2ps" "bib-mode" "nroff-mode" "refbib" "refer" "scribe" "tildify"))
 (put 'reftex-citation-support 'custom-loads '("reftex-vars"))
 (put 'gnus-summary-choose 'custom-loads '("gnus-sum"))
 (put 'widget-browse 'custom-loads '("wid-browse"))
@@ -295,7 +313,7 @@
 (put 'vhdl-highlight-faces 'custom-loads '("vhdl-mode"))
 (put 'which-func 'custom-loads '("which-func"))
 (put 'pc-select 'custom-loads '("pc-select"))
-(put 'i18n 'custom-loads '("cus-edit" "double" "ccl" "iso-acc" "iso-ascii" "ogonek"))
+(put 'i18n 'custom-loads '("ccl" "cus-edit" "double" "iso-acc" "iso-ascii" "ogonek"))
 (put 'sh 'custom-loads '("sh-script"))
 (put 'message-headers 'custom-loads '("message"))
 (put 'idlwave-code-formatting 'custom-loads '("idlwave"))
@@ -327,11 +345,13 @@
 (put 'gnus-duplicate 'custom-loads '("gnus-dup"))
 (put 'find-function 'custom-loads '("find-func"))
 (put 'menu 'custom-loads '("faces" "tmm" "easymenu"))
+(put 'eshell-test 'custom-loads '("esh-test"))
 (put 'vhdl-highlight 'custom-loads '("vhdl-mode"))
 (put 'widgets 'custom-loads '("wid-browse" "wid-edit"))
 (put 'log-view 'custom-loads '("log-view"))
 (put 'PostScript 'custom-loads '("ps-mode"))
 (put 'abbrev-mode 'custom-loads '("abbrev" "cus-edit" "mailabbrev"))
+(put 'eshell-term 'custom-loads '("em-term"))
 (put 'earcon 'custom-loads '("earcon"))
 (put 'feedmail-headers 'custom-loads '("feedmail"))
 (put 'hypermedia 'custom-loads '("wid-edit" "metamail" "browse-url" "goto-addr"))
@@ -354,6 +374,8 @@
 (put 'change-log 'custom-loads '("add-log"))
 (put 'gnus-group-levels 'custom-loads '("gnus-group" "gnus-start" "gnus"))
 (put 'cperl 'custom-loads '("cperl-mode"))
+(put 'pcmpl-cvs 'custom-loads '("pcmpl-cvs"))
+(put 'eshell-mode 'custom-loads '("esh-mode"))
 (put 'files 'custom-loads '("files" "autoinsert" "autorevert" "cus-edit" "filecache" "recentf" "shadow" "ange-ftp"))
 (put 'pcl-cvs 'custom-loads '("cvs-status" "log-edit" "log-view" "pcvs-defs" "pcvs-info" "pcvs-parse" "pcvs"))
 (put 'rmail-files 'custom-loads '("rmail"))
@@ -381,6 +403,7 @@
 (put 'ispell 'custom-loads '("ispell"))
 (put 'auto-revert 'custom-loads '("autorevert"))
 (put 'advice 'custom-loads '("advice"))
+(put 'eshell-util 'custom-loads '("esh-util"))
 (put 'picture 'custom-loads '("picture"))
 (put 'gnus-group 'custom-loads '("gnus-topic" "gnus"))
 (put 'eudc-bbdb 'custom-loads '("eudc-vars"))
@@ -411,16 +434,19 @@
 (put 'modeline 'custom-loads '("faces" "time"))
 (put 'archive-zoo 'custom-loads '("arc-mode"))
 (put 'gnus-group-level 'custom-loads '("gnus"))
+(put 'idlwave-completion 'custom-loads '("idlwave"))
+(put 'eshell-rebind 'custom-loads '("em-rebind"))
 (put 'bibtex 'custom-loads '("bibtex"))
-(put 'faces 'custom-loads '("faces" "facemenu" "cus-edit" "font-lock" "hilit-chg" "paren" "ps-print" "speedbar" "time" "wid-edit" "woman" "gnus" "message" "cwarn" "make-mode"))
+(put 'faces 'custom-loads '("faces" "facemenu" "cus-edit" "font-lock" "loaddefs" "hilit-chg" "paren" "ps-print" "speedbar" "time" "wid-edit" "woman" "gnus" "message" "cwarn" "make-mode"))
 (put 'gnus-summary-various 'custom-loads '("gnus-sum"))
-(put 'applications 'custom-loads '("calendar" "cus-edit" "uniquify" "spell"))
+(put 'applications 'custom-loads '("calendar" "cus-edit" "uniquify" "spell" "eshell"))
 (put 'ebrowse-member 'custom-loads '("ebrowse"))
 (put 'terminal 'custom-loads '("terminal"))
 (put 'shadow 'custom-loads '("shadowfile" "shadow"))
 (put 'hl-line 'custom-loads '("hl-line"))
+(put 'eshell-glob 'custom-loads '("em-glob"))
 (put 'internal 'custom-loads '("startup" "cus-edit"))
-(put 'lisp 'custom-loads '("simple" "lisp" "lisp-mode" "cmuscheme" "ielm" "xscheme" "advice" "bytecomp" "checkdoc" "cl-indent" "cust-print" "edebug" "elp" "find-func" "pp" "re-builder" "shadow" "trace" "scheme"))
+(put 'lisp 'custom-loads '("simple" "lisp" "lisp-mode" "cmuscheme" "ielm" "xscheme" "advice" "bytecomp" "checkdoc" "cl-indent" "cust-print" "edebug" "eldoc" "elp" "find-func" "pp" "re-builder" "shadow" "trace" "scheme"))
 (put 'local 'custom-loads '("calendar"))
 (put 'rlogin 'custom-loads '("rlogin"))
 (put 'debugger 'custom-loads '("debug"))
@@ -433,7 +459,7 @@
 (put 'message-sending 'custom-loads '("message"))
 (put 'archive-arc 'custom-loads '("arc-mode"))
 (put 'rmail-output 'custom-loads '("rmailout"))
-(put 'editing 'custom-loads '("simple" "indent" "paragraphs" "auto-show" "cus-edit" "faces" "outline" "hl-line" "hscroll" "vcursor" "view" "picture"))
+(put 'editing 'custom-loads '("simple" "view" "indent" "paragraphs" "auto-show" "cus-edit" "faces" "outline" "hl-line" "hscroll" "vcursor" "picture"))
 (put 'crisp 'custom-loads '("crisp"))
 (put 'nroff 'custom-loads '("nroff-mode"))
 (put 'executable 'custom-loads '("executable"))
@@ -441,6 +467,7 @@
 (put 'copyright 'custom-loads '("copyright"))
 (put 'bytecomp 'custom-loads '("bytecomp"))
 (put 'message-insertion 'custom-loads '("message"))
+(put 'pcmpl-unix 'custom-loads '("pcmpl-unix"))
 (put 'gnus-extract-post 'custom-loads '("gnus-uu"))
 (put 'reftex-viewing-cross-references 'custom-loads '("reftex-vars"))
 (put 'hanoi 'custom-loads '("hanoi"))
@@ -476,10 +503,12 @@
 (put 'uniquify 'custom-loads '("uniquify"))
 (put 'old-c++ 'custom-loads '("cplus-md"))
 (put 'ps-print-font 'custom-loads '("ps-mule" "ps-print"))
+(put 'eshell-basic 'custom-loads '("em-basic"))
 (put 'vhdl-misc 'custom-loads '("vhdl-mode"))
 (put 'dired-x 'custom-loads '("dired-x"))
 (put 'spook 'custom-loads '("spook"))
 (put 'tex-file 'custom-loads '("tex-mode"))
+(put 'eshell-dirs 'custom-loads '("em-dirs"))
 (put 'time-stamp 'custom-loads '("time-stamp"))
 (put 'todo 'custom-loads '("todo-mode"))
 (put 'ebnf-special 'custom-loads '("ebnf2ps"))
@@ -488,13 +517,13 @@
 (put 'gud 'custom-loads '("gud"))
 (put 'c-macro 'custom-loads '("cmacexp"))
 (put 'gnus-cache 'custom-loads '("gnus-cache" "gnus"))
+(put 'eshell-module 'custom-loads '("esh-groups" "esh-module"))
 (put 'gnus-extract 'custom-loads '("gnus" "gnus-uu"))
 (put 'quickurl 'custom-loads '("quickurl"))
 (put 'browse-url 'custom-loads '("browse-url"))
 (put 'cust-print 'custom-loads '("cust-print"))
 (put 'gnus-article 'custom-loads '("gnus-art" "gnus-cite"))
 (put 'fortran-indent 'custom-loads '("fortran"))
-(put 'idlwave-routine-info-and-completion 'custom-loads '("idlwave"))
 (put 'comment 'custom-loads '("newcomment"))
 (put 'hardware 'custom-loads '("battery"))
 (put 'edebug 'custom-loads '("edebug"))
@@ -510,18 +539,21 @@
 (put 'programming 'custom-loads '("cus-edit"))
 (put 'meta-font 'custom-loads '("meta-mode"))
 (put 'ps-print-zebra 'custom-loads '("ps-print"))
+(put 'eshell-unix 'custom-loads '("em-unix"))
+(put 'hi-lock-faces 'custom-loads '("hi-lock"))
 (put 'hideshow 'custom-loads '("hideshow"))
 (put 'viper-search 'custom-loads '("viper-init"))
-(put 'mule 'custom-loads '("mule-cmds"))
+(put 'mule 'custom-loads '("mule-cmds" "kkc"))
 (put 'glasses 'custom-loads '("glasses"))
 (put 'vhdl-style 'custom-loads '("vhdl-mode"))
 (put 'tempo 'custom-loads '("tempo"))
 (put 'c 'custom-loads '("tooltip" "cc-vars" "cmacexp" "cpp" "hideif"))
 (put 'nnmail-prepare 'custom-loads '("nnmail"))
-(put 'processes 'custom-loads '("comint" "cus-edit" "shell" "term" "metamail" "compile" "executable" "sql" "flyspell" "rcompile" "rlogin"))
+(put 'processes 'custom-loads '("comint" "cus-edit" "executable" "pcomplete" "shell" "term" "metamail" "compile" "sql" "flyspell" "rcompile" "rlogin"))
 (put 'ebnf2ps 'custom-loads '("ebnf2ps"))
 (put 'sendmail 'custom-loads '("sendmail"))
 (put 'gnus-article-signature 'custom-loads '("gnus-art"))
+(put 'eshell-ls 'custom-loads '("em-ls"))
 (put 'idlwave 'custom-loads '("idlw-shell" "idlwave"))
 (put 'viper-ex 'custom-loads '("viper-ex"))
 (put 'gulp 'custom-loads '("gulp"))
@@ -529,6 +561,7 @@
 (put 'find-dired 'custom-loads '("find-dired"))
 (put 'delphi 'custom-loads '("delphi"))
 (put 're-builder 'custom-loads '("re-builder"))
+(put 'eshell-io 'custom-loads '("esh-io"))
 (put 'killing 'custom-loads '("simple"))
 (put 'woman-interface 'custom-loads '("woman"))
 (put 'gnus-group-various 'custom-loads '("gnus-group" "gnus"))
@@ -589,8 +622,6 @@
 (custom-put-if-not 'input-mode-8-bit 'standard-value t)
 (custom-put-if-not 'elide-head 'custom-version "21.1")
 (custom-put-if-not 'elide-head 'group-documentation "Eliding copyright headers and the like in source files.")
-(custom-put-if-not 'flyspell 'custom-version "20.3")
-(custom-put-if-not 'flyspell 'group-documentation "Spellchecking on the fly.")
 (custom-put-if-not 'compilation-scroll-output 'custom-version "20.3")
 (custom-put-if-not 'compilation-scroll-output 'standard-value t)
 (custom-put-if-not 'vc-dired-recurse 'custom-version "20.3")
@@ -605,6 +636,8 @@
 (custom-put-if-not 'help-highlight-p 'standard-value t)
 (custom-put-if-not 'browse-url-mosaic-program 'custom-version "20.3")
 (custom-put-if-not 'browse-url-mosaic-program 'standard-value t)
+(custom-put-if-not 'sql-oracle-options 'custom-version "20.8")
+(custom-put-if-not 'sql-oracle-options 'standard-value t)
 (custom-put-if-not 'find-function-regexp 'custom-version "21.1")
 (custom-put-if-not 'find-function-regexp 'standard-value t)
 (custom-put-if-not 'vcursor-string 'custom-version "20.3")
@@ -617,6 +650,8 @@
 (custom-put-if-not 'browse-url-filename-alist 'standard-value t)
 (custom-put-if-not 'change-log-version-info-enabled 'custom-version "21.1")
 (custom-put-if-not 'change-log-version-info-enabled 'standard-value t)
+(custom-put-if-not 'sql-electric-stuff 'custom-version "20.8")
+(custom-put-if-not 'sql-electric-stuff 'standard-value t)
 (custom-put-if-not 'midnight 'custom-version "20.3")
 (custom-put-if-not 'midnight 'group-documentation "Run something every day at midnight.")
 (custom-put-if-not 'automatic-hscrolling 'custom-version "21.1")
@@ -651,6 +686,8 @@
 (custom-put-if-not 'diary-mail-days 'standard-value t)
 (custom-put-if-not 'diary-mail-addr 'custom-version "20.3")
 (custom-put-if-not 'diary-mail-addr 'standard-value t)
+(custom-put-if-not 'font-lock-support-mode 'custom-version "21.1")
+(custom-put-if-not 'font-lock-support-mode 'standard-value t)
 (custom-put-if-not 'compilation-error-screen-columns 'custom-version "20.4")
 (custom-put-if-not 'compilation-error-screen-columns 'standard-value t)
 (custom-put-if-not 'debugger-record-buffer 'custom-version "20.3")
@@ -695,6 +732,8 @@
 (custom-put-if-not 'cperl 'group-documentation "Major mode for editing Perl code.")
 (custom-put-if-not 'focus-follows-mouse 'custom-version "20.3")
 (custom-put-if-not 'focus-follows-mouse 'standard-value t)
+(custom-put-if-not 'pcl-cvs 'custom-version "21.1")
+(custom-put-if-not 'pcl-cvs 'group-documentation "Special support for the CVS versioning system.")
 (custom-put-if-not 'fortran-comment-line-start-skip 'custom-version "21.1")
 (custom-put-if-not 'fortran-comment-line-start-skip 'standard-value t)
 (custom-put-if-not 'checkdoc 'custom-version "20.3")
@@ -733,8 +772,6 @@
 (custom-put-if-not 'diary-unknown-time 'standard-value t)
 (custom-put-if-not 'browse-url-lynx-emacs-args 'custom-version "20.3")
 (custom-put-if-not 'browse-url-lynx-emacs-args 'standard-value t)
-(custom-put-if-not 'todo 'custom-version "21.1")
-(custom-put-if-not 'todo 'group-documentation "Maintain a list of todo items.")
 (custom-put-if-not 'tooltip 'custom-version "21.1")
 (custom-put-if-not 'tooltip 'group-documentation "Customization group for the `tooltip' package.")
 (custom-put-if-not 'quickurl 'custom-version "21.1")
@@ -770,7 +807,7 @@
 (custom-put-if-not 'eval-expression-print-level 'custom-version "21.1")
 (custom-put-if-not 'eval-expression-print-level 'standard-value t)
 
-(defvar custom-versions-load-alist '(("20.3.3" "dos-vars") (21.1 "ange-ftp") ("20.4" "files" "sh-script" "help" "compile") ("21.1" "debug" "dabbrev" "files" "paths" "sgml-mode" "net-utils" "fortran" "etags" "cus-edit" "frame" "add-log" "find-func" "wid-edit" "simple") ("20.3" "desktop" "easymenu" "hscroll" "dabbrev" "ffap" "rmail" "paren" "mailabbrev" "frame" "uce" "mouse" "diary-lib" "sendmail" "debug" "hexl" "vcursor" "vc" "compile" "etags" "help" "browse-url" "add-log" "find-func" "vc-hooks" "cus-edit" "replace"))
+(defvar custom-versions-load-alist '(("20.3.3" "dos-vars") (21.1 "ange-ftp") ("20.4" "files" "sh-script" "help" "compile") ("20.8" "sql") ("21.1" "debug" "dabbrev" "files" "paths" "sgml-mode" "net-utils" "font-lock" "fortran" "etags" "cus-edit" "frame" "add-log" "find-func" "wid-edit" "simple") ("20.3" "desktop" "easymenu" "hscroll" "dabbrev" "ffap" "rmail" "paren" "mailabbrev" "frame" "uce" "mouse" "diary-lib" "sendmail" "debug" "hexl" "vcursor" "vc" "compile" "etags" "help" "browse-url" "add-log" "find-func" "vc-hooks" "cus-edit" "replace"))
  "For internal use by custom.")
 
 (provide 'cus-load)
diff -r a363ab77020c -r 338238ca63ce lisp/hi-lock.el
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lisp/hi-lock.el	Wed Aug 02 21:29:36 2000 +0000
@@ -0,0 +1,518 @@
+;;; hi-lock.el --- Minor mode for interactive automatic highlighting.
+
+;; Copyright (C) 2000 Free Software Foundation, Inc.
+
+;; Author: David M. Koppelman, koppel@ee.lsu.edu
+;; Keywords: faces, minor-mode, matching, display
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary
+;; 
+;;  With the hi-lock commands text matching interactively entered
+;;  regexp's can be highlighted.  For example, `M-x highlight-regexp
+;;  RET clearly RET RET' will highlight all occurrences of `clearly'
+;;  using a yellow background face.  New occurrences of `clearly' will
+;;  be highlighted as they are typed.  `M-x unhighlight-regexp RET'
+;;  will remove the highlighting.  Any existing face can be used for
+;;  highlighting and a set of appropriate faces is provided.  The
+;;  regexps can be written into the current buffer in a form that will
+;;  be recognized the next time the corresponding file is read.
+;;
+;;  Applications:
+;;
+;;    In program source code highlight a variable to quickly see all
+;;    places it is modified or referenced:
+;;    M-x highlight-regexp ground_contact_switches_closed RET RET
+;;
+;;    In a shell or other buffer that is showing lots of program
+;;    output, highlight the parts of the output you're interested in:
+;;    M-x highlight-regexp Total execution time [0-9]+ RET hi-blue-b RET
+;;
+;;    In buffers displaying tables, highlight the lines you're interested in:
+;;    M-x highlight-lines-matching-regexp January 2000 RET hi-black-b RET
+;;
+;;    When writing text, highlight personal cliches.  This can be
+;;    amusing.
+;;    M-x highlight-regexp as can be seen RET RET
+;;
+;;  Setup
+;;
+;;    Put the following code in your .emacs file.  This turns on
+;;    hi-lock mode and adds an "Automatic Highlighting" entry
+;;    to the edit menu.
+;;
+;;    (hi-lock-mode 1)
+;;  
+;;    You might also want to bind the hi-lock commands to more
+;;    finger-friendly sequences:
+
+;;    (define-key hi-lock-map "\C-z\C-h" 'highlight-lines-matching-regexp)
+;;    (define-key hi-lock-map "\C-zi" 'hi-lock-find-patterns)
+;;    (define-key hi-lock-map "\C-zh" 'highlight-regexp)
+;;    (define-key hi-lock-map "\C-zr" 'unhighlight-regexp)
+;;    (define-key hi-lock-map "\C-zb" 'hi-lock-write-interactive-patterns))
+
+;;    See the documentation for hi-lock-mode `C-h f hi-lock-mode' for
+;;    additional instructions.
+
+;; Sample file patterns:
+
+; Hi-lock: (("^;;; .*" (0 (quote hi-black-hb) t)))
+; Hi-lock: ( ("make-variable-buffer-\\(local\\)" (0 font-lock-keyword-face)(1 'italic append)))))
+; Hi-lock: end
+
+;;; Code:
+
+(eval-when-compile
+  (require 'font-lock))
+
+;;;###autoload
+(defgroup hi-lock-interactive-text-highlighting nil
+  "Interactively add and remove font-lock patterns for highlighting text."
+  :group 'faces)
+
+;;;###autoload
+(defcustom hi-lock-mode nil
+  "Toggle hi-lock, for interactively adding font-lock text-highlighting patterns."
+  :set (lambda (symbol value)
+         (hi-lock-mode (or value 0)))
+  :initialize 'custom-initialize-default
+  :type 'boolean
+  :group 'hi-lock-interactive-text-highlighting
+  :require 'hi-lock)
+
+(defcustom hi-lock-file-patterns-range 10000
+  "Limit of search in a buffer for hi-lock patterns.
+When a file is visited and hi-lock mode is on patterns starting
+up to this limit are added to font-lock's patterns.  See documentation
+of functions `hi-lock-mode' and `hi-lock-find-patterns'."
+  :type 'integer
+  :group 'hi-lock-interactive-text-highlighting)
+
+(defcustom hi-lock-exclude-modes
+  '(rmail-mode mime/viewer-mode gnus-article-mode)
+  "List of major modes in which hi-lock will not run.
+For security reasons since font lock patterns can specify function
+calls."
+  :type 'variable
+  :group 'hi-lock-interactive-text-highlighting)
+
+
+(defgroup hi-lock-faces nil
+  "Faces for hi-lock."
+  :group 'hi-lock-interactive-text-highlighting)
+
+(defface hi-yellow
+  '((t (:background "yellow")))
+  "Default face for hi-lock mode."
+  :group 'hi-lock-faces)
+
+(defface hi-pink
+  '((t (:background "pink")))
+  "Face for hi-lock mode."
+  :group 'hi-lock-faces)
+
+(defface hi-green
+  '((t (:background "green")))
+  "Face for hi-lock mode."
+  :group 'hi-lock-faces)
+
+(defface hi-blue
+  '((t (:background "light blue")))
+  "Face for hi-lock mode."
+  :group 'hi-lock-faces)
+
+(defface hi-black-b
+  '((t (:weight bold)))
+  "Face for hi-lock mode."
+  :group 'hi-lock-faces)
+
+(defface hi-blue-b
+  '((t (:weight bold :foreground "blue")))
+  "Face for hi-lock mode."
+  :group 'hi-lock-faces)
+
+(defface hi-green-b
+  '((t (:weight bold :foreground "green")))
+  "Face for hi-lock mode."
+  :group 'hi-lock-faces)
+
+(defface hi-red-b
+  '((t (:weight bold :foreground "red")))
+  "Face for hi-lock mode."
+  :group 'hi-lock-faces)
+
+(defface hi-black-hb
+  '((t (:weight bold :family "helv" :height 200)))
+  "Face for hi-lock mode."
+  :group 'hi-lock-faces)
+
+(defvar hi-lock-file-patterns nil
+  "Patterns found in file for hi-lock.  Should not be changed.")
+
+(defvar hi-lock-interactive-patterns nil
+  "Patterns provided to hi-lock by user.  Should not be changed.")
+
+(defvar hi-lock-face-history
+  (list "hi-yellow" "hi-pink" "hi-green" "hi-blue" "hi-black-b"
+        "hi-blue-b" "hi-red-b" "hi-green-b" "hi-black-hb")
+      "History list of faces for hi-lock interactive functions.")
+
+;(dolist (f hi-lock-face-history) (unless (facep f) (error "%s not a face" f)))
+
+(defvar hi-lock-regexp-history nil
+  "History of regexps used for interactive fontification.")
+
+(defvar hi-lock-file-patterns-prefix "Hi-lock"
+  "Regexp for finding hi-lock patterns at top of file.")
+
+(make-variable-buffer-local 'hi-lock-interactive-patterns)
+(put 'hi-lock-interactive-patterns 'permanent-local t)
+(make-variable-buffer-local 'hi-lock-regexp-history)
+(put 'hi-lock-regexp-history 'permanent-local t)
+(make-variable-buffer-local 'hi-lock-file-patterns)
+(put 'hi-lock-file-patterns 'permanent-local t)
+
+(defvar hi-lock-menu (make-sparse-keymap "Hi Lock")
+  "Menu for hi-lock mode.")
+
+(define-key-after hi-lock-menu [highlight-regexp]
+  '(menu-item "Highlight Regexp..." highlight-regexp
+              :help "Highlight text matching PATTERN (a regexp)."))
+
+(define-key-after hi-lock-menu [highlight-lines-matching-regexp]
+  '(menu-item "Highlight Lines..." highlight-lines-matching-regexp
+              :help "Highlight lines containing match of PATTERN (a regexp).."))
+
+(define-key-after hi-lock-menu [unhighlight-regexp]
+  '(menu-item "Remove Highlighting..." unhighlight-regexp
+              :help "Remove previously entered highlighting pattern."
+              :enable hi-lock-interactive-patterns))
+
+(define-key-after hi-lock-menu [hi-lock-write-interactive-patterns]
+  '(menu-item "Patterns to Buffer" hi-lock-write-interactive-patterns
+              :help "Insert interactively added REGEXPs into buffer at point."
+              :enable hi-lock-interactive-patterns))
+
+(define-key-after hi-lock-menu [hi-lock-find-patterns]
+  '(menu-item "Patterns from Buffer" hi-lock-find-patterns
+              :help "Use patterns (if any) near top of buffer."))
+
+(defvar hi-lock-map (make-sparse-keymap "Hi Lock")
+  "Key map for hi-lock.")
+
+(define-key hi-lock-map "\C-xwi" 'hi-lock-find-patterns)
+(define-key hi-lock-map "\C-xwl" 'highlight-lines-matching-regexp)
+(define-key hi-lock-map "\C-xwh" 'highlight-regexp)
+(define-key hi-lock-map "\C-xwr" 'unhighlight-regexp)
+(define-key hi-lock-map "\C-xwb" 'hi-lock-write-interactive-patterns)
+
+(unless (assq 'hi-lock-mode minor-mode-map-alist)
+  (setq minor-mode-map-alist (cons (cons 'hi-lock-mode hi-lock-map)
+                                   minor-mode-map-alist)))
+
+(unless (assq 'hi-lock-mode minor-mode-alist)
+  (setq minor-mode-alist (cons '(hi-lock-mode " H") minor-mode-alist)))
+
+
+;; Visible Functions
+
+
+;;;###autoload
+(defun hi-lock-mode (&optional arg)
+  "Toggle minor mode for interactively adding font-lock highlighting patterns.
+
+If ARG positive turn hi-lock on.  Issuing a hi-lock command will also
+turn hi-lock on.  When hi-lock turned on an \"Automatic Highlighting\"
+submenu is added to the \"Edit\" menu.  The commands in the submenu,
+which can be called interactively, are:
+
+\\[highlight-regexp] REGEXP FACE
+  Highlight matches of pattern REGEXP in current buffer with FACE.
+
+\\[highlight-lines-matching-regexp] REGEXP FACE
+  Highlight lines containing matches of REGEXP in current buffer with FACE.
+
+\\[unhighlight-regexp] REGEXP
+  Remove highlighting on matches of REGEXP in current buffer.
+
+\\[hi-lock-write-interactive-patterns]
+  Write active REGEXPs into buffer as comments (if possible). They will
+  be read the next time file is loaded or when the \\[hi-lock-find-patterns] command
+  is issued.  The inserted regexps are in the form of font lock keywords.
+  (See `font-lock-keywords') They may be edited and re-loaded with \\[hi-lock-find-patterns],
+  any valid `font-lock-keywords' form is acceptable.
+
+\\[hi-lock-find-patterns]
+  Re-read patterns stored in buffer (in the format produced by \\[hi-lock-write-interactive-patterns]).
+
+When hi-lock is started and if the mode is not excluded, the
+beginning of the buffer is searched for lines of the form:
+  Hi-lock: FOO
+where FOO is a list of patterns. These are added to the font lock keywords
+already present.  The patterns must start before position (number
+of characters into buffer) `hi-lock-file-patterns-range'.  Patterns
+will be read until
+ Hi-lock: end
+is found. A mode is excluded if it's in the list `hi-lock-exclude-modes'."
+  (interactive)
+  (let ((hi-lock-mode-prev hi-lock-mode))
+    (setq hi-lock-mode
+           (if (null arg) (not hi-lock-mode)
+             (> (prefix-numeric-value arg) 0)))
+    ;; Turned on.
+    (when (and (not hi-lock-mode-prev) hi-lock-mode)
+      (if (not font-lock-mode) (turn-on-font-lock))
+      (add-hook 'find-file-hooks 'hi-lock-find-file-hook)
+      (add-hook 'font-lock-mode-hook 'hi-lock-font-lock-hook)
+      (define-key-after menu-bar-edit-menu [hi-lock]
+        (cons "Automatic Highlighting" hi-lock-menu))
+      (hi-lock-find-patterns))
+    ;; Turned off.
+    (when (and hi-lock-mode-prev (not hi-lock-mode))
+      (font-lock-remove-keywords nil hi-lock-interactive-patterns)
+      (font-lock-remove-keywords nil hi-lock-file-patterns)
+      (setq hi-lock-interactive-patterns nil)
+      (hi-lock-refontify)
+      (define-key-after menu-bar-edit-menu [hi-lock] nil)
+      (remove-hook 'find-file-hooks 'hi-lock-find-file-hook)
+      (remove-hook 'font-lock-mode-hook 'hi-lock-font-lock-hook))))
+
+
+;;;###autoload
+(defalias 'highlight-lines-matching-regexp 'hi-lock-line-face-buffer)
+;;;###autoload
+(defun hi-lock-line-face-buffer (regexp &optional face)
+  "Set face of all lines containing matches of REGEXP to FACE.
+
+Interactively, prompt for REGEXP then FACE.  Buffer-local history
+list maintained for regexps, global history maintained for faces.
+\\<minibuffer-local-map>Use \\[next-history-element] and \\[previous-history-element] to retrieve next or previous history item.
+(See info node `Minibuffer History')"
+  (interactive
+   (list
+    (hi-lock-regexp-okay
+     (read-from-minibuffer "Regexp to highlight line: "
+                           (cons (or (car hi-lock-regexp-history) "") 1 )
+                           nil nil 'hi-lock-regexp-history))
+    (hi-lock-read-face-name)))
+  (unless hi-lock-mode (hi-lock-mode))
+  (or (facep face) (setq face 'rwl-yellow))
+  (hi-lock-set-pattern
+   (list (concat "^.*" regexp ".*$") (list 0 (list 'quote face) t))))
+
+;;;###autoload
+(defalias 'highlight-regexp 'hi-lock-face-buffer)
+;;;###autoload
+(defun hi-lock-face-buffer (regexp &optional face)
+  "Set face of all matches of REGEXP to FACE.
+
+Interactively, prompt for REGEXP then FACE.  Buffer-local history
+list maintained for regexps, global history maintained for faces.
+\\<minibuffer-local-map>Use \\[next-history-element] and \\[previous-history-element] to retrieve next or previous history item.
+(See info node `Minibuffer History')"
+  (interactive
+   (list
+    (hi-lock-regexp-okay
+     (read-from-minibuffer "Regexp to highlight: "
+                           (cons (or (car hi-lock-regexp-history) "") 1 )
+                           nil nil 'hi-lock-regexp-history))
+    (hi-lock-read-face-name)))
+  (or (facep face) (setq face 'rwl-yellow))
+  (unless hi-lock-mode (hi-lock-mode))
+  (hi-lock-set-pattern (list regexp (list 0 (list 'quote face) t))))
+
+;;;###autoload
+(defalias 'unhighlight-regexp 'hi-lock-unface-buffer)
+;;;###autoload
+(defun hi-lock-unface-buffer (regexp)
+  "Remove highlighting of matches to REGEXP set by hi-lock.
+
+Interactively, prompt for REGEXP.  Buffer-local history of inserted
+regexp's maintained.  Will accept only regexps inserted by hi-lock
+interactive functions. (See `hi-lock-interactive-patterns')
+\\<minibuffer-local-must-match-map>Use \\[minibuffer-complete] to complete a partially typed regexp.
+(See info node `Minibuffer History'.)"
+  (interactive
+   (if (vectorp (this-command-keys))
+       (x-popup-menu
+        t
+        (cons
+         `keymap
+         (cons "Select Pattern to Unhighlight"
+               (mapcar (lambda (pattern)
+                         (list (car pattern)
+                               (format
+                                "%s (%s)" (car pattern)
+                                (symbol-name
+                                 (car (cdr (car (cdr (car (cdr pattern))))))))
+                               (cons nil nil)
+                               (car pattern)))
+                       hi-lock-interactive-patterns))))
+     (let ((history-list (mapcar (lambda (p) (car p))
+                                 hi-lock-interactive-patterns)))
+       (unless hi-lock-interactive-patterns
+         (error "No highlighting to remove"))
+       (list
+        (completing-read "Regexp to unhighlight: "
+                         hi-lock-interactive-patterns t t
+                         (car (car hi-lock-interactive-patterns))
+                         (cons 'history-list 1))))))
+  (let ((keyword (assoc regexp hi-lock-interactive-patterns)))
+    (when keyword
+      (font-lock-remove-keywords nil (list keyword))
+      (setq hi-lock-interactive-patterns
+            (delq keyword hi-lock-interactive-patterns))
+      (hi-lock-refontify))))
+
+;;;###autoload
+(defun hi-lock-write-interactive-patterns ()
+  "Write interactively added patterns, if any, into buffer at point.
+
+Interactively added patterns are those normally specified using
+`highlight-regexp' and `highlight-lines-matching-regexp'; they can
+be found in variable `hi-lock-interactive-patterns'."
+  (interactive)
+  (let ((prefix (format "%s %s:" (or comment-start "") "Hi-lock")))
+    (when (> (+ (point) (length prefix)) hi-lock-file-patterns-range)
+      (beep)
+      (message
+       "Warning, inserted keywords not close enough to top of file."))
+    (mapcar
+     (lambda (pattern)
+       (insert (format "%s (%s) %s\n"
+                       prefix (prin1-to-string pattern) (or comment-end ""))))
+     hi-lock-interactive-patterns)))
+
+
+;; Implementation Functions
+
+(defun hi-lock-regexp-okay (regexp)
+  "Return REGEXP if it appears suitable for a font-lock pattern.
+
+Otherwise signal an error.  A pattern that matches the null string is
+not suitable."
+  (if (string-match regexp "")
+      (error "Regexp cannot match an empty string")
+    regexp))
+
+(defun hi-lock-read-face-name ()
+  "Read face name from minibuffer with completion and history."
+  (intern (completing-read
+           "Highlight using face: "
+           obarray 'facep t
+           (cons (car hi-lock-face-history)
+                 (let ((prefix
+                        (try-completion
+                         (substring (car hi-lock-face-history) 0 1)
+                         (mapcar (lambda (f) (cons f f))
+                                 hi-lock-face-history))))
+                   (if (and (stringp prefix)
+                            (not (equal prefix (car hi-lock-face-history))))
+                       (length prefix) 0)))
+           '(hi-lock-face-history . 0))))
+
+(defun hi-lock-find-file-hook ()
+  "Add hi-lock patterns, if present."
+  (hi-lock-find-patterns))
+
+(defun hi-lock-current-line (&optional end)
+  "Return line number of line at point.
+Optional argument END is maximum excursion."
+  (interactive)
+  (save-excursion
+    (beginning-of-line)
+    (1+ (count-lines 1 (or end (point))))))
+
+(defun hi-lock-set-pattern (pattern)
+  "Add PATTERN to list of interactively highlighted patterns and refontify."
+  (hi-lock-set-patterns (list pattern)))
+
+(defun hi-lock-set-patterns (patterns)
+  "Add PATTERNS to list of interactively highlighted patterns and refontify.."
+  (dolist (pattern patterns)
+    (unless (member pattern hi-lock-interactive-patterns)
+      (font-lock-add-keywords nil (list pattern))
+      (add-to-list 'hi-lock-interactive-patterns pattern)))
+  (hi-lock-refontify))
+
+(defun hi-lock-set-file-patterns (patterns)
+  "Replace file patterns list with PATTERNS and refontify."
+  (font-lock-remove-keywords nil hi-lock-file-patterns)
+  (setq hi-lock-file-patterns patterns)
+  (font-lock-add-keywords nil hi-lock-file-patterns)
+  (hi-lock-refontify))
+
+(defun hi-lock-refontify ()
+  "Unfontify then refontify buffer.  Used when hi-lock patterns change."
+  (interactive)
+  (font-lock-unfontify-buffer)
+  (cond
+   (jit-lock-mode (jit-lock-fontify-buffer))
+   ;; Need a better way, since this assumes too much about lazy lock.
+   (lazy-lock-mode
+    (let ((windows (get-buffer-window-list (current-buffer) 'nomini t)))
+	(while windows
+	  (lazy-lock-fontify-window (car windows))
+	  (setq windows (cdr windows)))))
+   (t (font-lock-fontify-buffer))))
+
+
+(defun hi-lock-find-patterns ()
+  "Find patterns in current buffer for hi-lock."
+  (interactive)
+  (unless (memq major-mode hi-lock-exclude-modes)
+    (let ((all-patterns nil)
+          (target-regexp (concat "\\<" hi-lock-file-patterns-prefix ":")))
+      (save-excursion
+        (widen)
+        (goto-char (point-min))
+        (re-search-forward target-regexp
+                           (+ (point) hi-lock-file-patterns-range) t)
+        (beginning-of-line)
+        (while
+            (and
+             (re-search-forward target-regexp (+ (point) 100) t)
+             (not (looking-at "\\s-*end")))
+          (let
+              ((patterns
+                (condition-case nil
+                    (read (current-buffer))
+                  (error  (message
+                           (format "Could not read expression at %d"
+                                   (hi-lock-current-line))) nil))))
+            (if patterns
+                (setq all-patterns (append patterns all-patterns))))))
+      (if (and (not hi-lock-mode) all-patterns)
+          (hi-lock-mode 1))
+      (if hi-lock-mode (hi-lock-set-file-patterns all-patterns))
+      (if (interactive-p)
+        (message (format "Hi-lock added %d patterns." (length all-patterns)))))))
+
+(defun hi-lock-font-lock-hook ()
+  "Add hi lock patterns to font-lock's."
+  (when hi-lock-mode
+    (font-lock-add-keywords nil hi-lock-file-patterns)
+    (font-lock-add-keywords nil hi-lock-interactive-patterns)))
+
+(provide 'hi-lock)
+
+;;; hi-lock.el ends here
+
+
diff -r a363ab77020c -r 338238ca63ce lisp/loaddefs.el
--- a/lisp/loaddefs.el	Wed Aug 02 20:23:23 2000 +0000
+++ b/lisp/loaddefs.el	Wed Aug 02 21:29:36 2000 +0000
@@ -52,7 +52,7 @@
 ;;;***
 
 ;;;### (autoloads (ada-mode ada-add-extensions) "ada-mode" "progmodes/ada-mode.el"
-;;;;;;  (14630 46501))
+;;;;;;  (14716 9490))
 ;;; Generated autoloads from progmodes/ada-mode.el
 
 (autoload (quote ada-add-extensions) "ada-mode" "\
@@ -103,12 +103,12 @@
 If you use ada-xref.el:
  Goto declaration:          '\\[ada-point-and-xref]' on the identifier
                          or '\\[ada-goto-declaration]' with point on the identifier
- Complete identifier:       '\\[ada-complete-identifier]'" t nil)
+ Complete identifier:       '\\[ada-complete-identifier]'." t nil)
 
 ;;;***
 
 ;;;### (autoloads (ada-header) "ada-stmt" "progmodes/ada-stmt.el"
-;;;;;;  (14360 11651))
+;;;;;;  (14716 9444))
 ;;; Generated autoloads from progmodes/ada-stmt.el
 
 (autoload (quote ada-header) "ada-stmt" "\
@@ -216,8 +216,8 @@
 ;;;***
 
 ;;;### (autoloads (defadvice ad-add-advice ad-default-compilation-action
-;;;;;;  ad-redefinition-action) "advice" "emacs-lisp/advice.el" (14410
-;;;;;;  19111))
+;;;;;;  ad-redefinition-action) "advice" "emacs-lisp/advice.el" (14660
+;;;;;;  49405))
 ;;; Generated autoloads from emacs-lisp/advice.el
 
 (defvar ad-redefinition-action (quote warn) "\
@@ -306,9 +306,9 @@
 
 ;;;***
 
-;;;### (autoloads (align-unhighlight-rule align-highlight-rule align-current
-;;;;;;  align-entire align-regexp align) "align" "align.el" (14654
-;;;;;;  18018))
+;;;### (autoloads (align-newline-and-indent align-unhighlight-rule
+;;;;;;  align-highlight-rule align-current align-entire align-regexp
+;;;;;;  align) "align" "align.el" (14707 20012))
 ;;; Generated autoloads from align.el
 
 (autoload (quote align) "align" "\
@@ -378,10 +378,13 @@
 (autoload (quote align-unhighlight-rule) "align" "\
 Remove any highlighting that was added by `align-highlight-rule'." t nil)
 
+(autoload (quote align-newline-and-indent) "align" "\
+A replacement function for `newline-and-indent', aligning as it goes." t nil)
+
 ;;;***
 
 ;;;### (autoloads (ange-ftp-hook-function ange-ftp-reread-dir) "ange-ftp"
-;;;;;;  "net/ange-ftp.el" (14644 1631))
+;;;;;;  "net/ange-ftp.el" (14723 62215))
 ;;; Generated autoloads from net/ange-ftp.el
  (defalias 'ange-ftp-re-read-dir 'ange-ftp-reread-dir)
 
@@ -417,7 +420,7 @@
 ;;;### (autoloads (appt-make-list appt-delete appt-add appt-display-diary
 ;;;;;;  appt-display-duration appt-msg-window appt-display-mode-line
 ;;;;;;  appt-visible appt-audible appt-message-warning-time appt-issue-message)
-;;;;;;  "appt" "calendar/appt.el" (14628 26787))
+;;;;;;  "appt" "calendar/appt.el" (14726 36008))
 ;;; Generated autoloads from calendar/appt.el
 
 (defvar appt-issue-message t "\
@@ -469,8 +472,8 @@
 ;;;***
 
 ;;;### (autoloads (apropos-documentation apropos-value apropos apropos-command
-;;;;;;  apropos-variable apropos-mode) "apropos" "apropos.el" (14654
-;;;;;;  26903))
+;;;;;;  apropos-variable apropos-mode) "apropos" "apropos.el" (14671
+;;;;;;  47519))
 ;;; Generated autoloads from apropos.el
 
 (autoload (quote apropos-mode) "apropos" "\
@@ -480,42 +483,42 @@
 
 (autoload (quote apropos-variable) "apropos" "\
 Show user variables that match REGEXP.
-With optional prefix ARG or if `apropos-do-all' is non-nil, also show
+With optional prefix DO-ALL or if `apropos-do-all' is non-nil, also show
 normal variables." t nil)
 
 (fset (quote command-apropos) (quote apropos-command))
 
 (autoload (quote apropos-command) "apropos" "\
-Show commands (interactively callable functions) that match REGEXP.
-With optional prefix ARG, or if `apropos-do-all' is non-nil, also show
+Show commands (interactively callable functions) that match APROPOS-REGEXP.
+With optional prefix DO-ALL, or if `apropos-do-all' is non-nil, also show
 noninteractive functions.
 
 If VAR-PREDICATE is non-nil, show only variables, and only those that
 satisfy the predicate VAR-PREDICATE." t nil)
 
 (autoload (quote apropos) "apropos" "\
-Show all bound symbols whose names match REGEXP.
-With optional prefix ARG or if `apropos-do-all' is non-nil, also show unbound
-symbols and key bindings, which is a little more time-consuming.
-Returns list of symbols and documentation found." t nil)
+Show all bound symbols whose names match APROPOS-REGEXP.
+With optional prefix DO-ALL or if `apropos-do-all' is non-nil, also
+show unbound symbols and key bindings, which is a little more
+time-consuming.  Returns list of symbols and documentation found." t nil)
 
 (autoload (quote apropos-value) "apropos" "\
-Show all symbols whose value's printed image matches REGEXP.
-With optional prefix ARG or if `apropos-do-all' is non-nil, also looks
+Show all symbols whose value's printed image matches APROPOS-REGEXP.
+With optional prefix DO-ALL or if `apropos-do-all' is non-nil, also looks
 at the function and at the names and values of properties.
 Returns list of symbols and values found." t nil)
 
 (autoload (quote apropos-documentation) "apropos" "\
-Show symbols whose documentation contain matches for REGEXP.
-With optional prefix ARG or if `apropos-do-all' is non-nil, also use
+Show symbols whose documentation contain matches for APROPOS-REGEXP.
+With optional prefix DO-ALL or if `apropos-do-all' is non-nil, also use
 documentation that is not stored in the documentation file and show key
 bindings.
 Returns list of symbols and documentation found." t nil)
 
 ;;;***
 
-;;;### (autoloads (archive-mode) "arc-mode" "arc-mode.el" (14539
-;;;;;;  44524))
+;;;### (autoloads (archive-mode) "arc-mode" "arc-mode.el" (14665
+;;;;;;  58573))
 ;;; Generated autoloads from arc-mode.el
 
 (autoload (quote archive-mode) "arc-mode" "\
@@ -710,7 +713,7 @@
 
 ;;;### (autoloads (batch-update-autoloads update-autoloads-from-directories
 ;;;;;;  update-file-autoloads) "autoload" "emacs-lisp/autoload.el"
-;;;;;;  (14651 36597))
+;;;;;;  (14659 23014))
 ;;; Generated autoloads from emacs-lisp/autoload.el
 
 (autoload (quote update-file-autoloads) "autoload" "\
@@ -771,7 +774,7 @@
 ;;;***
 
 ;;;### (autoloads (mouse-avoidance-mode mouse-avoidance-mode) "avoid"
-;;;;;;  "avoid.el" (14637 38156))
+;;;;;;  "avoid.el" (14659 22945))
 ;;; Generated autoloads from avoid.el
 
 (defvar mouse-avoidance-mode nil "\
@@ -850,7 +853,7 @@
 ;;;***
 
 ;;;### (autoloads (display-battery battery) "battery" "battery.el"
-;;;;;;  (14422 6418))
+;;;;;;  (14693 50816))
 ;;; Generated autoloads from battery.el
 
 (autoload (quote battery) "battery" "\
@@ -2151,7 +2154,7 @@
 
 ;;;***
 
-;;;### (autoloads nil "cc-langs" "progmodes/cc-langs.el" (14419 57707))
+;;;### (autoloads nil "cc-langs" "progmodes/cc-langs.el" (14716 6817))
 ;;; Generated autoloads from progmodes/cc-langs.el
 
 (defvar c-mode-syntax-table nil "\
@@ -2176,7 +2179,7 @@
 
 ;;;### (autoloads (pike-mode idl-mode java-mode objc-mode c++-mode
 ;;;;;;  c-mode c-initialize-cc-mode) "cc-mode" "progmodes/cc-mode.el"
-;;;;;;  (14419 57707))
+;;;;;;  (14716 6857))
 ;;; Generated autoloads from progmodes/cc-mode.el
 
 (autoload (quote c-initialize-cc-mode) "cc-mode" nil nil nil)
@@ -2287,7 +2290,7 @@
 ;;;***
 
 ;;;### (autoloads (c-set-offset c-add-style c-set-style) "cc-styles"
-;;;;;;  "progmodes/cc-styles.el" (14419 57707))
+;;;;;;  "progmodes/cc-styles.el" (14716 6903))
 ;;; Generated autoloads from progmodes/cc-styles.el
 
 (autoload (quote c-set-style) "cc-styles" "\
@@ -2328,7 +2331,7 @@
 
 ;;;***
 
-;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (14419 57707))
+;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (14716 6917))
 ;;; Generated autoloads from progmodes/cc-vars.el
 
 (defconst c-emacs-features (let ((infodock-p (boundp (quote infodock-version))) (comments (let ((table (copy-syntax-table)) entry) (modify-syntax-entry 97 ". 12345678" table) (cond ((arrayp table) (setq entry (aref table 97)) (if (consp entry) (setq entry (car entry)))) ((fboundp (quote get-char-table)) (setq entry (get-char-table 97 table))) ((and (fboundp (quote char-table-p)) (char-table-p table)) (setq entry (car (char-table-range table [97])))) (t (error "CC Mode is incompatible with this version of Emacs"))) (if (= (logand (lsh entry -16) 255) 255) (quote 8-bit) (quote 1-bit))))) (if infodock-p (list comments (quote infodock)) (list comments))) "\
@@ -2596,7 +2599,7 @@
 ;;;***
 
 ;;;### (autoloads (common-lisp-indent-function) "cl-indent" "emacs-lisp/cl-indent.el"
-;;;;;;  (14518 39681))
+;;;;;;  (14671 47557))
 ;;; Generated autoloads from emacs-lisp/cl-indent.el
 
 (autoload (quote common-lisp-indent-function) "cl-indent" nil nil nil)
@@ -2638,7 +2641,7 @@
 
 ;;;### (autoloads (codepage-setup cp-supported-codepages cp-offset-for-codepage
 ;;;;;;  cp-language-for-codepage cp-charset-for-codepage cp-make-coding-systems-for-codepage)
-;;;;;;  "codepage" "international/codepage.el" (14642 24031))
+;;;;;;  "codepage" "international/codepage.el" (14720 1500))
 ;;; Generated autoloads from international/codepage.el
 
 (autoload (quote cp-make-coding-systems-for-codepage) "codepage" "\
@@ -2684,7 +2687,7 @@
 
 ;;;### (autoloads (comint-redirect-results-list-from-process comint-redirect-results-list
 ;;;;;;  comint-redirect-send-command-to-process comint-redirect-send-command
-;;;;;;  comint-run make-comint) "comint" "comint.el" (14634 20434))
+;;;;;;  comint-run make-comint) "comint" "comint.el" (14703 12325))
 ;;; Generated autoloads from comint.el
 
 (autoload (quote make-comint) "comint" "\
@@ -2753,7 +2756,7 @@
 ;;;### (autoloads (next-error compilation-minor-mode compilation-shell-minor-mode
 ;;;;;;  compilation-mode grep-find grep compile compilation-search-path
 ;;;;;;  compilation-ask-about-save compilation-window-height compilation-mode-hook)
-;;;;;;  "compile" "progmodes/compile.el" (14635 2514))
+;;;;;;  "compile" "progmodes/compile.el" (14726 56342))
 ;;; Generated autoloads from progmodes/compile.el
 
 (defvar compilation-mode-hook nil "\
@@ -2884,7 +2887,7 @@
 ;;;***
 
 ;;;### (autoloads (partial-completion-mode partial-completion-mode)
-;;;;;;  "complete" "complete.el" (14634 20434))
+;;;;;;  "complete" "complete.el" (14664 59525))
 ;;; Generated autoloads from complete.el
 
 (defvar partial-completion-mode nil "\
@@ -2933,7 +2936,7 @@
 ;;;### (autoloads (decompose-composite-char compose-last-chars compose-chars-after
 ;;;;;;  find-composition compose-chars decompose-string compose-string
 ;;;;;;  decompose-region compose-region) "composite" "composite.el"
-;;;;;;  (14422 57499))
+;;;;;;  (14720 1500))
 ;;; Generated autoloads from composite.el
 
 (defconst reference-point-alist (quote ((tl . 0) (tc . 1) (tr . 2) (Bl . 3) (Bc . 4) (Br . 5) (bl . 6) (bc . 7) (br . 8) (cl . 9) (cc . 10) (cr . 11) (top-left . 0) (top-center . 1) (top-right . 2) (base-left . 3) (base-center . 4) (base-right . 5) (bottom-left . 6) (bottom-center . 7) (bottom-right . 8) (center-left . 9) (center-center . 10) (center-right . 11) (ml . 3) (mc . 10) (mr . 5) (mid-left . 3) (mid-center . 10) (mid-right . 5))) "\
@@ -3072,7 +3075,8 @@
 MOD-FUNC is a modification function of the composition.
 
 WIDTH is a number of columns the composition occupies on the screen." nil nil)
-(put 'composition-function-table 'char-table-extra-slots 0)
+
+(put (quote composition-function-table) (quote char-table-extra-slots) 0)
 
 (defvar composition-function-table (make-char-table (quote composition-function-table)) "\
 Char table of patterns and functions to make a composition.
@@ -3128,7 +3132,7 @@
 ;;;***
 
 ;;;### (autoloads (shuffle-vector cookie-snarf cookie-insert cookie)
-;;;;;;  "cookie1" "play/cookie1.el" (13538 26685))
+;;;;;;  "cookie1" "play/cookie1.el" (14720 33845))
 ;;; Generated autoloads from play/cookie1.el
 
 (autoload (quote cookie) "cookie1" "\
@@ -3337,7 +3341,7 @@
 ;;;***
 
 ;;;### (autoloads (cpp-parse-edit cpp-highlight-buffer) "cpp" "progmodes/cpp.el"
-;;;;;;  (14568 36509))
+;;;;;;  (14726 36009))
 ;;; Generated autoloads from progmodes/cpp.el
 
 (autoload (quote cpp-highlight-buffer) "cpp" "\
@@ -3417,7 +3421,7 @@
 ;;;;;;  customize-option-other-window customize-changed-options customize-option
 ;;;;;;  customize-group-other-window customize-group customize customize-save-variable
 ;;;;;;  customize-set-variable customize-set-value) "cus-edit" "cus-edit.el"
-;;;;;;  (14626 23730))
+;;;;;;  (14709 28106))
 ;;; Generated autoloads from cus-edit.el
  (add-hook 'same-window-regexps "\\`\\*Customiz.*\\*\\'")
 
@@ -3656,7 +3660,7 @@
 ;;;***
 
 ;;;### (autoloads (dabbrev-expand dabbrev-completion) "dabbrev" "dabbrev.el"
-;;;;;;  (14642 37753))
+;;;;;;  (14688 20006))
 ;;; Generated autoloads from dabbrev.el
 
 (define-key esc-map "/" (quote dabbrev-expand))
@@ -4137,7 +4141,7 @@
 ;;;;;;  dired dired-copy-preserve-time dired-dwim-target dired-keep-marker-symlink
 ;;;;;;  dired-keep-marker-hardlink dired-keep-marker-copy dired-keep-marker-rename
 ;;;;;;  dired-trivial-filenames dired-ls-F-marks-symlinks dired-listing-switches)
-;;;;;;  "dired" "dired.el" (14628 26786))
+;;;;;;  "dired" "dired.el" (14724 3525))
 ;;; Generated autoloads from dired.el
 
 (defvar dired-listing-switches "-al" "\
@@ -4229,9 +4233,9 @@
 
 ;;;***
 
-;;;### (autoloads (dired-do-query-replace-regexp dired-do-search
-;;;;;;  dired-hide-all dired-hide-subdir dired-tree-down dired-tree-up
-;;;;;;  dired-kill-subdir dired-mark-subdir-files dired-goto-subdir
+;;;### (autoloads (dired-show-file-type dired-do-query-replace-regexp
+;;;;;;  dired-do-search dired-hide-all dired-hide-subdir dired-tree-down
+;;;;;;  dired-tree-up dired-kill-subdir dired-mark-subdir-files dired-goto-subdir
 ;;;;;;  dired-prev-subdir dired-insert-subdir dired-maybe-insert-subdir
 ;;;;;;  dired-downcase dired-upcase dired-do-symlink-regexp dired-do-hardlink-regexp
 ;;;;;;  dired-do-copy-regexp dired-do-rename-regexp dired-do-rename
@@ -4241,7 +4245,7 @@
 ;;;;;;  dired-do-compress dired-compress-file dired-do-kill-lines
 ;;;;;;  dired-do-shell-command dired-do-print dired-do-chown dired-do-chgrp
 ;;;;;;  dired-do-chmod dired-backup-diff dired-diff) "dired-aux"
-;;;;;;  "dired-aux.el" (14625 18672))
+;;;;;;  "dired-aux.el" (14697 36466))
 ;;; Generated autoloads from dired-aux.el
 
 (autoload (quote dired-diff) "dired-aux" "\
@@ -4453,6 +4457,11 @@
 If you exit (\\[keyboard-quit] or ESC), you can resume the query replace
 with the command \\[tags-loop-continue]." t nil)
 
+(autoload (quote dired-show-file-type) "dired-aux" "\
+Print the type of FILE, according to the `file' command.
+If FILE is a symbolic link and the optional argument DEREF-SYMLINKS is
+true then the type of the file linked to by FILE is printed instead." t nil)
+
 ;;;***
 
 ;;;### (autoloads (dired-jump) "dired-x" "dired-x.el" (14523 40402))
@@ -4502,7 +4511,7 @@
 ;;;;;;  standard-display-graphic standard-display-g1 standard-display-ascii
 ;;;;;;  standard-display-default standard-display-8bit describe-current-display-table
 ;;;;;;  describe-display-table set-display-table-slot display-table-slot
-;;;;;;  make-display-table) "disp-table" "disp-table.el" (14638 40743))
+;;;;;;  make-display-table) "disp-table" "disp-table.el" (14656 42937))
 ;;; Generated autoloads from disp-table.el
 
 (autoload (quote make-display-table) "disp-table" "\
@@ -4548,7 +4557,8 @@
 (autoload (quote standard-display-underline) "disp-table" "\
 Display character C as character UC plus underlining." nil nil)
 
-(autoload (quote create-glyph) "disp-table" nil nil nil)
+(autoload (quote create-glyph) "disp-table" "\
+Allocate a glyph code to display by sending STRING to the terminal." nil nil)
 
 (autoload (quote standard-display-european) "disp-table" "\
 Semi-obsolete way to toggle display of ISO 8859 European characters.
@@ -4639,7 +4649,7 @@
 
 ;;;### (autoloads (define-derived-mode easy-mmode-defsyntax easy-mmode-defmap
 ;;;;;;  easy-mmode-define-global-mode define-minor-mode) "easy-mmode"
-;;;;;;  "emacs-lisp/easy-mmode.el" (14651 36597))
+;;;;;;  "emacs-lisp/easy-mmode.el" (14659 23014))
 ;;; Generated autoloads from emacs-lisp/easy-mmode.el
 
 (defalias (quote easy-mmode-define-minor-mode) (quote define-minor-mode))
@@ -4708,8 +4718,8 @@
 ;;;***
 
 ;;;### (autoloads (easy-menu-change easy-menu-create-menu easy-menu-do-define
-;;;;;;  easy-menu-define) "easymenu" "emacs-lisp/easymenu.el" (14634
-;;;;;;  20460))
+;;;;;;  easy-menu-define) "easymenu" "emacs-lisp/easymenu.el" (14702
+;;;;;;  57276))
 ;;; Generated autoloads from emacs-lisp/easymenu.el
 
 (autoload (quote easy-menu-define) "easymenu" "\
@@ -4762,9 +4772,9 @@
 
    :key-sequence KEYS
 
-KEYS is nil a string or a vector; nil or a keyboard equivalent to this
+KEYS is nil, a string or a vector; nil or a keyboard equivalent to this
 menu item.
-This is a hint that will considerably speed up Emacs first display of
+This is a hint that will considerably speed up Emacs' first display of
 a menu.  Use `:key-sequence nil' when you know that this menu item has no
 keyboard equivalent.
 
@@ -4778,9 +4788,10 @@
 INCLUDE is an expression; this item is only visible if this
 expression has a non-nil value.
 
-   :suffix NAME
-
-NAME is a string; the name of an argument to CALLBACK.
+   :suffix FORM
+
+FORM is an expression that will be dynamically evaluated and whose
+value will be concatenated to the menu entry's NAME.
 
    :style STYLE
 
@@ -4791,7 +4802,7 @@
         Prepend the name with `(*) ' or `( ) ' depending on if selected or not.
 radio: A radio button.
        Prepend the name with `[X] ' or `[ ] ' depending on if selected or not.
-button: Surround the name with `[' and `]'. Use this for an item in the
+button: Surround the name with `[' and `]'.  Use this for an item in the
         menu bar itself.
 anything else means an ordinary menu item.
 
@@ -4837,7 +4848,7 @@
 ;;;;;;  ebnf-apply-style ebnf-merge-style ebnf-insert-style ebnf-setup
 ;;;;;;  ebnf-syntax-region ebnf-syntax-buffer ebnf-eps-region ebnf-eps-buffer
 ;;;;;;  ebnf-spool-region ebnf-spool-buffer ebnf-print-region ebnf-print-buffer
-;;;;;;  ebnf-customize) "ebnf2ps" "progmodes/ebnf2ps.el" (14485 59667))
+;;;;;;  ebnf-customize) "ebnf2ps" "progmodes/ebnf2ps.el" (14726 49311))
 ;;; Generated autoloads from progmodes/ebnf2ps.el
 
 (autoload (quote ebnf-customize) "ebnf2ps" "\
@@ -4949,8 +4960,8 @@
 
 ;;;### (autoloads (ebrowse-save-tree-as ebrowse-tags-query-replace
 ;;;;;;  ebrowse-tags-loop-continue ebrowse-tags-complete-symbol ebrowse-electric-choose-tree
-;;;;;;  ebrowse-tree-mode) "ebrowse" "progmodes/ebrowse.el" (14613
-;;;;;;  26536))
+;;;;;;  ebrowse-tree-mode) "ebrowse" "progmodes/ebrowse.el" (14727
+;;;;;;  65050))
 ;;; Generated autoloads from progmodes/ebrowse.el
 
 (autoload (quote ebrowse-tree-mode) "ebrowse" "\
@@ -4966,7 +4977,11 @@
 (autoload (quote ebrowse-electric-choose-tree) "ebrowse" "\
 Return a buffer containing a tree or nil if no tree found or canceled." t nil)
 
-(autoload (quote ebrowse-tags-complete-symbol) "ebrowse" "Perform completion on the C++ symbol preceding point.\nA second call of this function without changing point inserts the next match. \nA call with prefix PREFIX reads the symbol to insert from the minibuffer with\ncompletion." t nil)
+(autoload (quote ebrowse-tags-complete-symbol) "ebrowse" "\
+Perform completion on the C++ symbol preceding point.
+A second call of this function without changing point inserts the next match. 
+A call with prefix PREFIX reads the symbol to insert from the minibuffer with
+completion." t nil)
 
 (autoload (quote ebrowse-tags-loop-continue) "ebrowse" "\
 Repeat last operation on files in tree.
@@ -5018,7 +5033,7 @@
 ;;;***
 
 ;;;### (autoloads (edebug-eval-top-level-form def-edebug-spec edebug-all-forms
-;;;;;;  edebug-all-defs) "edebug" "emacs-lisp/edebug.el" (14637 38269))
+;;;;;;  edebug-all-defs) "edebug" "emacs-lisp/edebug.el" (14691 20410))
 ;;; Generated autoloads from emacs-lisp/edebug.el
 
 (defvar edebug-all-defs nil "\
@@ -5357,8 +5372,8 @@
 
 ;;;***
 
-;;;### (autoloads (turn-on-eldoc-mode eldoc-mode eldoc-mode) "eldoc"
-;;;;;;  "emacs-lisp/eldoc.el" (13881 39947))
+;;;### (autoloads (turn-on-eldoc-mode eldoc-mode eldoc-minor-mode-string
+;;;;;;  eldoc-mode) "eldoc" "emacs-lisp/eldoc.el" (14716 1570))
 ;;; Generated autoloads from emacs-lisp/eldoc.el
 
 (defvar eldoc-mode nil "\
@@ -5375,6 +5390,11 @@
 
 This variable is buffer-local.")
 
+(defvar eldoc-minor-mode-string " ElDoc" "\
+*String to display in mode line when Eldoc Mode is enabled.")
+
+(cond ((fboundp (quote add-minor-mode)) (add-minor-mode (quote eldoc-mode) (quote eldoc-minor-mode-string))) ((assq (quote eldoc-mode) (default-value (quote minor-mode-alist)))) (t (setq-default minor-mode-alist (append (default-value (quote minor-mode-alist)) (quote ((eldoc-mode eldoc-minor-mode-string)))))))
+
 (autoload (quote eldoc-mode) "eldoc" "\
 *Enable or disable eldoc mode.
 See documentation for the variable of the same name for more details.
@@ -5457,7 +5477,7 @@
 ;;;;;;  emerge-revisions emerge-files-with-ancestor-remote emerge-files-remote
 ;;;;;;  emerge-files-with-ancestor-command emerge-files-command emerge-buffers-with-ancestor
 ;;;;;;  emerge-buffers emerge-files-with-ancestor emerge-files) "emerge"
-;;;;;;  "emerge.el" (14345 52903))
+;;;;;;  "emerge.el" (14675 2831))
 ;;; Generated autoloads from emerge.el
 
 (defvar menu-bar-emerge-menu (make-sparse-keymap "Emerge"))
@@ -5527,7 +5547,7 @@
 ;;;***
 
 ;;;### (autoloads (enriched-decode enriched-encode enriched-mode)
-;;;;;;  "enriched" "enriched.el" (14539 53665))
+;;;;;;  "enriched" "enriched.el" (14717 41925))
 ;;; Generated autoloads from enriched.el
 
 (autoload (quote enriched-mode) "enriched" "\
@@ -5549,13 +5569,63 @@
 
 ;;;***
 
+;;;### (autoloads (eshell-mode) "esh-mode" "eshell/esh-mode.el" (14679
+;;;;;;  21649))
+;;; Generated autoloads from eshell/esh-mode.el
+
+(autoload (quote eshell-mode) "esh-mode" "\
+Emacs shell interactive mode.
+
+\\{eshell-mode-map}" nil nil)
+
+;;;***
+
+;;;### (autoloads (eshell-test) "esh-test" "eshell/esh-test.el" (14679
+;;;;;;  21629))
+;;; Generated autoloads from eshell/esh-test.el
+
+(autoload (quote eshell-test) "esh-test" "\
+Test Eshell to verify that it works as expected." t nil)
+
+;;;***
+
+;;;### (autoloads (eshell-report-bug eshell-command-result eshell-command
+;;;;;;  eshell) "eshell" "eshell/eshell.el" (14709 28151))
+;;; Generated autoloads from eshell/eshell.el
+
+(autoload (quote eshell) "eshell" "\
+Create an interactive Eshell buffer.
+The buffer used for Eshell sessions is determined by the value of
+`eshell-buffer-name'.  If there is already an Eshell session active in
+that buffer, Emacs will simply switch to it.  Otherwise, a new session
+will begin.  A new session is always created if the the prefix
+argument ARG is specified.  Returns the buffer selected (or created)." t nil)
+
+(autoload (quote eshell-command) "eshell" "\
+Execute the Eshell command string COMMAND.
+With prefix ARG, insert output into the current buffer at point." t nil)
+
+(autoload (quote eshell-command-result) "eshell" "\
+Execute the given Eshell COMMAND, and return the result.
+The result might be any Lisp object.
+If STATUS-VAR is a symbol, it will be set to the exit status of the
+command.  This is the only way to determine whether the value returned
+corresponding to a successful execution." nil nil)
+
+(autoload (quote eshell-report-bug) "eshell" "\
+Report a bug in Eshell.
+Prompts for the TOPIC.  Leaves you in a mail buffer.
+Please include any configuration details that might be involved." t nil)
+
+;;;***
+
 ;;;### (autoloads (complete-tag select-tags-table tags-apropos list-tags
 ;;;;;;  tags-query-replace tags-search tags-loop-continue next-file
 ;;;;;;  pop-tag-mark find-tag-regexp find-tag-other-frame find-tag-other-window
 ;;;;;;  find-tag find-tag-noselect tags-table-files visit-tags-table
 ;;;;;;  find-tag-default-function find-tag-hook tags-add-tables tags-table-list
-;;;;;;  tags-case-fold-search) "etags" "progmodes/etags.el" (14634
-;;;;;;  20489))
+;;;;;;  tags-case-fold-search) "etags" "progmodes/etags.el" (14669
+;;;;;;  64271))
 ;;; Generated autoloads from progmodes/etags.el
 
 (defvar tags-file-name nil "\
@@ -6027,10 +6097,15 @@
 
 ;;;***
 
-;;;### (autoloads (executable-self-display executable-set-magic)
-;;;;;;  "executable" "progmodes/executable.el" (13940 33734))
+;;;### (autoloads (executable-make-buffer-file-executable-if-script-p
+;;;;;;  executable-self-display executable-set-magic executable-find)
+;;;;;;  "executable" "progmodes/executable.el" (14659 23041))
 ;;; Generated autoloads from progmodes/executable.el
 
+(autoload (quote executable-find) "executable" "\
+Search for COMMAND in exec-path and return the absolute file name.
+Return nil if COMMAND is not found anywhere in `exec-path'." nil nil)
+
 (autoload (quote executable-set-magic) "executable" "\
 Set this buffer's interpreter to INTERPRETER with optional ARGUMENT.
 The variables `executable-magicless-file-regexp', `executable-prefix',
@@ -6042,6 +6117,11 @@
 Turn a text file into a self-displaying Un*x command.
 The magic number of such a command displays all lines but itself." t nil)
 
+(autoload (quote executable-make-buffer-file-executable-if-script-p) "executable" "\
+Make file executable according to umask if not already executable.
+If file already has any execute bits set at all, do not change existing
+file modes." nil nil)
+
 ;;;***
 
 ;;;### (autoloads (expand-jump-to-next-slot expand-jump-to-previous-slot
@@ -6150,7 +6230,7 @@
 ;;;;;;  facemenu-remove-special facemenu-remove-all facemenu-remove-face-props
 ;;;;;;  facemenu-set-read-only facemenu-set-intangible facemenu-set-invisible
 ;;;;;;  facemenu-set-face-from-menu facemenu-set-background facemenu-set-foreground
-;;;;;;  facemenu-set-face) "facemenu" "facemenu.el" (14634 20435))
+;;;;;;  facemenu-set-face) "facemenu" "facemenu.el" (14693 39146))
 ;;; Generated autoloads from facemenu.el
  (define-key global-map "\M-g" 'facemenu-keymap)
  (autoload 'facemenu-keymap "facemenu" "Keymap for face-changing commands." t 'keymap)
@@ -6166,7 +6246,7 @@
 (defalias (quote facemenu-foreground-menu) facemenu-foreground-menu)
 
 (defvar facemenu-background-menu (let ((map (make-sparse-keymap "Background Color"))) (define-key map "o" (cons "Other..." (quote facemenu-set-background))) map) "\
-Menu keymap for background colors")
+Menu keymap for background colors.")
 
 (defalias (quote facemenu-background-menu) facemenu-background-menu)
 
@@ -6211,7 +6291,7 @@
 typing a character to insert cancels the specification." t nil)
 
 (autoload (quote facemenu-set-foreground) "facemenu" "\
-Set the foreground color of the region or next character typed.
+Set the foreground COLOR of the region or next character typed.
 The color is prompted for.  A face named `fg:color' is used (or created).
 If the region is active, it will be set to the requested face.  If
 it is inactive (even if mark-even-if-inactive is set) the next
@@ -6220,7 +6300,7 @@
 typing a character cancels the request." t nil)
 
 (autoload (quote facemenu-set-background) "facemenu" "\
-Set the background color of the region or next character typed.
+Set the background COLOR of the region or next character typed.
 The color is prompted for.  A face named `bg:color' is used (or created).
 If the region is active, it will be set to the requested face.  If
 it is inactive (even if mark-even-if-inactive is set) the next
@@ -6229,7 +6309,7 @@
 typing a character cancels the request." t nil)
 
 (autoload (quote facemenu-set-face-from-menu) "facemenu" "\
-Set the face of the region or next character typed.
+Set the FACE of the region or next character typed.
 This function is designed to be called from a menu; the face to use
 is the menu item's name.
 
@@ -6416,7 +6496,7 @@
 ;;;***
 
 ;;;### (autoloads (find-grep-dired find-name-dired find-dired find-grep-options
-;;;;;;  find-ls-option) "find-dired" "find-dired.el" (14345 52903))
+;;;;;;  find-ls-option) "find-dired" "find-dired.el" (14717 43187))
 ;;; Generated autoloads from find-dired.el
 
 (defvar find-ls-option (if (eq system-type (quote berkeley-unix)) (quote ("-ls" . "-gilsb")) (quote ("-exec ls -ld {} \\;" . "-ld"))) "\
@@ -6651,10 +6731,20 @@
 
 ;;;***
 
-;;;### (autoloads (flyspell-mode-off flyspell-mode) "flyspell" "textmodes/flyspell.el"
-;;;;;;  (14512 26322))
+;;;### (autoloads (flyspell-mode-off flyspell-mode flyspell-prog-mode
+;;;;;;  flyspell-mode-line-string) "flyspell" "textmodes/flyspell.el"
+;;;;;;  (14718 57349))
 ;;; Generated autoloads from textmodes/flyspell.el
 
+(defvar flyspell-mode-line-string " Fly" "\
+*String displayed on the modeline when flyspell is active.
+Set this to nil if you don't want a modeline indicator.")
+
+(autoload (quote flyspell-prog-mode) "flyspell" "\
+Turn on `flyspell-mode' for comments and strings." t nil)
+
+(defvar flyspell-mode-map (make-sparse-keymap))
+
 (autoload (quote flyspell-mode) "flyspell" "\
 Minor mode performing on-the-fly spelling checking.
 Ispell is automatically spawned on background for each entered words.
@@ -6684,6 +6774,8 @@
 
 flyspell-buffer checks the whole buffer." t nil)
 
+(if (fboundp (quote add-minor-mode)) (add-minor-mode (quote flyspell-mode) (quote flyspell-mode-line-string) flyspell-mode-map nil (quote flyspell-mode)) (or (assoc (quote flyspell-mode) minor-mode-alist) (setq minor-mode-alist (cons (quote (flyspell-mode flyspell-mode-line-string)) minor-mode-alist))) (or (assoc (quote flyspell-mode) minor-mode-map-alist) (setq minor-mode-map-alist (cons (cons (quote flyspell-mode) flyspell-mode-map) minor-mode-map-alist))))
+
 (autoload (quote flyspell-mode-off) "flyspell" "\
 Turn Flyspell mode off." nil nil)
 
@@ -6760,7 +6852,7 @@
 ;;;### (autoloads (font-lock-fontify-buffer global-font-lock-mode
 ;;;;;;  global-font-lock-mode font-lock-remove-keywords font-lock-add-keywords
 ;;;;;;  turn-on-font-lock font-lock-mode) "font-lock" "font-lock.el"
-;;;;;;  (14620 23716))
+;;;;;;  (14677 53748))
 ;;; Generated autoloads from font-lock.el
 
 (defvar font-lock-mode-hook nil "\
@@ -6947,7 +7039,7 @@
 ;;;***
 
 ;;;### (autoloads (fortran-mode fortran-tab-mode-default) "fortran"
-;;;;;;  "progmodes/fortran.el" (14537 23071))
+;;;;;;  "progmodes/fortran.el" (14702 57276))
 ;;; Generated autoloads from progmodes/fortran.el
 
 (defvar fortran-tab-mode-default nil "\
@@ -6970,8 +7062,8 @@
 Variables controlling indentation style and extra features:
 
  `comment-start'
-    Normally nil in Fortran mode.  If you want to use comments
-    starting with `!', set this to the string \"!\".
+    If you want to use comments starting with `!',
+    set this to the string \"!\".
  `fortran-do-indent'
     Extra indentation within do blocks.  (default 3)
  `fortran-if-indent'
@@ -7074,7 +7166,7 @@
 ;;;***
 
 ;;;### (autoloads (glasses-mode) "glasses" "progmodes/glasses.el"
-;;;;;;  (14609 53573))
+;;;;;;  (14724 3308))
 ;;; Generated autoloads from progmodes/glasses.el
 
 (autoload (quote glasses-mode) "glasses" "\
@@ -7268,7 +7360,7 @@
 
 ;;;***
 
-;;;### (autoloads (gomoku) "gomoku" "play/gomoku.el" (13940 33566))
+;;;### (autoloads (gomoku) "gomoku" "play/gomoku.el" (14726 36008))
 ;;; Generated autoloads from play/gomoku.el
 
 (autoload (quote gomoku) "gomoku" "\
@@ -7288,7 +7380,7 @@
 ;;;***
 
 ;;;### (autoloads (goto-address goto-address-at-point goto-address-at-mouse)
-;;;;;;  "goto-addr" "net/goto-addr.el" (14637 38354))
+;;;;;;  "goto-addr" "net/goto-addr.el" (14711 25302))
 ;;; Generated autoloads from net/goto-addr.el
 
 (autoload (quote goto-address-at-mouse) "goto-addr" "\
@@ -7522,8 +7614,99 @@
 
 ;;;***
 
+;;;### (autoloads (hi-lock-write-interactive-patterns hi-lock-unface-buffer
+;;;;;;  hi-lock-face-buffer hi-lock-line-face-buffer hi-lock-mode
+;;;;;;  hi-lock-mode) "hi-lock" "hi-lock.el" (14728 34798))
+;;; Generated autoloads from hi-lock.el
+
+(defgroup hi-lock-interactive-text-highlighting nil "Interactively add and remove font-lock patterns for highlighting text." :group (quote faces))
+
+(defvar hi-lock-mode nil "\
+Toggle hi-lock, for interactively adding font-lock text-highlighting patterns.")
+
+(custom-add-to-group (quote hi-lock-interactive-text-highlighting) (quote hi-lock-mode) (quote custom-variable))
+
+(custom-add-load (quote hi-lock-mode) (quote hi-lock))
+
+(autoload (quote hi-lock-mode) "hi-lock" "\
+Toggle minor mode for interactively adding font-lock highlighting patterns.
+
+If ARG positive turn hi-lock on.  Issuing a hi-lock command will also
+turn hi-lock on.  When hi-lock turned on an \"Automatic Highlighting\"
+submenu is added to the \"Edit\" menu.  The commands in the submenu,
+which can be called interactively, are:
+
+\\[highlight-regexp] REGEXP FACE
+  Highlight matches of pattern REGEXP in current buffer with FACE.
+
+\\[highlight-lines-matching-regexp] REGEXP FACE
+  Highlight lines containing matches of REGEXP in current buffer with FACE.
+
+\\[unhighlight-regexp] REGEXP
+  Remove highlighting on matches of REGEXP in current buffer.
+
+\\[hi-lock-write-interactive-patterns]
+  Write active REGEXPs into buffer as comments (if possible). They will
+  be read the next time file is loaded or when the \\[hi-lock-find-patterns] command
+  is issued.  The inserted regexps are in the form of font lock keywords.
+  (See `font-lock-keywords') They may be edited and re-loaded with \\[hi-lock-find-patterns],
+  any valid `font-lock-keywords' form is acceptable.
+
+\\[hi-lock-find-patterns]
+  Re-read patterns stored in buffer (in the format produced by \\[hi-lock-write-interactive-patterns]).
+
+When hi-lock is started and if the mode is not excluded, the
+beginning of the buffer is searched for lines of the form:
+  Hi-lock: FOO
+where FOO is a list of patterns. These are added to the font lock keywords
+already present.  The patterns must start before position (number
+of characters into buffer) `hi-lock-file-patterns-range'.  Patterns
+will be read until
+ Hi-lock: end
+is found. A mode is excluded if it's in the list `hi-lock-exclude-modes'." t nil)
+
+(defalias (quote highlight-lines-matching-regexp) (quote hi-lock-line-face-buffer))
+
+(autoload (quote hi-lock-line-face-buffer) "hi-lock" "\
+Set face of all lines containing matches of REGEXP to FACE.
+
+Interactively, prompt for REGEXP then FACE.  Buffer-local history
+list maintained for regexps, global history maintained for faces.
+\\<minibuffer-local-map>Use \\[next-history-element] and \\[previous-history-element] to retrieve next or previous history item.
+\(See info node `Minibuffer History')" t nil)
+
+(defalias (quote highlight-regexp) (quote hi-lock-face-buffer))
+
+(autoload (quote hi-lock-face-buffer) "hi-lock" "\
+Set face of all matches of REGEXP to FACE.
+
+Interactively, prompt for REGEXP then FACE.  Buffer-local history
+list maintained for regexps, global history maintained for faces.
+\\<minibuffer-local-map>Use \\[next-history-element] and \\[previous-history-element] to retrieve next or previous history item.
+\(See info node `Minibuffer History')" t nil)
+
+(defalias (quote unhighlight-regexp) (quote hi-lock-unface-buffer))
+
+(autoload (quote hi-lock-unface-buffer) "hi-lock" "\
+Remove highlighting of matches to REGEXP set by hi-lock.
+
+Interactively, prompt for REGEXP.  Buffer-local history of inserted
+regexp's maintained.  Will accept only regexps inserted by hi-lock
+interactive functions. (See `hi-lock-interactive-patterns')
+\\<minibuffer-local-must-match-map>Use \\[minibuffer-complete] to complete a partially typed regexp.
+\(See info node `Minibuffer History'.)" t nil)
+
+(autoload (quote hi-lock-write-interactive-patterns) "hi-lock" "\
+Write interactively added patterns, if any, into buffer at point.
+
+Interactively added patterns are those normally specified using
+`highlight-regexp' and `highlight-lines-matching-regexp'; they can
+be found in variable `hi-lock-interactive-patterns'." t nil)
+
+;;;***
+
 ;;;### (autoloads (hide-ifdef-lines hide-ifdef-read-only hide-ifdef-initially
-;;;;;;  hide-ifdef-mode) "hideif" "progmodes/hideif.el" (14392 886))
+;;;;;;  hide-ifdef-mode) "hideif" "progmodes/hideif.el" (14709 36509))
 ;;; Generated autoloads from progmodes/hideif.el
 
 (defvar hide-ifdef-mode nil "\
@@ -7573,7 +7756,7 @@
 ;;;***
 
 ;;;### (autoloads (hs-minor-mode hs-hide-comments-when-hiding-all)
-;;;;;;  "hideshow" "progmodes/hideshow.el" (14512 26322))
+;;;;;;  "hideshow" "progmodes/hideshow.el" (14716 16655))
 ;;; Generated autoloads from progmodes/hideshow.el
 
 (defvar hs-hide-comments-when-hiding-all t "\
@@ -7630,7 +7813,7 @@
 ;;;### (autoloads (global-highlight-changes highlight-compare-with-file
 ;;;;;;  highlight-changes-rotate-faces highlight-changes-previous-change
 ;;;;;;  highlight-changes-next-change highlight-changes-mode highlight-changes-remove-highlight)
-;;;;;;  "hilit-chg" "hilit-chg.el" (14637 38207))
+;;;;;;  "hilit-chg" "hilit-chg.el" (14703 9943))
 ;;; Generated autoloads from hilit-chg.el
 
 (defvar highlight-changes-mode nil)
@@ -7787,9 +7970,18 @@
 
 ;;;***
 
-;;;### (autoloads (hl-line-mode) "hl-line" "hl-line.el" (14651 36465))
+;;;### (autoloads (hl-line-mode) "hl-line" "hl-line.el" (14709 28151))
 ;;; Generated autoloads from hl-line.el
 
+(defvar hl-line-mode nil "\
+Toggle Hl-Line mode.
+Setting this variable directly does not take effect;
+use either \\[customize] or the function `hl-line-mode'.")
+
+(custom-add-to-group (quote hl-line) (quote hl-line-mode) (quote custom-variable))
+
+(custom-add-load (quote hl-line-mode) (quote hl-line))
+
 (autoload (quote hl-line-mode) "hl-line" "\
 Global minor mode to highlight the line about point in the current window.
 With ARG, turn Hl-Line mode on if ARG is positive, off otherwise.
@@ -7813,7 +8005,7 @@
 ;;;***
 
 ;;;### (autoloads (hscroll-global-mode hscroll-mode turn-on-hscroll)
-;;;;;;  "hscroll" "hscroll.el" (14454 81))
+;;;;;;  "hscroll" "hscroll.el" (14671 47520))
 ;;; Generated autoloads from hscroll.el
 
 (autoload (quote turn-on-hscroll) "hscroll" "\
@@ -7880,7 +8072,7 @@
 ;;;***
 
 ;;;### (autoloads (idlwave-shell) "idlw-shell" "progmodes/idlw-shell.el"
-;;;;;;  (14495 18053))
+;;;;;;  (14671 47570))
 ;;; Generated autoloads from progmodes/idlw-shell.el
 
 (autoload (quote idlwave-shell) "idlw-shell" "\
@@ -7903,7 +8095,7 @@
 ;;;***
 
 ;;;### (autoloads (idlwave-mode) "idlwave" "progmodes/idlwave.el"
-;;;;;;  (14495 18054))
+;;;;;;  (14671 47574))
 ;;; Generated autoloads from progmodes/idlwave.el
 
 (autoload (quote idlwave-mode) "idlwave" "\
@@ -7947,17 +8139,25 @@
    These commands know about system routines, all routines in idlwave-mode
    buffers and (when the idlwave-shell is active) about all modules
    currently compiled under this shell.  Use \\[idlwave-update-routine-info] to update this
-   information, which is also used for completion (see next item).
-
-3. Completion
+   information, which is also used for completion (see item 4).
+
+3. Online IDL Help
+   ---------------
+   \\[idlwave-context-help] displays the IDL documentation relevant
+   for the system variable, keyword, or routine at point.  A single key
+   stroke gets you directly to the right place in the docs.  Two additional
+   files (an ASCII version of the IDL documentation and a topics file) must
+   be installed for this - check the IDLWAVE webpage for these files.
+
+4. Completion
    ----------
-   \\[idlwave-complete] completes the names of procedures, functions and
-   keyword parameters.  It is context sensitive and figures out what
-   is expected at point (procedure/function/keyword).  Lower case
-   strings are completed in lower case, other strings in mixed or
-   upper case.
-
-4. Code Templates and Abbreviations
+   \\[idlwave-complete] completes the names of procedures, functions
+   class names and keyword parameters.  It is context sensitive and
+   figures out what is expected at point (procedure/function/keyword).
+   Lower case strings are completed in lower case, other strings in
+   mixed or upper case.
+
+5. Code Templates and Abbreviations
    --------------------------------
    Many Abbreviations are predefined to expand to code fragments and templates.
    The abbreviations start generally with a `\\`.  Some examples
@@ -7979,22 +8179,22 @@
    current program unit (pro, function or main).  Change log entries
    can be added to the current program unit with \\[idlwave-doc-modification].
 
-5. Automatic Case Conversion
+6. Automatic Case Conversion
    -------------------------
    The case of reserved words and some abbrevs is controlled by
    `idlwave-reserved-word-upcase' and `idlwave-abbrev-change-case'.
 
-6. Automatic END completion
+7. Automatic END completion
    ------------------------
    If the variable `idlwave-expand-generic-end' is non-nil, each END typed
    will be converted to the specific version, like ENDIF, ENDFOR, etc.
 
-7. Hooks
+8. Hooks
    -----
    Loading idlwave.el runs `idlwave-load-hook'.
    Turning on `idlwave-mode' runs `idlwave-mode-hook'.
 
-8. Documentation and Customization
+9. Documentation and Customization
    -------------------------------
    Info documentation for this package is available.  Use \\[idlwave-info]
    to display (complain to your sysadmin if that does not work).
@@ -8002,7 +8202,7 @@
    homepage at `http://www.strw.leidenuniv.nl/~dominik/Tools/idlwave'.
    IDLWAVE has customize support - see the group `idlwave'.
 
-9. Keybindings
+10.Keybindings
    -----------
    Here is a list of all keybindings of this mode.
    If some of the key bindings below show with ??, use \\[describe-key]
@@ -8024,7 +8224,7 @@
 
 ;;;### (autoloads (defimage find-image remove-images insert-image
 ;;;;;;  put-image create-image image-type-available-p image-type-from-file-header
-;;;;;;  image-type-from-data) "image" "image.el" (14653 63162))
+;;;;;;  image-type-from-data) "image" "image.el" (14663 20184))
 ;;; Generated autoloads from image.el
 
 (autoload (quote image-type-from-data) "image" "\
@@ -8120,7 +8320,7 @@
 ;;;***
 
 ;;;### (autoloads (imenu imenu-add-menubar-index imenu-add-to-menubar
-;;;;;;  imenu-sort-function) "imenu" "imenu.el" (14634 20442))
+;;;;;;  imenu-sort-function) "imenu" "imenu.el" (14659 22945))
 ;;; Generated autoloads from imenu.el
 
 (defvar imenu-sort-function nil "\
@@ -8150,8 +8350,8 @@
  (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 FUNCTION POSITION-MARKER ARGUMENTS...)
-with FUNCTION and ARGUMENTS beiong copied from `imenu-generic-expression'.
+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.
@@ -8315,7 +8515,7 @@
 
 ;;;### (autoloads (Info-speedbar-browser Info-goto-emacs-key-command-node
 ;;;;;;  Info-goto-emacs-command-node Info-directory info-standalone
-;;;;;;  info info-other-window) "info" "info.el" (14651 47854))
+;;;;;;  info info-other-window) "info" "info.el" (14717 22198))
 ;;; Generated autoloads from info.el
 
 (autoload (quote info-other-window) "info" "\
@@ -8352,7 +8552,7 @@
 
 (autoload (quote Info-goto-emacs-key-command-node) "info" "\
 Go to the Info node in the Emacs manual the command bound to KEY, a string.
-Interactively, if the binding is execute-extended-command, a command is read.
+Interactively, if the binding is `execute-extended-command', a command is read.
 The command is found by looking up in Emacs manual's Command Index
 or in another manual found via COMMAND's `info-file' property or
 the variable `Info-file-list-for-emacs'." t nil)
@@ -8365,7 +8565,7 @@
 
 ;;;### (autoloads (info-complete-file info-complete-symbol info-lookup-file
 ;;;;;;  info-lookup-symbol info-lookup-reset) "info-look" "info-look.el"
-;;;;;;  (14539 53666))
+;;;;;;  (14710 63985))
 ;;; Generated autoloads from info-look.el
 
 (autoload (quote info-lookup-reset) "info-look" "\
@@ -8434,7 +8634,7 @@
 
 ;;;### (autoloads (isearch-process-search-multibyte-characters isearch-toggle-input-method
 ;;;;;;  isearch-toggle-specified-input-method) "isearch-x" "international/isearch-x.el"
-;;;;;;  (14644 61013))
+;;;;;;  (14669 64271))
 ;;; Generated autoloads from international/isearch-x.el
 
 (autoload (quote isearch-toggle-specified-input-method) "isearch-x" "\
@@ -8548,7 +8748,7 @@
 ;;;***
 
 ;;;### (autoloads nil "iso-transl" "international/iso-transl.el"
-;;;;;;  (14164 4477))
+;;;;;;  (14716 1570))
 ;;; Generated autoloads from international/iso-transl.el
  (or key-translation-map (setq key-translation-map (make-sparse-keymap)))
  (define-key key-translation-map "\C-x8" 'iso-transl-ctl-x-8-map)
@@ -8556,12 +8756,12 @@
 
 ;;;***
 
-;;;### (autoloads (ispell-message ispell-minor-mode ispell-complete-word-interior-frag
+;;;### (autoloads (ispell-message ispell-minor-mode ispell ispell-complete-word-interior-frag
 ;;;;;;  ispell-complete-word ispell-continue ispell-buffer ispell-comments-and-strings
 ;;;;;;  ispell-region ispell-change-dictionary ispell-kill-ispell
 ;;;;;;  ispell-help ispell-word ispell-dictionary-alist ispell-local-dictionary-alist
 ;;;;;;  ispell-personal-dictionary) "ispell" "textmodes/ispell.el"
-;;;;;;  (14637 38360))
+;;;;;;  (14728 11002))
 ;;; Generated autoloads from textmodes/ispell.el
 
 (defconst xemacsp (string-match "Lucid\\|XEmacs" emacs-version) "\
@@ -8765,6 +8965,11 @@
 (autoload (quote ispell-complete-word-interior-frag) "ispell" "\
 Completes word matching character sequence inside a word." t nil)
 
+(autoload (quote ispell) "ispell" "\
+Interactively check a region or buffer for spelling errors.
+If `transient-mark-mode' is on, an a region is active, spell-check
+that region.  Otherwise spell-check the buffer." t nil)
+
 (autoload (quote ispell-minor-mode) "ispell" "\
 Toggle Ispell minor mode.
 With prefix arg, turn Ispell minor mode on iff arg is positive.
@@ -8799,7 +9004,7 @@
 
 ;;;### (autoloads (iswitchb-buffer-other-frame iswitchb-display-buffer
 ;;;;;;  iswitchb-buffer-other-window iswitchb-buffer iswitchb-default-keybindings
-;;;;;;  iswitchb-read-buffer) "iswitchb" "iswitchb.el" (14619 3306))
+;;;;;;  iswitchb-read-buffer) "iswitchb" "iswitchb.el" (14727 65181))
 ;;; Generated autoloads from iswitchb.el
 
 (autoload (quote iswitchb-read-buffer) "iswitchb" "\
@@ -8843,7 +9048,7 @@
 ;;;### (autoloads (read-hiragana-string japanese-zenkaku-region japanese-hankaku-region
 ;;;;;;  japanese-hiragana-region japanese-katakana-region japanese-zenkaku
 ;;;;;;  japanese-hankaku japanese-hiragana japanese-katakana setup-japanese-environment-internal)
-;;;;;;  "japan-util" "language/japan-util.el" (14623 45991))
+;;;;;;  "japan-util" "language/japan-util.el" (14718 42200))
 ;;; Generated autoloads from language/japan-util.el
 
 (autoload (quote setup-japanese-environment-internal) "japan-util" nil nil nil)
@@ -8899,13 +9104,13 @@
 
 ;;;***
 
-;;;### (autoloads (turn-on-jit-lock jit-lock-mode) "jit-lock" "jit-lock.el"
-;;;;;;  (14651 36595))
+;;;### (autoloads (jit-lock-mode) "jit-lock" "jit-lock.el" (14672
+;;;;;;  33974))
 ;;; Generated autoloads from jit-lock.el
 
 (autoload (quote jit-lock-mode) "jit-lock" "\
 Toggle Just-in-time Lock mode.
-With arg, turn Just-in-time Lock mode on if and only if arg is positive.
+Turn Just-in-time Lock mode on if and only if ARG is non-nil.
 Enable it automatically by customizing group `font-lock'.
 
 When Just-in-time Lock mode is enabled, fontification is different in the
@@ -8933,10 +9138,7 @@
 Stealth fontification only occurs while the system remains unloaded.
 If the system load rises above `jit-lock-stealth-load' percent, stealth
 fontification is suspended.  Stealth fontification intensity is controlled via
-the variable `jit-lock-stealth-nice'." t nil)
-
-(autoload (quote turn-on-jit-lock) "jit-lock" "\
-Unconditionally turn on Just-in-time Lock mode." nil nil)
+the variable `jit-lock-stealth-nice'." nil nil)
 
 ;;;***
 
@@ -8987,10 +9189,17 @@
 
 ;;;***
 
-;;;### (autoloads (kkc-region) "kkc" "international/kkc.el" (14636
-;;;;;;  62730))
+;;;### (autoloads (kkc-region) "kkc" "international/kkc.el" (14708
+;;;;;;  9104))
 ;;; Generated autoloads from international/kkc.el
 
+(defvar kkc-after-update-conversion-functions nil "\
+Functions to run after a conversion is selected in `japanese' input method.
+With this input method, a user can select a proper conversion from
+candidate list.  Each time he changes the selection, functions in this
+list are called with two arguments; starting and ending buffer
+positions that contains the current selection.")
+
 (autoload (quote kkc-region) "kkc" "\
 Convert Kana string in the current region to Kanji-Kana mixed string.
 Users can select a desirable conversion interactively.
@@ -9014,7 +9223,7 @@
 ;;;***
 
 ;;;### (autoloads (lm lm-test-run) "landmark" "play/landmark.el"
-;;;;;;  (14256 23599))
+;;;;;;  (14726 36008))
 ;;; Generated autoloads from play/landmark.el
 
 (defalias (quote landmark-repeat) (quote lm-test-run))
@@ -9226,8 +9435,8 @@
 ;;;***
 
 ;;;### (autoloads (print-region lpr-region print-buffer lpr-buffer
-;;;;;;  lpr-command lpr-switches printer-name) "lpr" "lpr.el" (14563
-;;;;;;  22518))
+;;;;;;  lpr-command lpr-switches printer-name) "lpr" "lpr.el" (14692
+;;;;;;  45304))
 ;;; Generated autoloads from lpr.el
 
 (defvar printer-name (if (memq system-type (quote (ms-dos windows-nt))) "PRN") "\
@@ -9325,8 +9534,8 @@
 
 ;;;***
 
-;;;### (autoloads (m4-mode) "m4-mode" "progmodes/m4-mode.el" (13962
-;;;;;;  30919))
+;;;### (autoloads (m4-mode) "m4-mode" "progmodes/m4-mode.el" (14717
+;;;;;;  60217))
 ;;; Generated autoloads from progmodes/m4-mode.el
 
 (autoload (quote m4-mode) "m4-mode" "\
@@ -9444,7 +9653,7 @@
 
 ;;;### (autoloads (mail-hist-put-headers-into-history mail-hist-keep-history
 ;;;;;;  mail-hist-enable mail-hist-define-keys) "mail-hist" "mail/mail-hist.el"
-;;;;;;  (14075 51598))
+;;;;;;  (14723 62186))
 ;;; Generated autoloads from mail/mail-hist.el
 
 (autoload (quote mail-hist-define-keys) "mail-hist" "\
@@ -9466,8 +9675,8 @@
 
 ;;;### (autoloads (mail-fetch-field mail-unquote-printable-region
 ;;;;;;  mail-unquote-printable mail-quote-printable mail-file-babyl-p
-;;;;;;  mail-use-rfc822) "mail-utils" "mail/mail-utils.el" (14501
-;;;;;;  36191))
+;;;;;;  mail-use-rfc822) "mail-utils" "mail/mail-utils.el" (14710
+;;;;;;  50128))
 ;;; Generated autoloads from mail/mail-utils.el
 
 (defvar mail-use-rfc822 nil "\
@@ -9558,7 +9767,7 @@
 ;;;***
 
 ;;;### (autoloads (makefile-mode) "make-mode" "progmodes/make-mode.el"
-;;;;;;  (14608 7464))
+;;;;;;  (14717 60289))
 ;;; Generated autoloads from progmodes/make-mode.el
 
 (autoload (quote makefile-mode) "make-mode" "\
@@ -9647,7 +9856,7 @@
 
 ;;;***
 
-;;;### (autoloads (man-follow man) "man" "man.el" (14583 33482))
+;;;### (autoloads (man-follow man) "man" "man.el" (14684 27536))
 ;;; Generated autoloads from man.el
 
 (defalias (quote manual-entry) (quote man))
@@ -9658,7 +9867,10 @@
 command to retrieve and clean a manpage in the background and places the
 results in a Man mode (manpage browsing) buffer.  See variable
 `Man-notify-method' for what happens when the buffer is ready.
-If a buffer already exists for this man page, it will display immediately." t nil)
+If a buffer already exists for this man page, it will display immediately.
+
+To specify a man page from a certain section, type SUBJECT(SECTION) or
+SECTION SUBJECT when prompted for a manual entry." t nil)
 
 (autoload (quote man-follow) "man" "\
 Get a Un*x manual page of the item under point and put it in a buffer." t nil)
@@ -9975,7 +10187,7 @@
 ;;;***
 
 ;;;### (autoloads (midnight-delay-set clean-buffer-list) "midnight"
-;;;;;;  "midnight.el" (14035 10445))
+;;;;;;  "midnight.el" (14720 14160))
 ;;; Generated autoloads from midnight.el
 
 (autoload (quote clean-buffer-list) "midnight" "\
@@ -9998,7 +10210,7 @@
 ;;;***
 
 ;;;### (autoloads (convert-mocklisp-buffer) "mlconvert" "emulation/mlconvert.el"
-;;;;;;  (12536 45574))
+;;;;;;  (14660 49410))
 ;;; Generated autoloads from emulation/mlconvert.el
 
 (autoload (quote convert-mocklisp-buffer) "mlconvert" "\
@@ -10110,7 +10322,7 @@
 ;;;;;;  list-coding-systems describe-current-coding-system describe-current-coding-system-briefly
 ;;;;;;  describe-coding-system describe-char-after list-charset-chars
 ;;;;;;  read-charset list-character-sets) "mule-diag" "international/mule-diag.el"
-;;;;;;  (14652 49271))
+;;;;;;  (14697 36467))
 ;;; Generated autoloads from international/mule-diag.el
 
 (autoload (quote list-character-sets) "mule-diag" "\
@@ -10340,7 +10552,7 @@
 ;;;### (autoloads (network-connection network-connection-to-service
 ;;;;;;  whois-reverse-lookup whois finger ftp dig nslookup nslookup-host
 ;;;;;;  route arp netstat ipconfig ping traceroute) "net-utils" "net/net-utils.el"
-;;;;;;  (14644 7249))
+;;;;;;  (14727 65050))
 ;;; Generated autoloads from net/net-utils.el
 
 (autoload (quote traceroute) "net-utils" "\
@@ -10398,7 +10610,7 @@
 ;;;### (autoloads (comment-indent-new-line comment-dwim comment-region
 ;;;;;;  uncomment-region comment-kill comment-set-column comment-indent
 ;;;;;;  comment-multi-line comment-padding comment-style comment-column)
-;;;;;;  "newcomment" "newcomment.el" (14651 36595))
+;;;;;;  "newcomment" "newcomment.el" (14693 39146))
 ;;; Generated autoloads from newcomment.el
 
 (defalias (quote indent-for-comment) (quote comment-indent))
@@ -10409,7 +10621,7 @@
 
 (defalias (quote indent-new-comment-line) (quote comment-indent-new-line))
 
-(defgroup comment nil "Indenting and filling of comments." :prefix "comment-" :group (quote fill))
+(defgroup comment nil "Indenting and filling of comments." :prefix "comment-" :version "21.1" :group (quote fill))
 
 (defvar comment-column 32 "\
 *Column to indent right-margin comments to.
@@ -10450,8 +10662,7 @@
 makes the comment easier to read.  Default is 1.  nil means 0.")
 
 (defvar comment-multi-line nil "\
-*Non-nil means \\[indent-new-comment-line] should continue same comment
-on new line, with no new terminator or starter.
+*Non-nil means \\[comment-indent-new-line] continues comments, with no new terminator or starter.
 This is obsolete because you might as well use \\[newline-and-indent].")
 
 (autoload (quote comment-indent) "newcomment" "\
@@ -10894,7 +11105,7 @@
 ;;;***
 
 ;;;### (autoloads (pc-selection-mode pc-selection-mode) "pc-select"
-;;;;;;  "emulation/pc-select.el" (13674 34216))
+;;;;;;  "emulation/pc-select.el" (14671 23903))
 ;;; Generated autoloads from emulation/pc-select.el
 
 (autoload (quote pc-selection-mode) "pc-select" "\
@@ -10960,8 +11171,140 @@
 
 ;;;***
 
-;;;### (autoloads (cvs-dired-use-hook cvs-status cvs-update cvs-examine
-;;;;;;  cvs-checkout) "pcvs" "pcvs.el" (14619 3307))
+;;;### (autoloads (pcomplete/cvs) "pcmpl-cvs" "pcmpl-cvs.el" (14680
+;;;;;;  31123))
+;;; Generated autoloads from pcmpl-cvs.el
+
+(autoload (quote pcomplete/cvs) "pcmpl-cvs" "\
+Completion rules for the `cvs' command." nil nil)
+
+;;;***
+
+;;;### (autoloads (pcomplete/tar pcomplete/make pcomplete/bzip2 pcomplete/gzip)
+;;;;;;  "pcmpl-gnu" "pcmpl-gnu.el" (14680 31143))
+;;; Generated autoloads from pcmpl-gnu.el
+
+(autoload (quote pcomplete/gzip) "pcmpl-gnu" "\
+Completion for `gzip'." nil nil)
+
+(autoload (quote pcomplete/bzip2) "pcmpl-gnu" "\
+Completion for `bzip2'." nil nil)
+
+(autoload (quote pcomplete/make) "pcmpl-gnu" "\
+Completion for GNU `make'." nil nil)
+
+(autoload (quote pcomplete/tar) "pcmpl-gnu" "\
+Completion for the GNU tar utility." nil nil)
+
+(defalias (quote pcomplete/gdb) (quote pcomplete/xargs))
+
+;;;***
+
+;;;### (autoloads (pcomplete/mount pcomplete/umount pcomplete/kill)
+;;;;;;  "pcmpl-linux" "pcmpl-linux.el" (14680 31151))
+;;; Generated autoloads from pcmpl-linux.el
+
+(autoload (quote pcomplete/kill) "pcmpl-linux" "\
+Completion for GNU/Linux `kill', using /proc filesystem." nil nil)
+
+(autoload (quote pcomplete/umount) "pcmpl-linux" "\
+Completion for GNU/Linux `umount'." nil nil)
+
+(autoload (quote pcomplete/mount) "pcmpl-linux" "\
+Completion for GNU/Linux `mount'." nil nil)
+
+;;;***
+
+;;;### (autoloads (pcomplete/rpm) "pcmpl-rpm" "pcmpl-rpm.el" (14680
+;;;;;;  31160))
+;;; Generated autoloads from pcmpl-rpm.el
+
+(autoload (quote pcomplete/rpm) "pcmpl-rpm" "\
+Completion for RedHat's `rpm' command.
+These rules were taken from the output of `rpm --help' on a RedHat 6.1
+system.  They follow my interpretation of what followed, but since I'm
+not a major rpm user/builder, please send me any corrections you find.
+You can use \\[eshell-report-bug] to do so." nil nil)
+
+;;;***
+
+;;;### (autoloads (pcomplete/chgrp pcomplete/chown pcomplete/which
+;;;;;;  pcomplete/xargs pcomplete/rm pcomplete/rmdir pcomplete/cd)
+;;;;;;  "pcmpl-unix" "pcmpl-unix.el" (14680 31168))
+;;; Generated autoloads from pcmpl-unix.el
+
+(autoload (quote pcomplete/cd) "pcmpl-unix" "\
+Completion for `cd'." nil nil)
+
+(defalias (quote pcomplete/pushd) (quote pcomplete/cd))
+
+(autoload (quote pcomplete/rmdir) "pcmpl-unix" "\
+Completion for `rmdir'." nil nil)
+
+(autoload (quote pcomplete/rm) "pcmpl-unix" "\
+Completion for `rm'." nil nil)
+
+(autoload (quote pcomplete/xargs) "pcmpl-unix" "\
+Completion for `xargs'." nil nil)
+
+(defalias (quote pcomplete/time) (quote pcomplete/xargs))
+
+(autoload (quote pcomplete/which) "pcmpl-unix" "\
+Completion for `which'." nil nil)
+
+(autoload (quote pcomplete/chown) "pcmpl-unix" "\
+Completion for the `chown' command." nil nil)
+
+(autoload (quote pcomplete/chgrp) "pcmpl-unix" "\
+Completion for the `chgrp' command." nil nil)
+
+;;;***
+
+;;;### (autoloads (pcomplete-shell-setup pcomplete-comint-setup pcomplete-list
+;;;;;;  pcomplete-help pcomplete-expand pcomplete-continue pcomplete-expand-and-complete
+;;;;;;  pcomplete-reverse pcomplete) "pcomplete" "pcomplete.el" (14674
+;;;;;;  58518))
+;;; Generated autoloads from pcomplete.el
+
+(autoload (quote pcomplete) "pcomplete" "\
+Support extensible programmable completion.
+To use this function, just bind the TAB key to it, or add it to your
+completion functions list (it should occur fairly early in the list)." t nil)
+
+(autoload (quote pcomplete-reverse) "pcomplete" "\
+If cycling completion is in use, cycle backwards." t nil)
+
+(autoload (quote pcomplete-expand-and-complete) "pcomplete" "\
+Expand the textual value of the current argument.
+This will modify the current buffer." t nil)
+
+(autoload (quote pcomplete-continue) "pcomplete" "\
+Complete without reference to any cycling completions." t nil)
+
+(autoload (quote pcomplete-expand) "pcomplete" "\
+Expand the textual value of the current argument.
+This will modify the current buffer." t nil)
+
+(autoload (quote pcomplete-help) "pcomplete" "\
+Display any help information relative to the current argument." t nil)
+
+(autoload (quote pcomplete-list) "pcomplete" "\
+Show the list of possible completions for the current argument." t nil)
+
+(autoload (quote pcomplete-comint-setup) "pcomplete" "\
+Setup a comint buffer to use pcomplete.
+COMPLETEF-SYM should be the symbol where the
+dynamic-complete-functions are kept.  For comint mode itself, this is
+`comint-dynamic-complete-functions'." nil nil)
+
+(autoload (quote pcomplete-shell-setup) "pcomplete" "\
+Setup shell-mode to use pcomplete." nil nil)
+
+;;;***
+
+;;;### (autoloads (cvs-dired-use-hook cvs-dired-action cvs-status
+;;;;;;  cvs-update cvs-examine cvs-quickdir cvs-checkout) "pcvs"
+;;;;;;  "pcvs.el" (14660 49377))
 ;;; Generated autoloads from pcvs.el
 
 (autoload (quote cvs-checkout) "pcvs" "\
@@ -10971,6 +11314,14 @@
 
 With a prefix argument, prompt for cvs FLAGS to use." t nil)
 
+(autoload (quote cvs-quickdir) "pcvs" "\
+Open a *cvs* buffer on DIR without running cvs.
+With a prefix argument, prompt for a directory to use.
+A prefix arg >8 (ex: \\[universal-argument] \\[universal-argument]),
+  prevents reuse of an existing *cvs* buffer.
+Optional argument NOSHOW if non-nil means not to display the buffer.
+FLAGS is ignored." t nil)
+
 (autoload (quote cvs-examine) "pcvs" "\
 Run a `cvs -n update' in the specified DIRECTORY.
 That is, check what needs to be done, but don't change the disc.
@@ -10997,6 +11348,10 @@
 
 (add-to-list (quote completion-ignored-extensions) "CVS/")
 
+(defvar cvs-dired-action (quote cvs-examine) "\
+The action to be performed when opening a CVS directory.
+Sensible values are `cvs-examine', `cvs-status' and `cvs-quickdir'.")
+
 (defvar cvs-dired-use-hook (quote (4)) "\
 Whether or not opening a CVS directory should run PCL-CVS.
 NIL means never do it.
@@ -11004,11 +11359,13 @@
   command that prompted the opening of the directory.
 Anything else means to do it only if the prefix arg is equal to this value.")
 
-(progn (defun cvs-dired-noselect (dir) "Run `cvs-examine' if DIR is a CVS administrative directory.\nThe exact behavior is determined also by `cvs-dired-use-hook'." (when (stringp dir) (setq dir (directory-file-name dir)) (when (and (string= "CVS" (file-name-nondirectory dir)) (file-readable-p (expand-file-name "Entries" dir)) cvs-dired-use-hook (if (eq cvs-dired-use-hook (quote always)) (not current-prefix-arg) (equal current-prefix-arg cvs-dired-use-hook))) (save-excursion (cvs-examine (file-name-directory dir) t t))))))
-
-;;;***
-
-;;;### (autoloads nil "pcvs-defs" "pcvs-defs.el" (14552 48685))
+(defun cvs-dired-noselect (dir) "\
+Run `cvs-examine' if DIR is a CVS administrative directory.
+The exact behavior is determined also by `cvs-dired-use-hook'." (when (stringp dir) (setq dir (directory-file-name dir)) (when (and (string= "CVS" (file-name-nondirectory dir)) (file-readable-p (expand-file-name "Entries" dir)) cvs-dired-use-hook (if (eq cvs-dired-use-hook (quote always)) (not current-prefix-arg) (equal current-prefix-arg cvs-dired-use-hook))) (save-excursion (funcall cvs-dired-action (file-name-directory dir) t t)))))
+
+;;;***
+
+;;;### (autoloads nil "pcvs-defs" "pcvs-defs.el" (14663 20185))
 ;;; Generated autoloads from pcvs-defs.el
 
 (defvar cvs-global-menu (let ((m (make-sparse-keymap "PCL-CVS"))) (define-key m [status] (quote (menu-item "Directory Status" cvs-status :help "A more verbose status of a workarea"))) (define-key m [checkout] (quote (menu-item "Checkout Module" cvs-checkout :help "Check out a module from the repository"))) (define-key m [update] (quote (menu-item "Update Directory" cvs-update :help "Fetch updates from the repository"))) (define-key m [examine] (quote (menu-item "Examine Directory" cvs-examine :help "Examine the current state of a workarea"))) m))
@@ -11137,7 +11494,7 @@
 
 ;;;***
 
-;;;### (autoloads (pong) "pong" "play/pong.el" (14453 55473))
+;;;### (autoloads (pong) "pong" "play/pong.el" (14708 25304))
 ;;; Generated autoloads from play/pong.el
 
 (autoload (quote pong) "pong" "\
@@ -11250,7 +11607,7 @@
 ;;;### (autoloads (ps-mule-begin-page ps-mule-begin-job ps-mule-initialize
 ;;;;;;  ps-mule-plot-composition ps-mule-plot-string ps-mule-set-ascii-font
 ;;;;;;  ps-mule-prepare-ascii-font ps-multibyte-buffer) "ps-mule"
-;;;;;;  "ps-mule.el" (14588 21278))
+;;;;;;  "ps-mule.el" (14728 6241))
 ;;; Generated autoloads from ps-mule.el
 
 (defvar ps-multibyte-buffer nil "\
@@ -11347,7 +11704,7 @@
 ;;;;;;  ps-spool-region ps-spool-buffer-with-faces ps-spool-buffer
 ;;;;;;  ps-print-region-with-faces ps-print-region ps-print-buffer-with-faces
 ;;;;;;  ps-print-buffer ps-print-customize ps-paper-type) "ps-print"
-;;;;;;  "ps-print.el" (14654 17854))
+;;;;;;  "ps-print.el" (14724 2518))
 ;;; Generated autoloads from ps-print.el
 
 (defvar ps-paper-type (quote letter) "\
@@ -11484,7 +11841,7 @@
 ;;;### (autoloads (quail-update-leim-list-file quail-defrule-internal
 ;;;;;;  quail-defrule quail-install-map quail-define-rules quail-set-keyboard-layout
 ;;;;;;  quail-define-package quail-use-package) "quail" "international/quail.el"
-;;;;;;  (14644 61013))
+;;;;;;  (14666 30210))
 ;;; Generated autoloads from international/quail.el
 
 (autoload (quote quail-use-package) "quail" "\
@@ -11706,19 +12063,11 @@
 
 ;;;***
 
-;;;### (autoloads (recentf-open-more-files recentf-cleanup recentf-edit-list
-;;;;;;  recentf-save-list recentf-mode) "recentf" "recentf.el" (14654
-;;;;;;  24504))
+;;;### (autoloads (recentf-mode recentf-open-more-files recentf-open-files
+;;;;;;  recentf-cleanup recentf-edit-list recentf-save-list) "recentf"
+;;;;;;  "recentf.el" (14717 22266))
 ;;; Generated autoloads from recentf.el
 
-(autoload (quote recentf-mode) "recentf" "\
-Toggle recentf mode.
-With prefix ARG, turn recentf mode on if and only if ARG is positive.
-Returns the new status of recentf mode (non-nil means on).
-
-When recentf mode is enabled, it maintains a menu for visiting files that
-were operated on recently." t nil)
-
 (autoload (quote recentf-save-list) "recentf" "\
 Save the current `recentf-list' to the file `recentf-save-file'." t nil)
 
@@ -11728,16 +12077,30 @@
 (autoload (quote recentf-cleanup) "recentf" "\
 Remove all non-readable and excluded files from `recentf-list'." t nil)
 
+(autoload (quote recentf-open-files) "recentf" "\
+Open a buffer that allows the user to choose a file to open from
+the list of recently opened files. The optional argument FILES may be
+used to specify the list, otherwise recentf-list is used. The optional
+argument BUFFER-NAME specifies which buffer to use for the interaction." t nil)
+
 (autoload (quote recentf-open-more-files) "recentf" "\
 Allow the user to open files that are not in the menu." t nil)
 
+(autoload (quote recentf-mode) "recentf" "\
+Toggle recentf mode.
+With prefix ARG, turn recentf mode on if and only if ARG is positive.
+Returns the new status of recentf mode (non-nil means on).
+
+When recentf mode is enabled, it maintains a menu for visiting files that
+were operated on recently." t nil)
+
 ;;;***
 
 ;;;### (autoloads (clear-rectangle replace-rectangle string-rectangle
 ;;;;;;  delete-whitespace-rectangle open-rectangle insert-rectangle
 ;;;;;;  yank-rectangle kill-rectangle extract-rectangle delete-extract-rectangle
-;;;;;;  delete-rectangle move-to-column-force) "rect" "rect.el" (14537
-;;;;;;  23030))
+;;;;;;  delete-rectangle move-to-column-force) "rect" "rect.el" (14709
+;;;;;;  28151))
 ;;; Generated autoloads from rect.el
 
 (autoload (quote move-to-column-force) "rect" "\
@@ -11831,7 +12194,7 @@
 ;;;***
 
 ;;;### (autoloads (reftex-mode turn-on-reftex) "reftex" "textmodes/reftex.el"
-;;;;;;  (14495 18077))
+;;;;;;  (14671 47574))
 ;;; Generated autoloads from textmodes/reftex.el
 
 (autoload (quote turn-on-reftex) "reftex" "\
@@ -11871,7 +12234,7 @@
 ;;;***
 
 ;;;### (autoloads (reftex-citation) "reftex-cite" "textmodes/reftex-cite.el"
-;;;;;;  (14495 18066))
+;;;;;;  (14702 57277))
 ;;; Generated autoloads from textmodes/reftex-cite.el
 
 (autoload (quote reftex-citation) "reftex-cite" "\
@@ -11898,7 +12261,7 @@
 ;;;***
 
 ;;;### (autoloads (reftex-index-phrases-mode) "reftex-index" "textmodes/reftex-index.el"
-;;;;;;  (14495 18068))
+;;;;;;  (14671 47574))
 ;;; Generated autoloads from textmodes/reftex-index.el
 
 (autoload (quote reftex-index-phrases-mode) "reftex-index" "\
@@ -12090,7 +12453,7 @@
 ;;;;;;  rmail-mail-new-frame rmail-primary-inbox-list rmail-delete-after-output
 ;;;;;;  rmail-highlight-face rmail-highlighted-headers rmail-retry-ignored-headers
 ;;;;;;  rmail-displayed-headers rmail-ignored-headers rmail-dont-reply-to-names)
-;;;;;;  "rmail" "mail/rmail.el" (14643 46447))
+;;;;;;  "rmail" "mail/rmail.el" (14726 36008))
 ;;; Generated autoloads from mail/rmail.el
 
 (defvar rmail-dont-reply-to-names nil "\
@@ -12479,7 +12842,7 @@
 ;;;***
 
 ;;;### (autoloads (news-post-news) "rnewspost" "mail/rnewspost.el"
-;;;;;;  (14263 36299))
+;;;;;;  (14660 49436))
 ;;; Generated autoloads from mail/rnewspost.el
 
 (autoload (quote news-post-news) "rnewspost" "\
@@ -12610,7 +12973,7 @@
 ;;;;;;  mail-signature mail-personal-alias-file mail-alias-file mail-default-reply-to
 ;;;;;;  mail-archive-file-name mail-header-separator mail-yank-ignored-headers
 ;;;;;;  mail-interactive mail-self-blind mail-specify-envelope-from
-;;;;;;  mail-from-style) "sendmail" "mail/sendmail.el" (14603 14745))
+;;;;;;  mail-from-style) "sendmail" "mail/sendmail.el" (14720 1500))
 ;;; Generated autoloads from mail/sendmail.el
 
 (defvar mail-from-style (quote angles) "\
@@ -12630,7 +12993,7 @@
 to the mailer to specify the envelope-from address.  But that is now
 controlled by a separate variable, `mail-specify-envelope-from'.")
 
-(defvar mail-specify-envelope-from t "\
+(defvar mail-specify-envelope-from nil "\
 *If non-nil, specify the envelope-from address when sending mail.
 The value used to specify it is whatever is found in `user-mail-address'.
 
@@ -12770,7 +13133,7 @@
 
 ;;;***
 
-;;;### (autoloads (server-start) "server" "server.el" (14263 33343))
+;;;### (autoloads (server-start) "server" "server.el" (14688 19453))
 ;;; Generated autoloads from server.el
 
 (autoload (quote server-start) "server" "\
@@ -12847,7 +13210,7 @@
 ;;;***
 
 ;;;### (autoloads (sh-mode) "sh-script" "progmodes/sh-script.el"
-;;;;;;  (14651 36906))
+;;;;;;  (14672 61162))
 ;;; Generated autoloads from progmodes/sh-script.el
 
 (put (quote sh-mode) (quote mode-class) (quote special))
@@ -13163,8 +13526,8 @@
 
 ;;;***
 
-;;;### (autoloads (smerge-mode) "smerge-mode" "smerge-mode.el" (14637
-;;;;;;  38212))
+;;;### (autoloads (smerge-mode) "smerge-mode" "smerge-mode.el" (14716
+;;;;;;  1565))
 ;;; Generated autoloads from smerge-mode.el
 
 (autoload (quote smerge-mode) "smerge-mode" "\
@@ -13551,8 +13914,9 @@
 
 ;;;***
 
-;;;### (autoloads (sql-postgres sql-mode sql-help) "sql" "progmodes/sql.el"
-;;;;;;  (14395 64503))
+;;;### (autoloads (sql-postgres sql-ms sql-ingres sql-solid sql-mysql
+;;;;;;  sql-informix sql-sybase sql-oracle sql-mode sql-help) "sql"
+;;;;;;  "progmodes/sql.el" (14720 34739))
 ;;; Generated autoloads from progmodes/sql.el
 
 (autoload (quote sql-help) "sql" "\
@@ -13582,11 +13946,6 @@
 is generated.  See the In/Out menu in the SQLi buffer for some functions
 that help you navigate through the buffer, the input history, etc.
 
-Put a line with a call to autoload into your `~/.emacs' file for each
-entry function you want to use regularly:
-
-\(autoload 'sql-postgres \"sql\" \"Interactive SQL mode.\" t)
-
 If you have a really complex SQL statement or if you are writing a
 procedure, you can do this in a separate buffer.  Put the new buffer in
 `sql-mode' by calling \\[sql-mode].  The name of this buffer can be
@@ -13616,6 +13975,169 @@
 For information on how to create multiple SQLi buffers, see
 `sql-interactive-mode'." t nil)
 
+(autoload (quote sql-oracle) "sql" "\
+Run sqlplus by Oracle as an inferior process.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-oracle-program'.  Login uses
+the variables `sql-user', `sql-password', and `sql-database' as
+defaults, if set.  Additional command line parameters can be stored in
+the list `sql-oracle-options'.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input.  See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-oracle].  You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
+(autoload (quote sql-sybase) "sql" "\
+Run isql by SyBase as an inferior process.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-sybase-program'.  Login uses
+the variables `sql-user', `sql-password', and `sql-server' as
+defaults, if set.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input.  See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-sybase].  You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
+(autoload (quote sql-informix) "sql" "\
+Run dbaccess by Informix as an inferior process.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-informix-program'.  Login uses
+the variable `sql-database' as default, if set.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input.  See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-informix].  You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
+(autoload (quote sql-mysql) "sql" "\
+Run mysql by TcX as an inferior process.
+
+Note that the widespread idea that mysql is free software is inaccurate;
+its license is too restrictive.  We urge you to use PostGres instead.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-mysql-program'.  Login uses
+the variables `sql-user', `sql-password', `sql-database', and
+`sql-server' as defaults, if set.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input.  See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-mysql].  You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
+(autoload (quote sql-solid) "sql" "\
+Run solsql by Solid as an inferior process.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-solid-program'.  Login uses
+the variables `sql-user', `sql-password', and `sql-server' as
+defaults, if set.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input.  See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-solid].  You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
+(autoload (quote sql-ingres) "sql" "\
+Run sql by Ingres as an inferior process.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-ingres-program'.  Login uses
+the variable `sql-database' as default, if set.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input.  See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-ingres].  You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
+(autoload (quote sql-ms) "sql" "\
+Run isql by Microsoft as an inferior process.
+
+If buffer `*SQL*' exists but no process is running, make a new process.
+If buffer exists and a process is running, just switch to buffer
+`*SQL*'.
+
+Interpreter used comes from variable `sql-ms-program'.  Login uses the
+variables `sql-user', `sql-password', `sql-database', and `sql-server'
+as defaults, if set.
+
+The buffer is put in sql-interactive-mode, giving commands for sending
+input.  See `sql-interactive-mode'.
+
+To specify a coding system for converting non-ASCII characters
+in the input and output to the process, use \\[universal-coding-system-argument]
+before \\[sql-ms].  You can also specify this with \\[set-buffer-process-coding-system]
+in the SQL buffer, after you start the process.
+The default comes from `process-coding-system-alist' and
+`default-process-coding-system'.
+
+\(Type \\[describe-mode] in the SQL buffer for a list of commands.)" t nil)
+
 (autoload (quote sql-postgres) "sql" "\
 Run psql by Postgres as an inferior process.
 
@@ -13648,7 +14170,7 @@
 ;;;### (autoloads (strokes-mode strokes-load-user-strokes strokes-help
 ;;;;;;  strokes-describe-stroke strokes-do-complex-stroke strokes-do-stroke
 ;;;;;;  strokes-read-complex-stroke strokes-read-stroke strokes-global-set-stroke)
-;;;;;;  "strokes" "strokes.el" (14527 50024))
+;;;;;;  "strokes" "strokes.el" (14726 36008))
 ;;; Generated autoloads from strokes.el
 
 (defvar strokes-mode nil "\
@@ -13776,7 +14298,7 @@
 
 ;;;***
 
-;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (14651 36595))
+;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (14664 40536))
 ;;; Generated autoloads from tar-mode.el
 
 (autoload (quote tar-mode) "tar-mode" "\
@@ -13869,8 +14391,8 @@
 
 ;;;***
 
-;;;### (autoloads (ansi-term term make-term) "term" "term.el" (14268
-;;;;;;  17354))
+;;;### (autoloads (ansi-term term make-term) "term" "term.el" (14700
+;;;;;;  46635))
 ;;; Generated autoloads from term.el
 
 (autoload (quote make-term) "term" "\
@@ -13888,8 +14410,8 @@
 
 ;;;***
 
-;;;### (autoloads (terminal-emulator) "terminal" "terminal.el" (14280
-;;;;;;  10588))
+;;;### (autoloads (terminal-emulator) "terminal" "terminal.el" (14688
+;;;;;;  19748))
 ;;; Generated autoloads from terminal.el
 
 (autoload (quote terminal-emulator) "terminal" "\
@@ -14385,7 +14907,7 @@
 
 ;;;### (autoloads (list-at-point number-at-point symbol-at-point
 ;;;;;;  sexp-at-point thing-at-point bounds-of-thing-at-point forward-thing)
-;;;;;;  "thingatpt" "thingatpt.el" (14655 35092))
+;;;;;;  "thingatpt" "thingatpt.el" (14660 49377))
 ;;; Generated autoloads from thingatpt.el
 
 (autoload (quote forward-thing) "thingatpt" "\
@@ -14426,8 +14948,8 @@
 ;;;;;;  tibetan-compose-buffer tibetan-decompose-buffer tibetan-composition-function
 ;;;;;;  tibetan-decompose-string tibetan-decompose-region tibetan-compose-region
 ;;;;;;  tibetan-compose-string tibetan-transcription-to-tibetan tibetan-tibetan-to-transcription
-;;;;;;  tibetan-char-p) "tibet-util" "language/tibet-util.el" (14647
-;;;;;;  32047))
+;;;;;;  tibetan-char-p) "tibet-util" "language/tibet-util.el" (14672
+;;;;;;  33974))
 ;;; Generated autoloads from language/tibet-util.el
 
 (autoload (quote tibetan-char-p) "tibet-util" "\
@@ -14494,7 +15016,7 @@
 ;;;***
 
 ;;;### (autoloads (display-time-mode display-time display-time-day-and-date
-;;;;;;  display-time-mode) "time" "time.el" (14619 48411))
+;;;;;;  display-time-mode) "time" "time.el" (14667 40846))
 ;;; Generated autoloads from time.el
 
 (defvar display-time-mode nil "\
@@ -14556,7 +15078,7 @@
 
 ;;;### (autoloads (with-timeout run-with-idle-timer add-timeout run-with-timer
 ;;;;;;  run-at-time cancel-function-timers cancel-timer) "timer"
-;;;;;;  "timer.el" (13316 52821))
+;;;;;;  "timer.el" (14717 22266))
 ;;; Generated autoloads from timer.el
 
 (defalias (quote disable-timeout) (quote cancel-timer))
@@ -14593,9 +15115,11 @@
 
 (autoload (quote run-with-idle-timer) "timer" "\
 Perform an action the next time Emacs is idle for SECS seconds.
-If REPEAT is non-nil, do this each time Emacs is idle for SECS seconds.
+The action is to call FUNCTION with arguments ARGS.
 SECS may be an integer or a floating point number.
-The action is to call FUNCTION with arguments ARGS.
+
+If REPEAT is non-nil, do the action each time Emacs has been idle for
+exactly SECS seconds (that is, only once for each time Emacs becomes idle).
 
 This function returns a timer object which you can use in `cancel-timer'." t nil)
  (put 'with-timeout 'lisp-indent-function 1)
@@ -14665,38 +15189,36 @@
 
 ;;;***
 
-;;;### (autoloads (todo-show todo-cp todo-mode todo-print todo-insert-item)
-;;;;;;  "todo-mode" "calendar/todo-mode.el" (14653 63363))
+;;;### (autoloads (todo-print todo-save-top-priorities todo-top-priorities)
+;;;;;;  "todo-mode" "calendar/todo-mode.el" (14690 14754))
 ;;; Generated autoloads from calendar/todo-mode.el
 
-(autoload (quote todo-insert-item) "todo-mode" "\
-Insert new TODO list entry.
-With a prefix argument solicit the category, otherwise use the current
-category." t nil)
+(autoload (quote todo-top-priorities) "todo-mode" "\
+List top priorities for each category.
+
+Number of entries for each category is given by NOF-PRIORITIES which
+defaults to 'todo-show-priorities'.
+
+If CATEGORY-PR-PAGE is non-nil, a page separator '^L' is inserted
+between each category." t nil)
+
+(autoload (quote todo-save-top-priorities) "todo-mode" "\
+Save top priorities for each category in `todo-file-top'.
+
+Number of entries for each category is given by NOF-PRIORITIES which
+defaults to `todo-show-priorities'." t nil)
 
 (autoload (quote todo-print) "todo-mode" "\
 Print todo summary using `todo-print-function'.
-If CATEGORY-PR-PAGE is non-nil, a page separator '^L' is inserted
+If CATEGORY-PR-PAGE is non-nil, a page separator `^L' is inserted
 between each category.
 
-Number of entries for each category is given by
-'todo-print-priorities'." t nil)
-
-(autoload (quote todo-mode) "todo-mode" "\
-Major mode for editing TODO lists.
-
-\\{todo-mode-map}" t nil)
-
-(autoload (quote todo-cp) "todo-mode" "\
-Make a diary entry appear only in the current date's diary." nil nil)
-
-(autoload (quote todo-show) "todo-mode" "\
-Show TODO list." t nil)
+Number of entries for each category is given by `todo-print-priorities'." t nil)
 
 ;;;***
 
 ;;;### (autoloads (tooltip-mode tooltip-mode) "tooltip" "tooltip.el"
-;;;;;;  (14495 17998))
+;;;;;;  (14720 1500))
 ;;; Generated autoloads from tooltip.el
 
 (autoload (quote tooltip-mode) "tooltip" "\
@@ -14824,7 +15346,7 @@
 ;;;### (autoloads (type-break-guesstimate-keystroke-threshold type-break-statistics
 ;;;;;;  type-break type-break-mode type-break-keystroke-threshold
 ;;;;;;  type-break-good-rest-interval type-break-interval type-break-mode)
-;;;;;;  "type-break" "type-break.el" (14263 36029))
+;;;;;;  "type-break" "type-break.el" (14716 1568))
 ;;; Generated autoloads from type-break.el
 
 (defvar type-break-mode nil "\
@@ -15912,7 +16434,7 @@
 ;;;***
 
 ;;;### (autoloads (widget-delete widget-create widget-prompt-value)
-;;;;;;  "wid-edit" "wid-edit.el" (14651 36596))
+;;;;;;  "wid-edit" "wid-edit.el" (14726 36008))
 ;;; Generated autoloads from wid-edit.el
 
 (autoload (quote widget-prompt-value) "wid-edit" "\
@@ -15990,7 +16512,7 @@
 ;;;***
 
 ;;;### (autoloads (woman-find-file woman-dired-find-file woman) "woman"
-;;;;;;  "woman.el" (14636 62704))
+;;;;;;  "woman.el" (14689 44350))
 ;;; Generated autoloads from woman.el
 
 (autoload (quote woman) "woman" "\
@@ -16162,6 +16684,14 @@
 
 ;;;***
 
+;;;### (autoloads (zone) "zone" "play/zone.el" (14728 34415))
+;;; Generated autoloads from play/zone.el
+
+(autoload (quote zone) "zone" "\
+Zone out, completely." t nil)
+
+;;;***
+
 ;;;### (autoloads (zone-mode zone-mode-update-serial-hook) "zone-mode"
 ;;;;;;  "net/zone-mode.el" (13674 20513))
 ;;; Generated autoloads from net/zone-mode.el
diff -r a363ab77020c -r 338238ca63ce lisp/play/zone.el
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lisp/play/zone.el	Wed Aug 02 21:29:36 2000 +0000
@@ -0,0 +1,560 @@
+;;; zone.el --- idle display hacks
+
+;; Copyright (C) 2000 Free Software Foundation, Inc.
+
+;;; Author: Victor Zandy <zandy@cs.wisc.edu>
+;;; Maintainer: Thien-Thi Nguyen <ttn@gnu.org>
+;;; Keywords: games
+;;; Created: June 6, 1998
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;; Don't zone out in front of Emacs!  Try M-x zone.
+;; If it eventually irritates you, try M-x zone-leave-me-alone.
+
+;; Bored by the zone pyrotechnics?  Write your own!  Add it to
+;; `zone-programs'.
+
+;; WARNING: Not appropriate for Emacs sessions over modems or
+;; computers as slow as mine.
+
+;; THANKS: Christopher Mayer, Scott Flinchbaugh, Rachel Kalmar,
+;; Max Froumentin.
+
+;;; Code:
+
+(require 'timer)
+(require 'tabify)
+(eval-when-compile (require 'cl))
+
+(defvar zone-timer nil)
+
+(defvar zone-idle 20
+  "*Seconds to idle before zoning out.")
+
+;; Vector of functions that zone out.  `zone' will execute one of
+;; these functions, randomly chosen.  The chosen function is invoked
+;; in the *zone* buffer, which contains the text of the selected
+;; window.  If the function loops, it *must* periodically check and
+;; halt if `input-pending-p' is t (because quitting is disabled when
+;; Emacs idle timers are run).
+(defvar zone-programs [
+                       zone-pgm-jitter
+                       zone-pgm-putz-with-case
+                       zone-pgm-dissolve
+;                      zone-pgm-explode
+                       zone-pgm-whack-chars
+                       zone-pgm-rotate
+                       zone-pgm-rotate-LR-lockstep
+                       zone-pgm-rotate-RL-lockstep
+                       zone-pgm-rotate-LR-variable
+                       zone-pgm-rotate-RL-variable
+                       zone-pgm-drip
+                       zone-pgm-drip-fretfully
+                       zone-pgm-five-oclock-swan-dive
+                       zone-pgm-martini-swan-dive
+                       zone-pgm-paragraph-spaz
+                       zone-pgm-stress
+                       ])
+
+(defmacro zone-orig (&rest body)
+  `(with-current-buffer (get 'zone 'orig-buffer)
+     ,@body))
+
+;;;###autoload
+(defun zone ()
+  "Zone out, completely."
+  (interactive)
+  (and (timerp zone-timer) (cancel-timer zone-timer))
+  (setq zone-timer nil)
+  (let ((f (and window-system (selected-frame)))
+        (outbuf (get-buffer-create "*zone*"))
+	(text (buffer-substring (window-start) (window-end)))
+	(wp (1+ (- (window-point (selected-window))
+		   (window-start)))))
+    (put 'zone 'orig-buffer (current-buffer))
+    (set-buffer outbuf)
+    (setq mode-name "Zone")
+    (erase-buffer)
+    (insert text)
+    (switch-to-buffer outbuf)
+    (setq buffer-undo-list t)
+    (untabify (point-min) (point-max))
+    (set-window-start (selected-window) (point-min))
+    (set-window-point (selected-window) wp)
+    (sit-for 0 500)
+    (let ((pgm (elt zone-programs (random (length zone-programs))))
+          (ct (and f (frame-parameter f 'cursor-type))))
+      (when ct (modify-frame-parameters f '((cursor-type . (bar . 0)))))
+      (condition-case nil
+	  (progn
+            (message "Zoning... (%s)" pgm)
+	    (garbage-collect)
+	    (funcall pgm)
+	    (message "Zoning...sorry"))
+	(error
+	 (while (not (input-pending-p))
+	   (message (format "We were zoning when we wrote %s..." pgm))
+	   (sit-for 3)
+	   (message "...here's hoping we didn't hose your buffer!")
+	   (sit-for 3)))
+	(quit (ding) (message "Zoning...sorry")))
+      (when ct (modify-frame-parameters f (list (cons 'cursor-type ct)))))
+    (kill-buffer outbuf)
+    (zone-when-idle zone-idle)))
+
+;;;; Zone when idle, or not.
+
+(defvar zone-timer nil
+  "Timer that zone sets to triggle idle zoning out.
+If t, zone won't zone out.")
+
+(defun zone-when-idle (secs)
+  "Zone out when Emacs has been idle for SECS seconds."
+  (interactive "nHow long before I start zoning (seconds): ")
+  (or (<= secs 0)
+      (eq zone-timer t)
+      (timerp zone-timer)
+      (setq zone-timer (run-with-idle-timer secs t 'zone))))
+
+(defun zone-leave-me-alone ()
+  "Don't zone out when Emacs is idle."
+  (interactive)
+  (and (timerp zone-timer) (cancel-timer zone-timer))
+  (setq zone-timer t)
+  (message "I won't zone out any more"))
+
+
+;;;; zone-pgm-jitter
+
+(defun zone-shift-up ()
+  (let* ((b (point))
+	 (e (progn
+	      (end-of-line)
+	      (if (looking-at "\n") (1+ (point)) (point))))
+	 (s (buffer-substring b e)))
+    (delete-region b e)
+    (goto-char (point-max))
+    (insert s)))
+
+(defun zone-shift-down ()
+  (goto-char (point-max))
+  (forward-line -1)
+  (beginning-of-line)
+  (let* ((b (point))
+	 (e (progn
+	      (end-of-line)
+	      (if (looking-at "\n") (1+ (point)) (point))))
+	 (s (buffer-substring b e)))
+    (delete-region b e)
+    (goto-char (point-min))
+    (insert s)))
+
+(defun zone-shift-left ()
+  (while (not (eobp))
+    (or (eolp)
+	(let ((c (following-char)))
+	  (delete-char 1)
+	  (end-of-line)
+	  (insert c)))
+    (forward-line 1)))
+
+(defun zone-shift-right ()
+  (while (not (eobp))
+    (end-of-line)
+    (or (bolp)
+	(let ((c (preceding-char)))
+	  (delete-backward-char 1)
+	  (beginning-of-line)
+	  (insert c)))
+    (forward-line 1)))
+
+(defun zone-pgm-jitter ()
+  (let ((ops [
+              zone-shift-left
+              zone-shift-left
+              zone-shift-left
+              zone-shift-left
+              zone-shift-right
+              zone-shift-down
+              zone-shift-down
+              zone-shift-down
+              zone-shift-down
+              zone-shift-down
+              zone-shift-up
+              ]))
+    (goto-char (point-min))
+    (while (not (input-pending-p))
+      (funcall (elt ops (random (length ops))))
+      (goto-char (point-min))
+      (sit-for 0 10))))
+
+
+;;;; zone-pgm-whack-chars
+
+(defvar zone-wc-tbl
+  (let ((tbl (make-string 128 ?x))
+	(i 0))
+    (while (< i 128)
+      (aset tbl i i)
+      (setq i (1+ i)))
+    tbl))
+
+(defun zone-pgm-whack-chars ()
+  (let ((tbl (copy-sequence zone-wc-tbl)))
+    (while (not (input-pending-p))
+      (let ((i 48))
+	(while (< i 122)
+	  (aset tbl i (+ 48 (random (- 123 48))))
+	  (setq i (1+ i)))
+	(translate-region (point-min) (point-max) tbl)
+	(sit-for 0 2)))))
+
+
+;;;; zone-pgm-dissolve
+
+(defun zone-remove-text ()
+  (let ((working t))
+    (while working
+      (setq working nil)
+      (save-excursion
+	(goto-char (point-min))
+	(while (not (eobp))
+	  (if (looking-at "[^(){}\n\t ]")
+	      (let ((n (random 5)))
+		(if (not (= n 0))
+		    (progn
+		      (setq working t)
+		      (forward-char 1))
+		  (delete-char 1)
+		  (insert " ")))
+	    (forward-char 1))))
+      (sit-for 0 2))))
+
+(defun zone-pgm-dissolve ()
+  (zone-remove-text)
+  (zone-pgm-jitter))
+
+
+;;;; zone-pgm-explode
+
+(defun zone-exploding-remove ()
+  (let ((i 0))
+    (while (< i 20)
+      (save-excursion
+	(goto-char (point-min))
+	(while (not (eobp))
+	  (if (looking-at "[^*\n\t ]")
+	      (let ((n (random 5)))
+		(if (not (= n 0))
+		    (forward-char 1))
+		  (insert " ")))
+	    (forward-char 1)))
+      (setq i (1+ i))
+      (sit-for 0 2)))
+  (zone-pgm-jitter))
+
+(defun zone-pgm-explode ()
+  (zone-exploding-remove)
+  (zone-pgm-jitter))
+
+
+;;;; zone-pgm-putz-with-case
+
+;; Faster than `zone-pgm-putz-with-case', but not as good: all
+;; instances of the same letter have the same case, which produces a
+;; less interesting effect than you might imagine.
+(defun zone-pgm-2nd-putz-with-case ()
+  (let ((tbl (make-string 128 ?x))
+	(i 0))
+    (while (< i 128)
+      (aset tbl i i)
+      (setq i (1+ i)))
+    (while (not (input-pending-p))
+      (setq i ?a)
+      (while (<= i ?z)
+	(aset tbl i
+	      (if (zerop (random 5))
+		  (upcase i)
+		(downcase i)))
+	(setq i (+ i (1+ (random 5)))))
+      (setq i ?A)
+      (while (<= i ?z)
+	(aset tbl i
+	      (if (zerop (random 5))
+		  (downcase i)
+		(upcase i)))
+	(setq i (+ i (1+ (random 5)))))
+      (translate-region (point-min) (point-max) tbl)
+      (sit-for 0 2))))
+
+(defun zone-pgm-putz-with-case ()
+  (goto-char (point-min))
+  (while (not (input-pending-p))
+    (let ((np (+ 2 (random 5)))
+	  (pm (point-max)))
+      (while (< np pm)
+	(goto-char np)
+        (let ((prec (preceding-char))
+              (props (text-properties-at (1- (point)))))
+          (insert (if (zerop (random 2))
+                      (upcase prec)
+                    (downcase prec)))
+          (set-text-properties (1- (point)) (point) props))
+	(backward-char 2)
+	(delete-char 1)
+	(setq np (+ np (1+ (random 5))))))
+    (goto-char (point-min))
+    (sit-for 0 2)))
+
+
+;;;; zone-pgm-rotate
+
+(defun zone-line-specs ()
+  (let (ret)
+    (save-excursion
+      (goto-char (window-start))
+      (while (< (point) (window-end))
+	(when (looking-at "[\t ]*\\([^\n]+\\)")
+	  (setq ret (cons (cons (match-beginning 1) (match-end 1)) ret)))
+	(forward-line 1)))
+    ret))
+
+(defun zone-pgm-rotate (&optional random-style)
+  (let* ((specs (apply
+		 'vector
+                 (let (res)
+                   (mapcar (lambda (ent)
+                             (let* ((beg (car ent))
+                                    (end (cdr ent))
+                                    (amt (if random-style
+                                             (funcall random-style)
+                                           (- (random 7) 3))))
+                               (when (< (- end (abs amt)) beg)
+                                 (setq amt (random (- end beg))))
+                               (unless (= 0 amt)
+                                 (setq res
+                                       (cons
+                                        (vector amt beg (- end (abs amt)))
+                                        res)))))
+                           (zone-line-specs))
+                   res)))
+	 (n (length specs))
+	 amt aamt cut paste txt i ent)
+    (while (not (input-pending-p))
+      (setq i 0)
+      (while (< i n)
+	(setq ent (aref specs i))
+	(setq amt (aref ent 0) aamt (abs amt))
+	(if (> 0 amt)
+	    (setq cut 1 paste 2)
+	  (setq cut 2 paste 1))
+	(goto-char (aref ent cut))
+	(setq txt (buffer-substring (point) (+ (point) aamt)))
+	(delete-char aamt)
+	(goto-char (aref ent paste))
+	(insert txt)
+	(setq i (1+ i)))
+      (sit-for 0.04))))
+
+(defun zone-pgm-rotate-LR-lockstep ()
+  (zone-pgm-rotate (lambda () 1)))
+
+(defun zone-pgm-rotate-RL-lockstep ()
+  (zone-pgm-rotate (lambda () -1)))
+
+(defun zone-pgm-rotate-LR-variable ()
+  (zone-pgm-rotate (lambda () (1+ (random 3)))))
+
+(defun zone-pgm-rotate-RL-variable ()
+  (zone-pgm-rotate (lambda () (1- (- (random 3))))))
+
+
+;;;; zone-pgm-drip
+
+(defun zone-cpos (pos)
+  (buffer-substring pos (1+ pos)))
+
+(defun zone-fret (pos)
+  (let* ((case-fold-search nil)
+         (c-string (zone-cpos pos))
+         (hmm (cond
+               ((string-match "[a-z]" c-string) (upcase c-string))
+               ((string-match "[A-Z]" c-string) (downcase c-string))
+               (t " "))))
+    (do ((i 0 (1+ i))
+         (wait 0.5 (* wait 0.8)))
+        ((= i 20))
+      (goto-char pos)
+      (delete-char 1)
+      (insert (if (= 0 (% i 2)) hmm c-string))
+      (sit-for wait))
+    (delete-char -1) (insert c-string)))
+
+(defun zone-fall-through-ws (c col wend)
+  (let ((fall-p nil)                    ; todo: move outward
+        (wait 0.15)
+        (o (point))                     ; for terminals w/o cursor hiding
+        (p (point)))
+    (while (progn
+             (forward-line 1)
+             (move-to-column col)
+             (looking-at " "))
+      (setq fall-p t)
+      (delete-char 1)
+      (insert (if (< (point) wend) c " "))
+      (save-excursion
+        (goto-char p)
+        (delete-char 1)
+        (insert " ")
+        (goto-char o)
+        (sit-for (setq wait (* wait 0.8))))
+      (setq p (1- (point))))
+    fall-p))
+
+(defun zone-pgm-drip (&optional fret-p pancake-p)
+  (let* ((ww (1- (window-width)))
+         (wh (window-height))
+         (mc 0)                         ; miss count
+         (total (* ww wh))
+         (fall-p nil))
+    (goto-char (point-min))
+    ;; fill out rectangular ws block
+    (while (not (eobp))
+      (end-of-line)
+      (let ((cc (current-column)))
+        (if (< cc ww)
+            (insert (make-string (- ww cc) ? ))
+          (delete-char (- ww cc))))
+      (unless (eobp)
+        (forward-char 1)))
+    ;; what the hell is going on here?
+    (let ((nl (- wh (count-lines (point-min) (point)))))
+      (when (> nl 0)
+        (let ((line (concat (make-string (1- ww) ? ) "\n")))
+          (do ((i 0 (1+ i)))
+              ((= i nl))
+            (insert line)))))
+    ;;
+    (catch 'done			; ugh
+      (while (not (input-pending-p))
+        (goto-char (point-min))
+        (sit-for 0)
+        (let ((wbeg (window-start))
+              (wend (window-end)))
+          (setq mc 0)
+          ;; select non-ws character, but don't miss too much
+          (goto-char (+ wbeg (random (- wend wbeg))))
+          (while (looking-at "[ \n\f]")
+            (if (= total (setq mc (1+ mc)))
+                (throw 'done 'sel)
+              (goto-char (+ wbeg (random (- wend wbeg))))))
+          ;; character animation sequence
+          (let ((p (point)))
+            (when fret-p (zone-fret p))
+            (goto-char p)
+            (setq fall-p (zone-fall-through-ws
+                          (zone-cpos p) (current-column) wend))))
+        ;; assuming current-column has not changed...
+        (when (and pancake-p
+                   fall-p
+                   (< (count-lines (point-min) (point))
+                      wh))
+          (previous-line 1)
+          (forward-char 1)
+          (sit-for 0.137)
+          (delete-char -1)
+          (insert "@")
+          (sit-for 0.137)
+          (delete-char -1)
+          (insert "*")
+          (sit-for 0.137)
+          (delete-char -1)
+          (insert "_"))))))
+
+(defun zone-pgm-drip-fretfully ()
+  (zone-pgm-drip t))
+
+(defun zone-pgm-five-oclock-swan-dive ()
+  (zone-pgm-drip nil t))
+
+(defun zone-pgm-martini-swan-dive ()
+  (zone-pgm-drip t t))
+
+
+;;;; zone-pgm-paragraph-spaz
+
+(defun zone-pgm-paragraph-spaz ()
+  (if (memq (zone-orig major-mode) '(text-mode fundamental-mode))
+      (let ((fill-column fill-column)
+            (fc-min fill-column)
+            (fc-max fill-column)
+            (max-fc (1- (frame-width))))
+        (while (sit-for 0.1)
+          (fill-paragraph 1)
+          (setq fill-column (+ fill-column (- (random 5) 2)))
+          (when (< fill-column fc-min)
+            (setq fc-min fill-column))
+          (when (> fill-column max-fc)
+            (setq fill-column max-fc))
+          (when (> fill-column fc-max)
+            (setq fc-max fill-column))))
+    (message "Zoning... (zone-pgm-rotate)")
+    (zone-pgm-rotate)))
+
+
+;;;; zone-pgm-stress
+
+(defun zone-pgm-stress ()
+  (goto-char (point-min))
+  (let (lines bg m-fg m-bg)
+    (while (< (point) (point-max))
+      (let ((p (point)))
+        (forward-line 1)
+        (setq lines (cons (buffer-substring p (point)) lines))))
+    (sit-for 5)
+    (when window-system
+      (setq bg (frame-parameter (selected-frame) 'background-color)
+            m-fg (face-foreground 'modeline)
+            m-bg (face-background 'modeline))
+      (set-face-foreground 'modeline bg)
+      (set-face-background 'modeline bg))
+    (let ((msg "Zoning... (zone-pgm-stress)"))
+      (while (not (string= msg ""))
+        (message (setq msg (substring msg 1)))
+        (sit-for 0.05)))
+    (while (not (input-pending-p))
+      (when (< 50 (random 100))
+        (goto-char (point-max))
+        (forward-line -1)
+        (let ((kill-whole-line t))
+          (kill-line))
+        (goto-char (point-min))
+        (insert (nth (random (length lines)) lines)))
+      (message (concat (make-string (random (- (frame-width) 5)) ? ) "grrr"))
+      (sit-for 0.1))
+    (when window-system
+      (set-face-foreground 'modeline m-fg)
+      (set-face-background 'modeline m-bg))))
+
+(provide 'zone)
+
+;;; zone.el ends here
+