(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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"))
(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")
(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")
(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")
(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")
(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")
(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")
(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)
--- /dev/null
+;;; 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
+
+
;;;***
\f
;;;### (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" "\
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)
;;;***
\f
;;;### (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" "\
;;;***
\f
;;;### (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) "\
;;;***
\f
-;;;### (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" "\
(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)
+
;;;***
\f
;;;### (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)
;;;### (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 "\
;;;***
\f
;;;### (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" "\
(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)
;;;***
\f
-;;;### (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" "\
\f
;;;### (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" "\
;;;***
\f
;;;### (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 "\
;;;***
\f
;;;### (autoloads (display-battery battery) "battery" "battery.el"
-;;;;;; (14422 6418))
+;;;;;; (14693 50816))
;;; Generated autoloads from battery.el
(autoload (quote battery) "battery" "\
;;;***
\f
-;;;### (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 "\
\f
;;;### (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)
;;;***
\f
;;;### (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" "\
;;;***
\f
-;;;### (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))) "\
;;;***
\f
;;;### (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)
\f
;;;### (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" "\
\f
;;;### (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" "\
;;;### (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 "\
;;;***
\f
;;;### (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 "\
;;;### (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))) "\
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.
;;;***
\f
;;;### (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" "\
;;;***
\f
;;;### (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" "\
;;;;;; 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.*\\*\\'")
;;;***
\f
;;;### (autoloads (dabbrev-expand dabbrev-completion) "dabbrev" "dabbrev.el"
-;;;;;; (14642 37753))
+;;;;;; (14688 20006))
;;; Generated autoloads from dabbrev.el
(define-key esc-map "/" (quote dabbrev-expand))
;;;;;; 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" "\
;;;***
\f
-;;;### (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
;;;;;; 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" "\
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)
+
;;;***
\f
;;;### (autoloads (dired-jump) "dired-x" "dired-x.el" (14523 40402))
;;;;;; 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" "\
(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.
\f
;;;### (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))
;;;***
\f
;;;### (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" "\
: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.
INCLUDE is an expression; this item is only visible if this
expression has a non-nil value.
- :suffix NAME
+ :suffix FORM
-NAME is a string; the name of an argument to CALLBACK.
+FORM is an expression that will be dynamically evaluated and whose
+value will be concatenated to the menu entry's NAME.
:style STYLE
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.
;;;;;; 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" "\
\f
;;;### (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" "\
(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.
;;;***
\f
;;;### (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 "\
;;;***
\f
-;;;### (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 "\
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.
;;;;;; 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"))
;;;***
\f
;;;### (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" "\
(autoload (quote enriched-decode) "enriched" nil nil nil)
+;;;***
+\f
+;;;### (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)
+
+;;;***
+\f
+;;;### (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)
+
+;;;***
+\f
+;;;### (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)
+
;;;***
\f
;;;### (autoloads (complete-tag select-tags-table tags-apropos list-tags
;;;;;; 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 "\
;;;***
\f
-;;;### (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',
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)
+
;;;***
\f
;;;### (autoloads (expand-jump-to-next-slot expand-jump-to-previous-slot
;;;;;; 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)
(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)
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
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
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.
;;;***
\f
;;;### (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"))) "\
;;;***
\f
-;;;### (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.
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)
;;;### (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 "\
;;;***
\f
;;;### (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 "\
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'
;;;***
\f
;;;### (autoloads (glasses-mode) "glasses" "progmodes/glasses.el"
-;;;;;; (14609 53573))
+;;;;;; (14724 3308))
;;; Generated autoloads from progmodes/glasses.el
(autoload (quote glasses-mode) "glasses" "\
;;;***
\f
-;;;### (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" "\
;;;***
\f
;;;### (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" "\
Convert a binary buffer to hexl format.
This discards the buffer's undo information." t nil)
+;;;***
+\f
+;;;### (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)
+
;;;***
\f
;;;### (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 "\
;;;***
\f
;;;### (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 "\
;;;### (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)
;;;***
\f
-;;;### (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.
;;;***
\f
;;;### (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" "\
;;;***
\f
;;;### (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" "\
;;;***
\f
;;;### (autoloads (idlwave-mode) "idlwave" "progmodes/idlwave.el"
-;;;;;; (14495 18054))
+;;;;;; (14671 47574))
;;; Generated autoloads from progmodes/idlwave.el
(autoload (quote idlwave-mode) "idlwave" "\
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).
+ 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.
-3. Completion
+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.
+ \\[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.
-4. Code Templates and Abbreviations
+5. Code Templates and Abbreviations
--------------------------------
Many Abbreviations are predefined to expand to code fragments and templates.
The abbreviations start generally with a `\\`. Some examples
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).
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]
\f
;;;### (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" "\
;;;***
\f
;;;### (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 "\
(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.
\f
;;;### (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" "\
(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)
\f
;;;### (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" "\
\f
;;;### (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" "\
;;;***
\f
;;;### (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)
;;;***
\f
-;;;### (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) "\
(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.
\f
;;;### (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" "\
;;;### (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)
;;;***
\f
-;;;### (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
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)
;;;***
\f
;;;***
\f
-;;;### (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.
;;;***
\f
;;;### (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))
;;;***
\f
;;;### (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") "\
;;;***
\f
-;;;### (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" "\
\f
;;;### (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" "\
\f
;;;### (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 "\
;;;***
\f
;;;### (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" "\
;;;***
\f
-;;;### (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))
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)
;;;***
\f
;;;### (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" "\
;;;***
\f
;;;### (autoloads (convert-mocklisp-buffer) "mlconvert" "emulation/mlconvert.el"
-;;;;;; (12536 45574))
+;;;;;; (14660 49410))
;;; Generated autoloads from emulation/mlconvert.el
(autoload (quote convert-mocklisp-buffer) "mlconvert" "\
;;;;;; 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" "\
;;;### (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" "\
;;;### (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))
(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.
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" "\
;;;***
\f
;;;### (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" "\
;;;***
\f
-;;;### (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)
+
+;;;***
+\f
+;;;### (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))
+
+;;;***
+\f
+;;;### (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)
+
+;;;***
+\f
+;;;### (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)
+
+;;;***
+\f
+;;;### (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)
+
+;;;***
+\f
+;;;### (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)
+
+;;;***
+\f
+;;;### (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" "\
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.
(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.
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))))))
+(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)))))
;;;***
\f
-;;;### (autoloads nil "pcvs-defs" "pcvs-defs.el" (14552 48685))
+;;;### (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))
;;;***
\f
-;;;### (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" "\
;;;### (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 "\
;;;;;; 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) "\
;;;### (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" "\
;;;***
\f
-;;;### (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)
(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)
+
;;;***
\f
;;;### (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" "\
;;;***
\f
;;;### (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" "\
;;;***
\f
;;;### (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" "\
;;;***
\f
;;;### (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" "\
;;;;;; 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 "\
;;;***
\f
;;;### (autoloads (news-post-news) "rnewspost" "mail/rnewspost.el"
-;;;;;; (14263 36299))
+;;;;;; (14660 49436))
;;; Generated autoloads from mail/rnewspost.el
(autoload (quote news-post-news) "rnewspost" "\
;;;;;; 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) "\
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'.
;;;***
\f
-;;;### (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" "\
;;;***
\f
;;;### (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))
;;;***
\f
-;;;### (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" "\
;;;***
\f
-;;;### (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" "\
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
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.
;;;### (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 "\
;;;***
\f
-;;;### (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" "\
;;;***
\f
-;;;### (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" "\
;;;***
\f
-;;;### (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" "\
\f
;;;### (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" "\
;;;;;; 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" "\
;;;***
\f
;;;### (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 "\
\f
;;;### (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))
(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.
-SECS may be an integer or a floating point number.
The action is to call FUNCTION with arguments ARGS.
+SECS may be an integer or a floating point number.
+
+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)
;;;***
\f
-;;;### (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.
-(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
-between each category.
+Number of entries for each category is given by NOF-PRIORITIES which
+defaults to 'todo-show-priorities'.
-Number of entries for each category is given by
-'todo-print-priorities'." t nil)
+If CATEGORY-PR-PAGE is non-nil, a page separator '^L' is inserted
+between each category." t nil)
-(autoload (quote todo-mode) "todo-mode" "\
-Major mode for editing TODO lists.
+(autoload (quote todo-save-top-priorities) "todo-mode" "\
+Save top priorities for each category in `todo-file-top'.
-\\{todo-mode-map}" t nil)
+Number of entries for each category is given by NOF-PRIORITIES which
+defaults to `todo-show-priorities'." 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-print) "todo-mode" "\
+Print todo summary using `todo-print-function'.
+If CATEGORY-PR-PAGE is non-nil, a page separator `^L' is inserted
+between each category.
-(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)
;;;***
\f
;;;### (autoloads (tooltip-mode tooltip-mode) "tooltip" "tooltip.el"
-;;;;;; (14495 17998))
+;;;;;; (14720 1500))
;;; Generated autoloads from tooltip.el
(autoload (quote tooltip-mode) "tooltip" "\
;;;### (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 "\
;;;***
\f
;;;### (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" "\
;;;***
\f
;;;### (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" "\
(autoload (quote psychoanalyze-pinhead) "yow" "\
Zippy goes to the analyst." t nil)
+;;;***
+\f
+;;;### (autoloads (zone) "zone" "play/zone.el" (14728 34415))
+;;; Generated autoloads from play/zone.el
+
+(autoload (quote zone) "zone" "\
+Zone out, completely." t nil)
+
;;;***
\f
;;;### (autoloads (zone-mode zone-mode-update-serial-hook) "zone-mode"
projects / emacs.git / commitdiff