tiny-tools
authorJoerg Jaspert <joerg@debian.org>
Sun, 3 Mar 2013 13:37:32 +0000 (14:37 +0100)
committerJoerg Jaspert <joerg@debian.org>
Sun, 3 Mar 2013 13:37:32 +0000 (14:37 +0100)
58 files changed:
elisp/tiny/load-path.el [new file with mode: 0644]
elisp/tiny/loaddefs.el [new file with mode: 0644]
elisp/tiny/tiny-admin-util.el [new file with mode: 0644]
elisp/tiny/tiny-setup.el [new file with mode: 0644]
elisp/tiny/tinyadvice.el [new file with mode: 0644]
elisp/tiny/tinybookmark.el [new file with mode: 0644]
elisp/tiny/tinybuffer.el [new file with mode: 0644]
elisp/tiny/tinycache.el [new file with mode: 0644]
elisp/tiny/tinycomment.el [new file with mode: 0644]
elisp/tiny/tinycompile.el [new file with mode: 0644]
elisp/tiny/tinycygwin.el [new file with mode: 0644]
elisp/tiny/tinydebian.el [new file with mode: 0644]
elisp/tiny/tinydiff.el [new file with mode: 0644]
elisp/tiny/tinydired.el [new file with mode: 0644]
elisp/tiny/tinyeat.el [new file with mode: 0644]
elisp/tiny/tinyef.el [new file with mode: 0644]
elisp/tiny/tinygnus.el [new file with mode: 0644]
elisp/tiny/tinyhotlist.el [new file with mode: 0644]
elisp/tiny/tinyigrep.el [new file with mode: 0644]
elisp/tiny/tinyindent.el [new file with mode: 0644]
elisp/tiny/tinyirc.el [new file with mode: 0644]
elisp/tiny/tinylib.el [new file with mode: 0644]
elisp/tiny/tinyliba.el [new file with mode: 0644]
elisp/tiny/tinylibb.el [new file with mode: 0644]
elisp/tiny/tinylibenv.el [new file with mode: 0644]
elisp/tiny/tinylibid.el [new file with mode: 0644]
elisp/tiny/tinylibm.el [new file with mode: 0644]
elisp/tiny/tinylibmail.el [new file with mode: 0644]
elisp/tiny/tinylibmenu.el [new file with mode: 0644]
elisp/tiny/tinylibo.el [new file with mode: 0644]
elisp/tiny/tinylibt.el [new file with mode: 0644]
elisp/tiny/tinylibw.el [new file with mode: 0644]
elisp/tiny/tinyliby.el [new file with mode: 0644]
elisp/tiny/tinylisp.el [new file with mode: 0644]
elisp/tiny/tinyload.el [new file with mode: 0644]
elisp/tiny/tinylock.el [new file with mode: 0644]
elisp/tiny/tinylpr.el [new file with mode: 0644]
elisp/tiny/tinymacro.el [new file with mode: 0644]
elisp/tiny/tinymail.el [new file with mode: 0644]
elisp/tiny/tinymailbox.el [new file with mode: 0644]
elisp/tiny/tinymy.el [new file with mode: 0644]
elisp/tiny/tinynbr.el [new file with mode: 0644]
elisp/tiny/tinypad.el [new file with mode: 0644]
elisp/tiny/tinypage.el [new file with mode: 0644]
elisp/tiny/tinypair.el [new file with mode: 0644]
elisp/tiny/tinypath.el [new file with mode: 0644]
elisp/tiny/tinyperl.el [new file with mode: 0644]
elisp/tiny/tinyprocmail.el [new file with mode: 0644]
elisp/tiny/tinyreplace.el [new file with mode: 0644]
elisp/tiny/tinyscroll.el [new file with mode: 0644]
elisp/tiny/tinysearch.el [new file with mode: 0644]
elisp/tiny/tinytab.el [new file with mode: 0644]
elisp/tiny/tinytag.el [new file with mode: 0644]
elisp/tiny/tinytf.el [new file with mode: 0644]
elisp/tiny/tinyurl.el [new file with mode: 0644]
elisp/tiny/tinyvc.el [new file with mode: 0644]
elisp/tiny/tinyxreg.el [new file with mode: 0644]
elisp/tiny/update-autoloads.el [new file with mode: 0644]

diff --git a/elisp/tiny/load-path.el b/elisp/tiny/load-path.el
new file mode 100644 (file)
index 0000000..396bd9a
--- /dev/null
@@ -0,0 +1,140 @@
+;;; load-path.el --- Used for compiling Emacs lisp files
+
+;;; Commentary:
+
+;;
+;;  File id
+;;
+;;      Copyright (C) 1997-2012 Jari Aalto
+;;
+;;      This program 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 of
+;;      the License, or (at your option) any later version.
+;;
+;;      This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+;;
+;;      Visit <http://www.gnu.org/copyleft/gpl.html> for more information
+;;
+;;  Description
+;;
+;;      This file part of the Tiny Tools Kit for Emacs: collection of
+;;      various utilities.
+;;
+;;      Before compiling, this file is included via -l FILE switch and it
+;;      defines correct load path in order to find the files that are needed
+;;      in compilation. If your private directory is not in ~/elisp or
+;;      ~/lisp then add new path to the place shown below.
+
+;;; Code:
+
+(require 'cl)
+(setq debug-on-error nil) ;; Must be like this in batch byte compile
+
+(autoload 'ti::package-autoload-create-on-file            "tinylib")
+(autoload 'ti::package-autoload-loaddefs-build-recursive  "tinylib")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;
+;;      PLEASE CONFIFURE THIS `dolist' to include paths in your system
+;;
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(dolist (path
+         '(
+
+           "~/var/link/emacs"
+
+           ;; Define any new path HERE. It won't matter if you
+           ;; define non-exiting paths, they are stripped away.
+           ;;
+           ;;  some users prefer the directory called ~/lisp istead of
+           ;;  ~/elisp (Emacs Lisp)
+
+           "~/elisp"
+           "~/lisp"
+
+           ;;  Unix: Posisbly the best is to have
+           ;;  this directory to be a symbolic link to latest distribution
+           ;;
+           ;;  Windows: Symbolic links don't work, change this to the absolute
+           ;;  path of the kit location directories.
+
+           "~/elisp/tiny"
+           "~/elisp/tiny/lisp"
+           "~/elisp/tiny/lisp/tiny"
+           "~/elisp/tiny/lisp/other"
+
+           ;;  Any other directories that you have in you ~/elips or
+
+           "/usr/share/site-lisp"
+           "/usr/share/site-lisp/net"
+
+           ;; The best way to keep up with the development is to
+           ;; use CVS. See BBDB and Gnus sites for CVS.
+
+           "/usr/share/site-lisp/net/cvs-packages"
+           "/usr/share/site-lisp/net/cvs-packages/bbdb/lisp"
+           "/usr/share/site-lisp/net/cvs-packages/gnus/lisp"
+
+           ;;  Any other directories that you have in you ~/elips or
+           ;;  site wide /usr/share/site-lisp or under /opt hierarchy
+
+           "~/elisp/other"
+           "~/elisp/bbdb/lisp"        ;usually symbolic link to latest
+           "~/elisp/rc"
+           "."
+           ".."
+           "../other"
+           "../.."))
+  (when (file-exists-p path)
+    (pushnew (expand-file-name path) load-path :test 'string=)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;
+;;      LOAD PATH self-check
+;;
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-tmp-load-path-print (&optional function eval)
+  "Print `load-path' using `function'.
+Default is `message'. Eval optional EVAL."
+  (let ((i 0))
+    (if eval
+        (eval eval))
+    (dolist (path load-path)
+      (if function
+          (funcall function "  %d %s" i path)
+        (message "  %d %s" i path))
+      (incf i))))
+
+(eval-and-compile
+  ;;  Remove comment if you want to  see the load path
+  ;;  before compiling starts. The printed path (order) may give a clue
+  ;;  why compile might have failed.
+
+  ;; (tiny-tmp-load-path-print)
+
+  ;;  Check that load-path is in order
+  (let ((path (locate-library "tinylibm")))
+    (if path
+        nil ;; (message "FOUND: %s" path)
+      (tiny-tmp-load-path-print)
+      (message
+       "\
+  **  Can't find library [tinylibm]. Please update
+      file [load-path.el] which sets up load-path for compilation purposes."))))
+
+;;; load-path.el ends here
diff --git a/elisp/tiny/loaddefs.el b/elisp/tiny/loaddefs.el
new file mode 100644 (file)
index 0000000..d30e253
--- /dev/null
@@ -0,0 +1,2244 @@
+;;
+\f
+;;;### (autoloads nil "tinyadvice" "tinyadvice.el" (20371 6115))
+;;; Generated autoloads from tinyadvice.el
+ (autoload 'tinyadvice-version "tinyadvice" "Display commentary." t)
+
+;;;***
+\f
+;;;### (autoloads (tinybookmark-mouse tinybookmark-keyboard tinybookmark-mouse-parse
+;;;;;;  tinybookmark-keyboard-parse tinybookmark-parse tinybookmark-insert
+;;;;;;  tinybookmark-repeat tinybookmark-forward tinybookmark-backward)
+;;;;;;  "tinybookmark" "tinybookmark.el" (20371 6115))
+;;; Generated autoloads from tinybookmark.el
+
+(autoload 'tinybookmark-backward "tinybookmark" "\
+Search book mark line backward.
+
+\(fn)" t nil)
+
+(autoload 'tinybookmark-forward "tinybookmark" "\
+Search book mark line forward or optionally BACK.
+
+\(fn &optional BACK)" t nil)
+
+(autoload 'tinybookmark-repeat "tinybookmark" "\
+Repeats character or string sequence STR COUNT times.
+
+COUNT can be:
+
+  0       repeat until position 79 or COL , or if the STR is not single
+          character, until fits below COL
+  \"\"    interactive insert, as long as user presses RET or SPACE.
+
+STRICT has effect only if COL is given:
+
+  nil     insert as long as STR fits below COL
+  t       insert strictly up till COL and cut away portion
+          of STR if necessary
+
+\(fn STR COUNT &optional COL STRICT)" t nil)
+
+(autoload 'tinybookmark-insert "tinybookmark" "\
+Add book mark until the end of line.
+Normally line is filled as long as the pattern fits below max column,
+but if the optional argument is given, it will be filled in full ,
+truncating if necessary. To see an example, try with some long
+pattern.
+
+Input:
+
+  TXT       book mark name
+  SEP       separator string that is repeated.
+  STRICT
+            0       strict is nil in spite of `tinybookmark--insert-strict'
+            1       strict is t   in spite of `tinybookmark--insert-strict'
+            nil     use default value in `tinybookmark--insert-strict'
+
+References:
+
+  `tinybookmark--insert-strict'
+
+\(fn TXT SEP &optional STRICT)" t nil)
+
+(autoload 'tinybookmark-parse "tinybookmark" "\
+Build book mark list and save it to cache.
+
+Return:
+
+  t     cache was built.
+  nil   book marks not found or error happened. Cache untouched.
+
+\(fn)" t nil)
+
+(autoload 'tinybookmark-keyboard-parse "tinybookmark" "\
+Reparse book marks.
+
+\(fn)" nil nil)
+
+(autoload 'tinybookmark-mouse-parse "tinybookmark" "\
+Reparse book mark list. This function is called from mouse binding.
+Called with mouse EVENT. VERB displays message.
+
+\(fn &optional EVENT VERB)" t nil)
+
+(autoload 'tinybookmark-keyboard "tinybookmark" "\
+Complete and jump to bookmarks.
+Optional ARG rebuilds cache.
+
+\(fn BOOKMARK &optional ARG)" t nil)
+
+(autoload 'tinybookmark-mouse "tinybookmark" "\
+Display book mark pop up menu. Use mouse EVENT.
+Optional ARG rebuilds cache.
+
+\(fn EVENT &optional ARG)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinybuffer-next-buffer tinybuffer-previous-buffer
+;;;;;;  tinybuffer-iswitch-to-buffer) "tinybuffer" "tinybuffer.el"
+;;;;;;  (20371 6115))
+;;; Generated autoloads from tinybuffer.el
+
+(autoload 'tinybuffer-iswitch-to-buffer "tinybuffer" "\
+Switch to buffer when RETURN/SPACE/TAB pressed.
+Show buffer at echo area. ESC to cancel prompt.
+
+Note:
+
+  The startup time of calling this function may be high, because it has
+  to build list of choices and possibly filter out unwanted buffers.
+
+References:
+
+  `tinybuffer--iswitch-to-buffer-keys'    keys to scroll buffer list
+
+\(fn)" t nil)
+
+(autoload 'tinybuffer-previous-buffer "tinybuffer" "\
+Switch to previous buffer in current window.
+
+\(fn)" t nil)
+
+(autoload 'tinybuffer-next-buffer "tinybuffer" "\
+Switch to the other buffer (2nd in list-buffer) in current window.
+
+\(fn)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinycache-flush tinycache-flush-all-compilation
+;;;;;;  tinycache-mode tinycache-buffer-list-mark-cache-off tinycache-buffer-list-mark-deleted
+;;;;;;  tinycache-buffer-list-unmark tinycache-buffer-list-mark)
+;;;;;;  "tinycache" "tinycache.el" (20371 6115))
+;;; Generated autoloads from tinycache.el
+
+(autoload 'tinycache-buffer-list-mark "tinycache" "\
+Mark Cached files in buffer list.
+
+\(fn)" t nil)
+
+(autoload 'tinycache-buffer-list-unmark "tinycache" "\
+Mark Cached files in buffer list.
+
+\(fn)" t nil)
+
+(autoload 'tinycache-buffer-list-mark-deleted "tinycache" "\
+Mark Cached files in buffer list.
+
+\(fn)" t nil)
+
+(autoload 'tinycache-buffer-list-mark-cache-off "tinycache" "\
+Mark files whose cache property has been turned off.
+
+\(fn)" t nil)
+
+(autoload 'tinycache-mode "tinycache" "\
+Toggle cache flag for this buffer with ARG.
+If the file does not belong to compile cache, calling this function
+does nothing. If the file is in the cache, the mode line displays mode name.
+
+Removing the file from cache means that the file is not killed when
+the cache is flushed with \\[tinycache-flush].
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'tinycache-flush-all-compilation "tinycache" "\
+Kill all cached files by stepping through all compilation buffers. VERB.
+
+\(fn &optional VERB)" t nil)
+
+(autoload 'tinycache-flush "tinycache" "\
+Kill buffers listed in `tinycache--cache'. VERB.
+You must be in the Compilation/Dired buffer to execute this command.
+
+If you're not in dired buffer, function tries to find compilation
+buffer and kill compilation cached files.
+
+\(fn &optional VERB)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinycomment-indent-for-comment) "tinycomment"
+;;;;;;  "tinycomment.el" (20371 6115))
+;;; Generated autoloads from tinycomment.el
+
+(autoload 'tinycomment-indent-for-comment "tinycomment" "\
+Alternative to standard `indent-for-comment'.
+Relies on file extension
+and doesn't need specific mode to be turned on. Temporary buffers
+that has no file name cannot be identified by this function, so
+it passes control directly to mode. There is a chance you might not
+even notice that this function is working on the background.
+
+Verbose warnings are enabled by `tinycomment--comment-notify'
+Special cases are handled by tinycomment--comment-extra* variables
+Version info is on \\[tinycomment-version].
+
+\(fn)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "tinycompile" "tinycompile.el" (20371 6115))
+;;; Generated autoloads from tinycompile.el
+ (autoload 'turn-on-tinycompile-mode      "tinycompile" "" t)
+ (autoload 'turn-off-tinycompile-mode     "tinycompile" "" t)
+ (autoload 'tinycompile-mode              "tinycompile" "" t)
+ (autoload 'tinycompile-commentary        "tinycompile" "" t)
+
+;;;***
+\f
+;;;### (autoloads (tinycygwin-bug-report-batch tinycygwin-reportbug
+;;;;;;  tinycygwin-package-readme-find-file tinycygwin-package-info-port-maintainer-list
+;;;;;;  tinycygwin-turn-on-emacs-debug tinycygwin-update-file-autoloads-batch
+;;;;;;  tinycygwin-install) "tinycygwin" "tinycygwin.el" (20371 6115))
+;;; Generated autoloads from tinycygwin.el
+
+(autoload 'tinycygwin-install "tinycygwin" "\
+Install or optionally UNINSTALL (i.e. inactivate) this lisp package.
+
+\(fn &optional UNINSTALL)" t nil)
+
+(autoload 'tinycygwin-update-file-autoloads-batch "tinycygwin" "\
+Update autoloads in batch mode. Argument in command line is DIR. FORCE.
+
+\(fn &optional DIR FORCE)" t nil)
+
+(autoload 'tinycygwin-turn-on-emacs-debug "tinycygwin" "\
+Activate Emacs debug.
+
+\(fn)" t nil)
+
+(autoload 'tinycygwin-package-info-port-maintainer-list "tinycygwin" "\
+Generate list of all packages and their maintainers. Optionally DISPLAY.
+
+\(fn &optional DISPLAY)" t nil)
+
+(autoload 'tinycygwin-package-readme-find-file "tinycygwin" "\
+Open PACKAGE*.README.
+
+\(fn PACKAGE)" t nil)
+
+(autoload 'tinycygwin-reportbug "tinycygwin" "\
+Fully interactive Cygwin bug reporting entrance.
+See function `tinycygwin-bug-report-mail-main' which contains more
+detailled description.
+
+\(fn)" t nil)
+
+(autoload 'tinycygwin-bug-report-batch "tinycygwin" "\
+This function is called from external script. DO NOT USE.
+Do not call this from lisp in any circumstances or it will cause
+Emacs to exit.
+
+\(fn &optional PACKAGE)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads (tinydebian-bug-report-generic-bts-mail tinydebian-bug-report-launchpad-mail
+;;;;;;  tinydebian-bug-report-gnu-bts-mail tinydebian-bug-report-debian-bts-mail
+;;;;;;  tinydebian-install-in-buffers) "tinydebian" "tinydebian.el"
+;;;;;;  (20371 6115))
+;;; Generated autoloads from tinydebian.el
+
+(autoload 'tinydebian-install-in-buffers "tinydebian" "\
+Install or UNINSTALL `tinydebiab-bts-mode' in existing buffers.
+Run also `tinydebian-mail-mode-debian-default-keybindings' in all mail buffer.
+See variables:
+   `tinydebian--install-buffer-file-name-regexp'
+   `tinydebian--install-gnus-newsgroup-name-regexp'.
+
+\(fn &optional UNINSTALL)" nil nil)
+
+(autoload 'tinydebian-bug-report-debian-bts-mail "tinydebian" "\
+Submit Debian bug report. INFO is alist of attributes for a package.
+An example ┬┤reportbug(1)' looks like
+
+To: submit@bugs.debian.org
+Subject: autolog ....
+--text follows this line--
+Package: autolog
+Version: 0.35-10
+Severity: wishlist
+
+-- System Information
+Debian Release: 3.0
+  APT prefers testing
+  APT policy: (990, 'testing'), (500, 'unstable'), (1, 'experimental')
+Architecture: i386
+Kernel: Linux foo 2.4.17 #1 Fri Feb 8 21:32:43 EET 2002 i686
+Locale: LANG=en_US, LC_CTYPE=en_US
+
+Versions of packages autolog depends on:
+ii  cron                          3.0pl1-72  management of regular background p
+ii  libc6                         2.2.5-3    GNU C Library: Shared libraries an
+
+\(fn INFO)" t nil)
+
+(autoload 'tinydebian-bug-report-gnu-bts-mail "tinydebian" "\
+Submit GNU bug report to PACKAGE.
+
+\(fn PACKAGE)" t nil)
+
+(autoload 'tinydebian-bug-report-launchpad-mail "tinydebian" "\
+Submit GNU bug report to PACKAGE.
+
+\(fn)" t nil)
+
+(autoload 'tinydebian-bug-report-generic-bts-mail "tinydebian" "\
+Select BTS and submit a bug report.
+This function can only be callaed interactively.
+
+\(fn BTS)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinydiff-diff tinydiff-diff-show-noask tinydiff-diff-show)
+;;;;;;  "tinydiff" "tinydiff.el" (20371 6115))
+;;; Generated autoloads from tinydiff.el
+ (autoload 'tinydiff-mode          "tinydiff" "" t)
+ (autoload 'turn-on-tinydiff-mode  "tinydiff" "" t)
+ (autoload 'turn-off-tinydiff-mode "tinydiff" "" t)
+ (autoload 'tinydiff-commentary    "tinydiff" "" t)
+ (autoload 'tinydiff-debug-toggle "tinydiff" "" t)
+
+(autoload 'tinydiff-diff-show "tinydiff" "\
+Generate diff CMD for the buffer and show it in the other window.
+Lets user to edit option in the command line.
+
+\(fn CMD)" t nil)
+
+(autoload 'tinydiff-diff-show-noask "tinydiff" "\
+Generate diff CMD for the buffer. Guess all parameters.
+
+\(fn CMD)" t nil)
+
+(autoload 'tinydiff-diff "tinydiff" "\
+Run diff on buffer, possibly using rcsdiff if file is version controlled.
+Inserts contents into register.
+
+The version control is determined by searching RCS strings 'Id' or 'Log'
+
+Input:
+
+  CMD           diff command
+  SHOW          show the results
+  NO-ASK        run diff without asking any questions.
+  VERB          enable verbose messages
+
+References:
+
+  `tinydiff--extra-diff-program'
+  `tinydiff--diff-buffer'
+  `tinydiff--diff-options'
+
+Return:
+
+ nil            ,the no-ask parameter could not determine right diff.
+ buffer         ,the shell output buffer. Note, that the diff may have
+                 failed, in that case the buffer does not hold valid output.
+
+\(fn CMD &optional SHOW VERB)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads (tinydired-switch-to-some-ange-ftp-buffer tinydired-kill-all-ange-buffers
+;;;;;;  tinydired-kill-all-ange-and-dired-buffers tinydired-kill-dired-and-ange-session
+;;;;;;  tinydired-load-all-marked-files tinydired-refresh-view tinydired-mark-vc-files-in-Emacs
+;;;;;;  tinydired-mark-today-files tinydired-pop-to-buffer tinydired-leave-only-lines
+;;;;;;  tinydired-kill-lines tinydired-kill-unmarked-lines tinydired-last-file
+;;;;;;  tinydired-first-file tinydired-first-line tinydired-pgdown
+;;;;;;  tinydired-pgup tinydired-marks-restore tinydired-marks-save
+;;;;;;  tinydired-shorten-links tinydired-lenghten-links tinydired-dired-do-shell-command
+;;;;;;  tinydired-one-dir-up tinydired-marked-revert-files tinydired-mark-files-in-Emacs
+;;;;;;  tinydired-read-dir-as-is tinydired-ediff tinydired-hook-control)
+;;;;;;  "tinydired" "tinydired.el" (20371 6115))
+;;; Generated autoloads from tinydired.el
+
+(autoload 'tinydired-hook-control "tinydired" "\
+Add hooks to dired mode. Optional REMOVE all hooks inserted by package.
+
+\(fn &optional REMOVE)" t nil)
+
+(autoload 'tinydired-ediff "tinydired" "\
+Compare file at point with file FILE using `ediff'.
+FILE defaults to the file at the mark.
+The prompted-for file is the first file given to `ediff'.
+With prefix arg, prompt for second argument SWITCHES,
+ which is options for `diff'.
+
+\(fn FILE &optional SWITCHES)" t nil)
+
+(autoload 'tinydired-read-dir-as-is "tinydired" "\
+Read the directory without any filtering.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-mark-files-in-Emacs "tinydired" "\
+Mark all files in current directory that are in Emacs.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-marked-revert-files "tinydired" "\
+Revert ie. replace files in Emacs with true copies in directory.
+If ARG is non-nil, remove any marks if file was loaded.
+
+Exceptions:
+  Only reload files in Emacs whose modify flag is non-nil.
+  If file does not exist in Emacs, do nothing.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'tinydired-one-dir-up "tinydired" "\
+Go up one directory.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-dired-do-shell-command "tinydired" "\
+Like `dired-do-shell-command', but run running command in dired ange-ftp.
+This is not remote shell, but instead it
+transfers the file to your local system and then executes the dired
+command on the file.
+
+Remember: Every time you run this command this files are copied _blindly_
+to your local directory. No file cache information is kept.
+
+Input:
+
+  COMMAND
+  ARG
+
+References:
+
+  `tinydired--tmp-dir'
+
+\(fn COMMAND &optional ARG)" t nil)
+
+(autoload 'tinydired-lenghten-links "tinydired" "\
+Opposite to `tinydired-shorten-links'.
+This may take a while, because the whole directory structure must
+be read again.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-shorten-links "tinydired" "\
+Shortens all linked files. The link part is removed.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-marks-save "tinydired" "\
+Save mark list to private storage.
+Use this function if you know next operation will remove the marks.
+Restore saved marks with `tinydired-marks-restore'.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-marks-restore "tinydired" "\
+Restore mark list saved by `tinydired-marks-save'.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-pgup "tinydired" "\
+Move cursor to last file in dired mode.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-pgdown "tinydired" "\
+Move cursor up.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-first-line "tinydired" "\
+Move to first _line_ in dired.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-first-file "tinydired" "\
+Move to first file in dired.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-last-file "tinydired" "\
+Move to last file in dired.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-kill-unmarked-lines "tinydired" "\
+Remove unmarked lines. Ignore directories and symlinks.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-kill-lines "tinydired" "\
+Delete lines matching RE.
+
+\(fn RE)" t nil)
+
+(autoload 'tinydired-leave-only-lines "tinydired" "\
+Leave only lines matching RE. Directory lines are skipped.
+You can easily undo this with reverting the buffer (dired \"g\").
+
+\(fn RE)" t nil)
+
+(autoload 'tinydired-pop-to-buffer "tinydired" "\
+Pop to buffer if it exists in Emacs.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-mark-today-files "tinydired" "\
+Mark all files, not dirs, that are created today.
+Point sits on first today file. If no today's files are found, point stays
+on current filename.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-mark-vc-files-in-Emacs "tinydired" "\
+Mark all files in the current _view_ that are in Emacs _and_ in VC control.
+Optionally UNMARK. VERB.
+
+\(fn &optional UNMARK VERB)" t nil)
+
+(autoload 'tinydired-refresh-view "tinydired" "\
+Refresh current dired view.
+If you have used `tinydired-leave-only-lines' and have done some changes to
+the files. You can use this function to re-read the current view.
+
+The dired \"g\" will load full view back. This instead caches the
+current view, executes read, and deletes lines that weren't in the
+cache --> you get refreshed view. All this may take a while...
+
+Input:
+
+ VERB       Verbose messages
+
+Return:
+
+ t              if refreshed
+ nil
+
+\(fn &optional VERB)" t nil)
+
+(autoload 'tinydired-load-all-marked-files "tinydired" "\
+Load all marked files into Emacs.
+Does not load files which are already in Emacs.
+If ARG is non-nil, remove mark if file was loaded. VERB.
+
+\(fn &optional ARG VERB)" t nil)
+
+(autoload 'tinydired-kill-dired-and-ange-session "tinydired" "\
+Kill the current dired buffer and possible ange-ftp buffer. VERB.
+This is like `dired-delete-and-exit'.
+
+\(fn &optional VERB)" t nil)
+
+(autoload 'tinydired-kill-all-ange-and-dired-buffers "tinydired" "\
+Kill all ange-ftp buffers _and_ all remote dired buffers. VERB.
+
+\(fn &optional VERB)" t nil)
+
+(autoload 'tinydired-kill-all-ange-buffers "tinydired" "\
+Kill all ange-ftp process buffers.
+If you want to kill one buffer at a time, use
+`tinydired-switch-to-some-ange-ftp-buffer' to switch to individual buffer
+and use \\[kill-buffer] to kill session.
+
+This function is primarily used for cleanups. After a while
+you may end up with many ftp session and it's nice if
+you can get rid of them fast.
+
+Don't worry about the dired buffers, Ange will automatically
+create connection, if you use \"g\" -- rever-buffer, in a dired
+that is associated with ange-ftp.
+
+\(fn)" t nil)
+
+(autoload 'tinydired-switch-to-some-ange-ftp-buffer "tinydired" "\
+Gather all ange FTP buffers and offer completion menu.
+If there is only one Ange buffer, switches to it without asking.
+
+\(fn)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinyeat-eat tinyeat-delete-paragraph tinyeat-kill-buffer-lines-main
+;;;;;;  tinyeat-kill-buffer-lines-point-min tinyeat-kill-buffer-lines-point-max
+;;;;;;  tinyeat-kill-line-backward tinyeat-kill-line tinyeat-delete-whole-word
+;;;;;;  tinyeat-join-lines tinyeat-forward-preserve tinyeat-forward
+;;;;;;  tinyeat-backward-preserve tinyeat-backward tinyeat-zap-line
+;;;;;;  tinyeat-erase-buffer tinyeat-install tinyeat-install-default-bindings)
+;;;;;;  "tinyeat" "tinyeat.el" (20371 6115))
+;;; Generated autoloads from tinyeat.el
+ (autoload 'tinyeat-debug-toggle "tinyeat" "" t)
+ (autoload 'tinyeat-debug-show   "tinyeat" "" t)
+
+(autoload 'tinyeat-install-default-bindings "tinyeat" "\
+Bind default keys to various 'eat' functions.
+
+\(fn)" t nil)
+
+(autoload 'tinyeat-install "tinyeat" "\
+Call `tinyeat-install-default-bindings' with ARG.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'tinyeat-erase-buffer "tinyeat" "\
+Erase buffer. If read-only buffer, do nothing.
+
+\(fn)" t nil)
+
+(autoload 'tinyeat-zap-line "tinyeat" "\
+Kill COUNT times whole lines including the final newline.
+
+\(fn &optional COUNT)" t nil)
+
+(autoload 'tinyeat-backward "tinyeat" "\
+Eat backward COUNT times. See `tinyeat-eat'.
+
+\(fn &optional COUNT)" t nil)
+
+(autoload 'tinyeat-backward-preserve "tinyeat" "\
+Eat forward, but handle spaces differently. See `tinyeat-eat'.
+
+\(fn &optional COUNT)" t nil)
+
+(autoload 'tinyeat-forward "tinyeat" "\
+Eat forward COUNT times. See `tinyeat-eat'.
+
+\(fn &optional COUNT)" t nil)
+
+(autoload 'tinyeat-forward-preserve "tinyeat" "\
+Eat forward COUNT times. See `tinyeat-eat'.
+
+\(fn &optional COUNT)" t nil)
+
+(autoload 'tinyeat-join-lines "tinyeat" "\
+Join this and next line with one space, and go to the joint.
+
+\(fn &optional COUNT)" t nil)
+
+(autoload 'tinyeat-delete-whole-word "tinyeat" "\
+Delete COUNT words at point.
+
+- If there are multiple whitespaces around, call `fixup-whitespace'.
+- If on top of only one whitespcae, call `delete-horizontal-space'.
+- If on top of word, delete whole word.
+
+References:
+  `tinyeat--eat-full-word-charset'
+
+\(fn &optional COUNT)" t nil)
+
+(autoload 'tinyeat-kill-line "tinyeat" "\
+Like `kill-line'; COUNT times. Killed text isn't put into cut buffer.
+This way you can retain mouse selection in cut buffer.
+
+\(fn &optional COUNT)" t nil)
+
+(autoload 'tinyeat-kill-line-backward "tinyeat" "\
+Like `kill-line' back; COUNT times. Killed text isn't put into cut buffer.
+
+\(fn &optional COUNT)" t nil)
+
+(autoload 'tinyeat-kill-buffer-lines-point-max "tinyeat" "\
+Kill to the `point-max' or if BACK, then to the `point-min'.
+
+\(fn &optional BACK)" t nil)
+
+(autoload 'tinyeat-kill-buffer-lines-point-min "tinyeat" "\
+Kill until `point-min'.
+
+\(fn)" t nil)
+
+(autoload 'tinyeat-kill-buffer-lines-main "tinyeat" "\
+Kill until `point-max' or if BACKWARD, until `point-min'.
+
+\(fn &optional BACKWARD)" t nil)
+
+(autoload 'tinyeat-delete-paragraph "tinyeat" "\
+Delete current paragraph, separated by empty lines.
+
+\(fn)" t nil)
+
+(autoload 'tinyeat-eat "tinyeat" "\
+Eat *appropriate* text forward, if BACK then backward.
+
+The optional SPACE-PRESERVE changes the space eating.
+
+A.  when it is NIL and BACK is anything.   * marks the cursor.
+         text1 text1        *     text2  text2
+    -->  text1 text1 text2  text2                   ;one space left
+
+B.  when it is NON-NIL and BACK nil
+         text1 text1        *     text2  text2
+    -->  text1 text1        *text2  text2            ;delete right spaces
+
+C.  when it is NON-NIL and BACK t
+         text1 text1        *     text2  text2
+         text1 text1*     text2  text2               ;delete left spaces
+
+References:
+
+  `tinyeat--non-word-chars'
+
+\(fn &optional BACK TI::SPACE-PRESERVE)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads nil "tinyef" "tinyef.el" (20371 6115))
+;;; Generated autoloads from tinyef.el
+ (autoload 'tinyef-mode           "tinyef" "" t)
+ (autoload 'turn-off-tinyef-mode  "tinyef" "" t)
+ (autoload 'turn-on-tinyef-mode   "tinyef" "" t)
+ (autoload 'tinyef-commentary     "tinyef" "" t)
+ (autoload 'tinyef-version        "tinyef" "" t)
+
+;;;***
+\f
+;;;### (autoloads (tinygnus-nslookup-save tinygnus-mark-deleted tinygnus-install)
+;;;;;;  "tinygnus" "tinygnus.el" (20371 6115))
+;;; Generated autoloads from tinygnus.el
+ (autoload 'tinygnus-debug-toggle "tinygnus" "" t)
+ (autoload 'tinygnus-debug-show   "tinygnus" "" t)
+ (autoload 'tinygnus-summary-install-mode  "tinygnus" "" t)
+ (autoload 'tinygnus-summary-mode          "tinygnus" "" t)
+ (autoload 'turn-on-tinygnus-summary-mode  "tinygnus" "" t)
+ (autoload 'turn-off-tinygnus-summary-mode "tinygnus" "" t)
+ (autoload 'tinygnus-summary-commentary    "tinygnus" "" t)
+ (autoload 'tinygnus-summary-version       "tinygnus" "" t)
+ (autoload 'tinygnus-group-install-mode   "tinygnus" "" t)
+ (autoload 'tinygnus-group-mode           "tinygnus" "" t)
+ (autoload 'turn-on-tinygnus-group-mode   "tinygnus" "" t)
+ (autoload 'turn-off-tinygnus-group-mode  "tinygnus" "" t)
+ (autoload 'tinygnus-group-commentary     "tinygnus" "" t)
+ (autoload 'tinygnus-group-version        "tinygnus" "" t)
+
+(autoload 'tinygnus-install "tinygnus" "\
+Install package. Optionally UNINSTALL.
+
+\(fn &optional UNINSTALL)" t nil)
+
+(autoload 'tinygnus-mark-deleted "tinygnus" "\
+Mark current article expirable(mail) or deleted(news).
+
+\(fn)" t nil)
+
+(autoload 'tinygnus-nslookup-save "tinygnus" "\
+READ or save `tinygnus--nslookup-table' to `tinygnus--nslookup-file'.
+See function `tinygnus-article-ube-send-to-postmasters'.
+
+\(fn &optional READ)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinyhotlist-remove tinyhotlist-add tinyhotlist-control
+;;;;;;  tinyhotlist-control-kbd tinyhotlist-load-hotlist tinyhotlist-save-hotlist)
+;;;;;;  "tinyhotlist" "tinyhotlist.el" (20371 6115))
+;;; Generated autoloads from tinyhotlist.el
+
+(autoload 'tinyhotlist-save-hotlist "tinyhotlist" "\
+Call `tinyhotlist-load-hotlist' with arg to save hotlist. ARGS are ignored.
+
+\(fn &rest ARGS)" t nil)
+
+(autoload 'tinyhotlist-load-hotlist "tinyhotlist" "\
+Load or SAVE hotlist configuration from `tinyhotlist--hotlist-file'.
+When the hotlist file is loaded, only valid entries from there
+are selected to `tinyhotlist--cache': If File does not exist, it is dropped.
+
+Return:
+
+ nil t
+
+\(fn &optional SAVE)" t nil)
+
+(autoload 'tinyhotlist-control-kbd "tinyhotlist" "\
+Same as `tinyhotlist-control' with ARG, but you can call this from keyboard.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'tinyhotlist-control "tinyhotlist" "\
+Control center of hotlist. Use mouse EVENT to position popup.
+
+Optional ARG can be:
+
+  nil           show the hotlist
+  0             kill all members from hotlist.
+  9             kill all, but initalize with defaults.
+  nbr           any number, add current active buffer to hotlist
+  -             negative number, remove item from hotlist.
+                E.g. \\[universal-argument] -
+  1 x \\[universal-argument]       remove current buffer from hotlist
+  2 x \\[universal-argument]       Save hotlist
+  3 x \\[universal-argument]       load hotlist.
+
+\(fn EVENT &optional ARG)" t nil)
+
+(autoload 'tinyhotlist-add "tinyhotlist" "\
+Add current buffer to hotlist.
+
+\(fn)" t nil)
+
+(autoload 'tinyhotlist-remove "tinyhotlist" "\
+Remove current buffer from hotlist.
+
+\(fn)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinyigrep-menu) "tinyigrep" "tinyigrep.el" (20371
+;;;;;;  6115))
+;;; Generated autoloads from tinyigrep.el
+
+(autoload 'tinyigrep-menu "tinyigrep" "\
+Igrep command menu.
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinyindent-mode tinyindent-tt-mode) "tinyindent"
+;;;;;;  "tinyindent.el" (20371 6115))
+;;; Generated autoloads from tinyindent.el
+
+(autoload 'tinyindent-tt-mode "tinyindent" "\
+Toggle variable `tinyindent-tt-mode' with ARG. See description in `tinyindent-mode'.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'tinyindent-mode "tinyindent" "\
+Toggle relative indentation mode with ARG.
+
+Indentation is determined according to previous lines. Special
+indent happens only at the beginning of line, where user is asked if
+he wants to have relative or \"hard\" indentation.
+
+Abount function `tinyindent-tt-mode'
+
+This isn't really mode. It just turns one flag on in `tinyindent-mode', so that
+it behaves a little differently. If the `tinyindent-mode' is not running, it
+wiil be turned on. turning off `tinyindent-tt-mode' _does_not_ end `tinyindent-mode'.
+
+Sometimes you want to control between 'hard' tab and 'soft' tab, ie.
+relative indent. This mode causes second character to be read after
+tab key is hit. The following happens:
+
+TAB TAB     inserts hard tab
+TAB SPC     indent relative without inserting space char.
+TAB x       indents relative and inserting character x
+
+\\{tinyindent--mode-map}
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinyirc-pastebot-send-region tinyirc-pastebot-receive-url
+;;;;;;  tinyirc-pastebot-install-example-servers tinyirc-pastebot-install-perl-util-pastebot)
+;;;;;;  "tinyirc" "tinyirc.el" (20371 6115))
+;;; Generated autoloads from tinyirc.el
+
+(autoload 'tinyirc-pastebot-install-perl-util-pastebot "tinyirc" "\
+Install `tinyirc--pastebot-program-url'.
+
+\(fn)" t nil)
+
+(autoload 'tinyirc-pastebot-install-example-servers "tinyirc" "\
+Install the Pastebot `servers' example configuration file. This function
+tries to veriry the setup and suggest corrective actions how to get the
+PasteBot interface working. Once the installation look valid, this function
+should report an success status.
+
+References:
+  `tinyirc--pastebot-config-default-content'
+  `tinyirc--pastebot-program'
+  `tinyirc--pastebot-program-url'
+
+\(fn)" t nil)
+
+(autoload 'tinyirc-pastebot-receive-url "tinyirc" "\
+Retrieve URL from PasteBot service.
+
+\(fn URL)" t nil)
+
+(autoload 'tinyirc-pastebot-send-region "tinyirc" "\
+Send code to SERVICE using Perl script pastebot.pl.
+identify as USER with MSG. Send text in region BEG and END.
+
+See http://sial.org/code/perl/scripts/pbotutil.pl.html
+You also have to define databases for SERVICE selections, see script's
+manual page for details.
+
+References:
+  `tinyirc--pastebot-send-file'.
+
+\(fn SERVICE USER MSG BEG END)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (ti::compat-timer-control) "tinylib" "tinylib.el"
+;;;;;;  (20371 6115))
+;;; Generated autoloads from tinylib.el
+
+(autoload 'ti::compat-timer-control "tinylib" "\
+With `run-at-time' TIME REPEAT FUNCTION keep or remove timer. VERB.
+
+\(fn &optional TIME REPEAT FUNCTION DELETE VERB)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads (ti::id-info) "tinylibid" "tinylibid.el" (20371
+;;;;;;  6115))
+;;; Generated autoloads from tinylibid.el
+
+(autoload 'ti::id-info "tinylibid" "\
+Try to identify buffer type.
+
+Function doesn't rely on mode, because that doesn't necessarily tell what
+the buffer holds. Many users still program their shell scripts in
+`fundamental-mode' or so. This means that `major-mode' isn't checked,
+because calling function can do it easily.
+
+If this function returns nil, _then_ it's probably the time to check
+the `major-mode'.
+
+The normal order of evaluation is as follows:
+-  First line in the file
+-  Whole filename including path = `buffer-file-name'
+-  File name extension
+-  `buffer-name' is checked. [temporary buffer has no file name]
+-  Whole buffer is searched for RE texts
+
+Input:
+
+  MODE              flag, controls return value format
+  VARIABLE-LOOKUP   flag, read buffer type from cache. (From previous call)
+  VERB              if non-nil, verbose messages allowed.
+
+Return values:
+
+  when optional MODE = nil
+  Some appropriate _string_ that represents the content. notice that this
+  string is usually generalised description, _but_ it the file has special
+  1st line in form of -*-..-*- the string is direct mode name string.
+
+  when optional MODE = non-nil
+  Return possible mode name as _symbol_
+
+  when VARIABLE is non-nil, the variable `ti::id--info' is read instead.
+  If it has non-nil value, the value is returned, otherwise full buffer
+  is parsed again and variable's value is updated.
+
+References:
+
+  `ti::id-func-alist'  order of evaluation.
+  `ti::id--info'            buffer local variable updated during every call.
+
+\(fn &optional MODE VARIABLE-LOOKUP VERB)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (ti::menu-menu ti::menu-set-doc-string ti::menu-add)
+;;;;;;  "tinylibmenu" "tinylibmenu.el" (20371 6115))
+;;; Generated autoloads from tinylibmenu.el
+
+(autoload 'ti::menu-add "tinylibmenu" "\
+Add to menu MENU-SYMBOL elt (CH . CELL). Optionally DELETE.
+
+Example:
+
+  (ti::menu-add 'ti::menu--menu-sample ?2  nil 'delete)
+  (ti::menu-add 'ti::menu--menu-sample ?t '( (my-test 1 2 3)))
+
+Return:
+
+  nil       no add done due to existing CELL
+            no remove due to non-existing CELL
+
+\(fn MENU-SYMBOL CH CELL &optional DELETE)" nil nil)
+
+(autoload 'ti::menu-set-doc-string "tinylibmenu" "\
+Use  MENU-SYMBOL and set its DOC-STRING.
+
+Example:
+
+  (ti::menu-set-doc-string 'ti::menu--menu-sample \"?=help, 1=test1, t=myTest\")
+
+\(fn MENU-SYMBOL DOC-STRING)" nil nil)
+
+(autoload 'ti::menu-menu "tinylibmenu" "\
+The menu navigation engine.
+
+Input:
+
+  MENU-SYMBOL           variable symbol containing menu items
+  PFX-ARG               the prefix arg user ppossibly passed to menu
+
+References:
+
+  `ti::menu--menu-sample'   Show how the menu is constructed.
+  `ti::menu--prefix-arg'    Copy of current prefix arg
+
+\(fn MENU-SYMBOL &optional PFX-ARG)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads (ti::text-mark-region ti::text-unmark-region ti::text-mouse-unmark-region
+;;;;;;  ti::text-mouse-mark-region ti::text-re-search-backward ti::text-re-search-forward
+;;;;;;  ti::text-buffer ti::text-looking-at ti::text-re-search) "tinylibt"
+;;;;;;  "tinylibt.el" (20371 6115))
+;;; Generated autoloads from tinylibt.el
+
+(autoload 'ti::text-re-search "tinylibt" "\
+Highlight found text with search face.
+
+Note:
+
+    The beginning of match and end of match will have
+    property 'rear-nonsticky t, so that adding characters before of after
+    text, won't inherit the face.
+
+Input:
+
+  RE            str  regexp
+  DIRECTION     bool non-nil means backward
+  LEVEL         nbr  which subexpression in re to highlight, default is 0
+  MAXP          nbr  last search point [default until bob/eob]
+
+  FACE          sym  face symbol
+                     if symbol is 'null then set face to value nil
+                     or if this is list; then it must be properly list
+                     of format '(PROP PROP-VAL  PROP PROP-VAL ..)
+
+  MODE          nbr  signify that function should highlight all matches
+                     that occur within LEVEL..NBR
+                     if you have lot's of xx(match)yy|zz(match)tt|
+                     the subexpression are counted from left to to
+                     right: 1,2 ...
+  SAVE-UNDO     flag non-nil means that the highlight information is
+                     recorded for undo. This flag in on if function is
+                     called interactively. NOTE: the undo information is
+                     saved only if something was matched.
+
+Return:
+
+ nil            No match
+ nbr            start of match at LEVEL.
+
+\(fn RE &optional DIRECTION LEVEL MAXP FACE MODE SAVE-UNDO)" nil nil)
+
+(autoload 'ti::text-looking-at "tinylibt" "\
+Highlight found RE at LEVEL with FACE-OR-PLIST.
+The LEVEL is subexpression to highlight. PLIST means property list.
+
+\(fn RE &optional LEVEL FACE-OR-PLIST)" t nil)
+
+(autoload 'ti::text-buffer "tinylibt" "\
+Highlight RE and sub LEVEL in whole buffer, starting from `point-min'.
+Preserve point.
+
+See `ti::text-re-search' for descriptions of FACE MODE and SAVE-UNDO.
+
+\(fn RE &optional LEVEL FACE MODE SAVE-UNDO)" t nil)
+
+(autoload 'ti::text-re-search-forward "tinylibt" "\
+Search RE and highlight forward until `point-max'.
+Optional prefix arg tells which subexpression LEVEL to match that
+function should highlight. point is preserved during call.
+
+See `ti::text-re-search' for descriptions of FACE MODE SAVE-UNDO.
+
+\(fn RE &optional LEVEL FACE MODE SAVE-UNDO)" t nil)
+
+(autoload 'ti::text-re-search-backward "tinylibt" "\
+Search RE and highlight backward until `point-min'.
+Optional prefix arg tells which subexpression LEVEL to match that
+function should highlight. point is preserved during call.
+
+See `ti::text-re-search' for descriptions of FACE MODE SAVE-UNDO.
+
+\(fn RE &optional LEVEL FACE MODE SAVE-UNDO)" t nil)
+
+(autoload 'ti::text-mouse-mark-region "tinylibt" "\
+Highlight region BEG END. EVENT is mouse event.
+
+\(fn BEG END EVENT)" t nil)
+
+(autoload 'ti::text-mouse-unmark-region "tinylibt" "\
+Remove highlight from region BEG END. EVENT is mouse event.
+
+\(fn BEG END EVENT)" t nil)
+
+(autoload 'ti::text-unmark-region "tinylibt" "\
+Remove highlight from region BEG END.
+
+\(fn BEG END)" t nil)
+
+(autoload 'ti::text-mark-region "tinylibt" "\
+Highlight BEG END. With optional prefix arg REMOVE all matching FACE.
+
+\(fn BEG END &optional REMOVE FACE)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinylisp-autoload-quick-autoload-build-recursive
+;;;;;;  tinylisp-autoload-quick-build-interactive-from-file tinylisp-autoload-quick-build-from-file
+;;;;;;  tinylisp-autoload-generate-loaddefs-recursive tinylisp-autoload-generate-loaddefs-dir
+;;;;;;  tinylisp-autoload-guick-build-from-dir) "tinylisp" "tinylisp.el"
+;;;;;;  (20371 6115))
+;;; Generated autoloads from tinylisp.el
+ (autoload 'tinylisp-commentary    "tinylisp" "" t)
+ (autoload 'tinylisp-mode          "tinylisp" "" t)
+ (autoload 'turn-on-tinylisp-mode  "tinylisp" "" t)
+ (autoload 'turn-off-tinylisp-mode "tinylisp" "" t)
+ (autoload 'tinylisp-elp-summary-mode          "tinylisp" "" t)
+ (autoload 'turn-on-tinylisp-elp-summary-mode  "tinylisp" "" t)
+ (autoload 'turn-off-tinylisp-elp-summary-mode "tinylisp" "" t)
+
+(autoload 'tinylisp-autoload-guick-build-from-dir "tinylisp" "\
+Generate quick autoloads from list of FILE-OR-DIR matching REGEXP.
+Input:
+
+  FILE-OR-DIR File or directory.
+  REGEXP      If FILE-OR-DIR was directory, read files matching REGEXP.
+  NO-DESC     Optional, if non-nil, do not include function detection comments.
+              Interactively supply \\[universal-argument].
+  BUFFER      Optional buffer where to gather autoloads; default
+              `tinylisp--buffer-autoload'
+  VERB        Optional flag, if non-nil pop to result buffer.
+
+\(fn FILE-OR-DIR &optional REGEXP NO-DESC BUFFER VERB)" t nil)
+
+(autoload 'tinylisp-autoload-generate-loaddefs-dir "tinylisp" "\
+Generate loaddefs from DIR, optionally EXCLUDE by regexp.
+If VERB is non-nil, display verbose messages.
+
+\(fn DIR &optional EXCLUDE VERB)" t nil)
+
+(autoload 'tinylisp-autoload-generate-loaddefs-recursive "tinylisp" "\
+Generate ###autoload recursively starting from DIR.
+
+\(fn DIR)" t nil)
+
+(autoload 'tinylisp-autoload-quick-build-from-file "tinylisp" "\
+Generate autoload from FILE to DEST
+
+Input:
+
+  FILE     Read FILE
+  DEST     Destination file. Default is FILE-autoloads
+  PROVIDE   If non-nil, write `provide' statement.
+  FOOTER    If non-nil, write 'End of ...' footer.
+  VERB     Enable verbose messages.
+
+\(fn FILE &optional DEST PROVIDE FOOTER VERB)" t nil)
+
+(autoload 'tinylisp-autoload-quick-build-interactive-from-file "tinylisp" "\
+Read file list from `command-line-args-left'.
+Collect interactive defuns.
+
+Input:
+
+  SUFFIX    Destination file suffix. default is *-autoloads
+  PROVIDE   If non-nil, write `provide' statement.
+  FOOTER    If non-nil, write 'End of ...' footer.
+  VERB      If non-nil, write verbose messages.
+
+\(fn FILE &optional DEST PROVIDE FOOTER VERB)" t nil)
+
+(autoload 'tinylisp-autoload-quick-autoload-build-recursive "tinylisp" "\
+Generate all autoloads recursively starting from DIR.
+
+\(fn DIR &optional INCLUDE EXCLUDE)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinyload-loader-process tinyload-autoload-function-load
+;;;;;;  tinyload-install) "tinyload" "tinyload.el" (20371 6115))
+;;; Generated autoloads from tinyload.el
+
+(autoload 'tinyload-install "tinyload" "\
+Install package or REMOVE.
+This function removes any previous TinyLoad timer process and resets
+the list pointer to 0.
+
+\(fn &optional REMOVE)" t nil)
+
+(autoload 'tinyload-autoload-function-load "tinyload" "\
+Load all autoloaded functions. VERB.
+
+\(fn &optional VERB)" t nil)
+
+(autoload 'tinyload-loader-process "tinyload" "\
+Load packages defined in `tinyload--load-list'.
+If called interactively, FORCE loading all packages in the list.
+
+\(fn &optional FORCE)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinylock-lock tinylock-history) "tinylock" "tinylock.el"
+;;;;;;  (20371 6115))
+;;; Generated autoloads from tinylock.el
+
+(autoload 'tinylock-history "tinylock" "\
+Displays login history. Optionally to given buffer BUFFER.
+
+\(fn)" t nil)
+
+(autoload 'tinylock-lock "tinylock" "\
+Lock Emacs with PSW password and MSG.
+Message is displayed if LOCK-NOW is nil.
+If LOCK-NOW is non-nil emacs is immediately locked with PSW.
+
+\(fn PSW &optional MSG LOCK-NOW)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinymacro-assign tinymacro-end-kbd-macro-and-assign)
+;;;;;;  "tinymacro" "tinymacro.el" (20371 6115))
+;;; Generated autoloads from tinymacro.el
+
+(autoload 'tinymacro-end-kbd-macro-and-assign "tinymacro" "\
+Terminate reading macro and assign it to key.
+
+\(fn)" t nil)
+
+(autoload 'tinymacro-assign "tinymacro" "\
+Name last macro and assigns it to user defined KEY.
+Runs tinymacro--macro-assigned-hook if key macro gets installed.
+The query options should be turned off if you call this within
+function, since it always return nil if the options are on.
+
+Input:
+
+  KEY   Should be valid emacs key-bind-sequence/key-vector
+  VERB  Boolean, verbose messages
+
+Return:
+
+  t    is assigned
+  nil  not assigned `keyboard-quit'
+
+\(fn &optional KEY VERB)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinymail-on-off-toggle tinymail-mail tinymail-deactivate-and-send-to-you)
+;;;;;;  "tinymail" "tinymail.el" (20371 6115))
+;;; Generated autoloads from tinymail.el
+ (autoload 'tinymail-mode          "tinymail" "" t)
+ (autoload 'turn-on-tinymail-mode  "tinymail" "" t)
+ (autoload 'turn-off-tinymail-mode "tinymail" "" t)
+ (autoload 'tinymail-commentary    "tinymail" "" t)
+
+(autoload 'tinymail-deactivate-and-send-to-you "tinymail" "\
+Deactivate TinyMail and change To field to point to your address.
+This function is normally used when you use mailing lists. See
+documentation in the tinymail.el or call \\[tinymail-version].
+
+\(fn)" t nil)
+
+(autoload 'tinymail-mail "tinymail" "\
+Prepare mail mode.
+Add or changes Cc, FF, X-Sender-Info fields on the fly while you're
+composing the message.
+
+Input:
+
+  DISABLE       Disables package.
+  VERB          print verbose message.
+
+References:
+
+  `tinymail--feature-hook'.
+
+\(fn &optional DISABLE VERB)" nil nil)
+
+(autoload 'tinymail-on-off-toggle "tinymail" "\
+Toggle TinyMail mode on and off by Changing spacing of To field.
+This affects automatic Cc and X-Sender-Info tracking.
+ARG behaves  like mode argument.
+
+Without arg, this toggless Cc tracking, with prefix argument,
+it toggless both Cc and X-Sender-Info tracking.
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinymailbox-message-write-file tinymailbox-message-to-folder
+;;;;;;  tinymailbox-copy-body tinymailbox-copy tinymailbox-delete
+;;;;;;  tinymailbox-begin tinymailbox-uninstall tinymailbox-install)
+;;;;;;  "tinymailbox" "tinymailbox.el" (20371 6115))
+;;; Generated autoloads from tinymailbox.el
+ (autoload 'tinymailbox-install-mode  "tinymailbox" "" t)
+ (autoload 'tinymailbox-mode          "tinymailbox" "" t)
+ (autoload 'turn-on-tinymailbox-mode  "tinymailbox" "" t)
+ (autoload 'turn-off-tinymailbox-mode "tinymailbox" "" t)
+ (autoload 'tinymailbox-commentary    "tinymailbox" "" t)
+
+(autoload 'tinymailbox-install "tinymailbox" "\
+Install mode, or optionally UNINSTALL and print messages with VERB.
+
+\(fn &optional UNINSTALL VERB)" t nil)
+
+(autoload 'tinymailbox-uninstall "tinymailbox" "\
+Uninstall mode.
+
+\(fn)" nil nil)
+ (autoload 'tinymailbox-forward "tinymailbox" "Go to next message." t)
+ (autoload 'tinymailbox-backward "tinymailbox" "Go to previous message." t)
+
+(autoload 'tinymailbox-begin "tinymailbox" "\
+Move to next message begin. Optionally BACKWARD.
+
+\(fn &optional BACKWARD)" t nil)
+
+(autoload 'tinymailbox-delete "tinymailbox" "\
+Delete current message. point must be inside message.
+
+\(fn)" t nil)
+
+(autoload 'tinymailbox-copy "tinymailbox" "\
+Copy current message. point must be inside message.
+
+\(fn)" t nil)
+
+(autoload 'tinymailbox-copy-body "tinymailbox" "\
+Copy body of current message. point must be inside message.
+
+\(fn)" t nil)
+
+(autoload 'tinymailbox-message-to-folder "tinymailbox" "\
+File current message by appending it to FILE.
+
+\(fn FILE)" t nil)
+
+(autoload 'tinymailbox-message-write-file "tinymailbox" "\
+
+
+\(fn FILE)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinymy-compile-run-command-advice tinymy-buffer-file-chmod
+;;;;;;  tinymy-install tinymy-install-after-save-hook tinymy-define-keys-extra
+;;;;;;  tinymy-define-keys) "tinymy" "tinymy.el" (20371 6115))
+;;; Generated autoloads from tinymy.el
+
+(autoload 'tinymy-define-keys "tinymy" "\
+Install keys.
+
+\(fn)" t nil)
+
+(autoload 'tinymy-define-keys-extra "tinymy" "\
+Define extra global keys.
+
+\(fn)" t nil)
+
+(autoload 'tinymy-install-after-save-hook "tinymy" "\
+Intall or UNINSTALL functions to `after-save-hook'.
+
+\(fn &optional UNINSTALL)" nil nil)
+
+(autoload 'tinymy-install "tinymy" "\
+Intall or UNINSTALL package. Configure Emacs variables and bindings.
+
+\(fn &optional UNINSTALL)" t nil)
+
+(autoload 'tinymy-buffer-file-chmod "tinymy" "\
+Toggle current buffer's Read-Write permission permanently on disk. VERB.
+Does nothing if buffer is not visiting a file or file is not owned by us.
+
+\(fn &optional VERB)" t nil)
+
+(autoload 'tinymy-compile-run-command-advice "tinymy" "\
+Activate or DISABLE smart compile command vie \\[compile\\].
+See `tinymy-compile-run-command-ask' for more.
+
+\(fn &optional DISABLE)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "tinynbr" "tinynbr.el" (20371 6115))
+;;; Generated autoloads from tinynbr.el
+ (autoload 'tinynbr-mode          "tinynbr" "" t)
+ (autoload 'turn-on-tinynbr-mode  "tinynbr" "" t)
+ (autoload 'tun-off-tinynbr-mode  "tinynbr" "" t)
+ (autoload 'tinynbr-commentary    "tinynbr" "" t)
+ (autoload 'tinynbr-int-to-hex    "tinynbr" "" t)
+ (autoload 'tinynbr-int-to-oct    "tinynbr" "" t)
+ (autoload 'tinynbr-int-to-bin    "tinynbr" "" t)
+ (autoload 'tinynbr-hex-to-int    "tinynbr" "" t)
+ (autoload 'tinynbr-oct-to-int    "tinynbr" "" t)
+ (autoload 'tinynbr-bin-to-int    "tinynbr" "" t)
+
+;;;***
+\f
+;;;### (autoloads nil "tinypad" "tinypad.el" (20371 6115))
+;;; Generated autoloads from tinypad.el
+ (autoload 'tinypad-mode          "tinypad" "" t)
+ (autoload 'turn-on-tinypad-mode  "tinypad" "" t)
+ (autoload 'turn-off-tinypad-mode "tinypad" "" t)
+
+;;;***
+\f
+;;;### (autoloads (tinypage-go-next tinypage-go-previous tinypage-yank-after
+;;;;;;  tinypage-yank-before tinypage-yank tinypage-cut tinypage-copy
+;;;;;;  tinypage-select tinypage-region-action) "tinypage" "tinypage.el"
+;;;;;;  (20371 6115))
+;;; Generated autoloads from tinypage.el
+ (autoload 'tinypage-mode          "tinypage" "" t)
+ (autoload 'turn-on-tinypage-mode  "tinypage" "" t)
+ (autoload 'turn-off-tinypage-mode "tinypage" "" t)
+ (autoload 'tinypage-commentary    "tinypage" "" t)
+
+(autoload 'tinypage-region-action "tinypage" "\
+Execute action ACT. Return t or nil. VERB.
+
+\(fn ACT &optional VERB)" nil nil)
+
+(autoload 'tinypage-select "tinypage" "\
+Select page. If sitting on page Marker, use page below. VERB.
+
+\(fn &optional VERB)" t nil)
+
+(autoload 'tinypage-copy "tinypage" "\
+Select page. If sitting on page Marker, use page below. VERB.
+
+\(fn &optional VERB)" t nil)
+
+(autoload 'tinypage-cut "tinypage" "\
+Select page. If sitting on page Marker, use page below. VERB.
+
+\(fn &optional VERB)" t nil)
+
+(autoload 'tinypage-yank "tinypage" "\
+Yank page from register. VERB.
+
+\(fn &optional VERB)" t nil)
+
+(autoload 'tinypage-yank-before "tinypage" "\
+Yank page from register, but _before_ current page. VERB.
+
+\(fn &optional VERB)" t nil)
+
+(autoload 'tinypage-yank-after "tinypage" "\
+Yank page from register, but _after_ current page.
+Optionally BEFORE with MSG and VERB.
+
+\(fn &optional BEFORE MSG VERB)" t nil)
+
+(autoload 'tinypage-go-previous "tinypage" "\
+Go to previous page. VERB.
+
+\(fn &optional VERB)" t nil)
+
+(autoload 'tinypage-go-next "tinypage" "\
+Go to next page, optionally BACK. Return point if moved. VERB.
+
+\(fn &optional BACK VERB)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "tinypair" "tinypair.el" (20371 6115))
+;;; Generated autoloads from tinypair.el
+ (autoload 'tinypair-mode            "tinypair" "" t)
+ (autoload 'turn-on-tinypair-mode    "tinypair" "" t)
+ (autoload 'turn-off-tinypair-mode   "tinypair" "" t)
+ (autoload 'tinypair-commentary      "tinypair" "" t)
+
+;;;***
+\f
+;;;### (autoloads (tinypath-report-mode) "tinypath" "tinypath.el"
+;;;;;;  (20371 6115))
+;;; Generated autoloads from tinypath.el
+
+(autoload 'tinypath-report-mode "tinypath" "\
+Major mode to help working with `tinypath-cache-duplicate-report'.
+and `tinypath-cache-problem-report'. VERB.
+
+\\{tinypath-report-mode-map}
+
+\(fn &optional VERB)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinyperl-pod-grep-faq-answer tinyperl-process-wait
+;;;;;;  tinyperl-pod-grep tinyperl-pod-by-manpage tinyperl-pod-find-file
+;;;;;;  tinyperl-pod-by-module tinyperl-module-find-file tinyperl-perldoc
+;;;;;;  tinyperl-pod-kill-buffers turn-on-tinyperl-mode-all-buffers
+;;;;;;  tinyperl-uninstall tinyperl-install-force tinyperl-install)
+;;;;;;  "tinyperl" "tinyperl.el" (20371 6115))
+;;; Generated autoloads from tinyperl.el
+
+(autoload 'tinyperl-install "tinyperl" "\
+The main installer. Set up everything: hooks and variables.
+This function is best put into `tinyperl--load-hook'.
+
+Input:
+
+  UNINSTALL   Uninstall, remove hooks etc.
+  FORCE       Forced install. In case modules have installed from CPAN,
+              this variable should be set to force rescan of @INC instead
+              of using cache.
+
+\(fn &optional UNINSTALL FORCE)" t nil)
+
+(autoload 'tinyperl-install-force "tinyperl" "\
+Rebuild all global variables. Needed after CPAN module install.
+
+\(fn)" t nil)
+
+(autoload 'tinyperl-uninstall "tinyperl" "\
+Uninstall TinyPerl.
+
+\(fn)" t nil)
+
+(autoload 'turn-on-tinyperl-mode-all-buffers "tinyperl" "\
+Turn function `tinyperl-mode' on in every perl buffer. Optionally turn OFF.
+
+\(fn &optional OFF)" t nil)
+ (autoload 'tinyperl-mode           "tinyperl" "" t)
+ (autoload 'turn-on-tinyperl-mode   "tinyperl" "" t)
+ (autoload 'turn-off-tinyperl-mode  "tinyperl" "" t)
+ (autoload 'tinyperl-commentary     "tinyperl" "" t)
+ (autoload 'tinyperl-pod-view-mode          "tinyperl" "" t)
+ (autoload 'turn-on-tinyperl-pod-view-mode  "tinyperl" "" t)
+ (autoload 'turn-off-tinyperl-pod-view-mode "tinyperl" "" t)
+ (autoload 'tinyperl-pod-write-mode          "tinyperl" "" t)
+ (autoload 'turn-on-tinyperl-pod-write-mode  "tinyperl" "" t)
+ (autoload 'turn-off-tinyperl-pod-write-mode "tinyperl" "" t)
+ (autoload 'tinyperl-pod-write-skeleton-item            "tinyperl" "" t)
+ (autoload 'tinyperl-pod-write-skeleton-script-manpage  "tinyperl" "" t)
+ (autoload 'tinyperl-pod-write-skeleton-script-function "tinyperl" "" t)
+ (autoload 'tinyperl-pod-write-skeleton-module-header   "tinyperl" "" t)
+ (autoload 'tinyperl-pod-write-skeleton-module-footer   "tinyperl" "" t)
+ (autoload 'tinyperl-pod-write-skeleton-module-function "tinyperl" "" t)
+
+(autoload 'tinyperl-pod-kill-buffers "tinyperl" "\
+Kill all temporary POD buffers.
+
+\(fn)" t nil)
+
+(autoload 'tinyperl-perldoc "tinyperl" "\
+Run perldoc with STRING. First try with -f then without it.
+Show content in `tinyperl--perldoc-buffer'. If buffer is visible in
+some other frame, the cursor is not moved there. Only contents is updated.
+
+The last used STRING is cached and if called next time with same
+string, the shell command is not called unless FORCE is non-nil.
+
+Input:
+
+  STRING    Seach string
+  FORCE     Force calling shell although answer cached
+  VERB      flag, Allow verbose messages
+
+References:
+
+  `tinyperl--perldoc-hook'
+
+\(fn STRING &optional FORCE VERB)" t nil)
+
+(autoload 'tinyperl-module-find-file "tinyperl" "\
+Load Perl MODULE source.
+
+\(fn MODULE)" t nil)
+
+(autoload 'tinyperl-pod-by-module "tinyperl" "\
+Show pod manual page for MODULE or load MODULE.
+
+Input:
+
+  MODULE    The Perl module as it appears in `use' statement,
+            like Getopt::Long the '.pm' is automatically added.
+  MODE      If non-nil, load source file, not pod.
+
+\(fn MODULE &optional MODE)" t nil)
+
+(autoload 'tinyperl-pod-find-file "tinyperl" "\
+Run pod2text on FILE and create new buffer: '*pod' + FILE + '*'.
+If file contains pod documentation section, it will be formatted nicely.
+
+\(fn FILE)" t nil)
+
+(autoload 'tinyperl-pod-by-manpage "tinyperl" "\
+Display pod for FILE.
+
+\(fn FILE)" t nil)
+
+(autoload 'tinyperl-pod-grep "tinyperl" "\
+Grep REGEXP from perl pod files.
+This is your way to find what pages contain references to the items you're
+looking for. However if you select the file from compile buffer, it is
+in the unconverted format (.pod). A better would be to memorize the
+pod file name, like
+
+   perlre.pod:165:    \\Z       Match at only e
+
+And call immediately \\[tinyperl-pod-by-manpage] and view `perlre' in
+more pleasant manner. Few C-s searches or \\[occur] will take you
+to the correct position.
+
+\(fn REGEXP &optional POD-PATH)" t nil)
+
+(autoload 'tinyperl-process-wait "tinyperl" "\
+Wait until process in BUFFER has finished.
+
+\(fn BUFFER)" nil nil)
+
+(autoload 'tinyperl-pod-grep-faq-answer "tinyperl" "\
+Grep REGEXP from perl pod files. VERB.
+
+This function also gathers all =head topics that match the REGEXP.
+You can use generated page as an answer to 'Has this this question
+been answered in FAQ'
+
+\(fn REGEXP &optional VERB)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (turn-on-tinyprocmail-mode-all-buffers turn-off-tinyprocmail-mode-all-buffers)
+;;;;;;  "tinyprocmail" "tinyprocmail.el" (20371 6115))
+;;; Generated autoloads from tinyprocmail.el
+ (autoload 'tinyprocmail-mode             "tinyprocmail" "" t)
+ (autoload 'turn-on-tinyprocmail-mode     "tinyprocmail" "" t)
+ (autoload 'turn-off-tinyprocmail-mode    "tinyprocmail" "" t)
+ (autoload 'tinyprocmail-commentary       "tinyprocmail" "" t)
+ (autoload 'tinyprocmail-version          "tinyprocmail" "" t)
+ (autoload 'tinyprocmail-output-mode          "tinyprocmail" "" t)
+ (autoload 'turn-on-tinyprocmail-output-mode  "tinyprocmail" "" t)
+ (autoload 'turn-off-tinyprocmail-output-mode "tinyprocmail" "" t)
+ (autoload 'tinyprocmail-install-files "tinyprocmail" t t)
+
+(autoload 'turn-off-tinyprocmail-mode-all-buffers "tinyprocmail" "\
+Call `turn-on-tinyprocmail-mode-all-buffers' with parameter `off'. VERB.
+
+\(fn &optional VERB)" t nil)
+
+(autoload 'turn-on-tinyprocmail-mode-all-buffers "tinyprocmail" "\
+Turn on or OFF function `tinyprocmail-mode' for all procmail buffers. VERB.
+Procmail files start with `rc.' or end to `.rc' and file content
+must match `^:0'.
+
+\(fn &optional OFF VERB)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinyreplace-latex-math-replace tinyreplace-latex-blk-replace
+;;;;;;  tinyreplace-replace-forward tinyreplace-replace-region tinyreplace-replace-over-files-compile-buffer
+;;;;;;  tinyreplace-symmetry-toggle tinyreplace-menu tinyreplace-install
+;;;;;;  tinyreplace-install-hooks tinyreplace-define-keys-local-map
+;;;;;;  tinyreplace-install-default-keybings) "tinyreplace" "tinyreplace.el"
+;;;;;;  (20371 6115))
+;;; Generated autoloads from tinyreplace.el
+
+(autoload 'tinyreplace-install-default-keybings "tinyreplace" "\
+Install M-& default keybing.
+
+\(fn)" t nil)
+
+(autoload 'tinyreplace-define-keys-local-map "tinyreplace" "\
+Define key binding M-& in local map. For compilation like modes.
+
+\(fn)" t nil)
+
+(autoload 'tinyreplace-install-hooks "tinyreplace" "\
+Install or UNINSTALL `tinyreplace-define-keys-local-map' into hooks.
+See:
+  compilation-mode-hook
+  compilation-minor-mode-hook
+  grep-mode-hook
+
+\(fn &optional UNINSTALL)" t nil)
+
+(autoload 'tinyreplace-install "tinyreplace" "\
+Call `tinyreplace-install-default-keybings' and `tinyreplace-install-hooks'.
+
+\(fn)" t nil)
+
+(autoload 'tinyreplace-menu "tinyreplace" "\
+Run `tinyreplace--menu'.
+
+\(fn)" t nil)
+
+(autoload 'tinyreplace-symmetry-toggle "tinyreplace" "\
+Toggle variable` tinyreplace--symmetry' with ARG. VERB.
+
+\(fn &optional ARG VERB)" t nil)
+
+(autoload 'tinyreplace-replace-over-files-compile-buffer "tinyreplace" "\
+Read all files forward in buffer that is in compile buffer format.
+Perform replace over the found files. Checks Out files that are
+RCS controlled if necessary.
+
+Line format:
+
+  /DIR/DIR/FILE: matched text
+
+Input:
+
+  See function `tinyreplace-replace-1'
+  BEG END STR1 STR2 &OPTIONAL FUNC VERB
+
+\(fn BEG END STR1 STR2 &optional FUNC VERB)" t nil)
+
+(autoload 'tinyreplace-replace-region "tinyreplace" "\
+In region BEG END, find STR1 and replace with STR2.
+
+\(fn BEG END STR1 STR2)" t nil)
+
+(autoload 'tinyreplace-replace-forward "tinyreplace" "\
+Find STR1 and replace with STR2 from current point forward.
+See C-h f `tinyreplace-args-keymap-create' what key bindings
+you can use. Normally C - l yanks, and \"\\\" key deletes line.
+
+\(fn STR1 STR2)" t nil)
+
+(autoload 'tinyreplace-latex-blk-replace "tinyreplace" "\
+Select latex block areas for replace.
+
+Input:
+
+ STR1 STR2      Find and replace with.
+ BLK            Block delimiter to find
+ BEG-RE END-RE  Region bound regexps.
+
+\(fn STR1 STR2 BLK &optional BEG-RE END-RE)" t nil)
+
+(autoload 'tinyreplace-latex-math-replace "tinyreplace" "\
+Find STR1 and replace with STR2 inside latex math blocks.
+
+\(fn STR1 STR2)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinyscroll-control tinyscroll-list tinyscroll-timer-process-control)
+;;;;;;  "tinyscroll" "tinyscroll.el" (20371 6115))
+;;; Generated autoloads from tinyscroll.el
+
+(autoload 'tinyscroll-timer-process-control "tinyscroll" "\
+Keep the auto scroll process and timer process alive.
+Optionally DELETE auto scroll process. VERB.
+
+\(fn &optional DELETE VERB)" t nil)
+
+(autoload 'tinyscroll-list "tinyscroll" "\
+Show list of active auto scroll buffers.
+Buffers are listed inecho-area if they fit there, otherwise in separate buffer.
+
+If optional PRINT flag is non-nil, always generate report to temporary buffer.
+If list if empty, do nothing.
+
+Return:
+
+ t      report generated to temporary buffer
+ nil    no report
+
+\(fn &optional PRINT)" t nil)
+
+(autoload 'tinyscroll-control "tinyscroll" "\
+Turn on auto scroll on/off for current buffer.
+If this command is called from `tinyscroll--tmp-buffer' then the current
+word in the line is read and offered for default buffer name.
+
+Input:
+
+  BUFFER-OR-POINTER     buffer to scroll
+  OFF                   flag, prefix arg; is non-nil turn scrolling off
+  VERB                  flag, allow verbose messages.
+
+\(fn BUFFER-OR-POINTER &optional OFF VERB)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinysearch-install tinysearch-install-default-keybindings
+;;;;;;  tinysearch-search-word-backward tinysearch-search-word-forward)
+;;;;;;  "tinysearch" "tinysearch.el" (20371 6115))
+;;; Generated autoloads from tinysearch.el
+
+(autoload 'tinysearch-search-word-forward "tinysearch" "\
+Search word at point forward.
+
+\(fn)" t nil)
+
+(autoload 'tinysearch-search-word-backward "tinysearch" "\
+Search word at point backward.
+
+\(fn)" t nil)
+
+(autoload 'tinysearch-install-default-keybindings "tinysearch" "\
+Install default keybindings
+M-Mouse-1   M-s  search forward
+C-M-Mouse-1 M-r  reverse.
+
+\(fn &optional UNINSTALL)" t nil)
+
+(autoload 'tinysearch-install "tinysearch" "\
+Call `tinysearch-install-default-keybindings' with ARG.
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinytab-return-key-mode turn-off-tinytab-return-key-mode
+;;;;;;  turn-on-tinytab-return-key-mode tinytab-tab-del-key tinytab-tab-key)
+;;;;;;  "tinytab" "tinytab.el" (20371 6115))
+;;; Generated autoloads from tinytab.el
+ (autoload 'tinytab-mode                  "tinytab" "" t)
+ (autoload 'turn-on-tinytab-mode          "tinytab" "" t)
+ (autoload 'turn-off-tinytab-mode         "tinytab" "" t)
+ (autoload 'tinytab-commentary            "tinytab" "" t)
+
+(autoload 'tinytab-tab-key "tinytab" "\
+Run list of function to handle TAB key. See variable `tinytab--tab-insert-hook'.
+If region is active and BEG and END are nil, then call function
+`tinytab-indent-by-tab-width'.
+
+\(fn &optional BEG END)" t nil)
+
+(autoload 'tinytab-tab-del-key "tinytab" "\
+Remove indentation. See variable `tinytab--tab-delete-hook'.
+If region is active, indent all lines backward.
+
+\(fn &optional BEG END)" t nil)
+
+(autoload 'turn-on-tinytab-return-key-mode "tinytab" "\
+Turn on auto indent after RET key.
+
+\(fn)" nil nil)
+
+(autoload 'turn-off-tinytab-return-key-mode "tinytab" "\
+Turn on auto indent after RET key.
+
+\(fn)" nil nil)
+
+(autoload 'tinytab-return-key-mode "tinytab" "\
+Toggle auto indent MODE / regular newline mode. VERB.
+
+\(fn &optional MODE VERB)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (tinytag-post-command tinytag-main-mouse tinytag-main
+;;;;;;  tinytag-install-sample-database-c tinytag-install-sample-database-java
+;;;;;;  tinytag-uninstall tinytag-install) "tinytag" "tinytag.el"
+;;;;;;  (20371 6115))
+;;; Generated autoloads from tinytag.el
+
+(autoload 'tinytag-install "tinytag" "\
+Install package. Optionally UNINSTALL.
+
+\(fn &optional UNINSTALL)" t nil)
+
+(autoload 'tinytag-uninstall "tinytag" "\
+Uninstall package.
+
+\(fn)" nil nil)
+
+(autoload 'tinytag-install-sample-database-java "tinytag" "\
+Install Java database from Sub JDK documentation.
+
+\(fn)" t nil)
+
+(autoload 'tinytag-install-sample-database-c "tinytag" "\
+Install c/C++ database from file tintytag.el.
+
+\(fn)" t nil)
+
+(autoload 'tinytag-main "tinytag" "\
+Run `tinytag--try-hook' until some of the functions return non-nil.
+
+\(fn)" t nil)
+
+(autoload 'tinytag-main-mouse "tinytag" "\
+See `tinytag-main'. Function is called with mouse EVENT.
+
+\(fn &optional EVENT)" t nil)
+
+(autoload 'tinytag-post-command "tinytag" "\
+Activates only if `tinytag--set-database-hook' wakes up.
+Show the database definition for the current word under point.
+
+References:
+
+  `tinytag--noerror'
+  `tinytag--post-command-hook-wakeup'
+  `tinytag--set-database-hook'
+
+\(fn)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads (turn-on-tinytf-mode-maybe tinytf-mode-define-f-keys)
+;;;;;;  "tinytf" "tinytf.el" (20371 6115))
+;;; Generated autoloads from tinytf.el
+ (autoload 'tinytf-install-mode       "tinytf" "" t)
+ (autoload 'tinytf-mode               "tinytf" "" t)
+ (autoload 'turn-on-tinytf-mode       "tinytf" "" t)
+ (autoload 'turn-off-tinytf-mode      "tinytf" "" t)
+ (autoload 'tinytf-commentary         "tinytf" "" t)
+
+(autoload 'tinytf-mode-define-f-keys "tinytf" "\
+Define default function key to `tinytf--mode-map'.
+
+\(fn)" t nil)
+ (autoload 'tinytf-install-files "tinytf" "" t)
+
+(autoload 'turn-on-tinytf-mode-maybe "tinytf" "\
+If buffer looks like technical format, turn on `tinytf-mode'.
+References:
+  `tinytf--tinytf-mode-p-function'.
+
+\(fn)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads (tinyurl-install tinyurl-mode-1 turn-on-tinyurl-mode-mail
+;;;;;;  turn-on-tinyurl-mode-1-maybe turn-on-turn-off-tinyurl-mode-1-maybe)
+;;;;;;  "tinyurl" "tinyurl.el" (20371 6115))
+;;; Generated autoloads from tinyurl.el
+ (autoload 'tinyurl-debug-toggle "tinyurl" "" t)
+ (autoload 'tinyurl-mode            "tinyurl" "" t)
+ (autoload 'turn-on-tinyurl-mode    "tinyurl" "" t)
+ (autoload 'turn-off-tinyurl-mode   "tinyurl" "" t)
+ (autoload 'tinyurl-commentary      "tinyurl" "" t)
+
+(autoload 'turn-on-turn-off-tinyurl-mode-1-maybe "tinyurl" "\
+Activate or deactivate `tinyurl-mode-1' in current buffer.
+Try to find ftp, http or email URL.
+The value of `tinyurl--exclude-function' is consulted first.
+
+\(fn)" nil nil)
+
+(autoload 'turn-on-tinyurl-mode-1-maybe "tinyurl" "\
+Activate `tinyurl-mode-1' in current buffer if ftp, http or email is found.
+This function is meant to be used in e.g. Article display
+hooks in Mail Agents.
+
+References:
+
+  The value of `tinyurl--exclude-function' is consulted first.
+
+\(fn)" nil nil)
+
+(autoload 'turn-on-tinyurl-mode-mail "tinyurl" "\
+Turn on  `tinyurl-mode-1' and make `tinyurl--mouse-yank-at-point' local.
+
+\(fn)" nil nil)
+
+(autoload 'tinyurl-mode-1 "tinyurl" "\
+Turn mode on or off with mode ARG for current buffer only.
+If you want to turn on or off globally, use function `tinyurl-mode'.
+
+\(fn ARG)" t nil)
+
+(autoload 'tinyurl-install "tinyurl" "\
+Install or `UNINSTALL package.
+
+\(fn &optional UNINSTALL)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "tinyvc" "tinyvc.el" (20371 6115))
+;;; Generated autoloads from tinyvc.el
+ (autoload 'tinyvc-mode          "tinyvc" "" t)
+ (autoload 'turn-on-tinyvc-mode  "tinyvc" "" t)
+ (autoload 'turn-off-tinyvc-mode "tinyvc" "" t)
+
+;;;***
+\f
+;;;### (autoloads (tinyxreg-jump-to-register-mouse tinyxreg-jump-to-register
+;;;;;;  tinyxreg-remove-register tinyxreg-point-to-register tinyxreg-point-to-register-mouse
+;;;;;;  tinyxreg-trash tinyxreg-remove-reg) "tinyxreg" "tinyxreg.el"
+;;;;;;  (20371 6115))
+;;; Generated autoloads from tinyxreg.el
+
+(autoload 'tinyxreg-remove-reg "tinyxreg" "\
+Remove register CHAR from stored window and point lists.
+ARG suggests looking in window list.
+
+\(fn CHAR &optional ARG)" t nil)
+
+(autoload 'tinyxreg-trash "tinyxreg" "\
+Empties both window and point caches.
+
+\(fn)" t nil)
+
+(autoload 'tinyxreg-point-to-register-mouse "tinyxreg" "\
+Call `tinyxreg-point-to-register' using mouse EVENT.
+
+\(fn EVENT)" t nil)
+
+(autoload 'tinyxreg-point-to-register "tinyxreg" "\
+Store point to CHAR and to X-popup list.
+With prefix ARG, store current frame configuration. VERBOSE enables
+message printing.
+
+Use \\[tinyxreg-point-to-register]  to go to that location or restore the
+configuration.
+
+\(fn CHAR &optional ARG)" t nil)
+
+(autoload 'tinyxreg-remove-register "tinyxreg" "\
+Remove register from popup list.
+See `tinyxreg-jump-to-register-mouse' for more.
+
+\(fn)" t nil)
+
+(autoload 'tinyxreg-jump-to-register "tinyxreg" "\
+Call `tinyxreg-jump-to-register-mouse' with REMOVE.
+
+\(fn &optional REMOVE)" t nil)
+
+(autoload 'tinyxreg-jump-to-register-mouse "tinyxreg" "\
+Displays list of registers using mouse EVENT.
+Restore register or optionally REMOVE register from X-list.
+Input:
+
+  EVENT     mouse event
+  REMOVE    flag, if non-nil, remove register.
+  VERB      flag, Allow verbose messages.
+
+\(fn EVENT &optional REMOVE VERB)" t nil)
+
+;;;***
+\f
+;;;### (autoloads (update-autoloads-in-tiny-area) "update-autoloads"
+;;;;;;  "update-autoloads.el" (20371 8127))
+;;; Generated autoloads from update-autoloads.el
+
+(setq load-path (cons (file-name-directory load-file-name) load-path))
+
+(autoload 'update-autoloads-in-tiny-area "update-autoloads" "\
+Update autoloads for files in the diretory containing this file.
+
+\(fn &optional FILE)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil nil ("load-path.el" "tiny-admin-util.el" "tinyliba.el"
+;;;;;;  "tinylibb.el" "tinylibenv.el" "tinylibm.el" "tinylibmail.el"
+;;;;;;  "tinylibo.el" "tinylibw.el" "tinyliby.el" "tinylpr.el") (20371
+;;;;;;  8177 687421))
+
+;;;***
+\f
+;;;### (autoloads (tiny-setup-autoload-read tiny-setup-display tiny-setup)
+;;;;;;  "tiny-setup" "tiny-setup.el" (20371 6115))
+;;; Generated autoloads from tiny-setup.el
+
+(autoload 'tiny-setup "tiny-setup" "\
+Tiny Tools setup controller. See Message buffer for results.
+
+Please make sure you have run the makefile.pl with build option
+\"all\" or \"autoload\". You can verify this by finding files which
+contain word \"loaddefs\".
+
+Autoload statements are always defined when this function is called,
+so even if you do not define any options to be installed, they will be
+available in callable functions that trigger loading packages. This
+means, that you an call e.g function \\[tinytab-mode] and the call
+will trigger loading package tinytab.el
+
+Please notice, that this central setup function configures only the
+essential packages, even with TYPE and FEATURE-LIST. The listing
+\\[tiny-setup-display] lists many packages that are not loaded
+or set up in any default way because a) package's scope is very narrow
+and it may not interest the majority b) there is no sensible autoload
+and it requires manual settings: tinyload.el and tinypath.el are
+good example of this. c) package is a library and it has been
+taken cared of by other means.
+
+Remember that all functions are autoloaded and accessible, although
+packages marked <no options> may not have default configurations. Here is
+sample listing that you may expect from \\[tiny-setup-display] which
+displays then content of `tiny-setup-:option-table' when no tiny-setup
+configure options are not defined and you should load the package as
+instructed in the file itself:
+
+    ..
+    tinychist            <no options defined to install>
+    ...
+                         Command history save/restore utility.
+    tinyload             <no options defined to install>
+                         Load set of packages when Emacs is idle (lazy load).
+    tinylock             <no options defined to install>
+                         Simple emacs locking utility.
+    ...
+    tinynbr              <no options defined to install>
+                         Number conversion minor mode oct/bin/hex.
+    ...
+    tinypath             <no options defined to install>
+                         Manage Emacs startup dynamically.
+
+Here is one way to install packages: a) configure paths automatically b)
+load default setup and enable some extra features c) define
+delayed loading for some packages that you use most of the time.
+
+   (load \"/ABSOLUTE-PATH/tinypath.el\")
+
+   ;;  Define \"ready to use packages\"
+
+   (require 'tiny-setup)
+
+   (tinypath-setup
+     'all                       ;; Activate default features safely
+     ;; plus features that you want
+    '(tinyeat--bind
+      tinydesk--bindforce
+      tinymy--defadvice         ;;  Make M-x compile smarter
+      tinydiff--bind
+      tinydired--autoload
+      tinyef--bindextra
+      tinyeat--bindforce
+      tinymacro--bindforce
+      tinydesk--bindforce
+      tinypair--activate
+      tinylisp--activate        ;; turn on on in all .el buffers
+      ..))
+
+   ;; Delayed loading of these packages, when Emacs goes idle.
+
+   (setq tinyload--load-list
+     '(\"tinyadvice\"           ;; NOTE: for Emacs only.
+       \"tinymy\"
+       \"tinymail\"
+       \"tinygnus\"
+       \"tinyigrep\"
+      ..))
+
+  (require 'tinyload)
+
+Here is yet another example. The `tiny-setup' function can configure only
+the very basic features. You can manually set default values before
+packages are loaded (look into each file for interesting things).
+
+    ;; First, configure few packages MANUALLY
+
+    (require 'tinylibm)
+
+    (ti::add-hooks 'tinytf--mode-define-keys-hook
+                   '(tinytf-mode-define-keys tinytf-mode-define-f-keys))
+
+    (setq tinymy--define-key-force t)
+    (setq tinyef--mode-key \"\\C-cmr\")
+
+    (setq tinylock--auto-lock-interval1 45)     ;in minutes
+
+    (setq tinyef--mode-key-table
+          '((?[   . step-delete-back)          ;KEY -- action symbol
+            (?]   . step-delete-fwd)
+            (?*   . chunk-delete)
+            (?;   . move-back)
+            (?'   . move-fwd)
+            (?~   . e-tilde)
+            (?/   . e-slash)
+            (?$   . e-dollar)))
+
+    ;; After that, let the central configure tool do the rest
+
+    (require 'tiny-setup)
+
+    (tiny-setup
+     'all
+     '(tinymy--bind-bindemacs
+       tinytab--bindforce-bindextra
+       tinyreplace--bindemacs
+       tinyeat--bindforce))
+
+The major TYPE of installation can be one of the following:
+
+    'autoload
+
+    Setup packages so that they are loaded when the options are needed,
+    but do not define any key-bindings that already exist. This will
+    bind free keys to trigger loading packages.
+
+    'all
+
+    Configure with all options on. This will affect free key-bindings.
+
+    nil
+
+    Autoload files (functions are ready for calling), but
+    no defaults are configured unless OPTION-LIST is set.
+
+Alternatively, you can select from OPTION-LIST what packages and what
+options inside it will be installed. See list of packages and their
+options with command \\[tiny-setup-display]
+
+    The syntax for each package is the same and the symbol passed is
+    composed from keywords:
+
+        <package>--   Name of package affected, like `tinyeat--'.
+
+        activate    Activate feature in all related buffers.
+                    Like turning on `tinylisp-mode' in all Emacs lisp
+                    buffers or `tinyperl-mode' in all perl files.
+
+        bind        Bind default keys. This will arrange package
+                    to an autoload state. When a certain key is pressed,
+                    package is loaded.
+
+        bindforce   Overwrite any existing Emacs binding. This is like
+                    bind, but without a safe check.
+
+        bindemacs   Bind keys that are known to be occupied in Emacs.
+
+        load        Load package. If you're tempted to use this,
+                    consider investing to more efficient method described
+                    in tinyload.el. Packages that have complex setup or
+                    which can't be autoloaded easily are categorized as
+                    \"load\".
+
+        autoload    Configure package so that it will get loaded if function
+                    related to a package is needed.
+
+    For example, to enable options in tinyadvice.el and tinyurl.el, you could
+    send option list below. Notice that multiple options for a package
+    are separated by single dashes.
+
+        (require 'tiny-setup)
+        (tinypath-setup 'all '(tinyadvice--load tinyurl--autoload-bind ...))
+                                                |        |        |
+                                                |        |        Option 2.
+                                                |        Option 1.
+                                                Package.
+
+\(fn &optional TYPE OPTION-LIST)" t nil)
+
+(autoload 'tiny-setup-display "tiny-setup" "\
+List all packages and available setup options.
+With Argument, like, \\[universal-argument], list NO-DESCRIPTIONS.
+
+\(fn &optional NO-DESCRIPTIONS)" t nil)
+
+(autoload 'tiny-setup-autoload-read "tiny-setup" "\
+Read all autoloads. Makefile must have been run for this to work.
+Syntax in Tiny Tools kit bin/ directory: perl makefile.pl autoload.
+
+\(fn)" nil nil)
+
+;;;***
diff --git a/elisp/tiny/tiny-admin-util.el b/elisp/tiny/tiny-admin-util.el
new file mode 100644 (file)
index 0000000..04d4132
--- /dev/null
@@ -0,0 +1,514 @@
+;;; tiny-admin-util.el --- Tiny Tools administrative utilities for maintainer
+
+;; This file is not part of Emacs
+
+;;{{{ Id
+
+;; Copyright (C)    2001-2012 Jari Aalto
+;; Keywords:        extensions
+;; Author:          Jari Aalto
+;; Maintainer:      Jari Aalto
+
+;; Look at the code with folding.el
+
+;; COPYRIGHT NOTICE
+;;
+;; This program 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 of the License, or (at your option)
+;; any later version.
+;;
+;; This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+;;
+;; Visit <http://www.gnu.org/copyleft/gpl.html> for more information
+
+;;}}}
+;;{{{ Install
+
+;; Nothing to install. Load this file.
+
+;;}}}
+
+;;{{{ Documentation
+
+;;; Commentary:
+
+;;  Desription
+;;
+;;      This file contains administrative functions to maintain the
+;;      project. There are no user functions.
+;;
+;;  Administration
+;;
+;;     Autoload files
+;;
+;;      If *loaddef* files were not included in the package or if they were
+;;      mistakenly deleted. Use following functions
+;;
+;;          tiny-setup-generate-loaddefs-dir
+;;          tiny-setup-generate-loaddefs-recursive
+;;
+;;          tiny-setup-autoload-build-for-file
+;;          tiny-setup-autoload-build-for-dir
+;;          tiny-setup-autoload-build-recursive
+;;
+;;     Compilation check
+;;
+;;      To check for possible leaks in code, ran the byte compilation
+;;      function from shell by using XEmacs compiler. The Emacs byte
+;;      compiler is not that good in findings all errors.
+;;      See function `tiny-setup-compile-kit-all'.
+;;
+;;     Profiling
+;;
+;;      To check how much time each file load would take, see function
+;;      `tiny-setup-test-load-time-libraries'. Here are results as of
+;;      2001-03-18 running Win9x/512Meg/400Mhz, Emacs 20.7, non-compiled
+;;      files:
+;;
+;;          Timing tinyliba,  took     2.025000 secs (autoloads)
+;;          Timing tinylibb,  took     0.011000 secs
+;;          Timing tinylibm,  took     0.977000 secs
+;;          Timing tinylib,   took     0.982000 secs
+;;          Timing tinylibid, took     0.006000 secs
+;;          Timing tinylibo,  took     0.005000 secs
+;;          Timing tinylibt,  took     0.011000 secs
+;;          total time is 4.027999997138977 seconds
+
+;;}}}
+
+;;; Change Log:
+
+;;; Code:
+
+(eval-when-compile
+  (load "cl-seq")
+  (require 'cl))
+
+(require 'tinylib)
+
+(defconst tiny-setup-:library-compile-order
+  '("tinylibenv.el"
+    "tinyliba.el"
+    "tinylibm.el"
+    "tinylibb.el")
+  "Order of compilation of the libraries.
+This variable is list of REGEXPS.")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;
+;;      GENERAL UTILITIES
+;;
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defconst tiny-setup-:ignore-dir-regexp
+  "\\(\\.\\(bzr\\|hg\\|git\\|svn\\|mtn\\)\\|CVS\\|RCS\\|_MTN\\|\\.\\.?\\)$"
+  "Regexp to ignore directories.")
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-directory-list (dir)
+  "Return all directories under DIR."
+  (let (list)
+    (dolist (elt (directory-files dir 'full))
+      (when (and (file-directory-p elt)
+                 (not (string-match "[\\/]\\.\\.?$" elt)))
+        (push elt list)))
+    list))
+
+;;; ----------------------------------------------------------------------
+;;;
+(put 'tiny-setup-directory-recursive-macro 'lisp-indent-function 1)
+(put 'tiny-setup-directory-recursive-macro 'edebug-form-spec '(body))
+(defmacro tiny-setup-directory-recursive-macro (directory &rest body)
+  "Start from DIRECTORY and run BODY recursively in each directory.
+
+Following variables are set during BODY:
+
+`dir'      Directrory name
+`dir-list' All directories under `dir'."
+  (`
+   (flet ((recurse
+           (dir)
+           (let* ((dir-list (tiny-setup-directory-list dir)))
+             (,@ body)
+             (when dir-list
+               (dolist (elt dir-list)
+                 (unless (string-match tiny-setup-:ignore-dir-regexp elt)
+                   (recurse elt)))))))
+     (recurse (, directory)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;
+;;      TIMING UTILITIES
+;;      These are admistrative utilies for package maintainer(s)
+;;
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-time-difference (a b)
+  "Calculate difference between times A and B.
+The input must be in form of '(current-time)'
+The returned value is difference in seconds.
+E.g. if you want to calculate days; you'd do
+\(/ (ti::date-time-difference a b) 86400)  ;; 60sec * 60min * 24h"
+  (multiple-value-bind (s0 s1 s2) a
+    (setq a (+ (* (float (ash 1 16)) s0)
+               (float s1) (* 0.0000001 s2))))
+  (multiple-value-bind (s0 s1 s2) b
+    (setq b (+ (* (float (ash 1 16)) s0)
+               (float s1) (* 0.0000001 s2))))
+  (- a b))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defvar tiny-setup-:time nil)
+(put 'tiny-setup-time-this 'lisp-indent-function 0)
+(put 'tiny-setup-time-this 'edebug-form-spec '(body))
+(defmacro tiny-setup-time-this (&rest body)
+  "Run BODY with and time execution. Time is in `my-:tmp-time-diff'."
+  `(let* ((tmp-time-A (current-time))
+          tmp-time-B)
+     ,@body
+     (setq tmp-time-B (current-time))
+     (setq tiny-setup-:time
+           (tiny-setup-time-difference tmp-time-B tmp-time-A))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(put 'tiny-setup-with-file-env-macro 'lisp-indent-function 0)
+(put 'tiny-setup-with-file-env-macro 'edebug-form-spec '(body))
+(defmacro tiny-setup-with-file-env-macro (&rest body)
+  "Run BODY with all the interfering hooks turned off."
+  `(let* (find-file-hook
+          write-file-hooks
+          font-lock-mode
+          ;; buffer-auto-save-file-name
+          auto-save-hook
+          auto-save-default
+          (auto-save-interval 0)
+          (original-backup-inhibited backup-inhibited)
+          (backup-inhibited t))
+     ;; Reset also global
+     (setq-default backup-inhibited t)
+     ;;  When each file is loaded to emacs, do not turn on lisp-mode
+     ;;  or anything else => cleared file hooks. These are byte compiler
+     ;;  silencers:
+     (if (null find-file-hook)
+         (setq find-file-hook nil))
+     (if (null write-file-hooks)
+         (setq write-file-hooks nil))
+     (if (null font-lock-mode)
+         (setq font-lock-mode nil))
+     (if (null auto-save-hook)
+         (setq auto-save-hook nil))
+     (if (null auto-save-default)
+         (setq auto-save-default nil))
+     (if auto-save-interval
+         (setq auto-save-interval 0))
+     (if backup-inhibited
+         (setq backup-inhibited t))
+     ,@body))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-time-load-file (file)
+  "Time lisp FILE loading."
+  (interactive "fload file and time it: ")
+  (tiny-setup-time-this
+   (load file))
+  (message "Tiny: Timing %-15s took %12f secs" file tiny-setup-:time))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-test-load-time-libraries ()
+  "Time package load times."
+  (interactive)
+  (message "\n\n** Tiny setup: timing test start\n")
+  (message "load-path: %s"
+           (prin1-to-string load-path))
+  (let* ((path (locate-library "tinylib.el"))
+         (time-a (current-time))
+         time-b)
+    (if (not path)
+        (message "Tiny: [timing] Can't find tinylib.el along `load-path'")
+      (setq path (file-name-directory path))
+      (dolist (pkg (directory-files path 'full "^tinylib.*el"))
+        (tiny-setup-time-load-file pkg))
+      (setq time-b (current-time))
+      (message "Tiny: total time is %s seconds"
+               (tiny-setup-time-difference time-b time-a))
+      (display-buffer "*Messages*"))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-test-load-all ()
+  "Load each package to check against errors."
+  (interactive)
+  (message "\n\n** Tiny setup: load test start\n")
+  (let* ((path (locate-library "tinylib.el")))
+    (if (not path)
+        (message "Tiny: [load test] Can't find tinylib.el along `load-path'")
+      (setq path (file-name-directory path))
+      (dolist (pkg (directory-files path 'full "^tiny.*el"))
+        (load pkg))
+      (display-buffer "*Messages*"))))
+
+
+;;; ----------------------------------------------------------------------
+;;; FIXME: remove
+;;; (tiny-setup-autoload-build-functions "~/elisp/tiny/lisp/tiny")
+;;; (tiny-setup-autoload-build-functions "~/elisp/tiny/lisp/other")
+;;;
+(defun tiny-setup-autoload-build-functions (dir &optional regexp)
+  "Build all autoloads form DIR, except for files matching REGEXP.
+Store the autoloads to tiny-DIR-autoload.el"
+  (let* (make-backup-files                 ;; Do not make backups
+         (backup-enable-predicate 'ignore) ;; Really, no backups
+         (files   (directory-files
+                   dir
+                   'full
+                   "\\.el$"))
+         ;; There is no mistake in name here: it is "tiny-autoload-DIRNAME".
+         ;; the other autoload generater will generate
+         ;; "tiny-autoload-loaddefs-DIRNAME"
+         (to-file (tiny-setup-directory-to-file-name dir "tiny-autoload-"))
+         (name    (file-name-nondirectory to-file)))
+    (when files
+      (with-temp-buffer
+        (insert
+         (format ";;; %s -- " name)
+         "Autoload definitions\n"
+         ";;  Generate date: " (format-time-string "%Y-%m-%d" (current-time))
+         "\n\
+;;  This file was automatically generated. Do not change."
+         "\n\n")
+        (dolist (file files)
+          (if (and (stringp regexp)
+                   (string-match regexp file))
+              (message "Tiny: Ignoring autoload creation for %s" file)
+            (ti::package-autoload-create-on-file
+             file (current-buffer) 'no-show)))
+        (insert (tinypath-tmp-autoload-file-footer to-file 'eof))
+        (let ((backup-inhibited t))
+          (write-region (point-min) (point-max) to-file))
+        to-file))
+    (message "TinySetup: Updated ALL autoloads in dir %s" dir)))
+
+;;; ----------------------------------------------------------------------
+;;;     This is autoload generator will generate ALL, that means ALL,
+;;;     autoloads from EVERY function and macro.
+;;;     The implementation is in tinylib.el
+;;;
+;;; (tiny-setup-autoload-build-functions-all "~/elisp/tiny/lisp/")
+;;;
+(defun tiny-setup-autoload-build-functions-all (dir)
+  "Build all autoloads recursively below DIR."
+  (interactive "Dautoload build root dir: ")
+  (let* ((dirs (tiny-setup-directories
+                (directory-files
+                 (expand-file-name dir)
+                 'abs)))
+         (regexp "tinylib\\|autoload\\loaddefs"))
+    (cond
+     (dirs
+      (tiny-setup-autoload-build-functions dir regexp)
+      (dolist (dir dirs)
+        (tiny-setup-autoload-build-functions-all dir)))
+     (t
+      (tiny-setup-autoload-build-functions dir regexp)))))
+
+;;; ----------------------------------------------------------------------
+;;; (tiny-setup-autoload-build-loaddefs-tiny-tools "~/elisp/tiny/lisp/" t)
+;;; (tiny-setup-autoload-build-loaddefs-tiny-tools "~/elisp/tiny/lisp/other" t)
+;;;
+(defun tiny-setup-autoload-build-loaddefs-tiny-tools (dir &optional force)
+  "Build Tiny Tools autoloads below DIR. FORCE recreates everything."
+  (interactive "DAutoload root: \nP")
+  (ti::package-autoload-loaddefs-build-recursive
+   dir
+   "autoload\\|loaddefs" ;; Exclude these files
+   force
+   (function
+    (lambda (dir)
+      (tiny-setup-directory-to-file-name
+       (or dir
+           (error "TinySetup: No DIR"))
+       "tiny-autoload-loaddefs-")))))
+
+;;; ----------------------------------------------------------------------
+;;;     This is autoload generator will generate ONLY functions marked
+;;;     with special ### autoload tag. The implementation used is in
+;;;     core Emacs package autoload.el
+;;;
+;;; (tiny-setup-autoload-batch-update "~/elisp/tiny/lisp/" 'force)
+;;;
+;;; This function is invoked from the perl makefile.pl with the
+;;; ROOT directory as sole argument in Emacs command line.
+;;;
+;;; The build command from prompt is
+;;;
+;;;    $ perl makefile.pl --verbose 2 --binary emacs  autoload
+;;;
+(defun tiny-setup-autoload-batch-update (&optional dir force)
+  "Update autoloads in batch mode. Argument in command line is DIR. FORCE."
+  (interactive "DAutoload dir to update: ")
+  (unless dir
+    (setq dir (pop command-line-args-left))
+    (setq force t))
+  (if dir                               ;Require slash
+      (setq dir (file-name-as-directory dir)))
+  (unless dir
+    (message "Tiny: From what directory to make recursively autoloads?")
+    ;; Self generate error for command line ...
+    (error 'tiny-setup-autoload-batch-update))
+  (message "TinySetup: Generating all autoloads under %s" dir)
+  (let* ((default-directory (expand-file-name dir)))
+    (message "Tiny: tiny-setup-autoload-batch-update %s"  default-directory)
+    (when (not (string-match "^[/~]\\|^[a-zA-Z]:[/\\]"
+                             default-directory))
+      (message "Tiny: Autoload directory must be absolute path name.")
+      (error 'tiny-setup-autoload-batch-update))
+    (tiny-setup-autoload-build-loaddefs-tiny-tools
+     default-directory force)))
+    ;;  This would generate second set of autoloads. Don't do that any more,
+    ;;  rely on Emacs autoload.el instead.
+    ;; (tiny-setup-autoload-build-functions-all default-directory)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;
+;;      PACKAGE BYTE COMPILATION
+;;      These are admistrative utilies for package maintainer(s)
+;;
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; ----------------------------------------------------------------------
+;;;
+(defsubst tiny-setup-file-list-lisp (dir)
+  "Return all lisp files under DIR."
+  (directory-files dir 'full "\\.el$"))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defsubst tiny-setup-file-list-lisp-compiled (dir)
+  "Return all compiled lisp files under DIR."
+  (directory-files dir 'full "\\.elc$"))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-compile-directory (dir &optional function)
+  "Compile all isp files in DIRECTORY.
+Optional FUNCTION is passed one argument FILE, and it should return
+t or nil if file is to be compiled."
+  (dolist (file (tiny-setup-file-list-lisp dir))
+    (when (or (null function)
+              (funcall function file))
+      (byte-compile-file file))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-compile-directory-recursive (root &optional function)
+  "Compile all files under ROOT directory.
+Optional FUNCTION is passed one argument FILE, and it should return
+t or nil if file is to be compiled."
+  (tiny-setup-directory-recursive-macro
+   root
+   (message "TinySetup: compiling directory %s" dir)
+   (tiny-setup-compile-directory
+    dir function)))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-compile-directory-delete-recursive (root)
+  "Delete all compiled files under ROOT directory recursively."
+  (tiny-setup-directory-recursive-macro
+   root
+   (dolist (file (tiny-setup-file-list-lisp-compiled dir))
+     (message "TinySetup: deleting compiled file %s" file)
+     (delete-file file))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-compile-kit-libraries (dir)
+  "Compile tiny tools libraries"
+  (tiny-setup-directory-recursive-macro
+   dir
+   (let ((libs (directory-files dir 'abs-path "tinylib.*\\.el$")))
+     (when libs        ;;  Found correct directory
+       (message "TinySetup: compiling libraries in right order.")
+       (let ((default-directory dir)
+            compile-file)
+        ;; There is certain order of compilation. Low level libraries first.
+        (dolist (regexp tiny-setup-:library-compile-order)
+          (when (setq compile-file ;; compile these first
+                      (find-if (function
+                                (lambda (elt)
+                                  (string-match regexp elt)))
+                               libs))
+            (setq libs (delete compile-file libs))
+            (byte-compile-file compile-file)))
+        (message "TinySetup: compiling rest of the libraries.")
+        (dolist (file libs) ;; Rest of the libraries
+          (cond
+           ((find-if (function
+                      (lambda (regexp)
+                        (string-match regexp file)))
+                     tiny-setup-:library-compile-exclude)
+            (message "TinySetup: ignoring library %s" file))
+           (t
+            (byte-compile-file file)))))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-compile-kit-all (&optional dir)
+  "Compile tiny tools kit under DIR.
+This function can be called from shell command line, where the
+last argument is the DIR from where to start compiling.
+
+Notice that there is `.' at the end of call to `tiny-setup-compile-kit-all':
+
+$ cd root-dir
+$ find . -name \"*elc\" -exec rm {} \\;
+$ emacs -batch -l load-path.el -l tiny-setup.el -f tiny-setup-compile-kit-all .
+
+If only the libraries need compilation, use this command:
+
+$ emacs -batch -l load-path.el -l tiny-setup.el -f -eval '(tiny-setup-compile-kit-libraries \".\")
+
+If only one file needs to be compiled:
+
+$ emacs -batch -l load-path.el -l tiny-setup.el -f -eval batch-byte-compile <file>"
+  (interactive "D[compile] installation root dir: ")
+  (unless dir
+    (setq dir (car-safe command-line-args-left)))
+  (if dir                               ;Require slash
+      (setq dir (file-name-as-directory dir))
+    (error "Compile under which DIR? Give parameter"))
+  (message "tinySetup: byte compiling root %s" dir)
+  ;;  Remove compiled files first
+  (tiny-setup-compile-directory-delete-recursive dir)
+  ;;  Libraries first
+  (tiny-setup-compile-kit-libraries dir)
+  ;;  The rest follows, it doesn't matter if libs are are compiled twice.
+  (tiny-setup-compile-directory-recursive
+   dir
+   (function
+    (lambda (x)
+      (not (string-match "tinylib" x))))))
+
+(provide 'tiny-admin-util)
+
+;;; tiny-admin-util.el ends here
diff --git a/elisp/tiny/tiny-setup.el b/elisp/tiny/tiny-setup.el
new file mode 100644 (file)
index 0000000..08e4300
--- /dev/null
@@ -0,0 +1,1751 @@
+;;; tiny-setup.el --- Tiny Tools configure center.
+
+;; This file is not part of Emacs
+
+;;{{{ Id
+
+;; Copyright (C)    2001-2012 Jari Aalto
+;; Keywords:        extensions
+;; Author:          Jari Aalto
+;; Maintainer:      Jari Aalto
+
+;; Look at the code with folding.el
+
+;; COPYRIGHT NOTICE
+;;
+;; This program 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 of the License, or (at your option)
+;; any later version.
+;;
+;; This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+;;
+;; Visit <http://www.gnu.org/copyleft/gpl.html> for more information
+
+;;}}}
+;;{{{ Install
+
+;; Nothing to install. Load this file.
+
+;;}}}
+
+;;{{{ Documentation
+
+;;; Commentary:
+
+;;  Preface, overview of options
+;;
+;;      This file will configure all Tiny Tool files. The alternative method
+;;      is to look into each package individually and to follow instructions
+;;      there to set up the files.
+;;
+;;      To use this file, see control function `tinypath-setup' for
+;;      full description. Try this:
+;;
+;;          M-x RET load-library RET tiny-setup RET
+;;          C-h f tinypath-setup
+;;          M-x tinypath-setup-display
+;;
+;;          M-x tiny-setup RET                       Default 'all setup
+;;
+;;       To setup all tools from $HOME/.emacs, use:
+;;
+;;          (load "~/path/to/tinypath.el")   ;; Emacs autosetup, SEE THIS!
+;;          (require 'tiny-setup)            ;; control center
+;;          (tiny-setup 'all)                ;; configure all at once.
+;;
+;;       To activate individual features:
+;;
+;;          (tiny-setup nil '(tinymy--defadvice))  ;; Add smart M-x compile
+;;
+;;      After you have loaded this file, have a look at the *Messages*
+;,      (Emacs) or *Message-Log* (XEmcs) buffers, where you can find
+;;      messgaes from the setup procedure.
+;;
+;;      Emacs 21.x news: Windowed Emacs modeline contains new feature,
+;;      where you can activate and deactivate minor modes. Shoot
+;;      modeline with your mouse and follow message: "Mouse-3: minor
+;;      mode menu". Minor modes available here are installed to that menu.
+
+;;}}}
+
+;;; Change Log:
+
+;;; Code:
+
+(error
+ "tiny-setup.el is OBSOLETE and it will be removed. See individual packages how to install them.")
+
+(eval-when-compile
+  (require 'cl))
+
+(require 'tinyliba)
+
+(eval-and-compile
+  (defvar font-lock-mode)
+  (defvar mode-line-mode-menu) ;; Emacs only
+  (autoload 'tinydebian-install                 "tinydebian"   "" t)
+  (autoload 'tinydesk-edit-state-file           "tinydesk"     "" t)
+  (autoload 'tinydesk-unload                    "tinydesk"     "" t)
+  (autoload 'tinydesk-save-state                "tinydesk"     "" t)
+  (autoload 'tinydesk-recover-state             "tinydesk"     "" t)
+  (autoload 'byte-compile-file                  "bytecomp")
+  (autoload 'tinylisp-install                   "tinylisp"      "" t)
+  (autoload 'turn-on-tinylisp-mode              "tinylisp"      "" t)
+  (autoload 'ti::mail-mailbox-p                 "tinylibmail")
+  (autoload 'turn-on-tinymailbox-mode           "tinymailbox"   "" t)
+  (autoload 'turn-on-tinymailbox-mode-maybe     "tinymailbox"   "" t)
+  (autoload 'folding-uninstall                  "folding"       "" t)
+  (autoload 'folding-install-hooks              "folding")
+  (autoload 'turn-on-folding-mode               "folding"       "" t)
+  (autoload 'dired-sort-default-keys            "dired-sort")
+  (autoload 'tinymy-define-keys-extra           "tinymy")
+  (autoload 'tinymy-compile-run-command-advice  "tinymy"        "" t)
+  (autoload 'tinymy-define-keys                 "tinymy")
+  (autoload 'tinyef-minibuffer-define-key-extras "tinyef"      "" t)
+  (autoload 'turn-on-tinyef-mode                "tinyef"        "" t)
+  (autoload 'turn-on-tinypair-mode              "tinypair"      "" t)
+  (autoload 'turn-off-tinypair-mode             "tinypair"      "" t)
+  (autoload 'turn-on-tinyperl-mode-all-buffers  "tinyperl"      "" t)
+  (autoload 'tinyrmail-install                  "tinyrmail"     "" t)
+  (autoload 'turn-on-tinycompile-mode           "tinycompile"   "" t)
+  (autoload 'tinytag-install-sample-databases   "tinytag"       "" t)
+  (autoload 'turn-on-tinytf-mode                "tinytf"        "" t)
+  (autoload 'turn-on-tinyurl-mode               "tinyurl"       "" t))
+
+;;  Copy from tinylib.el
+(defmacro tiny-setup-ti::macrov-mode-line-mode-menu (mode-symbol text)
+  "Add MODE-SYMBOL to minor mode list in Emacs mode line menu."
+  (let ((sym  (vector (intern (symbol-name (` (, mode-symbol)))))))
+    (` (when (boundp 'mode-line-mode-menu) ;; Emacs 21.1
+         (define-key mode-line-mode-menu (, sym)
+           '(menu-item (, text)
+                       (, mode-symbol)
+                       :button (:toggle . (, mode-symbol))))))))
+
+(defvar tiny-setup-load-hook nil
+  "*Hook run when package is loaded.")
+
+(defconst tiny-setup-:library-compile-order
+  '("tinylibenv.el"
+    "tinyliba.el"
+    "tinylibm.el"
+    "tinylibb.el")
+  "Order of compilation of the libraries.
+This variable is list of REGEXPS.")
+
+(defconst tiny-setup-:library-compile-exclude
+  '("tinylib-ad.el") ;; adviced functions
+  "Libraries not to compile.")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;
+;;      SETUP CHOICES
+;;
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;  See list of file descriptions with this bash script:
+;;
+;;      head -1 $(ls *el | sort) | grep ';;'
+
+(defconst tiny-setup-:option-table
+  '(("dired-sort"
+     ("Dired sort package. Defines `s' key prefix to dired.")
+     ("autoload"))
+
+    ("folding"
+     ("Folding content management package. Detect {{{ and }}}.")
+     ("autoload"))
+
+    ("tinyadvice"
+     "Collection of advised functions."
+     ("load"))
+
+    ("tinyappend"
+     "A simple text gathering to buffer utility."
+     ("bind" "bindforce"))
+
+    ("tinybookmark"
+     "Keep file in organized sections."
+     ("bind"))
+
+    ("tinybuffer"
+     "Change buffers in current window."
+     ("bind" "bindforce"))
+
+    ("tinycache"
+     "Maintain a cache of visited files [compile, dired]."
+     ())
+
+    ("tinychist"
+     "Command history save/restore utility."
+     ())
+
+    ("tinycygwin"
+     "Cygwin bug reporting interface and other Cygwin utilities."
+     ()) ;;#todo:
+
+    ("tinycomment"
+     "Smart comment setting utility."
+     ("autoload" "bind"))
+
+    ("tinycompile"
+     "Compile buffer additions. Minor mode."
+     ("autoload"))
+
+    ("tinydesk"
+     "Save and restore files between Emacs sessions."
+     ("activate" "bind" "bindforce"))
+
+    ("tinydiff"
+     "Diff and patch minor mode. Browsing, patching."
+     ("autoload" "bind" "bindforce"))
+
+    ("tinydebian"
+     "Debian Linux utilities for system administrator. Bug reports etc."
+     ("autoload" "load"))
+
+    ("tinydired"
+     "Dired enhancements. Background Ange ftp support."
+     ("autoload"))
+
+    ("tinyeat"
+     "Eat blocks of text at point, forward and backward."
+     ("bind" "bindforce"))
+
+    ("tinyef"
+     "(E)lectric (f)ile minor mode. Easy C-x C-f filename composing."
+     ("autoload" "bindextra"))
+
+    ("tinygnus"
+     "Gnus Plug-in. Additional functions. Spam complain and more."
+     ("autoload"))
+
+    ("tinyhotlist"
+     "Hot-list of important buffers and  files. Entry can be ange-ftp or dired too."
+     ("autoload" "bind" "bindforce" "bindmouse"  "bindmouseforce"))
+
+    ("tinyigrep"
+     "Top level interface to igrep.el."
+     ("autoload" "bind" "bindforce"))
+
+    ;;  there is nothing to setup in libraries. These are already
+    ;;  autoloaded in tinyliba.el
+
+    ("tinylib-ad"
+     "Library of advised functions. Backward compatibility."
+     ())
+    ("tinylib"
+     "Library of general functions."
+     ())
+    ("tinyliba"
+     "Library for (a)utoload definitions."
+     ())
+    ("tinylibb"
+     "Library of (b)ackward compatible functions."
+     ())
+    ("tinylibck"
+     "Library to (c)onvert (k)eybindings for XEmacs or Emacs."
+     ())
+    ("tinylibenv"
+     "Library for environment check functions."
+     ())
+    ("tinylibid"
+     "Library for (Id)entifying buffer, regardless of mode."
+     ())
+    ("tinylibm"
+     "Library of s(m)all macros or functions."
+     ())
+    ("tinylibmenu"
+     "Library for echo-area menu."
+     ())
+    ("tinylibmail"
+     "Library of (m)ail and news (t)ool functions."
+     ())
+    ("tinylibo"
+     "Library for handling (o)verlays."
+     ())
+    ("tinylibt"
+     "Library for handling text properties."
+     ())
+    ("tinyliby"
+     "Library of functions related to Emacs s(y)stem."
+     ("defalias"))
+
+    ("tinylisp"
+     "Emacs lisp programming help grab-bag."
+     ("autoload" "activate"))
+
+    ("tinyload"
+     "Load set of packages when Emacs is idle (lazy load)."
+     ())
+
+    ;;  This asks lock password at startup, can't define "load" option
+    ;;  for this for unattended load.
+
+    ("tinylock"
+     "Simple Emacs locking utility."
+     ()) ;;#todo:
+
+    ("tinylpr"
+     "Easy Emacs lpr command handling, pop-up, completions."
+     ("bind"))
+
+    ("tinymacro"
+     "Fast way to assign newly created macro to a key. Redefines C-x )"
+     ("bind" "bindforce"))
+
+    ("tinymail"
+     "Mail add-ons. Report incoming mail, passwd, BBDB complete."
+     ("autoload"))
+
+    ("tinymailbox"
+     "Berkeley style mailbox browsing minor mode."
+     ("autoload"))
+
+    ("tinymy"
+     "Collection of user (`my') functions. Simple solutions."
+     ("load" "bind" "bindforce" "defalias" "defadvice"))
+
+    ("tinynbr"
+     "Number conversion minor mode oct/bin/hex."
+     ("autoload")) ;; Already autoloaded. M-x turn-on-tinynbr-mode
+
+    ("tinypad"
+     "Emulate Windows notepad with extra menu."
+     ("autoload"))
+
+    ("tinypage"
+     "Handling ^L pages. Select, cut, copy, renumber headings etc."
+     ("autoload" "bind"))
+
+    ("tinypair"
+     "Self insert character (pa)irs () \"\" '' <>."
+     ("autoload" "activate"))
+
+    ;; Please see the documentation in this file
+    ;; LOAD tinypath.el AS VERY FIRST PACKAGE. Before even tiny-setup.pl
+
+    ("tinypath"
+     "Manage Emacs startup dynamically."
+     ())
+
+    ("tinyperl"
+     "Grab-bag of Perl language utilities. Pod documentation browser."
+     ("autoload"))
+
+    ("tinypgp"
+     "PGP minor mode, remailing, keyring management."
+     ())
+
+    ("tinyprocmail"
+     "Procmail minor mode and coding checker. See http://www.procmail.org/"
+     ("autoload"))
+
+    ("tinyreplace"
+     "Handy query-replace, area, case preserve, words."
+     ("bind"))
+
+    ("tinyrmail"
+     "RMAIL add-ons, pgp, mime labels, Spam complaint."
+     ("autoload"))
+
+    ("tinyscroll"
+     "Enable or Disable auto-scroll for any buffer."
+     ("autoload"))
+
+    ("tinysearch"
+     "Grab and search word under cursor."
+     ("bind" "bindforce" "bindmousealt" "bindmousemeta"))
+
+    ("tinytab"
+     "Programmed TAB minor mode."
+     ("autoload" "bind" "bindforce" "bindextra" "bindextraforce"))
+
+    ("tinytag"
+     "Coding help. E.g. show Java/Perl/C++ function call syntax while coding."
+     ("autoload"))
+
+    ("tinytf"
+     "Document layout tool for '(T)echnical text (F)ormat."
+     ("autoload"))
+
+    ("tinyurl"
+     "Mark and jump to any URL on current line. Support also C, C++, Perl, Elisp."
+     ("autoload" "bind"))
+
+    ("tinyvc"
+     "CVS and RCS log minor mode. Check-out, Check-in."
+     ("autoload"))
+
+    ("tinyxreg"
+     "Restore points and window configurations stored in register via X-popup."
+     ("bind")))
+  "Packages and options. This variable is not user configurable.
+Format is:
+ '((PACKAGE ((OPTION-STR ..) ..))).")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;
+;;      USER SPACE: CONFIGURE SETUP FOR ALL FILES
+;;
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tiny-setup (&optional type option-list)
+  "Tiny Tools setup controller. See Message buffer for results.
+
+Please make sure you have run the makefile.pl with build option
+\"all\" or \"autoload\". You can verify this by finding files which
+contain word \"loaddefs\".
+
+Autoload statements are always defined when this function is called,
+so even if you do not define any options to be installed, they will be
+available in callable functions that trigger loading packages. This
+means, that you an call e.g function \\[tinytab-mode] and the call
+will trigger loading package tinytab.el
+
+Please notice, that this central setup function configures only the
+essential packages, even with TYPE and FEATURE-LIST. The listing
+\\[tiny-setup-display] lists many packages that are not loaded
+or set up in any default way because a) package's scope is very narrow
+and it may not interest the majority b) there is no sensible autoload
+and it requires manual settings: tinyload.el and tinypath.el are
+good example of this. c) package is a library and it has been
+taken cared of by other means.
+
+Remember that all functions are autoloaded and accessible, although
+packages marked <no options> may not have default configurations. Here is
+sample listing that you may expect from \\[tiny-setup-display] which
+displays then content of `tiny-setup-:option-table' when no tiny-setup
+configure options are not defined and you should load the package as
+instructed in the file itself:
+
+    ..
+    tinychist            <no options defined to install>
+    ...
+                         Command history save/restore utility.
+    tinyload             <no options defined to install>
+                         Load set of packages when Emacs is idle (lazy load).
+    tinylock             <no options defined to install>
+                         Simple emacs locking utility.
+    ...
+    tinynbr              <no options defined to install>
+                         Number conversion minor mode oct/bin/hex.
+    ...
+    tinypath             <no options defined to install>
+                         Manage Emacs startup dynamically.
+
+Here is one way to install packages: a) configure paths automatically b)
+load default setup and enable some extra features c) define
+delayed loading for some packages that you use most of the time.
+
+   (load \"/ABSOLUTE-PATH/tinypath.el\")
+
+   ;;  Define \"ready to use packages\"
+
+   (require 'tiny-setup)
+
+   (tinypath-setup
+     'all                       ;; Activate default features safely
+     ;; plus features that you want
+    '(tinyeat--bind
+      tinydesk--bindforce
+      tinymy--defadvice         ;;  Make M-x compile smarter
+      tinydiff--bind
+      tinydired--autoload
+      tinyef--bindextra
+      tinyeat--bindforce
+      tinymacro--bindforce
+      tinydesk--bindforce
+      tinypair--activate
+      tinylisp--activate        ;; turn on on in all .el buffers
+      ..))
+
+   ;; Delayed loading of these packages, when Emacs goes idle.
+
+   (setq tinyload--load-list
+     '(\"tinyadvice\"           ;; NOTE: for Emacs only.
+       \"tinymy\"
+       \"tinymail\"
+       \"tinygnus\"
+       \"tinyigrep\"
+      ..))
+
+  (require 'tinyload)
+
+Here is yet another example. The `tiny-setup' function can configure only
+the very basic features. You can manually set default values before
+packages are loaded (look into each file for interesting things).
+
+    ;; First, configure few packages MANUALLY
+
+    (require 'tinylibm)
+
+    (ti::add-hooks 'tinytf--mode-define-keys-hook
+                   '(tinytf-mode-define-keys tinytf-mode-define-f-keys))
+
+    (setq tinymy--define-key-force t)
+    (setq tinyef--mode-key \"\\C-cmr\")
+
+    (setq tinylock--auto-lock-interval1 45)     ;in minutes
+
+    (setq tinyef--mode-key-table
+          '((?\[   . step-delete-back)          ;KEY -- action symbol
+            (?\]   . step-delete-fwd)
+            (?\*   . chunk-delete)
+            (?\;   . move-back)
+            (?\'   . move-fwd)
+            (?\~   . e-tilde)
+            (?\/   . e-slash)
+            (?\$   . e-dollar)))
+
+    ;; After that, let the central configure tool do the rest
+
+    (require 'tiny-setup)
+
+    (tiny-setup
+     'all
+     '(tinymy--bind-bindemacs
+       tinytab--bindforce-bindextra
+       tinyreplace--bindemacs
+       tinyeat--bindforce))
+
+The major TYPE of installation can be one of the following:
+
+    'autoload
+
+    Setup packages so that they are loaded when the options are needed,
+    but do not define any key-bindings that already exist. This will
+    bind free keys to trigger loading packages.
+
+    'all
+
+    Configure with all options on. This will affect free key-bindings.
+
+    nil
+
+    Autoload files (functions are ready for calling), but
+    no defaults are configured unless OPTION-LIST is set.
+
+Alternatively, you can select from OPTION-LIST what packages and what
+options inside it will be installed. See list of packages and their
+options with command \\[tiny-setup-display]
+
+    The syntax for each package is the same and the symbol passed is
+    composed from keywords:
+
+        <package>--   Name of package affected, like `tinyeat--'.
+
+        activate    Activate feature in all related buffers.
+                    Like turning on `tinylisp-mode' in all Emacs lisp
+                    buffers or `tinyperl-mode' in all perl files.
+
+        bind        Bind default keys. This will arrange package
+                    to an autoload state. When a certain key is pressed,
+                    package is loaded.
+
+        bindforce   Overwrite any existing Emacs binding. This is like
+                    bind, but without a safe check.
+
+        bindemacs   Bind keys that are known to be occupied in Emacs.
+
+        load        Load package. If you're tempted to use this,
+                    consider investing to more efficient method described
+                    in tinyload.el. Packages that have complex setup or
+                    which can't be autoloaded easily are categorized as
+                    \"load\".
+
+        autoload    Configure package so that it will get loaded if function
+                    related to a package is needed.
+
+    For example, to enable options in tinyadvice.el and tinyurl.el, you could
+    send option list below. Notice that multiple options for a package
+    are separated by single dashes.
+
+        (require 'tiny-setup)
+        (tinypath-setup 'all '(tinyadvice--load tinyurl--autoload-bind ...))
+                                                |        |        |
+                                                |        |        Option 2.
+                                                |        Option 1.
+                                                Package."
+  (interactive)
+  (when (and (interactive-p)
+             (eq type nil)
+             (eq option-list nil))
+    (setq type 'all))
+  (tiny-setup-autoload-read)
+  (cond
+   ((eq type 'all)
+    (tiny-setup-all nil))
+   ((eq type 'autoload)
+    (tiny-setup-all 'autoload-bind)))
+  (when option-list
+    (tiny-setup-option-process option-list))
+  (message "TinySetup: Done.%s"
+           (if (ti::xemacs-p)
+               " See buffer \" *Message-Log*\""
+             " See buffer *Messages*")))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-option-process (option-list)
+  "Process OPTION-LIST described in `tiny-setup'.
+OPTION-LIST items items are in form:
+
+   PACKAGE--OPTION-OPTION-OPTION-..
+
+Like
+
+   '(tinymy--bind-bindextra)
+             |    |
+             |    option 2
+             option 1
+
+See also `tiny-setup-:option-table'."
+  (dolist (elt option-list)
+    (let* ((name (symbol-name elt))
+           (package (if (string-match "\\(^[^ \t-]+\\)--" name)
+                        (match-string 1 name))))
+      (if package
+          (tiny-setup-package package elt)
+        (message "TinySetup: Invalid setup option format %s" name)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-all (&optional type)
+  "Setup all tools with TYPE."
+  (dolist (elt tiny-setup-:option-table)
+    (tiny-setup-package (car elt) type)))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tiny-setup-display (&optional no-descriptions)
+  "List all packages and available setup options.
+With Argument, like, \\[universal-argument], list NO-DESCRIPTIONS."
+  (interactive "P")
+  (let* ((buffer (get-buffer-create "*tiny-setup*")))
+    (with-current-buffer buffer
+      (erase-buffer)
+      (insert "package              Supported install options\n"
+              "-----------          "
+              (make-string 30 ?-)
+              "\n")
+      (dolist (elt tiny-setup-:option-table)
+        (insert (format "%-20s %s\n%-20s %s\n"
+                        (car elt)
+                        (if (null (tiny-setup-nth-options elt))
+                            "<no options defined to install>"
+                          (mapconcat
+                           'identity
+                           (sort (tiny-setup-nth-options elt) 'string<)
+                           " "))
+                        ""
+                        (tiny-setup-nth-description elt))))
+      (insert "
+The options can be installed by adding code like this to .emacs:
+
+    (require 'tiny-setup)
+    (tinypath-setup nil '(tinyadvice--load tinyurl--autoload-bind ...))
+")
+      (goto-char (point-min))
+      (display-buffer (current-buffer)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(put 'tiny-setup-error-macro 'lisp-indent-function 0)
+(put 'tiny-setup-error-macro 'edebug-form-spec '(body))
+(defmacro tiny-setup-error-macro (&rest body)
+  "Show error."
+  (` (progn
+       (pop-to-buffer (get-buffer-create "*TinySetup Error*"))
+       (,@ body))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(put 'tiny-setup-dolist-buffer-list 'lisp-indent-function 0)
+(put 'tiny-setup-dolist-buffer-list 'edebug-form-spec '(body))
+(defmacro tiny-setup-dolist-buffer-list (&rest body)
+  "Run BODY in each buffer."
+  (`
+   (dolist (buffer (buffer-list))
+     (with-current-buffer buffer
+       (,@ body)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tiny-setup-autoload-read ()
+  "Read all autoloads. Makefile must have been run for this to work.
+Syntax in Tiny Tools kit bin/ directory: perl makefile.pl autoload."
+  (condition-case err
+      (progn
+        ;;  It's better to use `load' and not `require' because user may run
+        ;;  makefile again.
+        (load "tiny-autoload-loaddefs-tiny")
+        (load "tiny-autoload-loaddefs-other"))
+    (error
+     (let* ((str
+             (format
+              (concat
+               "\
+TinySetup: Error in reading autoload loaddefs. %s
+
+Symptoms: load-path:
+
+    Please check that your `load-path' contains directories
+    tiny/lisp/tiny and tiny/lisp/other.
+
+    To check your load path, run \\[tinypath-load-path-display]
+    or run this lisp code:
+
+       (insert (prin1-to-string load-path))
+                                           |
+                                           Put cursor here and press
+                                           C-u C-x C-e
+
+Symptoms: autoload files:
+
+    Check that the tiny-autoload*el files are present in these directories.
+    If there is no autoload files, create them by running makefile:
+
+    cd bin/
+    perl makefile.pl --verbose 2 autoload.
+
+Symptoms: compiled files
+
+    There may be problem with compiled  tiny-autoload*.elc files.
+    Please remove all *.elc files and try again.")
+              (prin1-to-string err))))
+       ;;  Write to *Message* buffer
+       (message str)
+       (tiny-setup-error-macro
+        (insert str
+                "
+
+Symptoms for tinypath.el usage:
+
+    If you use tinypath.el, it may be possible that it didn't find the
+    default ~/elisp or ~/lisp directories. Please move all your Emacs setup
+    files under one of these directories. Alternatively set the location
+    of your private lisp with:
+
+    (require 'cl)
+
+    (setq tinypath--load-path-root '(\"~/your-lisp-dir-location\"))
+    (pushnew \"/ABSOLUTE/INSTALLATION-PATH/HERE\"
+             load-path
+             :test 'string=)
+    (load \"tinypath\")
+
+    (require 'tiny-setup)
+    (tiny-setup 'all)
+
+    Refer to doc/txt/README.txt in tiny-tools kit and
+    \\[tinypath-version] documentation for more instructions how to let
+    tinypath.el set the `load-path' automatically."))
+       (error str)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-option-strings (type)
+  "Return list of options from symbol TYPE."
+  (setq type (symbol-name type))
+  (if (not (string-match "--\\(.*\\)" type))
+      type
+    (split-string (match-string 1 type) "[-]")))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-package-require (package)
+  (message "TinySetup: %s loaded." package)
+  (unless (featurep (intern package))
+    (message "TinySetup: %s LOADED." package)
+    (require (intern package))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-package-option-p (package opt option-list)
+  "Check if PACKAGE and OPT is part of user requested OPTION-LIST."
+  (let (ret)
+    (dolist (elt option-list)
+      (when (string= elt opt)
+        (setq ret t)
+        (return)))
+    (unless ret
+      (message "TinySetup: [%s] No option [] found for `%s'"
+               package
+               (if (eq 1 (length option-list))
+                   (car option-list)
+                 (prin1-to-string option-list))))
+    ret))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-package (package &optional type)
+  "Activate PACKAGE with TYPE.
+If TYPE is nil, activate all options that do not contain word
+`force' or `load'."
+  (let* ((req-options (and type
+                           (tiny-setup-option-strings type)))
+         (list     (tiny-setup-package-options package)))
+    (cond
+     ((null list)
+      (message "TinySetup: %-15s No options to configure."
+               package))
+     (t
+      (unless req-options ;; nil, activate almost all
+        (dolist (option list)
+          (unless (string-match "^load\\|force" option)
+            (push option req-options))))
+      (let* (function
+             sym)
+        (dolist (option req-options)
+          (cond
+           ((not (member option list))
+            (message "TinySetup: Unknown option %s. Choose from %s"
+                     option
+                     (prin1-to-string list)))
+           (t
+            (setq function (format "tiny-setup-%s-%s" package option))
+            (setq sym (intern-soft function))
+            (cond
+             ((and (null sym)
+                   (string= option "load"))
+              (tiny-setup-package-require package))
+             ((null sym)
+              (message "TinySetup: ERROR Unknown function %s"
+                       function))
+             (t
+              (setq function sym)
+              (message "TinySetup: %-15s configured with `%s'" package option)
+              (funcall function)))))))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-nth-options (elt)
+  "Return option list from ELT."
+  (nth 2 elt))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-nth-description (elt)
+  "Return option list from ELT."
+  (nth 1 elt))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-package-options (package)
+  "Return list of options for PACKAGE."
+  (let ((elt   (assoc package tiny-setup-:option-table)))
+    (when elt
+      (tiny-setup-nth-options elt))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-define-key-1
+  (key keymap function &optional prefix str force)
+  "Define KEY to KEYMAP using FUNCTION if not yet occupied.
+
+Input:
+
+  KEY       Key definitions
+  KEYMAP    The map.
+  FUNCTION  function to bind
+  PREFIX    Message prefix. Like \"Package:\" who requested change.
+  STR       Human readable key definition. Shown to user.
+  FORCE     Override key definition without a check."
+  (setq str (if (stringp str)
+                (format "\"%s\"" str)
+              ""))
+  (let ((def (lookup-key keymap key)))
+    (cond
+     (force
+      (message "%sKey %-10s%s set to `%s' (FORCED, was `%s')."
+               (or prefix "")
+               (prin1-to-string key)
+               str
+               (symbol-name function)
+               def)
+      (define-key keymap key function))
+     (t
+      (cond
+       ((or (eq def function)
+            (memq def '(nil ignore))
+            ;; Lookup key returns NBR if the sequence of keys exceed
+            ;; the last keymap prefix
+            ;; C-cck  --> C-cc  is undefined, so there is no C-c c map yet
+            (integerp def))
+        (message "%sKey %-10s%s set to `%s'."
+                 (or prefix "")
+                 (prin1-to-string key)
+                 str
+                 (symbol-name function))
+        (define-key keymap key function))
+       (t
+        (message
+         "%sKey %-10s%s already has a definition `%s'. Not set to `%s'"
+         (or prefix "")
+         (prin1-to-string key)
+         str
+         (prin1-to-string def)
+         (symbol-name function))))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-define-key (key keymap function &optional str force)
+  "Define KEY to KEYMAP using FUNCTION. Display STR and FORCE binding."
+  (tiny-setup-define-key-1
+   key keymap function "TinySetup: " str force))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-alist-search (alist regexp)
+  "Search ALIST for REGEXP."
+  (dolist (elt alist)
+    (if (string-match regexp (car elt))
+        (return elt))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-aput (sym regexp key value &optional force)
+  "Search SYM's for REGEXP and set KEY to VALUE if not found.
+This function effectively compares each key in SYM to REGEXP and
+if there is no matches, it adds new (KEY . VALUE) pair.
+
+Useful, if something needs to be added to the `auto-mode-alist', but
+previous definitions must be preserved."
+  (let* ((found (tiny-setup-alist-search (symbol-value sym) regexp)))
+    (cond
+     ((and found
+           (eq (cdr found) value))
+      (message "TinySetup: `%s' now contains (%s . %s)"
+               (symbol-name sym)
+               key
+               value))
+     (found
+      (message "TinySetup: `%s' already contains %s. Not set to (%s . %s)"
+               (symbol-name sym)
+               (prin1-to-string found)
+               key
+               value))
+     (t
+      (message "TinySetup: `%s' now contains (%s . %s)"
+               (symbol-name sym)
+               key
+               value))
+     (push (cons key value) (symbol-value sym)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tiny-setup-defalias (symbol definition)
+  "Like `defalias' but with verbose messages."
+  (message "TinySetup: defalias `%s' =>  `%s'"
+           (symbol-name symbol)
+           (symbol-name definition))
+  (defalias symbol definition))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;
+;;      USER SPACE: KIT AND PACKAGE CONFIGURATION
+;;
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun tiny-setup-folding-autoload-find-file-hook ()
+  "Install folding if file includes {{{ and }}}.
+Do nothing if folding is already installed."
+  (if (or (fboundp 'folding-install)
+          (featurep 'folding))
+      ;;  Remove ourself from the `find-file-hook'.
+      (remove-hook  'find-file-hook
+                    'tiny-setup-folding-autoload-find-file-hook)
+    (let* ((start  (concat "\\("
+                           (regexp-quote (or comment-start "dummy"))
+                           "\\)+"))
+           (regexp (concat "^" start "{{{ \\|^" start "}}}")))
+      (when (ti::re-search-check regexp)
+        (folding-install-hooks)
+        (turn-on-folding-mode)))))
+
+(defun tiny-setup-folding-autoload ()
+  "Autoload."
+  (defvar folding-mode nil)
+  (tiny-setup-ti::macrov-mode-line-mode-menu
+   folding-mode "Outline (Folding)")
+  (add-hook  'find-file-hook
+             'tiny-setup-folding-autoload-find-file-hook))
+
+(defun tiny-setup-dired-sort-autoload ()
+  "Autoload."
+  (add-hook  'dired-mode-hook 'dired-sort-default-keys 'end))
+
+(defun tiny-setup-tinyadvice-load ()
+  "Load for Emacs only."
+  (if (ti::emacs-p)
+      (require 'tinyadvice)
+    (message "TinySetup: tinyadvice.el is not for XEmacs. Didn't load.")))
+
+(defun tiny-setup-tinyappend-bind (&optional force)
+  "Bind."
+  ;; non-shift key
+  (tiny-setup-define-key  "\C-c+" global-map 'tinyappend-end
+                          "C-c+" force)
+  ;; non-shift key
+  (tiny-setup-define-key  "\C-c_" global-map 'tinyappend-beg
+                          "C-c_" force)
+  (tiny-setup-define-key  "\C-c-" global-map 'tinyappend-kill
+                          "C-c-" force)
+  (tiny-setup-define-key  "\C-c|" global-map 'tinyappend-yank
+                          "C-c|" force))
+
+(defun tiny-setup-tinyappend-bindforce ()
+  "Bind."
+  (tiny-setup-tinyappend-bind 'force))
+
+(defun tiny-setup-tinybookmark-defalias ()
+  "Defalias."
+  ;; (tiny-setup-defalias 'tinybookmark-insert 'bm)
+  nil)
+
+(defun tiny-setup-tinybookmark-bind ()
+  "Bind."
+  (if (ti::emacs-p)
+      (tiny-setup-define-key [(?\e) (control mouse-1)]
+                             global-map 'tinybookmark-mouse)
+    (tiny-setup-define-key [(control meta button1)]
+                           global-map 'tinybookmark-mouse))
+
+  ;; (tiny-setup-define-key [(?\e) (control shift mouse-1)]
+  ;;                     global-map 'tinybookmark-mouse-parse)
+
+  (tiny-setup-define-key [(shift left)]
+                         global-map 'tinybookmark-backward)
+  (tiny-setup-define-key [(shift right)]
+                         global-map 'tinybookmark-forward))
+
+(defun tiny-setup-tinycache-activate ()
+  "Autoload activate package."
+  (add-hook 'compilation-mode-hook
+            '(lambda () (require 'tinycache)))
+  (when (ti::emacs-p)
+    (add-hook 'dired-mode-hook
+              '(lambda () (require 'tinycache))))
+  (eval-after-load "compile"
+    '(progn (require 'tinycache)))
+  (eval-after-load "dired"
+    '(progn (require 'tinycache))))
+
+(defun tiny-setup-tinybuffer-bind (&optional force)
+  "Bind."
+  (tiny-setup-define-key [(control <)]
+                         global-map 'tinybuffer-previous-buffer
+                         nil force)
+  (tiny-setup-define-key [(control >)]
+                         global-map 'tinybuffer-next-buffer
+                         nil force)
+  (tiny-setup-define-key [(control meta <)]
+                         global-map 'tinybuffer-iswitch-to-buffer
+                         nil force)
+  (tiny-setup-define-key [(control meta >)]
+                         global-map 'tinybuffer-sort-mode-toggle
+                         nil force))
+
+(defun tiny-setup-tinybuffer-bindforce ()
+  "Bind."
+  (tiny-setup-tinybuffer-bind 'force))
+
+(defun tiny-setup-tinycomment-autoload ()
+  "Autoload."
+  (autoload 'tinycomment-indent-for-comment "tinycomment" "" t))
+
+(defun tiny-setup-tinycomment-bind (&optional force)
+  "Bind."
+  (tiny-setup-define-key
+   [(meta ?\;)]
+   global-map
+   'tinycomment-indent-for-comment "M-;"
+   (or force
+       ;;  Override default. In Emacs 21.2 this is more intelligent
+       ;;  function comment-dwim
+       (eq (lookup-key global-map [(meta ?\;)])
+           'indent-for-comment))))
+
+(defun tiny-setup-tinycompile-autoload ()
+  "Autoload."
+  (add-hook 'compilation-mode-hook 'turn-on-tinycompile-mode 'append)
+  (dolist (buffer (buffer-list))
+    (with-current-buffer buffer
+      (when (memq major-mode '(compilation-mode))
+        (turn-on-tinycompile-mode)))))
+
+(defun tiny-setup-tinydesk-bind (&optional force)
+  "Bind with optional FORCE."
+  (message "TinySetup: [tinydesk] binding keys in `ctl-x-4-map'")
+  (tiny-setup-define-key
+   "S" ctl-x-4-map
+   'tinydesk-save-state nil force) ;; free in 19.28
+  (tiny-setup-define-key
+   "R" ctl-x-4-map
+   'tinydesk-recover-state nil force) ;; Free in 21.2
+  (tiny-setup-define-key
+   "E" ctl-x-4-map
+   'tinydesk-edit-state-file nil force) ;; free in 19.28
+  (tiny-setup-define-key
+   "U" ctl-x-4-map
+   'tinydesk-unload nil force)) ;; free in 19.28
+
+(defun tiny-setup-tinydesk-bindforce ()
+  "Bind."
+  (tiny-setup-tinydesk-bind 'force))
+
+(defun tiny-setup-tinydesk-activate ()
+  "Activate.")
+
+(defun tiny-setup-tinydiff-autoload ()
+  "Autoload."
+  (tiny-setup-aput 'auto-mode-alist
+                   "diff" "\\.diff\\'" 'turn-on-tinydiff-mode)
+  (tiny-setup-aput 'auto-mode-alist
+                   "patch" "\\.patch\\'"  'turn-on-tinydiff-mode))
+
+(defun tiny-setup-tinydiff-bind (&optional force)
+  "Bind keys."
+  (tiny-setup-define-key
+   "\C-cD"
+   global-map 'tinydiff-diff-show "C-cD" force)
+  (tiny-setup-define-key
+   "\C-cP"
+   global-map 'tinydiff-patch  "C-cP" force))
+
+(defun tiny-setup-tinydiff-bindforce ()
+  "Bind keys."
+  (tiny-setup-tinydiff-bind 'force))
+
+(defun tiny-setup-tinydebian-autoload ()
+  "Autoload."
+  (autoload 'tinydebian-bug-report-mail "tinydebian" "" t))
+
+(defun tiny-setup-tinydebian-load ()
+  "Load."
+  (require 'tinydebian)
+  (tinydebian-install))
+
+(defun tiny-setup-tinydired-autoload ()
+  "Autoload. This is for Emacs only.
+You may want to set
+
+  (setq tinydired--force-add-keys 'override)."
+  (if (ti::xemacs-p)
+      (message "\
+TinySetup: tinydired.el works only with Emacs. Package not loaded.")
+    (add-hook 'tinydired--load-hook    'tinydired-hook-control)
+    (add-hook 'dired-mode-hook '(lambda () (require 'tinydired) nil))
+    ;;  If dired is already loaded, install immediately
+    (dolist (buffer (buffer-list))
+      (with-current-buffer buffer
+        (when (memq major-mode '(dired-mode))
+          (require 'tinydired)
+          (return))))))
+
+(defun tiny-setup-tinyeat-bind (&optional force)
+  "Bind."
+
+  (message "\
+TinySetup: [NOTE] The automatic setup will not make much much good,
+           because no default Emacs keys are redefined. tinyeat.el
+           package delete keys are installed only if you call function
+           `tinyeat-install-default-bindings' directly.")
+
+  ;;  These are REAL difficult choices, because almost every keyboard
+  ;;  interprets backspace differently.
+
+  (tiny-setup-define-key [(control backspace)]
+                         global-map 'tinyeat-forward-preserve
+                         nil force)
+  (tiny-setup-define-key [(control delete)]
+                         global-map 'tinyeat-forward-preserve
+                         nil force)
+
+  (tiny-setup-define-key [(control shift delete)]
+                         global-map 'tinyeat-delete-paragraph
+                         nil force)
+
+  (tiny-setup-define-key [(control shift backspace)]
+                         global-map 'tinyeat-delete-paragraph
+                         nil force)
+
+  (tiny-setup-define-key [(shift backspace)]
+                         global-map 'tinyeat-delete-whole-word
+                         nil force)
+
+  (tiny-setup-define-key [(meta delete)]
+                         global-map 'tinyeat-erase-buffer
+                         nil force)
+
+  (tiny-setup-define-key [(alt control k)]
+                         global-map 'tinyeat-zap-line
+                         nil force)
+
+  (unless (ti::compat-window-system)
+    (tiny-setup-define-key
+     [(control meta ?h)]
+     global-map 'tinyeat-erase-buffer nil force))
+
+  (when (fboundp 'read-kbd-macro)
+    (tiny-setup-define-key
+     (read-kbd-macro "ESC DEL")
+     global-map 'tinyeat-erase-buffer "ESC DEL" force)))
+
+(defun tiny-setup-tinyeat-bindforce ()
+  "Bind with override."
+  (tiny-setup-tinyeat-bind 'force))
+
+(defun tiny-setup-tinyef-bindextra ()
+  "Bind extra keys."
+  (if (not (fboundp 'tinyef-minibuffer-define-key-extras))
+      (add-hook 'tinyef-load-hook 'tinyef-minibuffer-define-key-extras)
+    (tinyef-minibuffer-define-key-extras)))
+
+(defun tiny-setup-tinyef-autoload ()
+  "Autoload."
+  (add-hook 'minibuffer-setup-hook 'turn-on-tinyef-mode))
+
+(defun tiny-setup-tinygnus-autoload ()
+  "Autoload."
+  (defvar tinygnus-group-mode nil)
+  (tiny-setup-ti::macrov-mode-line-mode-menu
+   tinygnus-group-mode "Gnus Group mode extras")
+  (defvar tinygnus-summary-mode nil)
+  (tiny-setup-ti::macrov-mode-line-mode-menu
+   tinygnus-summary-mode "Gnus Summary mode extras")
+  (add-hook 'gnus-startup-hook '(lambda () (require 'tinygnus)))
+  (when (featurep 'gnus)
+    ;;  Gnus already present
+    (require 'tinygnus)))
+
+(defun tiny-setup-tinyhotlist-autoload ()
+  "Autoload."
+  (add-hook 'tinyhotlist--load-hook 'tinyhotlist-load-hotlist))
+
+(defun tiny-setup-tinyhotlist-bindmouse (&optional force)
+  "Bind."
+  (if (not (ti::compat-window-system))
+      (message
+       (concat
+        "TinySetup: tinyhotlist.el Mouse binding skipped."
+        "No window system available."))
+    (if (ti::emacs-p)
+        (tiny-setup-define-key
+         [(control shift mouse-3)]
+         global-map
+         'tinyhotlist-control
+         force)
+      (tiny-setup-define-key
+       [(control shift button3)]
+       global-map
+       'tinyhotlist-control
+       force))))
+
+(defun tiny-setup-tinyhotlist-bindmouseforce ()
+  "Bind."
+  (tiny-setup-tinyhotlist-bindmouse 'force))
+
+(defun tiny-setup-tinyhotlist-bind (&optional force)
+  "Bind."
+  (tiny-setup-define-key
+   (read-kbd-macro "\C-cH")
+   global-map 'tinyhotlist-control "C-cH" force))
+
+(defun tiny-setup-tinyhotlist-bindforce ()
+  "Bind."
+  (tiny-setup-tinyhotlist-bind))
+
+(defun tiny-setup-tinyigrep-autoload ()
+  "Autoload."
+  (if (featurep 'igrep)
+      (require 'tinyigrep)
+    (eval-after-load "igrep" '(progn (require 'tinyigrep)))))
+
+(defun tiny-setup-tinyigrep-bind (&optional force)
+  "Bind."
+  (tiny-setup-define-key
+   (read-kbd-macro "\C-cG")
+   global-map 'tinyigrep-menu "C-cG" force))
+
+(defun tiny-setup-tinyigrep-bindforce ()
+  "Bind."
+  (tiny-setup-tinyigrep-bind 'force))
+
+(defun tiny-setup-tinyliby-defalias ()
+  "Defalias."
+  ;;  Shorter name.
+  (tiny-setup-defalias 'describe-symbols 'ti::system-describe-symbols))
+
+(defun tiny-setup-tinylibt-bind ()
+  "Bind."
+  ;;#todo:
+  ;;   (tiny-setup-define-key "\C-ztm" global-map 'ti::text-mark-region)   ;; e.g. permanent 'mark'
+  ;;   (tiny-setup-define-key "\C-ztu" global-map 'ti::text-unmark-region) ;; remove 'mark'
+  ;;   (tiny-setup-define-key "\C-ztc" global-map 'ti::text-clear-buffer-properties)
+  ;;   (tiny-setup-define-key "\C-ztb" global-map 'ti::text-buffer)
+  ;;   (tiny-setup-define-key "\C-ztU" global-map 'ti::text-undo)
+  nil)
+
+(defun tiny-setup-tinylisp-autoload ()
+  "Autoload."
+  (defvar tinylisp-mode nil)
+  (tiny-setup-ti::macrov-mode-line-mode-menu
+   tinylisp-mode "Emacs Lisp extras")
+  (add-hook 'lisp-mode-hook               'turn-on-tinylisp-mode)
+  (add-hook 'emacs-lisp-mode-hook         'turn-on-tinylisp-mode)
+  (add-hook 'lisp-interaction-mode-hook   'turn-on-tinylisp-mode))
+
+(defun tiny-setup-tinylisp-activate ()
+  "Activate on every lisp buffer."
+  (tiny-setup-tinylisp-autoload) ;; Make sure this is called
+  ;;  If this is vanilla emacs which only has one lisp buffer, *scratch*
+  ;;  then do not load tinylisp.el. install only hooks.
+  ;;
+  ;;  But if there are already any lisp buffers around (count), then
+  ;;  be sure to treat also *scratch*.
+  ;;
+  (let ((count 0))
+    (tiny-setup-dolist-buffer-list
+     (when (and (not (string-match "*scratch*" (buffer-name)))
+                (or (string-match "\\.el$" (buffer-name))
+                    (memq major-mode '(emacs-lisp-mode
+                                       lisp-interaction-mode))))
+       (message "TinySetup: activating tinylisp-mode in %s" (buffer-name))
+       (incf count)
+       (turn-on-tinylisp-mode)))
+    (when (> count 0)
+      (with-current-buffer "*scratch*"
+        (turn-on-tinylisp-mode)))))
+
+(defun tiny-setup-tinylpr-bind ()
+  "Bind."
+  ;;#todo:
+  ;; (ti::use-prefix-key "\C-z")          ;; Free C-z for us.
+  ;; (tiny-setup-define-key "\C-zp" (ti::definteractive (ti::menu-menu global-map 'tinylpr--menu)))
+  nil)
+
+(defun tiny-setup-tinymacro-bind (&optional force)
+  "Bind."
+  ;; (tiny-setup-define-key "\C-x(" global-map 'start-kbd-macro)
+
+  ;;  We must overwrite this any any case, othewise the packages
+  ;;  is not much use. Use 'force unconditionally.
+
+  (tiny-setup-define-key
+   "\C-x)"
+   global-map 'tinymacro-end-kbd-macro-and-assign
+   "C-x)" 'force))
+
+(defun tiny-setup-tinymacro-bindforce ()
+  "Bind."
+  (tiny-setup-tinymacro-bind 'force))
+
+(defun tiny-setup-tinymail-autoload ()
+  "Autoload."
+  (add-hook 'mail-setup-hook     'turn-on-tinymail-mode)
+  (add-hook 'message-mode-hook   'turn-on-tinymail-mode)
+  (add-hook 'tinymail-:mode-hook 'turn-on-tinytab-mode))
+
+(defun tiny-setup-tinymailbox-find-file-hook (&optional disable)
+  "Activate `tinymailbox-mode' on mailbox files."
+  (if (memq 'turn-on-tinymailbox-mode-maybe
+            find-file-hook)
+      ;;  Package has been installed. It handles `find-file-hook'
+      ;;  detection better, so remove us.
+      (setq disable t)
+    (when (ti::mail-mailbox-p)
+      (turn-on-tinymailbox-mode-maybe)))
+  (if disable
+      (remove-hook
+       'find-file-hook
+       'tiny-setup-tinymailbox-find-file-hook)))
+
+(defun tiny-setup-tinymailbox-autoload ()
+  "Autoload."
+  (add-hook  'find-file-hook
+             'tiny-setup-tinymailbox-find-file-hook)
+  ;;  Gnus temporary mailbox files have name "Incoming"
+  (tiny-setup-aput 'auto-mode-alist
+                   "Incoming" "Incoming"  'turn-on-tinymailbox-mode)
+  ;;  Other mailbox files
+  (tiny-setup-aput 'auto-mode-alist
+                   "mbo?x" "\\.mbo?x\\'"  'turn-on-tinymailbox-mode)
+  ;;  Typical procmail spool files, like ~/Mail/spool/mail.work.spool
+  (tiny-setup-aput 'auto-mode-alist
+                   "spool" "\\.spool\\'"  'turn-on-tinymailbox-mode))
+
+(defun tiny-setup-tinymy-defadvice ()
+  "Activate smart M-x compile support."
+  (tinymy-compile-run-command-advice))
+
+(defun tiny-setup-tinymy-bind ()
+  "Bind."
+  (message
+   "TinySetup: [tinymy] You should call function `tinymy-define-keys'."))
+
+(defun tiny-setup-tinymy-bindforce ()
+  "Bind extra keys that replace Emacs keys."
+
+  (tiny-setup-define-key
+   "\C-xq" global-map 'tinymy-buffer-file-chmod nil 'force)
+
+  (tiny-setup-define-key
+   [(prior)] global-map 'tinymy-scroll-up nil 'force)
+
+  (tiny-setup-define-key
+   [(next)] global-map 'tinymy-scroll-down nil 'force)
+
+  (tiny-setup-define-key
+   [(next)] global-map  'tinymy-scroll-down nil 'force)
+
+  (tiny-setup-define-key
+   [(control right)] global-map 'tinymy-word-forward nil 'force)
+
+  (tiny-setup-define-key
+   [(control left)] global-map 'tinymy-word-backward nil 'force)
+
+  (when (and (boundp 'window-system)
+             (symbol-value 'window-system))
+    (tiny-setup-define-key
+     [(meta f)] global-map 'tinymy-word-forward nil 'force)
+    (tiny-setup-define-key
+     [(meta b)] global-map 'tinymy-word-backward nil 'force))
+
+  (when (boundp 'shared-lisp-mode-map)
+    (defvar shared-lisp-mode-map nil) ;; Byte compiler silencer
+    (tiny-setup-define-key
+     "%" shared-lisp-mode-map 'tinymy-vi-type-paren-match nil 'force))
+
+  (when (boundp 'emacs-lisp-mode-map)
+    (tiny-setup-define-key
+     "%" emacs-lisp-mode-map 'tinymy-vi-type-paren-match nil 'force))
+
+  (when (boundp 'lisp-mode-map)
+    (tiny-setup-define-key
+     "%" lisp-mode-map 'tinymy-vi-type-paren-match nil 'force)))
+
+(defun tiny-setup-tinymy-defalias ()
+  "Bind."
+  ;;  Faster prompting for experts
+  (tiny-setup-defalias 'yes-or-no-p 'y-or-n-p))
+
+(defun tiny-setup-tinynbr-autoload ()
+  "Autoload."
+  (defvar tinynbr-mode nil)
+  (tiny-setup-ti::macrov-mode-line-mode-menu
+   tinynbr-mode "Number manipulation"))
+
+(defun tiny-setup-tinypad-autoload ()
+  "Autoload."
+  (defvar tinypad-mode nil)
+  (tiny-setup-ti::macrov-mode-line-mode-menu
+   tinypad-mode "Notepad emulation menu"))
+
+(defun tiny-setup-tinypage-bind ()
+  "Bind."
+  ;;#todo:
+  nil)
+
+(defun tiny-setup-turn-off-tinypair-mode ()
+  "Safeguard to function `turn-off-tinypair-mode'.
+If tinypair.el cannot be found, function `turn-off-tinypair-mode'
+cannot be called. Attempt to do so will yield serious error,
+preventing user to enter minibuffer at all.
+
+To prevent this serious error, package existence is
+verified."
+  (when (locate-library "tinypair")
+    ;; It's safe to call this. Function is already autoloaded.
+    (turn-off-tinypair-mode)))
+
+(defun tiny-setup-tinypair-autoload ()
+  "Autoload."
+  (defvar tinypair-mode nil)
+  (add-hook 'minibuffer-setup-hook 'turn-off-tinypair-mode)
+  (tiny-setup-ti::macrov-mode-line-mode-menu
+   tinypair-mode "Paired insert"))
+
+(defun tiny-setup-tinypair-activate-buffer (mode &optional uninstall)
+  "Activate or deactivate tinypair in buffers."
+  (dolist (buffer (buffer-list))
+    (with-current-buffer buffer
+      (when (eq major-mode mode)
+        (if uninstall
+            (turn-off-tinypair-mode)
+          (turn-on-tinypair-mode))
+        (message "TinySetup: tinypair-mode %s in buffer %s"
+                 (if uninstall
+                     "turned off"
+                   "turned on")
+                 (buffer-name))))))
+
+(defun tiny-setup-tinypair-activate (&optional uninstall)
+  "Install to programming modes."
+  ;;  In Cperl, CC, Java the "{" key is electric, so we don't
+  ;;  install into those buffers.
+  (dolist (mode '(awk-mode-hook
+                  emacs-lisp-mode-hook
+                  sh-mode-hook))
+    (ti::add-hooks mode 'turn-on-tinypair-mode uninstall)
+    (let ((name (symbol-name mode)))
+      (message "TinySetup: tinypair-mode %s %s"
+               (if uninstall
+                   "removed from"
+                 "added to")
+               name)
+      (when (and (string-match "^\\(.*-mode\\)" name)
+                 (setq mode (intern-soft (match-string 1 name))))
+        ;;  Activate in current Emacs
+        (tiny-setup-tinypair-activate-buffer mode uninstall)))))
+
+(defun tiny-setup-tinypage-autoload ()
+  "Autoload."
+  (defvar tinypage-mode nil)
+  (tiny-setup-ti::macrov-mode-line-mode-menu
+   tinypage-mode "Paged ^L mode"))
+
+(defun tiny-setup-tinyperl-autoload ()
+  "Autoload."
+  (defvar tinyperl-mode nil)
+  (tiny-setup-ti::macrov-mode-line-mode-menu
+   tinyperl-mode "Perl extras (pod)")
+  (add-hook 'perl-mode-hook  'turn-on-tinyperl-mode)
+  (add-hook 'cperl-mode-hook 'turn-on-tinyperl-mode)
+  (when (or (featurep 'cperl)
+            (featurep 'perl))
+    (turn-on-tinyperl-mode-all-buffers)))
+
+(defun tiny-setup-tinyprocmail-autoload ()
+  "Autoload."
+  ;;  old procmail files start with rc.*
+  (defvar tinyprocmail-mode nil)
+  (tiny-setup-ti::macrov-mode-line-mode-menu
+   tinyprocmail-mode "Procmail recipe coding")
+  (tiny-setup-aput 'auto-mode-alist
+                   "procmailrc"
+                   "\\.rc\\'\\|^rc\\.\\|procmailrc"
+                   'turn-on-tinyprocmail-mode))
+
+(defun tiny-setup-tinyreplace-bind ()
+  "Bind. Replace M-&"
+  (tiny-setup-define-key [(meta ?&)]
+                         global-map
+                         'tinyreplace-menu
+                         "Meta-&"))
+
+(defun tiny-setup-tinytag-install-sample-databases ()
+  "Delayd installation of databases."
+  (unless (get 'tinytag-install-sample-databases 'done)
+    (tinytag-install-sample-databases)
+    (tiny-setup-tinytag-hook
+     '(tiny-setup-tinytag-install-sample-databases)
+     'uninstall)))
+
+(defun tiny-setup-tinytag-hook (hook-list &optional uninstall)
+  "Activate database install."
+  (ti::add-hooks '(java-mode-hook
+                   jde-mode-hook
+                   c++-mode-hook)
+                 hook-list
+                 uninstall)
+  (ti::add-hooks '(cc-mode-hook
+                   c-mode-hook)
+                 hook-list
+                 uninstall
+                 nil
+                 'check-boundp))
+
+(defun tiny-setup-tinytag-autoload ()
+  "Autoload."
+  (tiny-setup-tinytag-hook
+   '(tinytag-install
+     tiny-setup-tinytag-install-sample-databases)))
+
+(defun tiny-setup-tinyvc-autoload ()
+  "Autoload."
+  ;;  This is bit tricky autoload setup, but it is the only way.
+  ;;  Otherwise you would have to say (require 'tinyvc),
+  ;;  which is not nice at all
+  (defadvice vc-print-log (after tinyvc act)
+    "Run hook `tinyvc-:vc-print-log-hook'."
+    (require 'tinyvc)
+    (run-hooks 'tinyvc-:vc-print-log-hook))
+  (eval-after-load "vc" '(progn (require 'tinyvc))))
+
+(defun tiny-setup-tinyrmail-autoload ()
+  "Autoload."
+  (add-hook 'rmail-mode-hook 'tinyrmail-install)
+  (if (featurep 'rmail)
+      (tinyrmail-install)))
+
+(defun tiny-setup-tinysearch-bindforce ()
+  "Bind search keys.")
+  ;; (tinysearch-install-default-keybindings)
+
+(defun tiny-setup-tinysearch-bindmousealt ()
+  "Bind."
+  (tiny-setup-define-key [(alt control mouse-1)]
+                         global-map 'tinysearch-search-word-forward)
+  (tiny-setup-define-key [(alt control shift mouse-1)]
+                         global-map 'tinysearch-search-word-backward))
+
+(defun tiny-setup-tinysearch-bindmousemeta ()
+  "Bind."
+  (tiny-setup-define-key [(meta control mouse-1)]
+                         global-map 'tinysearch-search-word-forward)
+  (tiny-setup-define-key [(meta control shift mouse-1)]
+                         global-map 'tinysearch-search-word-backward))
+
+(defun tiny-setup-tinyscroll-autoload ()
+  "Autoload."
+  (unless (boundp 'compilation-scroll-output)
+    (add-hook 'compilation-mode-hook
+              '(lambda () (require  'tinyscroll) nil))))
+
+(defun tiny-setup-tinytab-autoload ()
+  "Autoload."
+  (defvar tinytab-mode nil)
+  (tiny-setup-ti::macrov-mode-line-mode-menu
+   tinytab-mode "Tab indent mode"))
+
+(defun tiny-setup-tinytab-bind (&optional force)
+  "Bind."
+  (tiny-setup-define-key "\C-cT"
+                         global-map 'tinytab-mode "C-cT"
+                         force)
+  (tiny-setup-define-key "\C-c\C-m"
+                         global-map 'tinytab-return-key-mode "C-c <RET>"
+                         force))
+
+(defun tiny-setup-tinytab-bindforce ()
+  "Bind."
+  (tiny-setup-tinytab-bind 'force))
+
+(defun tiny-setup-tinytab-bindextra (&optional force)
+  "Bind."
+  ;;  make shift-TAB to toggle mode
+  (tiny-setup-define-key [(control shift backtab)]
+                         global-map 'tinytab-mode nil force)
+  (tiny-setup-define-key [(control shift tab)]
+                         global-map 'tinytab-mode nil force)
+  (tiny-setup-define-key [(control shift kp-tab)]
+                         global-map 'tinytab-mode nil force))
+
+(defun tiny-setup-tinytab-bindextraforce (&optional force)
+  "Bind with FORCE."
+  (tiny-setup-tinytab-bindextra 'force))
+
+;;; .......................................................... &tinytf ...
+
+(defun tiny-setup-tinytf-buffer-type-p ()
+  "Check if bufferi suitable for tinytf.el."
+  (let (case-fold-search)
+    (and (string-match "\\.txt"
+                       (or (buffer-file-name) ""))
+         (not (save-excursion
+                ;; Exclude mail buffers:
+                ;;     From: me@here.com
+                (goto-char (point-min))
+                (re-search-forward "^[-a-z]+: " nil t)))
+         (or (re-search-forward
+              "^Table [Oo]f [Cc]ontents[ \t]*$" nil t)
+             ;; See if we can find level 1 and 2 headings
+             ;;
+             ;; This Heading here
+             ;;
+             ;;     And This Heading here
+             ;;
+             (re-search-forward
+              "^[0-9.]*[A-Z][^ \t\n]+.*[\r\n]+    [A-Z][^ \t\n]" nil t)
+             ;;  Try finding wro headers then
+             ;;
+             ;; This is Header
+             ;;
+             ;; And this is header
+             ;;
+             (and (re-search-forward
+                   "^[0-9.]*[A-Z][^ \t\n][^ \t\n]+" nil t)
+                  (re-search-forward
+                   "^[0-9.]*[A-Z][^ \t\n][^ \t\n]+" nil t))))))
+
+(defun tiny-setup-turn-on-tinytf-mode-maybe ()
+  "Turn on mode function `tinytf-mode' as needed."
+  (let (case-fold-search)
+    (cond
+     ((memq 'turn-on-tinytf-mode-maybe find-file-hook)
+      ;;  tinytf is already loaded, remove ourself.
+      (remove-hook 'find-file-hook 'tiny-setup-turn-on-tinytf-mode-maybe))
+     ((tiny-setup-tinytf-buffer-type-p)
+      (turn-on-tinytf-mode)
+      (remove-hook 'find-file-hook 'tiny-setup-turn-on-tinytf-mode-maybe)))
+    ;;  Hook must return nil
+    nil))
+
+(defun tiny-setup-tinytf-autoload ()
+  "Autoload."
+  (defvar tinytf-mode nil)
+  (tiny-setup-ti::macrov-mode-line-mode-menu
+   tinytf-mode "Technical text")
+  (add-hook 'find-file-hook 'tiny-setup-turn-on-tinytf-mode-maybe))
+
+;;; ......................................................... &tinyurl ...
+
+(defun tiny-setup-tinyurl-mode-maybe ()
+  "Turn on `tinyurl-mode' as needed."
+  (if (featurep 'tinyurl)
+      ;; TinyUrl has already set up the watchdog.
+      (remove-hook 'find-file-hook 'tiny-setup-tinyurl-mode-maybe)
+    ;;  Use simplistic test here. TinyUrl has much better once it's active.
+    (if (ti::re-search-check "[fh]t?tp://[a-z]+[a-z.]+")
+        (turn-on-tinyurl-mode)))
+  ;;  Hook is best to return nil
+  nil)
+
+(defun tiny-setup-tinyurl-autoload ()
+  "Autoload."
+  (defvar tinyurl-mode nil)
+  (tiny-setup-ti::macrov-mode-line-mode-menu
+   tinyurl-mode "Url mode")
+  (add-hook 'find-file-hook 'tiny-setup-tinyurl-mode-maybe))
+
+(defun tiny-setup-tinyurl-bind ()
+  "Bind."
+  (message "TinySetup: [tinyurl] nothing to bind. Call `tinyurl-mode-1'.")
+  ;;*     (tiny-setup-define-key "\C-cmuu"  global-map 'tinyurl-mode)
+  ;;*     (tiny-setup-define-key "\C-cmu1"  global-map 'tinyurl-mode-1)
+  ;;*     (tiny-setup-define-key "\C-cmup"  global-map 'tinyurl-plugged-mode-toggle)
+  nil)
+
+(defun tiny-setup-tinyxreg-bind ()
+  "Bind."
+  (tiny-setup-define-key "\C-x/"
+                         global-map 'tinyxreg-point-to-register "C-x/" 'force)
+  (tiny-setup-define-key "\C-x\\"
+                         global-map 'tinyxreg-remove-register "C-x\\")
+  (tiny-setup-define-key "\C-cj"
+                         global-map 'tinyxreg-jump-to-register "C-cj" ))
+
+(provide   'tiny-setup)
+(run-hooks 'tiny-setup-load-hook)
+
+;;; tiny-setup.el ends here
diff --git a/elisp/tiny/tinyadvice.el b/elisp/tiny/tinyadvice.el
new file mode 100644 (file)
index 0000000..c656944
--- /dev/null
@@ -0,0 +1,1322 @@
+;;; tinyadvice.el --- Collection of adviced functions
+
+;; This file is not part of Emacs
+
+;; Copyright (C)    1996-2012 Jari Aalto
+;; Keywords:        extensions
+;; Author:          Jari Aalto
+;; Maintainer:      Jari aalto
+;;
+;; To get information on this program, call M-x tinyadvice-version.
+;; Look at the code with folding.el.
+
+;; COPYRIGHT NOTICE
+;;
+;; This program 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 of the License, or (at your option)
+;; any later version.
+;;
+;; This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+;;
+;; Visit <http://www.gnu.org/copyleft/gpl.html> for more information
+
+
+;;; Install:
+
+;; ....................................................... &t-install ...
+;; Put this file on your Emacs-Lisp `load-path', add following into your
+;; ~/.emacs startup file.
+;;
+;;     (require 'tinyadvice)
+;;
+;; Loading this package takes some time. A more faster startup "feel"
+;; could be achieved with following delayed loading:
+;;
+;;     (require 'tinylib)
+;;     (when (ti::emacs-p)                    ;Do not load in XEmacs
+;;       (if (fboundp 'run-with-idle-timer)   ;Emacs
+;;           (run-with-idle-time (* 4 60) nil
+;;             '(lambda () (require 'tinyadvice)))
+;;         (run-at-time "4 min" nil '(lambda () (require 'tinyadvice)))))
+;;
+;; But before you leap into that, make sure you want to do it.
+;;
+;;      CHECK IF YOUR EMACS IS SUPPORTED
+;;      THESE ADVICES ARE FOR Emacs, expect trouble in XEmacs.
+;;
+;;      Advice activation  controlled by variable `tinyadvice-:re'
+;;
+;; This file modifies original Emacs functions, so read the
+;; documentation carefully to tailor package for personal use
+;; (enabling/disabling advices). The up to date documentation can be
+;; generated from this file with ocmmands:
+;;
+;;      M-x eval-current-buffer
+;;      M-x load-library tinyliby.el
+;;      M-x ti::system-get-file-documentation RET tinyadvice.el RET
+;;
+;; If you have any questions, use this function
+;;
+;;      M-x tinyadvice-submit-bug-report      send bug report or feedback
+
+;; ..................................................... &t-commentary ...
+
+;;; Commentary:
+
+;;  Preface, Apr 1996
+;;
+;;      What you see here is a selection of adviced functions that
+;;      have proven to be useful. Some of them have been written by
+;;      the author (if there is no author mentioned) and some of them
+;;      have been collected form the Emacs newsgroups.
+;;
+;;      Here is one example how to to fontify automatically, whenever
+;;      compilation buffer runs:
+;;
+;;          (add-hook 'tinyadvice-:compile-internal-hook 'my-compile-font-lock)
+;;
+;;          (defun my-compile-font-lock  ()
+;;            "Compile buffer fontifying immediately."
+;;            (interactive)
+;;            (let* ((buffer tinyadvice-:compile-internal-buffer))
+;;              ;; According to buffer you could set up different font
+;;              ;; keyword parameters, say for
+;;              ;; *compilation*
+;;              ;; *grep*
+;;              ;; *igrep*
+;;              ;; ...
+;;              ;;  My setup automatically turn on the lazy-lock too, see
+;;              ;;  font-lock-mode-hook
+;;              (with-current-buffer
+;;               buffer
+;;                (font-lock-mode 1))))
+;;
+;;  Note: XEmacs
+;;
+;;      These advices are for Emacs and it would be a surprise if any
+;;      of them worked in XEmacs. Use at your own risk.
+;;
+;;  These advises and Emacs releases
+;;
+;;      Many of these enhancements could have shipped with the Emacs
+;;      itself. And there was a time when these were suggested to be
+;;      added to the next Emacs release, but the developers were not
+;;      interested in improving or changing functions at those times.
+;;
+;;  How to use this package
+;;
+;;      The best way is to try. Load package read the comments about
+;;      individual functions and how they change things.
+;;
+;;  Overview of features
+;;
+;;      In general, advices are activated only if Emacs release doesn't have
+;;      similar kind of support.
+;;
+;;      o   `gud' highlights full line
+;;      o   no dialogs in X for `y-or-n-p' styled questions. You shouldn't
+;;          need to lift your hands from keyboard and grab mouse for these
+;;          dialog questions.
+;;      o   Mouse-3 cinfirms window delete (pointing at the mode line)
+;;      o   `call-last-kbd-macro' ends the current macro
+;;          before trying to execute it.
+;;      o   `debugger-eval-expression',  Backtrace buffer's
+;;           "e" offers current word for prompt
+;;      o   `dired-man'       , make sure variables are initialized.
+;;      o   `dired-do-rename' , you can edit the old filename
+;;      o   `goto-line' and `imenu' now widens automatically before executing
+;;      o   `rename-buffer'   , offers old buffer name for editing
+;;      o   `recover-file'    , offers buffer filename by default
+;;      o   `switch-to-buffer-other-frame' , selects some non existing frame
+;;      o   `setenv'          , offer completion
+;;      o   `write-file'      , confirm overwrite
+;;      o   `write-region'    , confirm overwrite
+;;
+;;      o   `C-x' `;'   , `indent-for-comment' negative arg deletes comment.
+;;      o   `C-x' `='   , `what-cursor-position' shows the line number too
+;;      o   `C-x' `i'   , insert buffer offers other window
+;;      o   `C-x' `C-c' , `save-buffers-kill-emacs' asks confirmation
+;;                        to prevent accidents (Emacs 21 has this)
+;;      o   `C-x' `b'   , `swich-to-buffer' ask confirmation
+;;                        for non-existing buffers.
+;;      o   `C-x' `C-b' , list-buffers puts cursor to "*Buffer List*"
+;;
+;;      o   compilation: buffer auto scroll (disabled, see 'handling advices')
+;;          Smart save feature (only .cc .h files, not
+;;          all emacs files). Find-file is done in non dedicated frame.
+;;          TAB completes filenames.
+;;
+;;      o   completion: case sensitive filename completion
+;;
+;;      o   grep: filename and directory completion with TAB key
+;;
+;;      o   `vc-print-log', put cursor on the buffer's revision number.
+;;          Smarter `vc-mode-line' , shows "b" if version is in the middle.
+;;          `vc-register' creates RCS directory if does not exist and
+;;          offers checking as "original" file with existing version
+;;          numbers (tracking 3rd party sources).
+;;          User to set the initial comment when doing 1st checkin.
+;;          If `tinyadvice-:cvs-buffer-read-only' is nil, then keep.
+;;          CVS files in writable mode (the default CVS behavior)
+;;
+;;  Handling advices
+;;
+;;      If you have some other Emacs version that is not supported in
+;;      the `tinyadvice-:advice-table' you can modify the regexps in
+;;      the list and try if the advice works. If it does, please drop
+;;      me a mail to have the regecp updated. If some advice is
+;;      annoying, there is simple method how you disable advice(s).
+;;
+;;          (setq tinyadvice-load-hook
+;;                '(tinyadvice-install my-tinyadvice-load-hook))
+;;
+;;          (defun my-tinyadvice-load-hook ()
+;;            "Configure advices"
+;;            (interactive)
+;;            ;; This diables two advices
+;;            (tinyadvice-advice 'disable
+;;               '(switch-to-buffer mouse-delete-other-windows)))
+;;
+;;          (require 'tinyadvice)
+;;
+;;  Disabling a disturbing advice by hand
+;;
+;;      If some piece of advice disturbs or causes trouble, it is
+;;      possible to deactivate it immediately. First you have to know
+;;      the function name that generates problems. Say you used `C-x'
+;;      `C-b' `switch-to-buffer' and you don't like the confirmation
+;;      for non-existent buffers. You can disable this behavior by
+;;      calling:
+;;
+;;          C-u M-x tinyadvice-advice
+;;
+;;      and give the function name `switch-to-buffer' to it. To
+;;      permanently turn the advice off, see previous lisp code.
+;;
+;;  Code note
+;;
+;;      You see this in the code:
+;;
+;;          (when (tinyadvice-activate-p)
+;;              (defadvice ..
+;;
+;;      If emacs version is wrong, the advice is _never_ actually
+;;      intrumented. You can't activate or deactivate those functions
+;;      with `tinyadvice-advice'.
+;;
+;;  Many thanks to, in no particular order:
+;;
+;;      Vladimir Alexiev        <vladimir@cs.ualberta.ca>
+;;      Kevin    Rodgers        <kevinr@ihs.com>
+;;      Ilya     Zakharevich    <ilya@math.ohio-state.edu>
+;;      Peter    Breton         <pbreton@i-kinetics.com>
+;;      T. V.    Raman          <raman@adobe.com>
+
+;;; Change Log:
+
+;;; Code:
+
+;;; ......................................................... &require ...
+
+(require 'advice)
+(require 'tinylibm)
+
+(eval-and-compile
+  (defvar vc-parent-buffer)             ;Emacs vc.el
+  (defvar grep-command)
+  (defvar grep-default)
+  (defvar grep-history)
+  (autoload 'grep-compute-defaults "compile")
+  (when (ti::xemacs-p)
+    (message "\
+** TinyAdvice: You must configure this package manually to XEmacs
+               In general, do not use this packaage on XEmacs.")
+    (load "overlay" 'noerr)))           ;19.15+
+
+;;; ......................................................... &v-hooks ...
+
+(defvar tinyadvice-load-hook '(tinyadvice-install)
+  "Hook that is run when package is loaded.")
+
+;;; ........................................................ &v-public ...
+
+(defvar tinyadvice-:cvs-buffer-read-only t
+  "*nil makes CVS buffers writable.  Value t preserves vc.el's decision.
+Many times vc.el sets read-only status to CVS buffers when there is no need.
+In default case, CVS itself does not mark files read-only, unlike RCS.
+But if you do \"cvs watch on\" on a tree then when you do \"cvs co tree\" it
+will check files out read-only. You have to do \"cvs edit\" to make them
+writable.
+
+Setting this variable to nil, will override vc.el and
+keep CVS buffers always writable. The t value preserves what vc.el does.")
+
+(defvar tinyadvice-:compile-save-re
+  "\\(\\.hh?\\|\\.cc?\\|\\.C?\\|\\.java\\)$"
+  "*Regexp. Case sensitive. Which buffers to save when compiling.")
+
+(defvar tinyadvice-:gud-overlay
+  (when (and (ti::emacs-p)
+             (not (fboundp 'make-extent)))
+    (let* ((ov (make-overlay (point-min) (point-min))))
+      (overlay-put ov 'face 'highlight)
+      ov))
+  "*Gud. Current line overlay.")
+
+(defvar tinyadvice-:find-alternate-file-flag  t
+  "*Non-nil means : `buffer-name' in \\[find-file] if no `buffer-file-name'.")
+
+;;  Ignore tmp/ dir files
+;;  like ~/T  ~/TT ~/T1 ~/T2 ~/T.test ~/T1.xx ...
+
+(defconst tinyadvice-:write-file-no-confirm
+  "^/tmp\\|/[Tt][Tt0-9]?\\.?\\|/[Tt]$"
+  "*Do not verify overwriting these files. See advice `write-file'.")
+
+(defvar tinyadvice-:switch-to-buffer-find-file  t
+  "*Suggest `find-file' for non-existing buffers in `switch-to-buffer'.")
+
+(defvar tinyadvice-:vc-main-rcs-dir  "~/RCS"
+  "Main RCS repository. See advice of function `vc-register'.")
+
+;;; ........................................................ &v-advice ...
+
+(defvar tinyadvice-:re "19\\.2[7-9]\\|19\\.3[0-5]\\|2[01]\\."
+  "General regexp for advices that work in variety of (X)Emacs versions.")
+
+;; - Change the REGEXP is you know the advice works in your emacs ver.
+;;   Drop me mail if you change any of these, so that I can update list
+;;
+;; - Functions that have ".", almost always get advice, see the code.
+;;   In those rows the regexp value is almost always ignored.
+;;
+;; - If it says ";; always on", then the regexp has no effect,
+;;   you have to disable feature by hand, if you don't want it.
+
+(defconst tinyadvice-:advice-table      ;alphabetically ordered
+  (list
+   (list 'after-find-file               ".")    ;;always on
+
+   (list 'call-last-kbd-macro
+         ".")
+   (list 'compile                       ".")
+   (list 'compilation-find-file         ".")
+   (list 'shell                         ".")
+
+   (list 'debugger-eval-expression      ".")
+
+   (list 'dired-do-rename               ".")
+   (list 'dired-man                     ".") ;;always
+
+   (list 'exchange-point-and-mark       ".")
+   (list 'find-file                     ".")
+
+   (list 'grep                          ".")
+   (list 'igrep-read-expression         ".")
+   (list 'igrep-read-options            ".")
+
+   (list 'find-alternate-file           ".")
+   (list 'find-file-literally           ".")
+   (list 'find-tag                      ".")
+
+   (list 'getenv                        ".") ;;always on
+   (list 'goto-line                     ".")
+   (list 'grep                          ".")
+   (list 'gud-display-line              ".") ;;always
+
+   (list 'hkey-help-show                ".") ;;hyberbole
+
+   (list 'indent-for-comment            ".")
+   (list 'insert-buffer                 tinyadvice-:re)
+   (list 'list-buffers                  ".")
+   (list 'line-move                     ".")
+
+   (list 'map-y-or-n-p                  tinyadvice-:re)
+   (list 'mouse-delete-other-windows    tinyadvice-:re)
+   (list 'mouse-delete-window           tinyadvice-:re)
+   (list 'mouse-wheel-scroll-screen     tinyadvice-:re)
+
+   (list 'occur                         ".")
+   (list 'PC-complete                   ".") ;;always on
+
+   (list 'recompile                     ".")
+   (list 'recover-file                  ".")
+   (list 'rename-buffer                 tinyadvice-:re)
+
+   (list 'save-some-buffers             ".")
+   (list 'sendmail-pre-abbrev-expand-hook tinyadvice-:re)
+   (list 'setenv                        ".") ;;always on
+   (list 'set-mark-command              ".") ;;always on
+   (list 'switch-to-buffer              tinyadvice-:re)
+   (list 'switch-to-buffer-other-frame  ".")
+
+   (list 'vc-mode-line                  tinyadvice-:re)
+
+   (list 'what-cursor-position          tinyadvice-:re)
+   (list 'write-file                    ".")
+   (list 'write-region                  ".")
+
+   (list 'y-or-n-p                      tinyadvice-:re))
+  "*Flag table of enabled advices.
+It is consulted if particular advice can be used in current emacs. Format is
+
+  ((FUNCTION ALLOW-ADVICE-REGEXP [FLAG])
+   (FUNCTION ALLOW-ADVICE-REGEXP)
+   ..)
+
+The FLAG is optional and values can be:
+
+  nil   or missing: Only works in Emacs
+  'xe   only works in Xemacs
+  t     works both Emacs and XEmacs")
+
+;;; ....................................................... &v-private ...
+
+(defconst tinyadvice-:advice-re  "^tinyadvice"
+  "Prefix name used in advices for TinyAdvice package.")
+
+(defconst tinyadvice-:tmp-buffer  "*tinyadvice*"
+  "Temporary working buffer.")
+
+(defvar tinyadvice-:vc-p nil
+  "Variable indicating if file in `vc-do-command' is version controlled.")
+
+;;; ....................................................... &v-version ...
+
+;;;###autoload (autoload 'tinyadvice-version "tinyadvice" "Display commentary." t)
+(eval-and-compile
+  (ti::macrof-version-bug-report
+   "tinyadvice.el"
+   "tinyadvice"
+   tinyadvice-:version-id
+   "$Id: tinyadvice.el,v 2.71 2007/05/07 10:50:07 jaalto Exp $"
+   '(tinyadvice-version-id
+     tinyadvice-:compile-save-re
+     tinyadvice-:write-file-no-confirm
+     tinyadvice-:re)))
+
+;;; ########################################################### &Funcs ###
+
+;;; ----------------------------------------------------------------------
+;;;
+(defmacro tinyadvice-elts (elt func re type)
+  "Decode ELT to variables FUNC RE TYPE."
+  `(setq ,func (nth 0 ,elt)
+         ,re   (nth 1 ,elt)
+         ,type (if (eq 3 (length ,elt))
+                      (nth 0 ,elt)
+                    nil)))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinyadvice-match (re &optional type)
+  "Check if RE match emacs version according to TYPE.
+TYPE :
+  nil = Emacs
+  t   = XEmacs and Emacs
+  'xe = XEmacs"
+  (let* ((ver   (emacs-version))
+         ret)
+    (when (stringp re)
+      (cond
+       ((and (eq type 'xe)
+             (ti::xemacs-p)
+             (string-match re ver))
+        (setq ret 1))
+       ((and (eq type nil)
+             (ti::emacs-p)
+             (string-match re ver))
+        (setq ret 2))
+       ((and (eq type t)
+             (string-match re ver))
+        (setq ret 3)))
+      ret)))
+
+;;; ----------------------------------------------------------------------
+;;; Testing... (tinyadvice-activate-p 'compile-internal)
+;;;
+(defun tinyadvice-activate-p (func-sym)
+  "Determine if we can advice FUNC-SYM."
+  (let* ((elt   (assoc func-sym tinyadvice-:advice-table))
+         func
+         re
+         type)
+    (when elt
+      (tinyadvice-elts elt func re type)
+      ;;  XEmacs 19.14 ByteComp, Shut up "bound but not referenced"
+      ;;  the `func' is set above.
+      (if func
+          (setq func 'ignore))
+      (tinyadvice-match re type))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinyadvice-ad-function-list  (&optional string-format)
+  "Return list of tinyadvice ad-functions for current emacs.
+Notice: all functions may not be adviced; this merely
+return entries in the table. See source file's \"Code note\"
+
+If STRING-FORMAT is non nil, then return string list.
+
+Return:
+
+  '(func    func ..)
+  '(\"func\" \"func\" ..)"
+  (let* (func
+         re
+         type
+         list)
+    (dolist (member tinyadvice-:advice-table)
+      (tinyadvice-elts member func re type)
+      (when (tinyadvice-match re type)
+        (if  string-format
+            (push (symbol-name func) list)
+          (push func list))))
+    list))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinyadvice-install  ()
+  "Activates advices that are listed in `tinyadvice-:advice-table'."
+  (interactive)
+  (tinyadvice-advice nil (tinyadvice-ad-function-list)))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;; This is slow, but returns only tinyadvice adviced functions...
+;;;
+;;; (ad-do-advised-functions (func)
+;;;  (if (ad-find-some-advice func 'any tinyadvice-:advice-re)
+;;;      (push func list)))
+;;;
+;;;
+(defun tinyadvice-advice (&optional disable func-or-list)
+  "Activate or optionally DISABLE tinyadvice advice for FUNC-OR-LIST."
+  (interactive
+   (list
+    current-prefix-arg
+
+    (let* (var)
+      (setq var (completing-read
+                 (concat
+                  (if current-prefix-arg "un"  "")
+                  "advice function: ")
+                 (ti::list-to-assoc-menu (tinyadvice-ad-function-list 'strings))
+                 nil t))
+      (intern-soft var))))
+  ;; This is in fact cheating a little; we check against full advice list,
+  ;; not just "tinyadvice" owned functions.
+  (when (and (symbolp func-or-list)
+             (not (member (list (symbol-name func-or-list))
+                          ad-advised-functions )))
+    ;; This makes the call to 'ti::' after this if, unefective
+    (setq func-or-list nil)
+    (if (interactive-p)
+        ;; more accurate: "No advice found..." but since we deal with
+        ;; tinyadvice ones only the following is better.
+        (message "\
+TinyAdvice: Sorry, the function is not advice controlled by TinyAdvice.")))
+  (ti::advice-control
+   func-or-list tinyadvice-:advice-re disable (interactive-p)))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinyadvice-advice-control  (&optional disable verb)
+  "Acivate all TinyAdvice advices. Use extra argument to DISABLE all. VERB."
+  (interactive "P")
+  (or verb
+      (setq verb (interactive-p)))
+  (let* (
+         (re    tinyadvice-:advice-re)
+         (doit  t)
+         msg)
+    (if verb ;;  This is rough! Be sure...
+        (setq
+         doit
+         (y-or-n-p (format
+                    "Advices will be turned %s. Are you sure? "
+                    (if disable "OFF" "ON")))))
+    (when doit
+      (cond
+       (disable
+        (ad-disable-regexp re)          ;only sets flag
+        (setq msg "Tinyadvice: All advices deactivated"))
+       (t
+        (ad-enable-regexp re)           ;only sets flag
+        (setq msg "Tinyadvice: All TinyAdvice advices activated")))
+      (ad-update-regexp re)
+      (if verb
+          (message msg)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinyadvice-convert-filename  (file &optional cautious)
+  "Return normal or compressed filename.
+
+Input:
+
+ FILE       full filename
+ CAUTIOUS   if non-nil then when in doubt do not change the filename.
+            (e.g. in clash situation, where there is bot un/compressed  file)
+
+Return:
+
+ string     possibly modified."
+  (interactive)
+  (unless (string-match "\\.Z$\\|\\.gz$"  file)
+    (when (and (file-exists-p file)
+               (or (file-exists-p (concat file ".gz"))
+                   (file-exists-p (concat file ".Z"))))
+      (message "TinyAdvice: clash, both un/compressed file found. %s " file)
+      (sleep-for 1)
+      (if (and
+           (null cautious)              ;only if no cautious mode
+           (setq
+            file
+            (or (ti::file-newer-exist file (concat file ".gz"))
+                (ti::file-newer-exist file (concat file ".Z")))))
+          ;;  We must load this package too to enable compress support.
+          (require 'jka-compr))))
+  file)
+
+;;; ........................................................ &built-in ...
+
+;;; ----------------------------------------------------------------------
+;;;
+(when (tinyadvice-activate-p 'rename-buffer)
+  (defadvice rename-buffer (around tinyadvice dis)
+    "Gives old buffer name for editing."
+    (interactive
+     (list
+      (read-from-minibuffer
+       "Rename buffer (to new name): "
+       (buffer-name))))
+    ad-do-it))
+
+
+;;; ......................................................... &compile ...
+
+;;; ----------------------------------------------------------------------
+;;; (ad-disable-advice 'compilation-find-file 'before 'tinyadvice)
+;;; (ad-activate       'compilation-find-file)
+;;;
+(defadvice compilation-find-file  (before tinyadvice act)
+  "Move to some non dedicated frame."
+  (ti::select-frame-non-dedicated))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice shell (around tinyadvice dis)
+  "If there is *shell* buffer, ask user to give new name for new shell.
+If new buffer name is given, a new shell is created. pressing RET
+does not create new buffer, but jumps to existing *shell* buffer."
+  (let* (name
+         prev-name)
+    (when (and
+           (interactive-p)
+           (comint-check-proc "*shell*")
+           (setq
+            name
+            (read-string
+             "Create new shell by typing a buffer name for it [RET = cancel]? "))
+           (not (ti::nil-p name)))
+      (with-current-buffer "*shell*"
+        (rename-uniquely)
+        (setq prev-name (buffer-name))))
+    ad-do-it
+    (when (and (stringp name)
+               (not (string= name "")))
+      (with-current-buffer "*shell*"
+        (rename-buffer name))
+      (with-current-buffer prev-name
+        (rename-buffer "*shell*")))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinyadvice-compile-save-buffers ()
+  "Check what buffers for current compilation target should be saved."
+  (interactive)
+  (let ((case-fold-search      nil)    ;case sensitive
+       (re-file               tinyadvice-:compile-save-re))
+    ;; Save only interesting buffers, don't care about others.
+    (ti::dolist-buffer-list
+     (string-match re-file  (buffer-name))
+     nil
+     nil
+     (and (buffer-modified-p)
+          (y-or-n-p (format "Buffer %s modified. Save it? "
+                            (buffer-name)))
+          (save-buffer)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice igrep-read-expression (around tinyadvice dis)
+  "Replace function: TAB key completes file names."
+  (setq
+   ad-return-value
+   (let ((default-expression (igrep-default-arg igrep-expression-default)))
+     (if (string= default-expression "")
+         (setq default-expression nil))
+     (ti::file-complete-filename-minibuffer-macro
+       (read-from-minibuffer (igrep-prefix prompt-prefix "Expression: ")
+                             default-expression map nil
+                             'igrep-expression-history)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice igrep-read-options (around tinyadvice act)
+  "Replace function: TAB key completes file names."
+  (setq
+   ad-return-value
+   (if (or igrep-read-options
+           (and (consp current-prefix-arg)
+                (memq (prefix-numeric-value current-prefix-arg)
+                      '(4 64))))
+       (let ((prompt "Options: "))
+         (ti::file-complete-filename-minibuffer-macro
+           (read-from-minibuffer
+            (igrep-prefix prompt-prefix prompt)
+            (or igrep-options "-")
+            map)))
+     igrep-options)))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinyadvice-grep-default (arg)
+  "Set default value. This function use dynamically bound variables.
+See `grep' advice."
+  (unless grep-command
+    (grep-compute-defaults))
+  ;; `arg' is bound during M-x grep
+  (when arg
+    (let* ((tag-default
+            (funcall (or find-tag-default-function
+                         (get major-mode 'find-tag-default-function)
+                         ;; We use grep-tag-default instead of
+                         ;; find-tag-default, to avoid loading etags.
+                         'grep-tag-default))))
+      (setq grep-default (or (car grep-history) grep-command))
+      ;; Replace the thing matching for with that around cursor
+      (when (string-match "[^ ]+\\s +\\(-[^ ]+\\s +\\)*\\(\"[^\"]+\"\\|[^ ]+\\)\\(\\s-+\\S-+\\)?" grep-default)
+        (unless (or (match-beginning 3) (not (stringp buffer-file-name)))
+          (setq grep-default (concat grep-default "*."
+                                     (file-name-extension buffer-file-name))))
+        (setq grep-default (replace-match (or tag-default "")
+                                          t t grep-default 2))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice grep (around tinyadvice act)
+  "Modify interactive spec: TAB key completes file names."
+  (interactive
+   (let (grep-default (arg current-prefix-arg))
+     (tinyadvice-grep-default arg)
+     (list (ti::file-complete-filename-minibuffer-macro
+             (read-from-minibuffer "Run grep (like this): "
+                                   (or grep-default
+                                       grep-command)
+                                   map nil 'grep-history)))))
+  ad-do-it)
+
+;;; ----------------------------------------------------------------------
+;;; - More smarter buffer saving.
+;;;
+(defadvice compile (around tinyadvice dis)
+  "Replace original function. More smarter buffer saving.
+See function `tinyadvice-compile-save-buffers'.
+In addition, TAB key completes file names."
+  (interactive
+   (if compilation-read-command
+       (list (ti::file-complete-filename-minibuffer-macro
+               (read-from-minibuffer "Compile command: "
+                                     compile-command map nil
+                                     '(compile-history . 1))))
+     (list compile-command)))
+  (setq compile-command command)
+
+  (if (null compilation-ask-about-save)
+      (save-some-buffers (not compilation-ask-about-save) nil)
+    (tinyadvice-compile-save-buffers))
+
+  (compile-internal compile-command "No more errors"))
+
+;;; ----------------------------------------------------------------------
+;;; Run compile with the default command line
+;;;
+(defadvice recompile (around tinyadvice dis)
+  "Replace original function.
+More smarter buffer saving, seefunction `tinyadvice-compile-save-buffers'."
+  (interactive)
+  (if (null compilation-ask-about-save)
+      (save-some-buffers (not compilation-ask-about-save) nil)
+    (tinyadvice-compile-save-buffers))
+  (compile-internal compile-command "No more errors"))
+
+
+;;; ...................................................... &completion ...
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice call-last-kbd-macro (before tinyadvice dis)
+  "If still defining a macro, end it before attempting to call-last.
+  This prevents whacking the current definition."
+  (if defining-kbd-macro
+      (end-kbd-macro)))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice PC-complete  (around tinyadvice dis)
+  "In file name prompt, use case sensitive completion.
+Set `completion-ignore-case' locally to nil."
+  (let* ((completion-ignore-case  completion-ignore-case)
+         word)
+    (setq word (or (save-excursion (ti::buffer-read-space-word)) ""))
+
+    (if (string-match "^[/~]" word)
+        (setq completion-ignore-case nil))
+    ad-do-it))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice debugger-eval-expression (around tinyadvice dis)
+  "Chnage interactive so that it offer word from buffer."
+  (interactive
+   (list
+    (read-from-minibuffer
+     "(tinyadvice) Eval: "
+     (or (ti::buffer-read-space-word) "")
+     read-expression-map t
+     'read-expression-history)))
+  ad-do-it)
+
+
+;;; ........................................................... &dired ...
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice dired-mark-read-file-name (around tinyadvice dis)
+  "Instead of asking directory, offer full filename for editing."
+  (if (and dir (string-match "/" dir))
+      (setq dir (dired-get-filename)))
+  ad-do-it)
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice dired-do-rename  (around tinyadvice act)
+  "Offer editing the current filename.
+Without this advice you don't get the old filename for editing.
+Activates advice 'dired-mark-read-file-name during call."
+  (let* ((ADVICE 'dired-mark-read-file-name))
+    (ad-enable-advice ADVICE 'around 'tinyadvice)
+    (ad-activate ADVICE)
+    ad-do-it
+    (ad-disable-advice ADVICE 'around 'tinyadvice)
+    (ad-activate ADVICE)))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice dired-man (before tinyadvice dis)
+  "Make sure man variables are initialized."
+  (require 'man)
+  (Man-init-defvars))
+
+;;; ............................................................. &env ...
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinyadvice-read-envvar (prompt &optional require-match)
+  "Read an environment variable name from the minibuffer.
+Prompt with PROMPT and complete from `process-environment'.
+If optional arg REQUIRE-MATCH is non-nil, only defined variable
+names are allowed."
+  (completing-read
+   prompt
+   (mapcar (function
+            (lambda (var=value)
+              (list (substring var=value 0
+                               (string-match "=" var=value)))))
+           process-environment)
+   nil
+   require-match))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;; Hangs sometimes, don't know why..
+;;; Currently owned by "my" and disabled. Enable this manyally in load-hook
+;;; if you want to try it.
+;;;
+(defadvice getenv (around my dis)
+  "Offer completion."
+  (interactive (list (tinyadvice-read-envvar "Get environment variable: " t)))
+  ad-do-it
+  (if (and (interactive-p)
+           ad-return-value)
+      (message "%s" ad-return-value)
+    ad-return-value))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice setenv (around tinyadvice dis)
+  "Add interactive completion."
+  (interactive
+   (if current-prefix-arg
+       (list (tinyadvice-read-envvar "Clear environment variable: " t) nil t)
+     (let ((var (tinyadvice-read-envvar "Set environment variable: ")))
+       (list var
+             (read-from-minibuffer
+              (format "Set %s to value: " var)
+              (or (getenv var) ""))))))
+  ad-do-it
+  (if (and (interactive-p) value)
+      (message "%s" value)
+    value))
+
+;;; ------------------------------------------------------------ &grep ---
+;;;
+(defadvice grep  (around tinyadvice  dis)
+  "Complete filenames with TAB.
+Read word from the current pointand put it into grep prompt."
+  (interactive
+   (ti::file-complete-filename-minibuffer-macro
+     (list
+      (read-from-minibuffer
+       "(tinyadvice) Run grep: "
+       (concat grep-command  (or (ti::buffer-read-space-word) ""))
+       map
+       nil
+       'grep-history))))
+  ad-do-it)
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice find-tag (after tinyadvice-reposition-window act)
+  "Call reposition-window after finding a tag."
+  (reposition-window))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;                         files.el
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice find-file-literally
+  (around  tinyadvice-disable-write-file-functions dis)
+  "Disable `write-file-functions' so that file can edited and saved in pure manner."
+  ad-do-it
+  (add-hook 'write-file-functions 'ignore nil 'local)
+  (setq write-file-functions nil)
+  ;; (setq indent-tabs-mode t)
+  (message "TinyAdvice: write-file-hooks is now nil in %s" (buffer-name)))
+
+;;; ----------------------------------------------------------------------
+;;; 19.30 doesn't offer the filename, so enable this in all emacs versions
+;;;
+(defadvice find-alternate-file  (around tinyadvice dis)
+  "Interactive change: offer buffer filename as default.
+Reference:
+  `tinyadvice-:find-alternate-file-flag'"
+  (interactive
+   (list
+    (read-file-name
+     "find alternate file: "
+     (file-name-directory (or (buffer-file-name)
+                              default-directory))
+     nil
+     t
+     (if (buffer-file-name)
+         (file-name-nondirectory (buffer-file-name))
+       (if tinyadvice-:find-alternate-file-flag
+           (buffer-name) "")))))
+  ad-do-it)
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice recover-file  (around tinyadvice dis)
+  "Offer current buffer's filename in prompt."
+  (interactive
+   (list
+    (read-file-name
+     "(TinyAdvice) Recocer file: "
+     (file-name-directory (or (buffer-file-name)
+                              default-directory))
+     nil
+     t
+     (if (buffer-file-name)
+         (file-name-nondirectory (buffer-file-name))
+       (if tinyadvice-:find-alternate-file-flag
+           (buffer-name) "")))))
+  ad-do-it)
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice write-file (around tinyadvice-file dis)
+  "File handling additions.
+
+Interactive change:
+
+    Changes the interactive prompt so, that full `buffer-file-name' is given
+    for editing.
+
+Confirm overwrite:
+
+    When called interactively, require confirmation if FILENAME already exists.
+    If FILENAME matches `tinyadvice-:write-file-no-confirm', no confirmation
+    is asked."
+  (interactive
+   ;; Change    "Fwrite to file: "
+   (list
+    (read-file-name
+     "write to file: "
+     (or (buffer-file-name)
+         "~/"))))
+
+  (let* ((fn           (ad-get-arg 0))
+         ;;  Tmp buffers do not have filename
+         (buffer-file  (or fn (buffer-file-name) ""))
+         (pass         t))
+
+    (if (stringp fn)
+        (setq pass
+              (ti::string-match-case tinyadvice-:write-file-no-confirm fn)))
+
+    (if (or (not (interactive-p))   ;only when user call it, do checks
+            (not (file-exists-p fn))
+            pass
+            (y-or-n-p (format "%s already exists; overwrite it? " fn)))
+        ad-do-it
+      (message "Aborted"))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice write-region (around tinyadvice-file dis)
+  "See `write-file' which explains the advice behavior."
+  (interactive "r\nFwrite region: ")
+  (let* ((fn           (ad-get-arg 2))
+         (buffer-file  fn)
+         (pass         t))
+    (if (stringp fn)
+        (setq pass
+              (ti::string-match-case tinyadvice-:write-file-no-confirm fn)))
+    (if (or (not (interactive-p))
+            (not (file-exists-p fn))
+            pass
+            (y-or-n-p (format "%s already exists; overwrite it? " fn)))
+        ad-do-it
+      (message "Aborted"))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice save-some-buffers (before tinyadvice dis)
+  "Always save changed abbrevs without questions if `save-abbrevs' is set."
+  (when (and save-abbrevs abbrevs-changed)
+    (write-abbrev-file nil)
+    (setq abbrevs-changed nil)))
+
+;;; ............................................................. &gud ...
+
+;;; ----------------------------------------------------------------------
+;;; See gud.el
+;;;
+(defadvice gud-display-line (after tinyadvice dis)
+  "Highlight current line."
+  (when (and tinyadvice-:gud-overlay
+             (fboundp 'move-overlay))
+    (let ((ov tinyadvice-:gud-overlay)
+         (bf (gud-find-file true-file)))
+      (save-excursion
+        (set-buffer bf)
+        (move-overlay
+         ov
+         (line-beginning-position)
+         (line-end-position)
+         (current-buffer))))))
+
+;;; ............................................................ &mail ...
+
+;;; ----------------------------------------------------------------------
+;;; See mailabbrev.el
+;;;
+(defadvice sendmail-pre-abbrev-expand-hook
+  (around tinyadvice-no-abbrevs-in-body dis)
+  "Do not expand any abbrevs in the message body through `self-insert-command'."
+  (if (or (mail-abbrev-in-expansion-header-p)
+          ;; (not (eq last-command 'self-insert-command)) ; can't be used
+          ;; since last-command is the previous, not the current command
+          (not (integerp last-command-char))
+          (eq (char-syntax last-command-char) ?w)) ; this uses that
+      ;; the last char in {C-x '} {C-x a '} {C-x a e} is `w' syntax
+      ad-do-it
+    (setq abbrev-start-location (point) ; this hack stops expand-abbrev
+          abbrev-start-location-buffer (current-buffer))))
+
+
+;;; ......................................................... &map-ynp ...
+
+;; 19.28
+;; - map-ynp.el::map-y-or-n-p  Get's loaded in loadup.el, it pops up
+;;   an dialog Box of questions if the input is event type and it is
+;;   annoying to answer yes/no dialog boxes. It is much quicker to
+;;   hit SPACE/DEL for yes/no.
+;; - Hmm actually it looks back what the command was by looking at
+;;   `last-nonmenu-event' variable, so I should reset it instead.
+;; - *argh* I was wrong, it is the `y-or-n-p' (built-in) command that pops up
+;;   the dialog, anyway the advice works for it too: built-in or not
+;;   doesn't matter
+;;
+;; The way to do this in XEmacs is:
+;;
+;;    (setq use-dialog-box nil)
+
+(when (and (ti::compat-window-system)
+           (ti::emacs-p))
+  (defadvice map-y-or-n-p (before tinyadvice dis)
+    "Reset any mouse event to key event so that no dialogs are displayed."
+    (if (listp last-nonmenu-event)
+        ;; replace with some harmless value
+        (setq last-nonmenu-event ?\n)))
+  (defadvice y-or-n-p (before tinyadvice dis)
+    "Reset any mouse event to key event so that no dialogs are displayed."
+    (if (listp last-nonmenu-event)
+        ;; replace with some harmless value
+        (setq last-nonmenu-event ?\n))))
+
+;;; ........................................................... &mouse ...
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice mouse-wheel-scroll-screen (around tinyadvice act)
+  "Use tinymy.el scrolling if possible."
+  (if (and (fboundp 'tinymy-scroll-down)
+           (fboundp 'tinymy-scroll-up))
+      (let ((event (ad-get-arg 0)))
+        (ignore-errors
+          (if (< (car (cdr (cdr event))) 0)
+              (tinymy-scroll-down)
+            (tinymy-scroll-up))))
+    ad-do-it))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice mouse-delete-other-windows  (around tinyadvice dis)
+  "Confirm window delete."
+  (if (y-or-n-p "Really delete _all_ windows ")
+      ad-do-it
+    (message "")))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice mouse-delete-window  (around tinyadvice dis)
+  "Confirms window delete."
+  (if (y-or-n-p "Really delete _this_ window ")
+      ad-do-it
+    (message "")))
+
+
+(defadvice occur  (before tinyadvice act)
+  "Iinteractive change: ask if user want the occur to start from `point-min'.
+also Possibly unfold/un-outline the code."
+  (when (and (interactive-p)
+             (not (eq (point) (point-min)))
+             (y-or-n-p "TinyAdvice: Start occur from point-min? "))
+    (if (and (or (and (featurep 'folding)
+                      (symbol-value 'folding-mode))
+                 (and (and (featurep 'outline)
+                           (boundp  'outline-mode))
+                      (symbol-value 'outline-mode)))
+             (save-excursion
+               (ti::pmin)
+               (re-search-forward "\r" nil t))
+             (y-or-n-p "TinyAdvice: Open buffer's selective display too? "))
+        (ti::buffer-outline-widen))))
+
+;;; .......................................................... &simple ...
+
+;;; ----------------------------------------------------------------------
+;;; See simple.el
+;;;
+(defadvice exchange-point-and-mark (around tinyadvice-pop-if-prefix dis)
+  "If given prefix, call `set-mark-command' to pop previous mark positions."
+  (if (and current-prefix-arg
+           (interactive-p))
+      (call-interactively 'set-mark-command))
+  ad-do-it)
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice goto-line (around tinyadvice dis)
+  "Widen the buffer before and after `goto-line' command."
+  (widen)
+  ad-do-it
+  ;;  We do this because, the folding.el sets narrowing in effect,
+  ;;  when the goto-line has finished.
+  ;;  #todo: should we check featurep 'folding?
+  (widen))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice indent-for-comment (around tinyadvice dis)
+  "Kill the comment with negative prefix."
+  (if (eq current-prefix-arg '-)
+      (kill-comment nil)
+    ad-do-it))
+
+;;; ----------------------------------------------------------------------
+;;; Redefine insert-buffer to insert a visible buffer, if there's one.
+;;;
+(defadvice insert-buffer (before tinyadvice dis)
+  "Use a more reasonable default, the other window's content."
+  (interactive
+   (list
+    (progn
+      (barf-if-buffer-read-only)
+      (read-buffer "Insert buffer: "
+                   (if (eq (selected-window)
+                           (next-window (selected-window)))
+                       (other-buffer (current-buffer))
+                     (window-buffer (next-window (selected-window))))
+                   t)))))
+
+;;; ----------------------------------------------------------------------
+;;; avoid deactivation of region when buffer end or beginning is reached
+;;;
+(defadvice line-move (around tinyadvice dis)
+  "Avoid deactivation of region. in `beginning-of-buffer' or `end-of-buffer'."
+  (condition-case ()
+      ad-do-it
+    ((beginning-of-buffer end-of-buffer)
+     (if (bobp)
+         (message "Beginning of buffer.")
+       (message "End of buffer.")))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice set-mark-command (around tinyadvice-global-if-negative dis)
+  "If the argument is negative, call `pop-global-mark'."
+  (if (< (prefix-numeric-value current-prefix-arg) 0)
+      (pop-global-mark)
+    ad-do-it))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice what-cursor-position (around tinyadvice dis)
+  "Displays line number info too."
+  ad-do-it
+  ;;  we have to use 'princ' because there is percentage mark
+  ;;  in returned string and that would run 'message' beserk,
+  ;;  since it thinks it's formatting code
+  (princ (concat
+          ad-return-value
+          (number-to-string (ti::widen-safe (ti::current-line-number))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice switch-to-buffer (around tinyadvice dis)
+  "When called interactively: Confirm switch to non-existing buffer.
+
+References:
+
+  `tinyadvice-:switch-to-buffer-find-file'
+   if non-nil, suggest `find-file' for non-existing buffers"
+  (interactive "Bbuffer name: ")
+  (let ((buffer-name (ad-get-arg 0)))
+    (if (or (not (interactive-p))       ;user didn't call us
+            (get-buffer buffer-name))   ;it exists
+        ad-do-it
+      (cond
+       ((y-or-n-p (format "`%s' does not exist, create? " buffer-name))
+        ad-do-it)                       ;ceate new buffer
+
+       (tinyadvice-:switch-to-buffer-find-file ;is this enabled ?
+        (find-file (read-file-name "(tinyadvice) Find-file: "
+                                   nil
+                                   nil
+                                   nil
+                                   buffer-name)))))
+    (message "")))                      ;clear the echo area
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice switch-to-buffer-other-frame  (around tinyadvice dis)
+  "Replace function. Don't ever create new frame; reuse some existing frame."
+  (let ((free-frames (ti::window-frame-list nil 'exclude-current))
+        stat)
+    (if (null free-frames)
+        (pop-to-buffer buffer)
+      (cond
+       ((setq stat (ti::window-get-buffer-window-other-frame buffer))
+        ;;  buffer is displayed already in some OTHER frame; go to it.
+        (raise-frame (car stat))
+        (select-frame (car stat))
+        (select-window (cdr stat)))
+       (t
+        ;;  Go to some free frame and pop up there
+        (raise-frame  (car free-frames))
+        (select-frame (car free-frames))
+        (switch-to-buffer buffer))))))
+
+;;; ----------------------------------------------------------------------
+;;; - This puts cursor to generated list. Propably what we
+;;;   want 99% of the time.
+;;;
+(defadvice list-buffers  (after tinyadvice dis)
+  "Select buffer list after display."
+  (if (interactive-p)
+      (select-window (get-buffer-window "*Buffer List*"))))
+
+;;; ........................................................... &other ...
+
+;;; ----------------------------------------------------------------------
+;;;
+(mapc
+ (function
+  (lambda (x)
+    (eval
+     (`
+      (defadvice (, x) (around tinyadvice-kill-buffer act)
+        "Kill the buffer if there is no process."
+        (condition-case error
+            ad-do-it
+          (error
+           (if (equal error '(error "Current buffer has no process"))
+               (kill-buffer (current-buffer))))))))))
+ '(term-copy-old-input
+   term-send-input
+   term-send-raw-string))
+
+;;; ----------------------------------------------------------------------
+;;; hyberbole package
+;;;
+(defadvice hkey-help-show (around tinyadvice-shrink-window act)
+  "Shrink auxiliary windows to buffer size.
+For `help-mode',switch `view-mode' off."
+  ;;
+  ;; hkey-help-show is part of Bob Wiener's Hyperbole. In pure emacs
+  ;; a hook is more appropriate: with-output-to-temp-buffer asks the
+  ;; function in the variable temp-buffer-show-function (if non-nil)
+  ;; to take care of the showing. That function also must call
+  ;; temp-buffer-show-hook. Take your pick.
+  ;;
+  (if (and (not current-window)         ; second arg
+           (get-buffer-window buffer))
+      (delete-window (get-buffer-window buffer))) ; force recreation
+  ad-do-it
+  (if (and (not current-window)         ; second arg
+           (not (one-window-p t)))      ; not counting the minibuffer
+      (shrink-window-if-larger-than-buffer (get-buffer-window buffer)))
+  (if (and (eq major-mode 'help-mode)
+           (boundp view-mode) view-mode)
+      (view-exit)))
+
+(provide   'tinyadvice)
+(run-hooks 'tinyadvice-load-hook)
+
+;;; tinyadvice.el ends here
diff --git a/elisp/tiny/tinybookmark.el b/elisp/tiny/tinybookmark.el
new file mode 100644 (file)
index 0000000..5ddd79d
--- /dev/null
@@ -0,0 +1,1025 @@
+;;; tinybookmark.el --- Keep file in organized sections
+
+;; This file is not part of Emacs
+
+;;{{{ Id
+
+;; Copyright (C)    1995-2012 Jari Aalto
+;; Keywords:        tools
+;; Author:          Jari Aalto
+;; Maintainer:      Jari Aalto
+;;
+;; Look at the code with folding.el
+
+;; COPYRIGHT NOTICE
+;;
+;; This program 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 of the License, or (at your option)
+;; any later version.
+;;
+;; This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+;;
+;; Visit <http://www.gnu.org/copyleft/gpl.html> for more information
+
+;;}}}
+;;{{{ Installation
+
+;;; Install:
+
+;; ........................................................ &t-install ...
+;; Put this file on your Emacs-Lisp `load-path', add following into your
+;; ~/.emacs startup file
+;;
+;;      (require 'tinybookmark)
+;;
+;; or use autoload, and Emacs starts up faster, prefered:
+;;
+;;      (autoload 'tinybookmark-insert          "tinybookmark" "" t)
+;;      (autoload 'tinybookmark-repeat          "tinybookmark" "" t)
+;;      (autoload 'tinybookmark-parse           "tinybookmark" "" t)
+;;      (autoload 'tinybookmark-forward         "tinybookmark" "" t)
+;;      (autoload 'tinybookmark-backward        "tinybookmark" "" t)
+;;      (autoload 'tinybookmark-keyboard        "tinybookmark" "" t)
+;;      (autoload 'tinybookmark-keyboard-parse  "tinybookmark" "" t)
+;;
+;;      (when window-system
+;;        (autoload 'tinybookmark-mouse         "tinybookmark" "" t)
+;;        (autoload 'tinybookmark-mouse-parse   "tinybookmark" "" t))
+;;
+;; Ideas for keybindings
+;;
+;;      M-x tinybookmark-insert  to add bookmark
+;;
+;;      ;;  This is for windowed Emacs. It brings up nice pop up menu
+;;      ;;  In XEmacs, use different mouse event: `mouse1down'
+;;
+;;      (global-set-key [(?\e) (control mouse-1)]        'tinybookmark-mouse)
+;;      (global-set-key [(?\e) (control shift mouse-1)]  'tinybookmark-mouse-parse)
+;;
+;;      ;;  To use keyboard to navigate between bookmarks
+;;
+;;      (global-set-key [(shift left)]  'tinybookmark-backward)
+;;      (global-set-key [(shift right)] 'tinybookmark-forward)
+;;
+;;      ;; To navigate with completion menu
+;;
+;;      (global-set-key [(control shift right)] 'tinybookmark-keyboard)
+;;
+;; BE SURE THAT
+;;
+;;      Variables `comment-start' and `comment-end' are defined,
+;;      otherwise the inserted text won't have proper prefix abd ending.
+
+;;}}}
+;;{{{ Documentation
+
+;;; .................................................... &t-commentary ...
+
+;;; Commentary:
+
+;;  Preface, feb 1995
+;;
+;;      Long ago I used a little function I wrote that inserted section
+;;      breaks, those that I call `book' `marks'. There was also
+;;      `folding.el' to keep the code in separate sections. Findings things
+;;      was easy when you just searched either book marks or jumped between
+;;      folds. Next *imenu.el* was announced which provided X-pop up for
+;;      book marks and adding support to it was the start of this package.
+;;
+;;  Overview of features
+;;
+;;      o   Provide 'setting book marks' functions: Add
+;;          repeated characters and sequences up till end of line with
+;;          named identifier.
+;;      o   Automatically parse book marks from file, if it contains
+;;          identifier `bookMarkRegexp' which defines book mark syntax for
+;;          the file. Uses X-popup [imenu] to show those book marks and
+;;          moving between them.
+;;
+;;  How to keep files organized
+;;
+;;      There are several tools to keep your code organized and they are at
+;;      their best if you think how they can co-operate. There is
+;;      *folding.el* and *tinybookmark.el*, which might seem to do double
+;;      job, since they both divide code into more easily manageable
+;;      sections. The key point is that when folding is used, one works
+;;      _within_ some special section and possibly want to hide all the
+;;      rest of the code. But when jumping easily back and forth on the
+;;      buffer, it us *unfolded* and TinyBookmark is used. Now, to confuse
+;;      you more, there is also *imenu.el* which can be used to jump inside
+;;      code. It can be configured so that it will pick all function names
+;;      inside list, and when you want to go to specific function, just
+;;      pick one from imenu.
+;;
+;;      To summarize:
+;;
+;;      o   folding.el      - For hide unneeded code,
+;;                            clear view on the structure
+;;      o   tinybookmark.el - Jump between/finding  _large_ code sections
+;;      o   imenu.el        - Finding specific function, more detailed control.
+;;      o   tinyhotlist.el  - Add/remove files from permanent X-popup list
+;;
+;;  How to use this package
+;;
+;;      There is following function that inserts book mark on the current line
+;;
+;;          M-x tinybookmark-insert
+;;
+;;      There is also normal repeat function, that fills line with your
+;;      pattern:
+;;
+;;          M-x tinybookmark-repeat
+;;
+;;      Normally the usual book mark separator is the "." <dot> , which
+;;      isn't so "noisy" as continuous '-' line. Normally you add some
+;;      unused ID character, like '&' at front of real book mark, like
+;;      this:
+;;
+;;          ;;; .................................. &How-to-use ...
+;;          (defun test ()
+;;           (progn
+;;            ..
+;;            (goto-char ..
+;;            ;; ^^^^^^^^^^^^^^^^^^^^^^^^^^ sepratorInsideCode ^^^
+;;
+;;      The `How-to-use' is book mark, because it has `&' on it, whilst the
+;;      latter isn't -- it is used inside code to make it more readable and
+;;      The latter on is not included in *imenu*.
+;;
+;;  About the book mark identifier naming
+;;
+;;      When you name the breaks, keep in mind that when identifiers are
+;;      sorted, the ones that start with big letters A-Z show up first, a-z
+;;      come next. Allthougt it would be convenient to have all subwords in
+;;      capital, it is usually better to start with lowercase letter,
+;;      because it's easily unintentionally mix up/down case letters.
+;;      Besides you have to reah out for shift to have uppercase.
+;;
+;;          ............. breakName ...         ;prefered, starting low
+;;          ............. BreakName ...         ;watch out for mixed case!
+;;
+;;      It is also adviced that you choose some common beginning for the
+;;      identifier, so that they get sorted nicely. If you define variables
+;;      at the beginning of file it might be good idea to attach beginning
+;;      letter like `v-' for variables before the real identifier name
+;;      begins, like:
+;;
+;;          ............. v-globals ...
+;;          ............... v-hooks ...
+;;
+;;      Of course, we can now use the uppercase letter trick to have them
+;;      sorted first in the list, just change `v-' to `V-'. Generally
+;;      you should think which ones do you use most, do you leave the
+;;      variables alone when you have defined them and mostly work with new
+;;      functions? Then the variables can stay at the end of list and
+;;      there is no need for `V-' trick. but if you need to access
+;;      variables often, then you might want to see variables first in the
+;;      list. It's up to your decision how you name the variables and how
+;;      you want to see them listed.
+;;
+;;  Breaks and sub-break naming
+;;
+;;      If you have very large file, you'll probably need major breaks,
+;;      level one breaks and possibly level 2 breaks too. To keep the list
+;;      well sorted, put the functions into bigger groups and name the
+;;      sub-level breaks so that they have some common beginning in respect
+;;      to the major break they belong to. Let's see an example where
+;;      you're dealing with mail handling. Notice the CAPITAL letter.
+;;
+;;          ;; ################################# &h-Header ###
+;;          ;;  this is beginning block of header handling
+;;
+;;          ;; ..................................... &h-cc ...
+;;          ;;  Some special function here to handle CC
+;;          ;;  field, killing all recipients, or only
+;;          ;;  some of them
+;;
+;;          ;; .. .. . .. . .. . .. . .. . .. . .. . .. . .. .
+;;          ;;  More detailed functions under h-cc, Not
+;;          ;;  named, because there is only 2 function
+;;
+;;      Again there are couple of points to follow here. All the tricks are
+;;      discussed already: the `Big' letter trick put's major break to the
+;;      top of imenu list, common beginning keeps the subsections together.
+;;
+;;  Example breaks
+;;
+;;      Some book mark breaks are proposed here, but you can use whatever you
+;;      like. Thumb of rule: be consistent, always use same convention in
+;;      your files and consider the "level of noisiness" of your breaks, so that
+;;      they build up nicely and the code is easy to read. Too many
+;;      _different_ breaks is not good idea, because they clutter the view
+;;      fast, instead use variations on a theme: same break character but
+;;      varying spaces and continuous character lengths.
+;;
+;;      Thumb rule: select 1-3 break chars, and never change them in you
+;;      files; your files look alike. Vary the spacing, not the break
+;;      characters.
+;;
+;;      These are 'noisy breaks' , Major section separators, pick only one
+;;      and use it in your files, do not use all three!
+;;
+;;          ##############################################################
+;;          %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+;;          ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
+;;
+;;      less noisy breaks
+;;
+;;          .`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`.`
+;;
+;;          .^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^
+;;
+;;          .:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:
+;;          .~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~
+;;
+;;
+;;      This is sub section break
+;;
+;;          ................................................................
+;;
+;;
+;;      This is even lighter subsection break (varying spacing)
+;;
+;;          ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...
+;;
+;;      'Draw one's attention' break: something special in this section
+;;
+;;
+;;          --++-- --++-- --++-- --++-- --++-- --++-- --++-- --++-- --++--
+;;
+;;      Internal break 1, inside function, long case statement etc.
+;;
+;;          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+;;
+;;      Internal break 2, to separate long case elements etc.
+;;
+;;
+;;          ^^^  ^^^  ^^^  ^^^  ^^^  ^^^  ^^^  ^^^  ^^^  ^^^  ^^^  ^^^  ^^^
+;;
+;;     Book Mark Cache
+;;
+;;      So that imenu works fast, it is not desirable that the breaks are
+;;      always parsed from scratch, because it takes time to scan the file
+;;      for possible book marks. That's why the information is cached. If
+;;      the break cache is empty, the breaks are gathered from buffer and
+;;      stored to the cache and when you call the imenu, the cache is
+;;      offered to it --> fast response time. When you add new breaks to
+;;      the buffer [especially at the beginning of code development], you
+;;      may want to call function `tinybookmark-parse' which will empty the
+;;      cache and re-read all book marks. If you write lot of code the
+;;      points that were cached do no longer represent exact points of book
+;;      marks, because they have been sliding off their places. If you want
+;;      *always* have updated book mark points, there is variable
+;;      `tinybookmark-cache-update' which you can set to 'always, if you
+;;      want the cache to be updated always prior showing X-menu. In large
+;;      buffer this remarkably slows down the menu appering. See variable
+;;      for more choices.
+;;
+;;  Automatic book mark detection
+;;
+;;      In order book marks to be detected in file, you may define following
+;;      RCS identifier [see ident(1)] preferably at the beginning of your
+;;      file:
+;;
+;;          $BookMarkRegexp:<space>'REGEXP'<space>$
+;;
+;;      Be careful so that the identifier is _exactly_ in this form: pay
+;;      attention to spaces and (') around the REGEXP. The regular
+;;      expression tells what line can be considered as book mark and the
+;;      book mark name is indicated in subexpression 1 [\\(.*\\)] , look at
+;;      this file, how it is constructed. In order to find all book marks
+;;      and build up the cache, it needs to widen the buffer in case the
+;;      file is narrowed with some folding or outline editor. When the
+;;      cache has been built the buffer's narrowing is restored, so you
+;;      shouldn't even notice this. Of course you don't want to find book
+;;      marks from your RMAIL file.
+;;
+;;      One word about the regexp construction, let's see regexp that
+;;      matches the identifier:
+;;
+;;          &+\\([^ ]+\\)
+;;
+;;      Pay attention to using exclusive regexp, not just '.*'
+;;      construction. When you use folding or outline editor the '.*' form
+;;      is very ill behaving, because if the line being scanned is
+;;      currently folded, IT WILL MATCH WHOLE folded section --> your
+;;      identifier surely isn't that one. We can't unfold the sections
+;;      during scanning, because if there are subfolds, what editor is on
+;;      use .. it's too complex/slow to handle such situations. But using
+;;      the exclusive list [^ ] will surely match the identifier, because
+;;      it stops when it can find first space. This means that you can't
+;;      use _spaces_ inside the identifiers. Cat the words together.
+;;
+;;  If the BookMarkRegexp isn't defined in file
+;;
+;;      Then the programs tries to search for the default book marks.
+;;      See function `tinybookmark-regexp-default' for more.
+;;
+;; Message: Empty cache. Building...
+;;
+;;      Do you wonder why you get this message displayed, while you were
+;;      sure that you the buffer had cache already? Don't be surprised. This
+;;      is totally normal behavior: whenever you switch mode for the
+;;      buffer the new mode _kills_ all local variables, including cache
+;;      information. Obviously the information must be restored when you
+;;      call the hot list again. The cache could have been programmed to be
+;;      buffer local, but in the present format only one cache s active at
+;;      the time. This was simpler to implement and manage in the code.
+;;
+;;  About imenu
+;;
+;;      You definitely want to look at the documentation of imenu to find
+;;      many more usages for it. It makes your day shine in X-display. You
+;;      should also configure few variables for it, like:
+;;
+;;          (setq imenu-max-items 20)
+;;
+;;  Test run
+;;
+;;      Load this file and set those key bindings mentioned. Hit the mouse
+;;      bindings and you're running book mark package. Since the break
+;;      marks are used in commentary also, the list of book marks are not
+;;      in their most informative form, I use following convention to name
+;;      book marks;
+;;
+;;          'v-'     variable topic
+;;          't-'     text topic
+;;
+;;  Design thoughts
+;;
+;;      Sooner or later someone wonders: "Can't we have sub-breaks listed
+;;      nicely with indentation in front lines in X-popup?" Present answer
+;;      "No", since it would require keeping track of the 'Main break' and
+;;      then seeing if there exist sub-breaks. Immediately this leads to
+;;      question "What is the main break?", and if we say main breaks start
+;;      with "#|/%" character set we limit the use of breaks. Besides deciding
+;;      what are sub-breaks, main-breaks with regexp may be too slow.
+;;      The breaks are intended to to give an *overview* of the buffer.
+;;      Please use imenu to find single functions if you don't feel like
+;;      tapping couple of pgUp/pgDown after the point is positioned in the break
+;;      section.
+
+;;}}}
+
+;;; Change Log:
+
+;;; Code:
+
+;;{{{ setup: require
+
+;;; ......................................................... &require ...
+
+(require 'tinylibm)
+
+(eval-and-compile
+  (autoload 'imenu--mouse-menu          "imenu"    "" t)
+  (autoload 'folding-show-current-entry "folding"  "" t))
+
+(ti::package-defgroup-tiny TinyBookmark tinybookmark-- tools
+  "Minor mode for writing text in 'Technical text format'.
+  Overview of features
+
+        o   Provides some 'setting book marks' functions: adding
+            repeated characters and sequences up till end of line with
+            named identifier. (like breaks in this file)
+        o   Automatically parses book marks from file, if it contains
+            RCS identifier 'book markRegexp' which defines book mark syntax for
+            the file. Uses X-popup [imenu] for showing those book marks and
+            moving between them.")
+
+(defvar tinybookmark--version-time "2010.1119.1452"
+  "Last modified time.")
+
+;;}}}
+;;{{{ setup: -- hooks
+
+;;; ......................................................... &v-hooks ...
+
+(defcustom tinybookmark--parse-before-hook nil
+  "*Hook that is run just before the buffer is scanned for book marks."
+  :type  'hook
+  :group 'TinyBookmark)
+
+(defcustom tinybookmark--load-hook nil
+  "*Hook run when file is loaded."
+  :type  'hook
+  :group 'TinyBookmark)
+
+;;}}}
+;;{{{ setup: user configuration
+
+;;; ........................................................ &v-public ...
+
+(defcustom tinybookmark--cache-update 'threshold
+  "*Method when to update cache.
+
+nil         manual update -- you have to call `tinybookmark-parse'
+'always     always update cache when menu displayed.
+'threshold  update happens when buffer's total character change
+            exceeds previous value of `tinybookmark--cache-threshold-val'."
+  :type '(choice
+          (const nil)
+          (const 'always)
+          (const 'threshold))
+  :group 'TinyBookmark)
+
+(defcustom tinybookmark--cache-threshold-val 100
+  "*When cache is constructed, the total character count is saved.
+When user adds more code, the total count changes accordingly. If the
+difference between current count and last saved count gets bigger than
+this value the cache is re-read."
+  :type  'integer
+  :group 'TinyBookmark)
+
+(defcustom tinybookmark--re-default-chars "[-~+=*%/|#.,'`^]"
+  "*Default book mark repeat chars."
+  :type  'string
+  :group 'TinyBookmark)
+
+(defcustom tinybookmark--max-col '(progn  (tinybookmark-calc-max-col))
+  "*Last column to extend the break.
+This can be FORM which evaluates to column number"
+  :type  'sexp
+  :group 'TinyBookmark)
+
+(defcustom tinybookmark--trailer-space-len 3
+  "*How much space is left to the right before the book mark ID ends."
+  :type  'integer
+  :group 'TinyBookmark)
+
+(defcustom tinybookmark--comment-start-func 'tinybookmark-comment-start
+  "*Function that return appropriate start comment.
+Must return empty string if comment not defined."
+  :type  'function
+  :group 'TinyBookmark)
+
+(defcustom tinybookmark--comment-end-func 'tinybookmark-comment-end
+  "*Function that return appropriate end comment.
+Must return empty string if comment not defined."
+  :type  'function
+  :group 'TinyBookmark)
+
+(defcustom tinybookmark--scan-filter-func 'tinybookmark-scan-filter
+  "*Filter out match.
+When building up the book marks from file, there may be false hits,
+or you may look at special lines only. This function accepts three arguments:
+- current line string
+- line beginning point
+- identifier found from line
+
+If the function return nil the line is not added to the cache."
+  :type  'function
+  :group 'TinyBookmark)
+
+(defcustom tinybookmark--goto-func 'tinybookmark-goto
+  "*Function that handles moving to the point.
+If you have folding in effect around that point you may wish
+to open it in your custom function.
+
+This function receives one argument: POINT"
+  :type  'function
+  :group 'TinyBookmark)
+
+(defcustom tinybookmark--insert-strict t
+  "*Controls if the book Mark insertion is strict when no argument is given.
+See `tinybookmark-insert'"
+  :type  'boolean
+  :group 'TinyBookmark)
+
+;;}}}
+;;{{{ setup: -- private vars
+
+;;; ....................................................... &v-private ...
+
+(defvar tinybookmark--cache nil
+  "Private.
+Cache where book marks are stored in alist \(bookMarkName . point\)")
+(make-variable-buffer-local 'tinybookmark--cache)
+
+;;  We don't want cache to be wiped away when major mode changes
+(put 'tinybookmark--cache           'permanent-local t)
+
+(defvar tinybookmark--cache-char-count nil
+  "Private. Totals characters in buffer.")
+(make-variable-buffer-local 'tinybookmark--cache-char-count)
+
+(defvar tinybookmark--bookmark-regexp nil
+  "Private. Hold buffers book mark regexp.")
+(make-variable-buffer-local 'tinybookmark--bookmark-regexp)
+
+;;}}}
+;;{{{ Macros
+
+;;; ----------------------------------------------------------------------
+;;;
+(defsubst tinybookmark-regexp-read-from-buffer ()
+  "Return buffer's book mark regexp.
+If the local value where the regexp is stored is nil, the rescan buffer.
+
+References:
+  `tinybookmark--bookmark-regexp'"
+  (or tinybookmark--bookmark-regexp     ;changing mode kill local vars
+      (setq tinybookmark--bookmark-regexp
+            (tinybookmark-search-bm-re))))
+
+;;; ----------------------------------------------------------------------
+;;; Default book mark syntax that is used if file does not contain
+;;; it's own definition of book mark syntax.
+;;;
+(defsubst tinybookmark-regexp-default  ()
+  "Return default book mark regexp.
+References:
+  `tinybookmark--re-default-chars'"
+  (concat
+   tinybookmark--re-default-chars
+   tinybookmark--re-default-chars "+"
+   " &+\\([^ \t]+\\) "
+   tinybookmark--re-default-chars "+"))
+
+;;}}}
+;;{{{ movement functions
+
+;;; ........................................................ &movement ...
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinybookmark-search-regexp ()
+  "Return book mark search regexp."
+  (concat "^[ \t]*" (or comment-start "") "+ *"
+          (tinybookmark-regexp-read-from-buffer)))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinybookmark-backward ()
+  "Search book mark line backward."
+  (interactive)
+  (re-search-backward (tinybookmark-search-regexp) nil t))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinybookmark-forward (&optional back)
+  "Search book mark line forward or optionally BACK."
+  (interactive)
+  (re-search-forward (tinybookmark-search-regexp) nil t))
+
+;;}}}
+
+;;{{{ miscellaneous functions
+
+;;; ............................................................ &misc ...
+
+;;; ----------------------------------------------------------------------
+;;; LISP column
+;;;  - I can hear you saying: "Why 74? why not 70 or 75 ?..."
+;;;  - Well, I usually add book mark section to my elisp code and while
+;;;    I did them by hand I added ';;; ' comment at the beginning of
+;;;    line and fed 70  continuous characters with ESC 70 '-'after
+;;;    comment  --> totals 4 + 70 chars :-/
+;;;
+;;;  - The idea of this calculation is that when you hit separator,
+;;;    like this: COMMENT-SPACE-70_CHAR_SEPARATOR, this will calculate
+;;;    the column so, that when tinybookmark-insert is called, the last
+;;;    char lines up with yours.
+;;;
+;;;    E.g. in shell mode:
+;;;
+;;;             # ---------------, 70 chars long sep, last col is 2 + 70
+;;;             # ..............., tinybookmark-insert lines up to col 72
+;;;
+;;;    But in lisp
+;;;
+;;;             ;;; -------------, again 70 chars long sep, 4 + 70
+;;;             ;;; ............., tinybookmark-insert lines up to col 74
+;;;
+;;;    Now you can hit 70 line separator in any mode and to be sure the
+;;;    tinybookmark-insert lines up with you.
+;;;
+(defun tinybookmark-calc-max-col ()
+  "Calculates column for mode."
+  (let ((mode (symbol-name major-mode))
+       (cs   (or comment-start ""))
+       (len  70))            ; like "# " + 70 chars
+    (cond
+     ((string-match "lisp" mode)
+      74)
+     (t
+      (if (string-match "[ \t]+" cs)  ;does it already have space "# "
+          (+ len (length cs)) ;no it does not "#", add room for it.
+        (1+ (+ len (length cs))))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinybookmark-goto (point)
+  "Go to the selected POINT."
+  (let ((re ".*{{{"))
+    (cond
+     ((and (featurep 'folding)
+           (symbol-value 'folding-mode))
+      (goto-char point)
+      (save-excursion
+        (beginning-of-line)
+        (if (looking-at re)
+            (folding-show-current-entry))))
+     (t
+      (goto-char point)))))
+
+;;; ----------------------------------------------------------------------
+;;; - include all lines
+;;;
+(defun tinybookmark-scan-filter (full-line pos id)
+  "Return always t, so all matched lines are cached.
+Ignore FULL-LINE POS ID."
+  t)
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinybookmark-comment-end ()
+  "Return appropriate comment end, according to mode."
+  (let ((str (or comment-end "")))
+    (unless (equal "" str)
+      (setq str (ti::string-add-space str)))
+    str))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinybookmark-comment-start ()
+  "Return appropriate comment, according to mode."
+  (let ((str (or comment-start "")))   ;comment
+    ;;   Lisp is special, due to it's comment usage
+    (when (memq major-mode  '(lisp-mode emacs-lisp-mode lisp-interaction-mode))
+      (if (bolp)
+          (setq str ";;;")
+        (setq str ";;")))
+    (unless (equal "" str)
+      (setq str (ti::string-add-space str t)))
+    str))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinybookmark-cache-update ()
+  "Determines when and how to update cache.
+References: `tinybookmark-cache-update'"
+  (let* ((mode       tinybookmark--cache-update)
+         (end        (marker-position (point-max-marker)))
+         (cache-end  (or tinybookmark--cache-char-count
+                        end))
+         (limit      tinybookmark--cache-threshold-val)
+         diff)
+    (cond
+     ((eq mode nil)
+      nil)                              ;manual
+     ((eq mode 'always)
+      (tinybookmark-parse))
+     ((eq mode 'threshold)
+      (setq diff (abs (- end cache-end)))
+      (if (< diff limit) nil
+        ;; Hmm, should we print a message "threshold exceeded, reparsing..?"
+        ;; Let's be transparent this time: no messages.
+        (tinybookmark-parse))))))
+
+;;}}}
+;;{{{ book mark line insert
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinybookmark-repeat (str count &optional col strict)
+  "Repeats character or string sequence STR COUNT times.
+
+COUNT can be:
+
+  0       repeat until position 79 or COL , or if the STR is not single
+          character, until fits below COL
+  \"\"    interactive insert, as long as user presses RET or SPACE.
+
+STRICT has effect only if COL is given:
+
+  nil     insert as long as STR fits below COL
+  t       insert strictly up till COL and cut away portion
+          of STR if necessary"
+
+  (interactive "sString:\nsCount[0=eol]: ")
+  (let* ((swide (or col 79))            ;screen width
+         (i     0)
+         (ok    t)
+         ch
+         c
+         len
+         p)
+    (unless (or (not (stringp str))         ;it's not string
+               (eq 0 (length str)))        ;string is empty
+      (cond
+       ((stringp count)
+       (if (equal "" count)
+           (setq c -1)                   ;interactive
+         (setq c (string-to-number count))))
+       ((numberp count)
+       (setq c count))
+       (t
+       (error "Invalid count arg %s" count)))
+      ;; ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
+      (cond
+       ((eq c -1)                        ;ask confirmation every time...
+       (while ok
+         (message "insert? <spc,enter> ")
+         (setq ch (read-char))
+         (cond
+          ((or (char-equal ch ?\C-m )
+               (char-equal ch ?\ ))
+           (insert str))
+          (t (setq ok nil))))
+       (message ""))
+       ;; ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
+       ((eq c 0)
+       (setq len         (length str)
+             p           (current-column))
+       ;; we have to remove tabs from this line to get count right
+       (untabify (line-beginning-position) (line-end-position))
+       (move-to-column p)                ;restore position
+       ;; the added str must not move point further than COL
+       (while (<= (+ len (current-column)) swide)
+         (insert str))
+       ;;   Check if it was multicharacter and we didn't get to last position
+       ;;   Insert the last string and cut after COL
+       (if (null strict)
+           nil
+         (if (= (current-column) swide)
+             nil
+           (insert str)
+           (ti::buffer-move-to-col swide)
+           (delete-region (point)
+                          (progn
+                            (end-of-line)
+                            (point))))))
+       ;; ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
+       (t                                 ;straight number !
+       (while (< i c)
+         (insert str) (setq i (1+ i))))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinybookmark-insert (txt sep &optional strict)
+  "Add book mark until the end of line.
+Normally line is filled as long as the pattern fits below max column,
+but if the optional argument is given, it will be filled in full ,
+truncating if necessary. To see an example, try with some long
+pattern.
+
+Input:
+
+  TXT       book mark name
+  SEP       separator string that is repeated.
+  STRICT
+            0       strict is nil in spite of `tinybookmark--insert-strict'
+            1       strict is t   in spite of `tinybookmark--insert-strict'
+            nil     use default value in `tinybookmark--insert-strict'
+
+References:
+
+  `tinybookmark--insert-strict'"
+  (interactive "sBookmark: \nsSep: \nP")
+  (let* ((strict-def  tinybookmark--insert-strict)
+         (cs-func     tinybookmark--comment-start-func)
+         (ce-func     tinybookmark--comment-end-func)
+         (line-col    (eval tinybookmark--max-col))
+         (trail-len   tinybookmark--trailer-space-len) ;how much to leave
+         (bolp        (line-beginning-position))
+         (cur-col     (current-column))
+         (orig-point  (+ bolp cur-col))
+         col
+         cs
+         ce)
+    (cond
+     ((eq nil strict)                   ;use default
+      (setq strict strict-def))
+     ((eq 0 strict)
+      (setq strict nil))
+     ((eq 1 strict)
+      (setq strict t))) ;; cond end
+    (if (= 0 (length sep))
+        (error "No separator"))
+    ;;  Add surrounding spaces if they are not included
+    (unless (equal "" txt)
+      (setq txt (ti::string-add-space txt)
+            txt (ti::string-add-space txt t)))
+    (setq cs (funcall cs-func)          ;Set comments
+          ce (funcall ce-func))
+    ;;  I tried to turn overwrite-mode on, but SUPRISE!
+    ;;  - While it was on, and I tried to do 'insert',
+    ;;    it didn't _overwrite_; emacs why can't you behave as expected ?
+    ;;  - So I have to hack with delete-region instead.
+    ;;  - skip lenght of comment start
+    (ti::buffer-move-to-col (+ cur-col (length cs)))
+    ;; We must clear the rest of line
+    (unless (looking-at "$")
+      (delete-region (point) (line-end-position)))
+    ;;  - draw the line until max col
+    (setq col line-col)                 ;maximum repeat column
+    (tinybookmark-repeat sep 0 col strict) ;insert full separator
+    ;;  - Now cut room for identifier
+    (backward-char (+ (length txt) trail-len)) ;leave trailer space
+    (delete-region (point) (+ (point) (length txt)))
+    ;;  - write the identifier
+    (insert txt)
+    (end-of-line)
+    (insert ce)                         ;comment end
+    ;;  - delete spaces at front and replace it with comment start
+    (goto-char orig-point)
+    (delete-region (point) (+ (point) (length cs)))
+    (insert cs)
+    (goto-char orig-point)))
+
+;;}}}
+;;{{{ Book Mark find, caching
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinybookmark-scan (re)
+  "Gather all book marks from current point forward using RE.
+Return list: (id . beginning-of-line-point).
+
+References:
+  `tinybookmark--scan-filter-func'"
+  (let ((func tinybookmark--scan-filter-func) ;should we filter something ?
+       id
+       point
+       list)
+    (while (re-search-forward re nil t)
+      (when (setq id (match-string 1))
+        (setq point (line-beginning-position))
+        ;;  Is this line allowed to add ?
+        (if (funcall func (ti::read-current-line) id point)
+            ;;  Nothing magic in this expression, just build list
+            ;;  '((id point) (id .point) ..)
+            (ti::nconc list (cons id point)))))
+    list))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinybookmark-search-bm-re ()
+  "Search buffer for automatic book mark identifier 'BookMarkRegexp'.
+Returns regexp defined in it. if is doesn't exist returns default
+book mark regexp."
+  (let ((id          "BookMarkRegexp")
+       (re-default  (tinybookmark-regexp-default))
+       id-val
+       fixed-val
+       ret)
+    (setq id-val (ti::vc-rcs-str-find-buffer id t))
+    ;;  while reading from buffer the \ doubles, convert it back to \
+    (setq fixed-val (ti::string-plain-string-to-regexp id-val))
+    (if (or  (null fixed-val)
+             ;;  We must find the '' marks
+             (not (string-match "'\\(.+\\)'" fixed-val)))
+        (setq ret re-default)
+      (setq ret (match-string 1 fixed-val)))
+    ret))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinybookmark-parse ()
+  "Build book mark list and save it to cache.
+
+Return:
+
+  t     cache was built.
+  nil   book marks not found or error happened. Cache untouched."
+  (interactive)
+  (let ((op             (point))       ;user's original point
+       (beg            (point-min-marker))
+       (end            (point-max-marker))
+       (end-pos        (marker-position (point-max-marker)))
+       (end-max        (point-max))
+       end-wmax
+       re
+       ret
+       list)
+    (run-hooks 'tinybookmark--parse-before-hook)
+    (setq tinybookmark--cache-char-count end-pos) ;Set GLOBAL
+    (if (null (setq re (tinybookmark-regexp-read-from-buffer)))
+        (message "TinyBookmark: No book mark syntax Identifier found.")
+      (unwind-protect                   ;handle narrowed buffers too
+          (progn
+            (widen)
+            (setq end-wmax (point-max))
+            (ti::pmin)
+            (setq list (tinybookmark-scan re))
+            (if (null list)
+                (message "TinyBookmark: No book marks found.")
+              (setq ret t)
+              (setq tinybookmark--cache list)))
+        (save-excursion
+          (with-current-buffer (marker-buffer beg)
+           ;; what about after widen ? Were we in narrow mode ?
+           (unless (= end-wmax end-max)
+             (narrow-to-region beg end))))))
+    ;; only reasonable way to return to current point
+    (goto-char op)
+    ret))
+
+;;}}}
+;;{{{ mouse
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinybookmark-keyboard-parse ()
+  "Reparse book marks."
+  (tinybookmark-mouse-parse nil (interactive-p)))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinybookmark-mouse-parse (&optional event verb)
+  "Reparse book mark list. This function is called from mouse binding.
+Called with mouse EVENT. VERB displays message."
+  (interactive "e")
+  (ti::verb)
+  (if (and verb (tinybookmark-parse))
+      (message "TinyBookmark: Book Marks cached.")))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinybookmark-selection (event)
+  "Display cache menu. Called with mouse EVENT."
+  (interactive "e")
+  (let ((go-func   tinybookmark--goto-func)
+       cache
+       data)
+    (tinybookmark-cache-update)
+    (setq cache     tinybookmark--cache)
+    (if (null cache)
+        (message "TinyBookmark: No book marks found.")
+      (cond
+       ((ti::compat-window-system)
+        (setq data (imenu--mouse-menu cache event)))
+       (t
+        (setq data (completing-read "Select: " cache))
+        (setq data (assoc data cache))))
+      (if data
+          (funcall go-func (cdr data))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinybookmark-cache-regenerate (&optional force)
+  "Regenerate cache if needed. Optional FORCE."
+  (let ((cache-ok tinybookmark--cache))
+    (when (or (null cache-ok)
+              force)
+      (message "TinyBookmark: building cache...")
+      (sleep-for 1)
+      (message "")
+      (tinybookmark-parse))))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinybookmark-keyboard (bookmark &optional arg)
+  "Complete and jump to bookmarks.
+Optional ARG rebuilds cache."
+  (interactive
+   (progn
+     (if current-prefix-arg
+         (tinybookmark-cache-regenerate t))
+     (let* ((ans (completing-read "TinyBookmark: "
+                                  tinybookmark--cache nil 'match)))
+       (list ans
+             current-prefix-arg))))
+  (unless (interactive-p)
+    (tinybookmark-cache-regenerate arg))
+  (let* ((elt (assoc bookmark tinybookmark--cache)))
+    (if (not elt)
+        (message
+         (substitute-command-keys
+          (concat
+           "TinyBookmark: ERROR, rebuild with "
+           "\\[universal-argument] \\[tinybookmark-keyboard]")))
+      (goto-char (cdr elt)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinybookmark-mouse (event &optional arg)
+  "Display book mark pop up menu. Use mouse EVENT.
+Optional ARG rebuilds cache."
+  (interactive "e\nP")
+  (tinybookmark-cache-regenerate arg)
+  (tinybookmark-selection event))
+
+;;}}}
+
+(provide   'tinybookmark)
+(run-hooks 'tinybookmark--load-hook)
+
+;;; tinybookmark.el ends here
diff --git a/elisp/tiny/tinybuffer.el b/elisp/tiny/tinybuffer.el
new file mode 100644 (file)
index 0000000..a66f98b
--- /dev/null
@@ -0,0 +1,451 @@
+;;; tinybuffer.el --- Change buffers in current window.
+
+;; Copyright (C) 1996-2012 Jari Aalto
+
+;; Author:      Jari Aalto
+;; Maintainer:  Jari Aalto
+;; Keywords:    extensions
+;; Version:    2.1
+;; Keywords:    tools
+;; URL:                http://www.emacswiki.org/emacs/TinyTools
+
+;; This file is not part of Emacs.
+
+;; This program 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 of the License, or (at your option)
+;; any later version.
+;;
+;; This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+;;
+;; Visit <http://www.gnu.org/copyleft/gpl.html> for more information
+
+;; Install:
+
+;;  Add following statement(s) to your ~/.emacs
+;;
+;;      (require 'tinybuffer)
+;;
+;;  or use autoload and your ~/.emacs starts lot faster. Preferred method.
+;;
+;;    (autoload 'tinybuffer-iswitch-to-buffer     "tinybuffer.el" "" t)
+;;    (autoload 'tinybuffer-previous-buffer       "tinybuffer.el" "" t)
+;;    (autoload 'tinybuffer-next-buffer           "tinybuffer.el" "" t)
+;;    (autoload 'tinybuffer-sort-mode-toggle      "tinybuffer.el" "" t)
+;;
+;;  You don't need to copy these if you used the `require', but in order
+;;  to trigger autoload you must insert these into your ~/.emacs. These
+;;  are also the defaults bindings. If you use something other that these,
+;;  reset the `tinybuffer--load-hook' variable.
+;;
+;;    (setq tinybuffer--load-hook nil)  ;; Don't load default bindings.
+;;
+;;    ;;    If you use Emacs with X window, these could be suitable keys.
+;;
+;;    (global-set-key [(control <)]         'tinybuffer-previous-buffer)
+;;    (global-set-key [(control >)]         'tinybuffer-next-buffer)
+;;    (global-set-key [(control meta <)]    'tinybuffer-iswitch-to-buffer)
+;;    (global-set-key [(alt <)]             'tinybuffer-sort-mode-toggle)
+;;
+;;    ;;    For non-windowed Emacs; you want to program your own keys.
+;;    ;;    Please check C-h l `view-lossage' for your keybindings, these
+;;    ;;    examples are from HP-UX numpad:
+;;
+;;    (global-set-key "\eOq" 'tinybuffer-previous-buffer)  ;; numpad 1
+;;    (global-set-key "\eOr" 'tinybuffer-sort-mode-toggle) ;; numpad 2
+;;    (global-set-key "\eOs" 'tinybuffer-next-buffer)      ;; numpad 3
+;;
+;;    ;;    Here is code to switch between all visible windows
+;;
+;;    (global-set-key [(f5)]
+;;                   (lambda ()
+;;                     (interactive)
+;;                     (other-window 1 t)
+;;                     (raise-frame (window-frame
+;;                                   (get-buffer-window
+;;                                    (current-buffer))))))
+;;
+;;   If you have any questions, use this function to contact author
+;;
+;;      M-x tinybuffer-submit-bug-report
+
+;;; Commentary:
+
+;;
+;;  Preface, May 1996
+;;
+;;      With this small package you can switch to next or previous buffer
+;;      in a current window. If you only have small amount of buffers in
+;;      `buffer-list', this may be the fastest way to select a working
+;;      buffer. On the other hand, if you have more than 20 working
+;;      buffers, I'd recommend that you use exellent substring buffer
+;;      switching utility instead: *iswitchb.el* which is included in
+;;      standard Emacs distribution
+;;
+;;      If you have windowed environment and want to have hot list of your
+;;      permanent buffers available, use *imenu.el* or *tinyhotlist.el* and
+;;      you can select buffers instantly.
+;;
+;;  Description
+;;
+;;      If you don't want default bindings, clear the installation with
+;;      following command. This must be prior the 'require statement.
+;;
+;;          (setq tinybuffer--load-hook nil)
+;;
+;;      To change buffers forward or backward, the default setup would install
+;;      following key bindings:
+;;
+;;      o   Control->       Next buffer
+;;      o   Control-<       Previous buffer
+;;      o   Alt-Control-<   Iswitch mode, where you can scroll with < and >.
+;;          Press RET to select or ESC/q to quit
+;;          This may come handy if you have many buffers and just want to
+;;          skip 2-5 buffers fast. E.g. if the buffers are font-lock
+;;          controlled, switching to them with the C-, and C-, keys might
+;;          be slow due to fontification which happens every time you
+;;          switch over a buffer.
+;;
+;;      In iswitch mode, the command prompt looks like following. The
+;;      mode name is put last if buffer has and associated file name,
+;;      so that filename gets as much display as possible.
+;;
+;;              "TinyIswitch: my-lisp.el     ~/elisp/my-lisp.el <Emacs lisp>"
+;;              "TinyIswitch: test           <dired> ~/tmp/test"
+;;              "TinyIswitch: *Messages*     <fundamental-mode>"
+;;
+;;      Have a look at `tinybuffer--ignore-regex' which you can configure
+;;      to ignore some buffers permanently.
+;;
+;;  Thanks
+;;
+;;      Original idea for this package comes from *yic-buffer.el*
+;;      by choo@cs.yale.edu (young-il choo) 1990-08-07.
+
+;;; Change Log:
+
+;;; Code:
+
+(if (featurep 'xemancs)
+    (error "XEmacs unsupported. The character reading code does not work in XEmacs"))
+
+(defgroup tinybuffer nil
+  "Change buffers in current window.
+With this small package you can switch to next or previous buffer
+in a current window. If you only have small amount of buffers it
+may be the fastest way."
+  :link '(url-link :tag "Homepage" "http://www.emacswiki.org/emacs/TinyTools")
+  :group 'extensions)
+
+;;{{{ setup: -- variables
+
+;;; User configurable
+
+(defcustom tinybuffer--load-hook '(tinybuffer-install-default-bindings)
+  "*Hook run when file has been loaded.
+Default value contains function `tinybuffer-install-default-bindings'."
+  :type  'hook
+  :group 'TinyBuffer)
+
+(defcustom tinybuffer--ignore-regexp
+  (concat
+   "^ "                                 ;hidden buffers
+   "\\|completion\\|summary"
+   "\\|buffer list\\|help\\|ispell\\|abbrev"
+   "\\|temp\\|tmp\\|vc\\|compile-log\\|occur")
+  "*Buffers to ignore when changing to another."
+  :type  'regexp
+  :group 'TinyBuffer)
+
+(defcustom tinybuffer--sort-flag nil
+  "*Non-nil means that buffers are switched in sorted order."
+  :type  'boolean
+  :group 'TinyBuffer)
+
+(defcustom tinybuffer--iswitch-to-buffer-keys  '(?< ?>)
+  "*Keys to scroll buffers backward and forward in iswitch mode.
+See \\[tinybuffer-iswitch-to-buffer]."
+  :type '(list
+          (character :tag "Backward")
+          (character :tag "Forward"))
+  :group 'TinyBuffer)
+
+(defcustom tinybuffer--iswitch-show-directory-flag  t
+  "*Non-nil means that directory name is shown in iswitch mode.
+See \\[tinybuffer-iswitch-to-buffer]."
+  :type  'boolean
+  :group 'TinyBuffer)
+
+;;; Internal variables
+
+(defvar tinybuffer--buffer-list  nil
+  "Global buffer list for `tinybuffer-iswitch-to-buffer'.")
+
+(defmacro tinybuffer-nconc (list place)
+  "Add LIST to PLACE, modify PLACE."
+  `(setq ,place (nconc ,list ,place)))
+
+(defmacro tinybuffer-iswitch-next ()
+  "Return next buffer in list."
+  `(let* ((first (car tinybuffer--buffer-list))
+          (rest  (cdr tinybuffer--buffer-list))
+          (ret   (car rest)))
+     (setq list rest)
+     (tinybuffer-nconc list first)                     ;add to the end
+     (setq tinybuffer--buffer-list list)        ;update list
+     ret))
+
+(defmacro tinybuffer-iswitch-previous ()
+  "Return previous buffer in list."
+  `(let* ((rev   (reverse tinybuffer--buffer-list))
+          (last  (car rev))
+          (rest  (reverse (cdr rev)))
+          (ret   last))
+     (setq list rest)
+     (push last list)                           ;add to the end
+     (setq tinybuffer--buffer-list list)        ;update list
+     ret))
+
+(defun tinybuffer-read-char (&optional prompt)
+  "Read character safely with optional PROMPT."
+  (let (char)
+    (while (null
+           (setq char
+                 (ignore-errors
+                   (if prompt
+                       (message prompt))
+                   (discard-input)     ;this is a must before we read
+                   (read-char)))))
+    char))
+
+(defun tinybuffer-char-in-list (char list)
+  "If CHAR can be found in LIST, return a pointer to it.
+The match is case sensitive."
+  (if char
+      (let (case-fold-search)
+       (memq char list))))
+
+(defun tinybuffer-install-default-bindings ()
+  "Define default global keys."
+  (interactive)
+  (global-set-key [(control <)]      'tinybuffer-previous-buffer)
+  (global-set-key [(control >)]      'tinybuffer-next-buffer)
+  (global-set-key [(control meta <)] 'tinybuffer-iswitch-to-buffer)
+  (global-set-key [(control meta >)] 'tinybuffer-sort-mode-toggle))
+
+(defun tinybuffer-start-list  (buffer-pointer list)
+  "Let BUFFER-POINTER be first and arrange LIST."
+  (let ((start (memq buffer-pointer list))
+       (rev   (reverse list))
+       before
+       ret)
+    ;; Basic idea is this, say pointer is at B:
+    ;;
+    ;; list:   A B C D
+    ;; start:    B C D
+    ;; rev     D C B A
+    ;; before      B A  --> take cdr --> A
+    ;;
+    ;; ret     start + before = B C D A
+    ;;
+    (unless start
+      (error "No such elt in list %s" buffer-pointer))
+    (setq before (cdr-safe (memq buffer-pointer rev)))
+    (setq ret start)
+    (when before
+      (setq start (reverse start))
+      (add-to-list 'start before))
+    ret))
+
+(defun tinybuffer-buffer-filter (&optional blist)
+  "Filter BLIST, which defaults to `buffer-list'.
+References:
+  `tinybuffer--ignore-regexp'"
+  (let (ret)
+    (dolist (elt (or blist (buffer-list))  )
+      (if (not (string-match tinybuffer--ignore-regexp
+                             (buffer-name elt)))
+          (push elt ret)))
+    ret))
+
+(defun tinybuffer-sort-buffer-list-1 (&optional blist reverse)
+  "Sort BLIST, which defaults to `buffer-list'. Optionally REVERSE."
+  (let ((list (or blist (buffer-list))))
+    (setq
+     list
+     (if reverse
+         (sort list
+               (function
+                (lambda (a b)
+                  (string< (buffer-name b) (buffer-name a)))))
+       (sort list
+             (function
+              (lambda (a b)
+                (string< (buffer-name a) (buffer-name b)))))))
+    list))
+
+(defun tinybuffer-sort-buffer-list  (&optional reverse blist)
+  "Sort buffer list, optionally REVERSE and use BLIST."
+  (let (sorted
+       part
+       list)
+    (setq sorted (tinybuffer-sort-buffer-list-1 blist reverse))
+    ;;  What is this? Okay, you see, when we sort the buffer list...
+    ;;     A B C D E F G
+    ;;         ^
+    ;;     #############  'sorted' holds all
+    ;;           %%%%%%%  'part'   contains only these
+    ;;
+    ;;  We're currently in C, and next one must be D. But if we're
+    ;;  at the end, we're in G, and no buffers follow.
+    ;;
+    ;;  So, to get past G, we have to make list in following way:
+    ;;
+    ;;      @@@@@@ =  %%%%%    ############
+    ;;      list   =  'part' + 'sorted
+    ;;
+    ;;  Sure, there is redundancy, since the 'sorted' holds all elements,
+    ;;  but since we actually ignore buffers in the moving loop, we need
+    ;;  all buffers past G.
+    (when (setq part (memq (current-buffer) sorted))
+      (setq list (cdr part))
+      (tinybuffer-nconc list sorted))
+    sorted))
+
+(defun tinybuffer-buffer-list-next (&optional reverse)
+  "Switch to next buffer in list, skipping unwanted ones. Optionally REVERSE.
+See variable `tinybuffer--ignore-regexp'."
+  (let ((re  tinybuffer--ignore-regexp)
+       list
+       go)
+    (cond
+     (tinybuffer--sort-flag
+      (setq list (tinybuffer-sort-buffer-list reverse)))
+     (reverse
+      (setq list (reverse (buffer-list))))
+     (t
+      (setq list (buffer-list))))
+    (setq list (delq (current-buffer) list))
+    (dolist (buffer list)
+      (unless (string-match re (buffer-name buffer))
+        (setq go buffer)                ;Stop and select it
+        (return)))
+    (if (null go)
+        (message
+        (concat
+         "TinyBuffer: No buffers to circulate; "
+         "see `tinybuffer--ignore-regexp'")))
+    (if go
+        (switch-to-buffer go))))
+
+(defun tinybuffer-init-buffer-list  ()
+  "Initialize global variable `tinybuffer--buffer-list'."
+  (let ((list (tinybuffer-buffer-filter)))
+    (if tinybuffer--sort-flag
+        (setq list (tinybuffer-start-list
+                    (current-buffer)
+                    (tinybuffer-sort-buffer-list-1 list))))
+    (setq tinybuffer--buffer-list list)))
+
+;;;###autoload
+(defun tinybuffer-iswitch-to-buffer  ()
+  "Switch to buffer when RETURN/SPACE/TAB pressed.
+Show buffer at echo area. ESC to cancel prompt.
+
+Note:
+
+  The startup time of calling this function may be high, because it has
+  to build list of choices and possibly filter out unwanted buffers.
+
+References:
+
+  `tinybuffer--iswitch-to-buffer-keys'    keys to scroll buffer list"
+  (interactive)
+  (let* ((keys      tinybuffer--iswitch-to-buffer-keys)
+         (show-dir  tinybuffer--iswitch-show-directory-flag)
+         (go-list   '(?\C-m ?\t ?\ ?\e ?\q ?\Q))
+         (quit-list '(?\e ?\q ?\Q))
+         (key-back  (nth 0 keys))
+         (key-fw    (nth 1 keys))
+         (str       (buffer-name))
+         (loop      t)
+         dir
+         fmt
+         list
+         buffer
+         mode
+         ch)
+    (tinybuffer-init-buffer-list)
+    (while loop
+      (setq mode
+            (with-current-buffer (get-buffer str)
+              (cond
+               ((eq major-mode 'dired-mode)
+                (format "<dired> %s"
+                        (symbol-value 'dired-directory)))
+               (t
+                (format "<%s>" (symbol-name major-mode))))))
+      (when show-dir
+        (setq dir (or (buffer-file-name (get-buffer str))
+                      nil)))
+      ;;  This formats the line so that it is visually more pleasant
+      ;;  to read. If the file and dir are sticked together, it's
+      ;;  hard to distinguish the words.
+      ;;
+      ;;  FILE      DIR
+      (setq fmt
+            (if (and str (< (+ (length str) (length dir)) 55))
+                "TinyIswich: %-20s %s %s"
+              "TinyIswich: %s %s %s"))
+      (unless dir
+        (setq dir  mode
+              mode nil))
+      (setq ch (tinybuffer-read-char
+                (format fmt str (or dir "") (or mode "" ))))
+      (cond
+       ((and ch (char-equal ch key-back))
+        (setq buffer (tinybuffer-iswitch-previous)))
+       ((and ch (char-equal ch key-fw))
+        (setq buffer (tinybuffer-iswitch-next)))
+       ((and ch (tinybuffer-char-in-list ch go-list))
+        (setq loop nil)))
+      (if buffer
+          (setq str (buffer-name buffer))))
+    (if (and ch
+             buffer
+             (not (tinybuffer-char-in-list ch quit-list)))
+        (switch-to-buffer buffer))))
+
+;;;###autoload
+(defun tinybuffer-previous-buffer ()
+  "Switch to previous buffer in current window."
+  (interactive)
+  (tinybuffer-buffer-list-next 'reverse))
+
+;;;###autoload
+(defun tinybuffer-next-buffer ()
+  "Switch to the other buffer (2nd in list-buffer) in current window."
+  (interactive)
+  (bury-buffer (current-buffer))
+  (tinybuffer-buffer-list-next))
+
+(defun tinybuffer-sort-mode-toggle ()
+  "Sort mode on/off."
+  (interactive)
+  (setq tinybuffer--sort-flag (not tinybuffer--sort-flag))
+  (message (concat "TinyBuffer: sort mode "
+                   (if tinybuffer--sort-flag
+                       "on"
+                     "off"))))
+
+
+(provide   'tinybuffer)
+(run-hooks 'tinybuffer--load-hook)
+
+;;; tinybuffer.el ends here
diff --git a/elisp/tiny/tinycache.el b/elisp/tiny/tinycache.el
new file mode 100644 (file)
index 0000000..978e623
--- /dev/null
@@ -0,0 +1,801 @@
+;;; tinycache.el --- Maintain a cache of visited files [compile,dired]
+
+;; This file is not part of Emacs
+
+;;{{{ Id
+
+;; Copyright (C)    1996-2012 Jari Aalto
+;; Keywords:        extensions
+;; Author:          Jari Aalto
+;; Maintainer:      Jari Aalto
+;;
+;; Look at the code with folding.el
+
+;; This program 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 of the License, or (at your option)
+;; any later version.
+;;
+;; This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+;;
+;; Visit <http://www.gnu.org/copyleft/gpl.html> for more information
+
+;;}}}
+;;{{{ Install
+
+;;   Put this file on your Emacs-Lisp `load-path', add following into
+;;   ~/.emacs startup file:
+;;
+;;       (add-hook tinycache--load-hook 'tinycache-install)
+;;       (add-hook tinycache--load-hook 'tinycache-install-msb)
+;;       (require 'tinycache)
+;;
+;;   Or use quicker autoload:
+;;
+;;       (add-hook tinycache--load-hook 'tinycache-install-msb)
+;;       (eval-after-load "compile" '(progn (require 'tinycache)))
+;;       (eval-after-load "dired"   '(progn (require 'tinycache)))
+;;
+;;   If you use *gnuserv.el*, be sure that to load the packages in order:
+;;   gnuserv, tinycache.
+;;
+;;   To disable this package:
+;;
+;;      M-x tinycache-uninstall
+;;
+;;   If you have any questions, use this function
+;;
+;;      M-x tinycache-submit-bug-report
+
+;;}}}
+;;{{{ Documentation
+
+;;; Commentary:
+
+;;  Preface, overview of features
+;;
+;;      This package is meant to be used with `dired' and compilation
+;;      buffers. When you load file from either one, the file is
+;;      "remembered". This way you can browse bunch of files easily and
+;;      when you have finished you can flush the cache and get rid of all
+;;      vieved files.
+;;
+;;  Dired description
+;;
+;;      When you load a file from dired with `dired-view-file', the
+;;      file is remembered. You can load several files for viewing and when you
+;;      have finished, call `tinycache-flush' (Defaults to `C-c' `k' in
+;;      dired) to remove all the remembered (cached) files from emacs.
+;;
+;;      This way you don't end up having files that you're not interested
+;;      in any more. Using the cache makes browsing bunch of files very
+;;      easy. Each dired buffer has it's own cache. The cache is also
+;;      flushed if you kill the dired buffer.
+;;
+;;  Compilation cache description
+;;
+;;      Maintain also a cache of buffers visiting files via the
+;;      `next-error' and `compile-goto-error' commands; each compile/grep
+;;      buffer has its own cache.  To kill the cached buffers manually, use
+;;      `C-c' `C-d' (compile-flush-cache) in the compile/grep buffer;
+;;      deleting the compile/grep buffer automatically kills the cached
+;;      buffers.  To disable the cache, set `compilation-find-file-cache'
+;;      to a non-list value (e.g. 'disable).
+;;
+;;      After loading this file, every file that is loaded by calling some
+;;      compile function, i.e. `compile-goto-error', is cached if it is not
+;;      in emacs already. I.e. when you fix some small errors in other
+;;      files, you may not want to keep those files in emacs after you've
+;;      done; remember, those got loaded during the calls to
+;;      compile-goto-error. The easiest way to get rid of these extra
+;;      files, that were not originally in emacs, is to:
+;;
+;;          A. kill compilation buffer, C-x k *compilation*
+;;          B. Call M-x tinycache-flush directly
+;;
+;;      See *igrep.el* also how you can browse (grep) files easily and when
+;;      you've done, you can call this package top get rid of those browsed
+;;      files.
+;;
+;;  Cache minor mode indication --  Controlling the cache flag
+;;
+;;      Mode line indication shows for loaded buffer
+;;
+;;          "+C"    if file is loaded as cached.
+;;          "+c"    If you have manually turned off the cache
+;;
+;;      And for root buffer where the file were loaded, normally
+;;      compilation or dired buffer, the mode line shows
+;;
+;;          "+CN"  where N is number of files currently in the cache
+;;
+;;      Sometimes you want to keep some file that belongs to the cache
+;;      and you don't want to loose it when you execute `M-x' `tinycache-flush'
+;;      or when you kill the root buffer.
+;;
+;;      For that purpose there is function `tinycache-mode' to turn
+;;      off the cache for current buffer. When the cache mark says
+;;      "+c" in the mode line, it tells you that the file will not be
+;;      killed when you `tinycache-flush' is called.
+;;
+;;      Note: the root buffer's xx count is not updated when you kill
+;;      buffer that was cached. So if the count says 10, and you kill 3
+;;      files that, the count will still still say 10. The count is
+;;      updated only when you load some *new* file from the root buffer.
+;;      At that time all the buffers cached are checked and the ones that
+;;      do not exist any more are removed.
+;;
+;;  Buffer list commands
+;;
+;;      There are some additional commands added to buffer list which
+;;      helps you to keep track of the cached files better. The "c"
+;;      prefix is chosen for (c)ache related commands.
+;;
+;;          C-c c m     mark all cached files
+;;          C-c c d     mark as deleted
+;;          C-c c u     unmark cached files.
+;;
+;;  Dired mode commands
+;;
+;;      Similar to buffer list, there is some dired commands too
+;;
+;;          C-c c k     tinycache-flush, remove all cached files from this dired
+;;          C-c c m     tinycache-dired-mark
+;;          C-c c u     tinycache-dired-unmark
+;;
+;;  Thanks
+;;
+;;      Kevin Rodgers, his *igrep.el* gave me an idea for this. The
+;;      original cache code from where this package evolved was
+;;      written by Kevin under name *compile-cache.el*
+
+;;; Change Log:
+
+;;}}}
+;;{{{ setup: require, variables
+
+;;; Code:
+
+(eval-when-compile (require 'advice))
+(require 'tinylibm)
+
+(eval-and-compile
+  (autoload 'compilation-find-buffer    "compile"   "" t)
+  (autoload 'dired-view-file            "dired"     "" t)
+  (autoload 'dired-get-filename         "dired")
+  (autoload 'dired-mark                 "dired"     "" t)
+  (autoload 'dired-unmark               "dired"     "" t))
+
+(ti::package-defgroup-tiny TinyCache tinycache-- extensions
+  "Maintain a cache of visited files [compile, dired].
+    overview of features
+
+        This package is meant to be used with dired and compilation
+        buffers. When you load file from either one, the file is
+        cached. This way you can view files easily and when you
+        have finished you can flush the cache and get rid of all
+        viewed files.")
+
+;;; ............................................. &emacs-compatibility ...
+;;;  We must install this for older emacs versions ( 19.30< )
+
+(unless (boundp 'kill-buffer-hook)
+  ;; gnuserv.el
+  ;; - We have to do this now, because if user loads files in this order:
+  ;;
+  ;;        tinycache
+  ;;        gnuserv
+  ;;
+  ;;   The gnuserv won't see the real function, because tinycache
+  ;;   put advice around the function. And using the adviced function
+  ;;   as "real" causes infinite loop.
+  ;;
+  ;;   If user doesn't use gnuserv, this just defines one extra function,
+  ;;   which does no harm.
+  ;;
+  (or (fboundp 'server-real-kill-buffer)
+      (fset 'server-real-kill-buffer (symbol-function 'kill-buffer)))
+
+  (defvar kill-buffer-hook nil
+    "Defined in tinycache.el package. Hook run just before buffer
+     is killed.")
+
+  (defadvice kill-buffer (around tinycache act)
+    "Run kill-buffer-hook before buffer iss killed."
+    (run-hooks 'kill-buffer-hook)
+    ;; prevent accidents by setting this hook to nil
+    (let ((kill-buffer-hook nil))
+      ad-do-it)))
+
+;;; ........................................................ &v-public ...
+
+(defcustom tinycache--mode-on-string " +C"
+  "*Cache property on indicator. File can be flushed."
+  :type  'string
+  :group 'TinyCache)
+
+(defcustom tinycache--mode-off-string " +c"
+  "*Cache property off indicator. File will not be flushed."
+  :type  'string
+  :group 'TinyCache)
+
+(defcustom tinycache--load-hook nil
+  "*Hook run when file has been loaded.
+Suggested functions:
+  `tinycache-install'
+  `tinycache-install-msb'."
+  :type  'hook
+  :group 'TinyCache)
+
+(defcustom tinycache--find-file-buffer-hook 'tinycache-maybe-view-mode
+  "*Hook run inside buffer which is loaded from compile output."
+  :type 'hook
+  :group 'TinyCache)
+
+;;; ....................................................... &v-private ...
+
+(defvar tinycache--mode-name tinycache--mode-on-string
+  "String in the mode line to mark if that file is part the cache or not.
+This is changed by program and not a user variable.")
+
+(defvar tinycache-mode nil
+  "Mode on/off variable.")
+(make-variable-buffer-local 'tinycache-mode)
+(put 'tinycache-mode  'permanent-local t)
+
+(defvar tinycache--info nil
+  "Variable to keep information about the cache.
+Contains the compile buffer pointer from where the file was loaded.")
+(make-variable-buffer-local 'tinycache--info)
+(put 'tinycache--info 'permanent-local t)
+
+(defvar tinycache--mode-user-flag nil
+  "If non-nil, user has touched the `tinycache-mode' flag in this buffer.")
+(make-variable-buffer-local 'tinycache--mode-user-flag)
+(put 'tinycache--mode-user-flag   'permanent-local t)
+
+(defvar tinycache--cache nil
+  "List of buffers created by `compilation-find-file'. Local to each buffer.
+Format: (BUFFER-POINTER BP ..)")
+
+;; If user starts new compilation in *grep* buffer, it wipes the results
+;; but the cache must remain there, since he may have loaded files from
+;; previous compilation.
+
+(put 'tinycache--cache            'permanent-local t)
+
+;;}}}
+;;{{{ code: misc functions
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycache-uninstall ()
+  "Deactivate package."
+  (tinycache-advice-control 'disable))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycache-advice-control (&optional disable)
+  "Turn advices on. Optionally DISABLE."
+  (interactive)
+  (ti::advice-control
+   '(compile-internal compilation-find-file) "^tinycache"  disable 'verb))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycache-install-mode ()
+  "Install `tinycache-mode'."
+  ;;  Make sure we can display string in mode line
+  (if (null (assq 'tinycache-mode minor-mode-alist))
+      (ti::keymap-add-minor-mode 'tinycache-mode
+                                 'tinycache--mode-name
+                                 ;; No key map
+                                 (make-sparse-keymap))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycache-install (&optional uninstall)
+  "Install or UNINSTALL cache."
+  (interactive)
+  (cond
+   (uninstall
+    (remove-hook 'buffer-menu-mode-hook 'tinycache-buffer-list-bindings-on)
+    (remove-hook 'compilation-mode-hook 'tinycache-define-default-keys)
+    (remove-hook 'dired-mode-hook       'tinycache-add-local-hook)
+    (remove-hook 'dired-mode-hook       'tinycache-define-default-keys))
+   (t
+    (add-hook 'buffer-menu-mode-hook 'tinycache-buffer-list-bindings-on)
+    (add-hook 'compilation-mode-hook 'tinycache-define-default-keys)
+    (add-hook 'dired-mode-hook       'tinycache-add-local-hook)
+    (add-hook 'dired-mode-hook       'tinycache-define-default-keys))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycache-install-msb ()
+  "Install new cache menu to msb.el if it is loaded."
+  (let ((elt
+        '((and (boundp 'tinycache-mode)
+               tinycache-mode)
+          1005
+          "Cached compile files (%d)"))
+       (sym  'msb-menu-cond)
+       menu)
+    (when (and (featurep 'msb)
+               ;;  Install only once.
+               ;;  symbol-value just silences byteComp
+               (setq menu (symbol-value sym))
+               (not (member menu elt)))
+      (push elt menu)
+      (set sym menu))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycache-define-default-keys ()
+  "Define keys to `compilation-minor-mode-map'."
+  (interactive)
+  (let (map)
+    ;;  Avoid byte compilation warnings this way....
+    (when (and (boundp  'compilation-minor-mode-map)
+               (setq map (symbol-value 'compilation-minor-mode-map))
+               (keymapp map))
+      (ti::use-prefix-key map "\C-cc")
+      (ti::define-key-if-free map "\C-cck" 'tinycache-flush))
+    (when (and (boundp  'compilation-minor-mode-map)
+               (setq map (symbol-value 'compilation-minor-mode-map))
+               (keymapp  map))
+      (ti::use-prefix-key map "\C-cc")
+      (ti::define-key-if-free map "\C-cck" 'tinycache-flush))
+    (when (and (boundp  'dired-mode-map)
+               (setq map (symbol-value 'dired-mode-map))
+               (keymapp  map))
+      (ti::use-prefix-key map "\C-cc")
+      (ti::define-key-if-free map "\C-cck" 'tinycache-flush)
+      (ti::define-key-if-free map "\C-ccm" 'tinycache-dired-mark)
+      (ti::define-key-if-free map "\C-ccu" 'tinycache-dired-unmark))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycache-buffer-list-bindings-on ()
+  "Add default bindings to buffer list, \\[list-buffers]."
+  ;;  Choose "c" for cache commands
+  (ti::use-prefix-key Buffer-menu-mode-map "\C-cc")
+  ;;  With these you can see the cachec files
+  (ti::define-key-if-free Buffer-menu-mode-map "\C-ccd"
+                          'tinycache-buffer-list-mark-deleted)
+  (ti::define-key-if-free Buffer-menu-mode-map "\C-ccm"
+                          'tinycache-buffer-list-mark)
+  (ti::define-key-if-free Buffer-menu-mode-map "\C-ccu"
+                          'tinycache-buffer-list-unmark)
+  (ti::define-key-if-free Buffer-menu-mode-map "\C-ccf"
+                          'tinycache-buffer-list-mark-cache-off)
+  ;;  Bye, bye. No need to call us again. Installation already done.
+  (remove-hook 'buffer-menu-mode-hook 'tinycache-define-default-keys))
+
+;;; ----------------------------------------------------------------------
+;;;  - The following says that "Load view-(minor)mode in Emacs 19.30, but
+;;;    for other (X)Emacs load mview-mode if it exists."
+;;;  - The view-mode is minor mode in new Emacs releases, older
+;;;    versions are encouraged to get mview.el minor mode
+;;;
+;;;            mview.el
+;;;            Mike Williams
+;;;
+(defun tinycache-maybe-view-mode ()
+  "Turen on view (minor) mode if needed."
+  (interactive)
+  (let ((zip-re ;; arc-mode's zip file prompt
+        ;; M Filemode      Length  Date         Time      File
+        ;; - ----------  --------  -----------  --------  ---------
+        ;; -rw-r--r--      9695  10-Sep-1993  17:53:46  Makefile
+        ;; -rw-r--r--      7441   8-Sep-1993  14:21:20  README
+        ;;
+        ".*Filemode[ \t]+Length[ \t]+Date[ \t]+Time[ \t]+File[ \t]*$")
+       func)
+    ;;  Now; if you load from dired a .zip or .tar file; you don't
+    ;;  want view mode on, check buffer file name.
+    (cond
+     ((and (not (ti::emacs-p "21"))
+           (ti::emacs-p)
+           (< emacs-minor-version 30)
+           (require 'mview nil 'noerr)
+           ;; Not loaded from dired-view-file, but from compile buffer?
+           (not (eq major-mode 'view-mode)))
+      (when (fboundp 'view-mode)        ;Turn off this mode.
+        (ti::funcall 'view-mode 0)) ;in 19.28 won't work, but try anyway
+      ;; Use minor mode instead
+      (setq func 'mview-mode))
+     ((fboundp 'view-mode)
+      (setq func 'view-mode)))
+    (cond
+     ((save-excursion
+        (ti::pmin)
+        (and (looking-at zip-re)
+             (fboundp 'archive-mode)))
+      (ti::funcall 'archive-mode))
+     (func
+      (funcall func)))))
+
+;;}}}
+;;{{{ code: Buffer list control
+
+;;; ----------------------------------------------------------------------
+;;;
+(defsubst tinycache--mode-on-string-p ()
+  "Check if `tinycache-mode' is on."
+  (memq tinycache-mode '(t on)))
+
+;;; ----------------------------------------------------------------------
+;;;
+(put 'tinycache-map-over-buffers 'lisp-indent-function 1)
+(defmacro tinycache-map-over-buffers (off &rest body)
+  "Map over all cached buffers.
+If OFF is non-nil, maps over buffers whose `tinycache--cache' is off
+and do BODY.
+
+In macro you can refer to these variables. The names are mangled
+so that they don't clash with the toplevel definitions.
+
+    'BuffeR'    as current buffer
+    'NamE'      buffers's name
+    'LisT'      current list of buffers to loop over.
+
+Setting 'list' to nil terminates this macro."
+  `(let (NamE)
+     (dolist (BuffeR (tinycache-cached-file-list ,off) )
+       (setq NamE (buffer-name BuffeR))
+       (if (null NamE)
+           (setq NamE nil))             ; No-op, silence byte compiler
+       ,@body)))
+
+;;; ----------------------------------------------------------------------
+;;;
+(put 'tinycache-buffer-list-map-over-buffers 'lisp-indent-function 0)
+(defmacro tinycache-buffer-list-map-over-buffers (&rest body)
+  "Special Buffer list macro to execute BODY at found buffer line."
+  `(tinycache-map-over-buffers nil
+                               (setq NamE (regexp-quote NamE))
+                               (ti::pmin)
+                               (when (re-search-forward NamE nil t)
+                                 (beginning-of-line)
+                                 ,@body)))
+
+;;; ----------------------------------------------------------------------
+;;;
+(put 'tinycache-buffer-list-map-over-off-buffers 'lisp-indent-function 0)
+(defmacro tinycache-buffer-list-map-over-off-buffers (&rest body)
+  "Special Buffer list macro to execute BODY at found buffer line."
+  `(tinycache-map-over-buffers 'off
+                               (setq NamE (regexp-quote NamE))
+                               (ti::pmin)
+                               (when (re-search-forward NamE nil t)
+                                 (beginning-of-line)
+                                 ,@body)))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinycache-buffer-list-mark ()
+  "Mark Cached files in buffer list."
+  (interactive)
+  (tinycache-buffer-list-map-over-buffers (Buffer-menu-mark)))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinycache-buffer-list-unmark ()
+  "Mark Cached files in buffer list."
+  (interactive)
+  (tinycache-buffer-list-map-over-buffers (Buffer-menu-unmark)))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinycache-buffer-list-mark-deleted ()
+  "Mark Cached files in buffer list."
+  (interactive)
+  (tinycache-buffer-list-map-over-buffers (Buffer-menu-delete)))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinycache-buffer-list-mark-cache-off ()
+  "Mark files whose cache property has been turned off."
+  (interactive)
+  (tinycache-buffer-list-map-over-off-buffers (Buffer-menu-mark)))
+
+;;}}}
+;;{{{ Dired buffer
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycache-dired-mark (&optional unmark verb)
+  "Mark cached files. Optionally UNMARK. VERB."
+  (interactive)
+  (let ((i 0)
+         file)
+    (ti::verb)
+    (ti::save-line-column-macro nil nil
+      (dolist (elt tinycache--cache)
+        (setq file (buffer-name elt))
+        (ti::pmin)
+        (when (re-search-forward (format "%s$" file))
+          (cond
+           (unmark
+            (beginning-of-line)
+            (when (eq (following-char)
+                      (symbol-value 'dired-marker-char))
+              (incf  i)
+              (dired-unmark 1)))
+           (t
+            (incf  i)
+            (dired-mark 1))))))
+    (if verb
+        (message "%d cached files %smarked" i
+                 (if unmark
+                    "un"
+                  "") ))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycache-dired-unmark (&optional verb)
+  "Unmark cached files. VERB."
+  (interactive)
+  (ti::verb)
+  (tinycache-dired-mark 'unmark verb))
+
+;;}}}
+;;{{{ code: cache control
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycache-add-local-hook ()
+  "Make `kill-buffer-hook' local to this buffer. And add `tinycache-flush' to it.
+When you kill the dired buffer, cached buffers loaded from this
+buffer are also killed."
+  (let (buffer)
+    ;; Make sure this hook does not contain tinycache-flush outside
+    ;; the compilation buffer
+    (remove-hook 'kill-buffer-hook 'tinycache-flush)
+    (save-excursion
+      ;;   Select right buffer where to localize the hook
+      (cond
+       ((eq major-mode 'dired-mode))
+       ((and (boundp 'compilation-last-buffer)
+             (setq buffer (symbol-value 'compilation-last-buffer))
+             (buffer-live-p (get-buffer buffer)))
+        (set-buffer buffer))
+       (t
+        (error "improper use of tinycache-add-local-hook: no dired/compilation")))
+      ;;  force the hook local to buffer
+      (add-hook 'kill-buffer-hook 'tinycache-flush nil 'local)
+      ;;  Make sure there are no constants in the hook.
+      (setq kill-buffer-hook (delq nil (delq t kill-buffer-hook))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycache-activate (this-buffer buffer)
+  "THIS-BUFFER is the root buffer (dired,compile) and put BUFFER to cache."
+  (interactive)
+  (let (new-list)
+    ;;  update cache list
+    (with-current-buffer this-buffer
+      (make-local-variable 'tinycache--cache)
+      (dolist (elt tinycache--cache) ;Remove buffers that do not exist
+        (if (buffer-live-p (get-buffer elt))
+            (push elt new-list)))
+      (setq tinycache--cache new-list)
+      (if (not (memq buffer tinycache--cache))
+          (push buffer tinycache--cache))
+      (tinycache-mode-root-buffer))
+    ;;  Turn on cache mode
+    (with-current-buffer buffer
+      (setq tinycache--info this-buffer)
+      ;;  - We don't touch the tinycache-mode if user has taken control
+      ;;  - If the flag shows untouched buffer, mark the buffer
+      ;;    to cache.
+      (unless tinycache--mode-user-flag
+        (setq tinycache-mode 'on)
+        (setq tinycache--mode-name tinycache--mode-on-string)
+        (ti::compat-modeline-update))
+      (run-hooks 'tinycache--find-file-buffer-hook))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycache-cached-file-list (&optional off)
+  "Return all cached files by looking at every compilation buffer.
+This excludes files that user has manually instructed not to be in
+cache (tinycache-mode is off for buffer)
+
+if optional OFF is non-nil, then return buffers whose `tinycache--cache'
+has been turned manually off."
+  (let ((modes '(compilation-mode compilation-minor-mode dired-mode))
+       buffers
+       blist2)
+    (dolist (elt (buffer-list))
+      (with-current-buffer elt
+        (when (and (memq major-mode modes)
+                   tinycache--cache)
+          ;;  Read the value of cache and loop over it
+          (setq blist2 tinycache--cache)
+          ;;  Check the `tinycache-mode' for every cached file.
+          (dolist (elt2 blist2)
+            (with-current-buffer elt2
+              (cond
+               ((null off)
+                (if (tinycache--mode-on-string-p)
+                    (push elt2 buffers)))
+               (t
+                (if (null (tinycache--mode-on-string-p))
+                    (push elt2 buffers))))))  ))) ;; dolist1 - 2
+    buffers))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycache-mode-root-buffer (&optional remove)
+  "Update root buffer's `tinycache-mode' flag. Optionally REMOVE from cache.
+This is the buffer where `tinycache--cache' resides."
+  ;; (make-variable-buffer-local 'tinycache--mode-name)
+  (make-local-variable 'tinycache--mode-name)
+  (cond
+   (remove
+    (setq tinycache-mode nil))
+   (t
+    (setq tinycache-mode 'on)
+    (setq tinycache--mode-name
+          (format "%s%d" tinycache--mode-on-string (length tinycache--cache))))))
+;;; ----------------------------------------------------------------------
+;;; - This function must be called by user only!
+;;;
+;;;###autoload
+(defun tinycache-mode (&optional arg)
+  "Toggle cache flag for this buffer with ARG.
+If the file does not belong to compile cache, calling this function
+does nothing. If the file is in the cache, the mode line displays mode name.
+
+Removing the file from cache means that the file is not killed when
+the cache is flushed with \\[tinycache-flush]."
+  (interactive)
+  (unless tinycache--info
+    (message "Can't find tinycache--info, Buffer is not part of the cache?")
+    (sleep-for 1))
+  (if (null tinycache-mode)
+      (message "This buffer is not in cache controlled.")
+    (setq tinycache--mode-user-flag t)
+    (cond
+     ((memq arg '(0 -1))
+      (setq tinycache-mode 'off))
+     ((eq arg nil)
+      (if (tinycache--mode-on-string-p)
+          (setq tinycache-mode 'off)
+        (setq tinycache-mode 'on)))
+     (t
+      (setq tinycache-mode 'on)))
+    (message
+     (format "Buffer is %s in cache control"
+             (if (tinycache--mode-on-string-p)
+                 (progn
+                   (setq tinycache--mode-name tinycache--mode-on-string)
+                   "now")
+               (setq tinycache--mode-name tinycache--mode-off-string)
+               "no more")))
+    (ti::compat-modeline-update)))
+
+;;}}}
+;;{{{ code: flush
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinycache-flush-all-compilation (&optional verb)
+  "Kill all cached files by stepping through all compilation buffers. VERB."
+  (interactive)
+  (let ((count  0)
+       (verb   (or verb (interactive-p))))
+    (tinycache-map-over-buffers nil
+                                (when (buffer-live-p  (get-buffer BuffeR))
+                                  (kill-buffer BuffeR)
+                                  (incf  count)))
+    (if verb
+        (message (format "Flushed %d buffers." count)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinycache-flush (&optional verb)
+  "Kill buffers listed in `tinycache--cache'. VERB.
+You must be in the Compilation/Dired buffer to execute this command.
+
+If you're not in dired buffer, function tries to find compilation
+buffer and kill compilation cached files."
+  (interactive)
+  (let ((cache-buffer  (current-buffer))
+       count
+       do-it)
+    (ti::verb)
+    (unless (eq major-mode 'dired-mode)
+      ;;  This calls error if no compile buffer found...
+      (setq cache-buffer (ignore-errors (compilation-find-buffer))))
+    (when cache-buffer                  ;if there is buffer for us
+      (with-current-buffer cache-buffer
+        (tinycache-mode-root-buffer 'remove)
+        ;;  This variable is local to buffer
+        (setq count   (length tinycache--cache))
+        (dolist (buffer tinycache--cache)
+          (setq do-it nil)
+          (if (not (buffer-live-p  (get-buffer buffer)))
+              (setq do-it t)
+            (with-current-buffer buffer
+              ;;  kill-buffer-hook is local to each buffer.
+              ;;  prevent alias loop
+              (let ((kill-buffer-hook kill-buffer-hook))
+                (remove-hook 'kill-buffer-hook 'tinycache-flush)
+                (when (tinycache--mode-on-string-p) ;it's allowed to kill
+                  (kill-buffer buffer)
+                  (setq do-it t)))))
+          (if do-it
+              (setq tinycache--cache (delq buffer tinycache--cache))))))
+    (if verb
+        (message (format "Cache flushed [%s] files. " count)))))
+
+;;}}}
+;;{{{ code: advice
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice compilation-find-file (around tinycache activate)
+  "Cache newly visited files in `tinycache--cache';
+use `\\[tinycache-flush]' in compilation buffer,
+to kill these loaded files."
+  (let ((this-buffer    (current-buffer))
+        (file           filename)       ;ADVICE variable
+        buffer)
+    (tinycache-install-mode)
+    ;;  Already in emacs ?
+    (setq buffer (get-file-buffer file))
+    (prog1
+        ad-do-it
+      (unless buffer                    ;Loaded new file
+        (if (setq buffer ad-return-value)
+            (tinycache-activate this-buffer buffer))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice compile-internal (after tinycache activate)
+  "Automatically kill the buffers listed in `tinycache--cache'.
+`kill-buffer-hook' when the `compile' buffer is killed."
+  (tinycache-add-local-hook))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defadvice dired-view-file (around tinycache act)
+  "Cache newly visited files in `tinycache--cache';
+Kill the dired buffer to kill cached files."
+  (let ((this-buffer    (current-buffer))
+        (file           (dired-get-filename))
+        buffer)
+    (tinycache-install-mode)
+    (cond
+     ((file-directory-p file)
+      (setq buffer t))                  ;skip this one
+     ((get-file-buffer file)            ;Already in emacs ?
+      (setq buffer t))
+     (t
+      (setq buffer (get-file-buffer file))))
+    (prog1
+        ad-do-it
+      (when (and (null buffer)          ;Loaded new file
+                 (setq buffer (get-file-buffer file)))
+        (tinycache-activate this-buffer buffer)))))
+
+;;}}}
+
+(provide   'tinycache)
+(run-hooks 'tinycache--load-hook)
+
+;; tinycache.el ends here
diff --git a/elisp/tiny/tinycomment.el b/elisp/tiny/tinycomment.el
new file mode 100644 (file)
index 0000000..a5d6aca
--- /dev/null
@@ -0,0 +1,840 @@
+;;; tinycomment.el --- Smart comment setting utility
+
+;; This file is not part of Emacs
+
+;;{{{ Id
+
+;; Copyright (C) 1994-2012 Jari Aalto
+;; Keywords:     extensions
+;; Author:       Jari Aalto
+;; Maintainer:   Jari Aalto
+;;
+;; Look at the code with folding.el
+
+;; COPYRIGHT NOTICE
+;;
+;; This program 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 of the License, or (at your option)
+;; any later version.
+;;
+;; This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+;;
+;; Visit <http://www.gnu.org/copyleft/gpl.html> for more information
+
+;;}}}
+;;{{{ Installation
+
+;; ........................................................ &t-install ...
+;; - Put this file on your Emacs-Lisp `load-path', add following into your
+;;   ~/.emacs startup file
+;;
+;;      (require            'tinycomment)
+;;      (global-set-key     "\M-;" 'tinycomment-indent-for-comment)
+;;      (setq-default       comment-column 48)
+;;
+;;   Or use autoload and your .emacs starts quicker
+;;
+;;      (global-set-key  "\M-;" 'tinycomment-indent-for-comment)
+;;      (autoload 'tinycomment-indent-for-comment "tinycomment" "" t)
+
+;;}}}
+;;{{{ Commentary
+
+;;; Commentary:
+
+;;}}}
+;;{{{ Documentation
+
+;;  Preface, Sep 1994
+;;
+
+;;      In 1994-10-18 Era Eriksson wrote in gnu.emacs.help that he didn't
+;;      like 'modes' because they redefined his tab key strangely. What he
+;;      wanted was tab 8 in _every possible case_. He wrote: "..if mode
+;;      messes with tab key, I don't want it". He also wanted his comments
+;;      always to be positioned at column 56 (tab #7). The problem was that
+;;      how he could he add comments with tab key, when the mode occied it
+;;      already. He also always used to program using `fundamental-mode';
+;;      what a cool dude. As a result this package was born. The
+;;      original lisp file sent  to Era was posted under name
+;;      general-comment.el.
+;;
+;;  What's this all about, short introduction
+;;
+;;      Let's see...You're in C/C++ mode, and want to switch to better mode
+;;      before starting to adjust comments. But wait, the new mode doesn't
+;;      know about C++-comments! Or if you're editing ~/.Xdefauls, there is
+;;      no mode for it (at the time of writing), no-one to know the comment
+;;      syntax. Boom. Now it's time to give this packet a run. It hooks
+;;      itself directly to `\M-;' replacing any previous function. The
+;;      packages defines comment syntax and position on the fly when it can
+;;      identify the file name. If the file isn't known then it passes
+;;      control to mode to handle the commenting. This is handy in
+;;      temporary buffers that do not have filename: e.g. *scratch* buffer.
+;;      Repetitive calls to `M-;' shift between comment *classes*: comment
+;;      is adjusted according to previous one, or move it on the line.
+;;
+;;  Overview of features
+;;
+;;      o   Replaces `M-;' comment key. Suitable for any major mode.
+;;      o   Determine comment variables on the fly, no matter where you
+;;          are or what mode you are using.
+;;      o   There is no-list that tells not to touch this mode's commenting.
+;;          This is for modes that has `comment-end' which aren't supported.
+;;      o   Repetitive `M-;' converts single comment into *bigger* *classes*.
+;;      o   Position new comment on empty line by looking at previous
+;;          comment.
+;;      o   It is possible to define column position for those comments
+;;          that are not allowed to move This handy for long lines
+;;          or special comments.
+;;      o   If there are multiple so called comments, like $#var # comment
+;;          in `perl-mode', the last # char is treated as a comment.
+;;
+;;  Limitations
+;;
+;;      This isn't designed for modes that have `comment-end', you get
+;;      only '/* */' string e.g. in C-mode and no comment class shifting.
+;;
+;;  Examples
+;;
+;;      At the end of file there is simple general editing mode, which can
+;;      be used for perl, shells, awk, C++ [sometimes]
+
+;;}}}
+
+;;; Change Log:
+
+;;; Code:
+
+;;{{{ setup: require
+
+;;; ......................................................... &require ...
+
+(require 'tinylibm)
+
+(ti::package-defgroup-tiny TinyComment tinycomment-- extensions
+  "Smart comment setting utility
+  Overview of features:
+
+        o   Replaces M-; commenting key. Suitable for any major-mode
+        o   Determines comment variables on the fly, no matter where you
+            are or what mode you are.
+        o   There is no-list that tells not to touch this mode's commenting.
+            This is for modes that has comment-end. TIC can't handle those.
+        o   Repetitive M-; converts single comments into 'bigger classes'
+        o   Positions new comment on empty line by looking at previous
+            comment.
+        o   You can define column position for those comments that are not
+            allowed to move This handy for long lines or special comments.
+        o   If there are multiple 'comments' , like $#var # comment
+            in perl-mode, TIC picks the last # char and treats
+            it as a comment. Emacs commention cope similar situations.")
+
+;;}}}
+;;{{{ setup:
+
+;;; ......................................................... &v-hooks ...
+
+(defcustom tinycomment--load-hook nil
+  "*Hook run when package has been loaded."
+  :type 'hook
+  :group 'TinyComment)
+
+;;; ........................................................ &v-public ...
+;;; User configurable
+
+(defcustom tinycomment--not-comment-re ".*[$]\\(#\\)[a-zA-Z]"
+  "*Reject comment position according to subexpression 1.
+When searching for comment position, the position found will be
+rejected, if comment subexpression 1 match's position is the same as
+initially found comment position. The test will be done with `looking-at' at
+the beginnning of line.
+
+      $#variable_in_csh
+0123456789 123456789 12345       ;columns
+       *                         ;found comment pos, reject it."
+  :type 'regexp
+  :group 'TinyComment)
+
+(defcustom tinycomment--tab-call-no-alist
+  '(fundamental-mode
+    text-mode)
+  "*List of modes which enable using TIC's own indent-for-code algorithm.
+
+Most programming modes supply function that knows how to indent the
+statement.  But in some cases mode does not supply it's own indent
+function placed on variable `indent-line-function', which is called by
+tab key."
+  :type '(repeat (function :tag "Mode function"))
+  :group 'TinyComment)
+
+(defcustom tinycomment--adj-no-alist
+  '(lisp-interaction-mode
+    lisp-mode
+    emacs-lisp-mode
+    c-mode ;; we use use // in c++, not /* */
+    pascal-mode)
+  "*List of modes which disable converting comment class.
+
+The function `tinycomment-adjust-comment' isn't suitable for all possible
+modes. Eg. Lisp has it's own idea about placing comments according
+to comment used.
+      ;     --> comment column
+      ;;    --> right to code level
+      ;;;+  --> left margin.
+
+This defines list of mode names where `tinycomment-adjust-comment' is suppressed
+and the normal `indent-for-comment' is used."
+  :type '(repeat (function :tag "Mode function"))
+  :group 'TinyComment)
+
+(defcustom tinycomment--comment-notify nil
+  "*If non-nil allow printing notify messages.
+When the comment syntax wasn't found according to file name.
+The message is _not_ displayed when `buffer-name' contains '*'.
+
+You may want to set this to 't for awhile, so that you can add all
+those files that are missing from the list. When you're satisfied,
+you can turn off the warning."
+  :type 'boolean
+  :group 'TinyComment)
+
+(defcustom tinycomment--def-com-pos 'code
+  "*Default comment position for empty lines.
+Possible choices are:
+
+  'code            code level indent [usually as previous code line]
+  'cpos            normal `comment-column'
+
+Note that 'cpos doesn't always put comment where you would expect, because
+it looks back until it finds code. In spite of that, it normally works
+well _inside_ functions"
+  :type  '(choice
+           (const code)
+           (const cpos))
+  :group 'TinyComment)
+
+(defcustom tinycomment--comment-extra-arg 1
+  "*See documentation of `tinycomment--comment-extra'."
+  :type 'integer
+  :group 'TinyComment)
+
+(defcustom tinycomment--comment-extra-stop 63 ;TAB position 64
+  "*See documentation of `tinycomment--comment-extra'.
+The comment movement is not done if `current-column' > this variable."
+  :type 'integer
+  :group 'TinyComment)
+
+(defcustom tinycomment--comment-extra 'tab
+  "*This affects function `tinycomment-set-com'. Let's see an example:
+
+    abcd abcd abcd abcd abcd abcd[x] abcd abcd # COMMENT
+
+You have line, where line exeeds the comment column[x] and your
+comment is at the end. This variable determines how such
+line is handled when you now hit M-;
+
+Current choices are:
+    'tab      Insert tab between code and comment, so that they get
+              separated. Any previous whitespace is deleted.
+    'spc      Same, but insert space instead. The number or spaces inserted
+              is told in variable  `tinycomment--comment-extra-arg'
+
+None of these actions are carried out if the comment was placed in
+column `tinycomment--comment-extra-stop' +1 or further. Such comment is
+left untouched, because adjusting may push it out of the window edge."
+  :type  '(choice
+           (const tab)
+           (const spc))
+  :group 'TinyComment)
+
+;;}}}
+;;{{{ code: misc
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycomment-find-prev-com-col (com-start &optional not-this-col column-further)
+  "Look upward to find previous comment column.
+
+Input:
+
+  COM-START      comment start string.
+  NOT-THIS-COL   if given,  scan backward until different column
+                 is found.
+  COLUMN-FURTHER If number, comment searched must reside further
+                 in in the line than this column.
+
+Return:
+
+  nil   unable to find previous comment
+  col"
+  (let ((loop t)
+       (re   com-start)
+       ret
+       found)
+    (save-excursion
+      (while loop
+        (beginning-of-line)
+        (setq ret nil found nil)
+        (if (setq found (re-search-backward re nil t))
+            (setq ret (current-column)))
+        (setq loop nil)                 ;default
+        (if (or (null found)
+                (null not-this-col))
+            nil
+          (if (not (= ret not-this-col))
+              (setq loop nil)          ;this will do !
+            (setq loop t found nil)))  ;keep searching
+        (if (or (null found)
+                (null column-further))
+            nil
+          (if (> ret column-further)   ;this IS suitable !
+              (setq loop nil)
+            (setq loop t found nil))))) ;keep going
+    ret))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycomment-find-com-col ()
+  "Look current line to find `comment-start'.
+
+Return:
+
+   nil
+   nbr  column."
+  (let ((no-com   (or tinycomment--not-comment-re   "dummy"))
+        (max      (save-excursion (end-of-line) (point)))
+        (clen     (length comment-start))
+        (re       comment-start)
+        ret found
+        not-pos
+        cp)
+    (save-excursion
+      (beginning-of-line)
+      ;;  is there restrictions ?
+      (setq not-pos (if (and (looking-at no-com)
+                             (match-beginning 1))
+                        (match-beginning 1)
+                      nil))
+      (while (re-search-forward re  max t) ; find last comment
+        (setq found t))
+      (if (null found)
+          nil
+        (backward-char clen)
+        (setq cp (point))
+        (if (eq cp not-pos)
+            nil                         ;cannot use this
+          (setq ret (current-column))))
+      ret)))
+
+;;}}}
+;;{{{ positions
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycomment-check-line (mode &optional arg)
+  "Few commands to use to determine line data according to MODE and ARG.
+
+Return:
+
+  Depends heavily on the MODE"
+  (let (ret
+       re
+       re2
+       bp
+       p
+       p2)
+    (if (null (symbolp mode)) nil       ;handle literals
+      (cond
+       ;;  ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
+       ((and (eq 'code-last-col mode) comment-start)
+        (setq re comment-start)
+        (save-excursion
+          (beginning-of-line)
+          (setq bp (point))
+
+          (if (null (re-search-backward comment-start bp t))
+              nil                       ;not moved anywhere
+            (goto-char (match-beginning 0)))
+          (skip-syntax-backward " " bp)
+          (setq ret (current-column))))
+       ;;  ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
+       ;;   find *last* comment start pos
+       ;;   like '// i = 1000;   // temporarily commented out'
+
+       ((and (eq 'com-last-col mode) comment-start)
+        ;;  the '.*' always matches up till last one
+        (setq re (concat ".*\\(" comment-start  "\\)"  ))
+        (save-excursion
+          (beginning-of-line)
+          (if (not (looking-at re))
+              nil
+            (goto-char (match-beginning 1))
+            (setq ret (current-column)))))
+       ;;  ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
+       ;;  whole line is 'alone' comment, so that there is no
+       ;;  double comments, return it's starting position
+       ;;  Double comment is like the previous cond-case
+       ((and (eq 'com-alone-col mode) comment-start)
+        (setq re (concat "[ \t]*\\(" comment-start  "\\)"  ))
+        ;;  notice COM + SPC in re2
+        ;;  - user may write '// this is separator /////////////////////'
+        ;;    But that's one comment
+        ;;  - '// i = MaxPos; // commented'. There is SPC in second
+        ;;    comment, so it has to be Double Commented line.
+        (setq re2 (concat ".*\\(" comment-start  " \\)"  ))
+        (save-excursion
+          (beginning-of-line)
+          (if (not (looking-at re))
+              nil
+            (setq p (match-beginning 1))
+            (if (not (looking-at re2))
+                (progn                  ;only single comment
+                  (goto-char p)
+                  (setq ret (current-column)))
+              (setq p2 (match-beginning 1))
+              (if (not (eq p p2))       ;Double Commented
+                  nil
+                (goto-char p)           ;same comment hit twice
+                (setq ret (current-column)))))))
+       ;;  ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
+       ((eq 'eolpos mode)
+        (save-excursion (end-of-line) (setq ret (point))))
+       ;;  ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
+       ((eq 'bolpos mode)
+        (save-excursion (beginning-of-line) (setq ret (point))))
+       ;;  ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
+       ((eq 'emptyEol mode)
+        ;; If the rest of line empty ?
+        (setq ret (looking-at "[ \t]*")))))
+    ret))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycomment-find-comment-col (com-start)
+  "Look upward to find possible COM-START position."
+  (save-excursion
+    (if (re-search-backward (regexp-quote com-start) nil t)
+        (current-column))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycomment-find-code-col (com-start)
+  "Look upward to find possible code indent column. Use COM-START.
+Eg.
+
+   echo something
+                     # ridiculous comment
+   <now press ESC ;> # inserts comment here
+
+The problem is that the first comment is considered as indent
+for code by normal Lisp functions, when it should be the 'echo' line.
+We look upward till there is code line that isn't full comment line.
+
+NOTE:
+
+  This doesn't work on C/C++, or any mode that has `comment-end',
+  because we can't keep track of multiline comments.
+
+Return:
+
+  nbr           found code, proposed column returned.
+  nil           unable to find proper code indent"
+  (let ((re-com  (concat
+                 "^[ \t]*" (regexp-quote com-start)
+                 "\\|^[ \t]*$"))       ;skip empty lines.
+       (move t)
+       point                           ;point mark
+       ret)
+    (save-excursion
+      (while (and move
+                 (eq ret nil))         ;while RET is not set
+        (re-search-backward "[^ \t]+" nil t)
+        (if (save-excursion
+              (beginning-of-line)
+              (looking-at re-com))      ;ignore full comment lines.
+            (if (eq (point) point)     ;have we moved since?
+                (setq move nil))
+          ;; Maybe this real code line?
+          (setq ret (1+ (current-column)))) ;1+ due to re-search
+        (setq point (point))))
+    ret))
+
+;;}}}
+
+;;; ######################################################### &comment ###
+;;; The real engine parts to do the job
+
+;;{{{ tinycomment-set-com
+
+;;; ----------------------------------------------------------------------
+;;; See simple.el (funcall comment-indent-function)
+;;; - Funny thing is that you just can't set comment-column to NBR
+;;;   and expect it to be comment place, because the indent-for-comment
+;;;   might decide to move the position to another place!
+;;; - This function instead, will always put comment there where
+;;;   user want's it.
+;;;
+(defun tinycomment-set-com (&optional new)
+  "Lighter version of function `indent-for-comment'.
+Moves current comment tocomment-position. Doesn't signal any errors.
+
+Features:
+
+-  if there is multiple comments on the line, like in shell or
+   perl code '#', the last one is considered as comment, *unless*
+   optional artgument NEW is given. In that case, nothing is considered
+   as old comments.
+-  If line is too long for comment column it inserts additional SPC or TAB
+   between the code and comment. See variable `tinycomment--comment-extra'
+
+Return:
+
+  t             position changed OR new comment added
+  nil           position not allowed"
+  (let* ((xtra     tinycomment--comment-extra)
+         (x-spc    (make-string tinycomment--comment-extra-arg ?\ ))
+         (x-spc    (if (eq 'tab xtra)
+                      "\t"
+                    x-spc)) ; what's the insert type ?
+         (stop-col tinycomment--comment-extra-stop)
+         (ep       (save-excursion
+                    (end-of-line)
+                    (point)))
+         (skip     (or comment-start-skip
+                      comment-start))
+         found
+         bp                             ;BEG of line point
+         com-c
+        code-c
+        com-p
+         ret)
+    (beginning-of-line)
+    (setq bp (point))
+
+    (if (null new)                      ;did user say new vomment ?
+        (while (re-search-forward skip ep t) ;last comment
+          (setq found t)))
+    (if (null found)
+        (progn
+          (end-of-line)
+          (indent-to comment-column)
+          (insert comment-start)
+          (setq ret t))
+      ;;  first set comment position
+      (goto-char (match-beginning 0))
+      (setq com-p (point))
+      (setq com-c (current-column))     ;comment column
+      ;; Now where is the code position
+      ;; Give argument "nil" (no limit) for skip syntax function is line
+      ;; is first line in buffer.
+      (backward-char 1)
+      (skip-syntax-backward " " (if (eq 1 bp)
+                                    nil
+                                  (1- bp)))
+      (setq code-c (current-column))
+      (goto-char com-p)
+      (if (= comment-column com-c)
+          nil                           ;nothing to do
+        (setq ret t)
+        (if (< code-c comment-column)
+            (progn                      ;we can indent ok
+              (delete-horizontal-space)
+              (indent-to comment-column))
+          ;;  line is too long to get position to comment-col
+          (if (> com-c stop-col) nil    ;do not touch this
+            (delete-horizontal-space)
+            (insert x-spc)))))
+    ret))
+
+;;}}}
+;;{{{ tinycomment-adj-com
+
+;;; ----------------------------------------------------------------------
+;;; Original idea in asm-mode.el by :
+;;;   Martin Neitzel,  Techn. Univ. Braunschweig, W.Germany
+;;;   BITNET/EARN:   neitzel@dbsinf6.bitnet    (mail via bitnet preferred)
+;;
+;;; - Thank you Martin! I'm Afraid the code isn't like yours any more,
+;;;   but the same principle 'converting to bigger class'
+;;;   is preserved.
+;;; - This is self standing function.
+;;;
+;;; - I really should write this again some day, divide into more smaller
+;;;   blocks of funcs...
+;;;
+(defun tinycomment-adjust-comment ()
+  "Introduce a comment or convert an already existing comment to next class.
+These are the known comment classes:
+
+        1-- Left margin             ;; omitted if there is CODE on the line
+        2-- indented like code
+        3-- on comment column
+
+Suggested usage: while writing your code, trigger this command repeatedly
+until you are satisfied with the comment.
+
+Comment on it's own line note:
+
+- Following lines has two comment chars '#', I call it double commented line.
+              # comment text # more text
+              # set myVariable = 100;      # temporarily commented
+  Because It's hard to know if the line is 'full comment' as in case 1, or
+  has 'code temporarily commented out' as line 2, we always consider
+  line as 'full comment' if line starts with `comment-start'.
+- In this case whole line moves when converting to classes.
+
+Code note:
+
+-  `tinycomment-set-com' is used instead of standard `indent-for-comment'.
+-  Considered adding 4th choice: indent like previous comment,
+   but I decided 4th choice or 4 taps was too much...3 seemed ideal,
+   so I left it out from 'full comment line'."
+  (let* ((def-place tinycomment--def-com-pos)
+         (tab-alist tinycomment--tab-call-no-alist)
+         (ci        (current-indentation))
+         (cc        (current-column))
+         (com       comment-start)
+         (col       comment-column)
+         (clen      (length comment-start))
+         ;;    handle ONLY lines that have only comment, no code.
+         (re-com    (concat "^[ \t]*\\("
+                           (regexp-quote com)
+                           "+\\)"))
+         (re-com2   (concat ".*"
+                           (regexp-quote com)))
+         cur-code-c
+         prev-cc cur-cc                 ;various com-col points
+         code-col
+         class
+         prev-code-ind
+         cont
+         tmp)
+    (catch 'done
+      (if (or (not (integerp col)) (not (stringp com)))
+          (error "comment-[column/start] not set"))
+      (when (string-match "^[ \t]*$" com) ;empty comment?
+        (if (tinycomment-check-line 'emptyEol)
+            (indent-to col)
+          (message "tinycomment-adj: no comment-start defined.")
+          (throw 'done t)))
+      (setq cur-code-c (tinycomment-check-line 'code-last-col))
+      (setq prev-cc (tinycomment-find-prev-com-col com col cur-code-c))
+      (setq cur-cc (tinycomment-find-com-col)) ;current comment column
+      ;;  - If we do NOT already have a comment, indent for a new one.
+      (beginning-of-line)
+
+      (unless (looking-at re-com)       ;comment on it's own line ?
+        ;; .............................................................
+        (cond
+         ;;  no comment at all or not suitable comment ?
+         ((or (null (setq tmp (looking-at re-com2)))
+              (and tmp
+                   (null (tinycomment-find-com-col)))) ;it isn't suitable
+          (if (not (looking-at "[ \t]*$"))             ; CODE + no COM
+              (progn
+                (tinycomment-set-com 'new) ;Normal column, but it'll be changed
+                (setq cur-cc (tinycomment-find-com-col))
+                (setq class 3))         ;indent like prev line by DEF
+            ;;  empty line
+            (insert com)                ;see cont, it passes thru
+            ;;  User propably want CODE level indent on empty line by DEF
+            (if (eq def-place 'code )
+                (setq cont t))))
+         ;;   There is existing comment
+         ((and cur-cc (= cur-cc col))   ;change class if possible
+          (setq class 3))
+         ((and cur-cc prev-cc           ;make sure these are set
+               (or (null prev-cc) (= cur-cc prev-cc)))
+          ;;   possibly change class to standard column
+          (tinycomment-set-com)) ; no prev comment or position was same
+         (t
+          ;;  add New comment
+          (tinycomment-set-com)))
+        ;;   Determine how CODE + COM line is handled
+        (when (eq class 3)
+          (save-excursion
+            (forward-line -1) (end-of-line)
+            (setq prev-code-ind (tinycomment-find-comment-col com)))
+          (if (or (null prev-code-ind)  ;No code found
+                  (>= cur-code-c col)   ;cannot put to comment-col
+                  (null prev-cc)   ;cannot convert to class, isn't set
+                  (>= cur-code-c prev-cc) ;cannot use prev com class
+                  (not (= cur-cc col)))   ;convert to com-col CLASS
+              (progn
+                (tinycomment-set-com))
+            ;;   Convert to previous comment column class then
+            (setq comment-column prev-cc) ; change temporarily
+            (tinycomment-set-com)
+            ;; restore value
+            (setq comment-column col)))
+        (if cont
+            nil                         ;do we continue forward ?
+          (if (not (eolp))
+              (forward-char (length comment-start)))
+          (throw 'done t)))
+      ;; --``-- --``-- --``-- --``-- --``-- --``-- --``-- --``-- --``--
+      ;;  There is a comment, convert it between classes.
+      ;;  Also correct the search position due to S-FWD command
+      (beginning-of-line)
+      (if (re-search-forward comment-start (tinycomment-check-line 'eolpos))
+          (goto-char (match-beginning 0)))
+      (setq cc (current-column))        ;at front of comment
+      (setq code-col (tinycomment-find-code-col com))
+      ;;   First select where to convert?
+      (cond
+       ((= cc 0)                        ;BEG of line ?
+        (setq class 1))
+       ((or (eq code-col cc)
+            (eq cc col))                ; in Comment column ?
+        (setq class 0))
+       ((and (not (eq ci 0))            ; prallel to code ?
+             (not (eq cc col)))         ; this is rough guess...
+        (setq class 2)))
+      ;; --``-- --``-- --``-- --``-- --``-- --``-- --``-- --``-- --``--
+      (cond                             ;Now the converting procedure
+       ((eq class 0)                    ;BEG of line
+        (delete-horizontal-space))
+       ((eq class 1)                    ;code level
+        (beginning-of-line) (delete-horizontal-space)
+        ;; Are we allowed to indent this by ourself ?
+        (if (null (memq major-mode tab-alist))
+            (indent-according-to-mode)  ;let mode place the statement
+          (if (null code-col)           ;no code
+              (indent-to comment-column)
+            (if (and (= cc 0) (= col 0)) ;if suggested POS is same
+                (indent-relative))
+            (indent-to col))))
+       ((eq class 2)                    ;column level
+        (indent-to col)))
+      (forward-char clen))              ;after class change
+    ;;  do we need to restore the point ? [experimental]
+    ;;    (if save-excur (goto-char op))
+    nil))
+
+;;}}}
+;;{{{ code: main
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycomment-status ()
+  "Displays comment info."
+  (interactive)
+  (message
+   (concat
+    "cc=" (prin1-to-string comment-column) " "
+    "cs=" (prin1-to-string comment-start) " "
+    "ce=" (prin1-to-string comment-end) " "
+    "css=" (prin1-to-string comment-start-skip) " ")))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycomment-set-c-vars-maybe (&optional cs ce cc css)
+  "Set comment variables CS CE CC and CSS.
+The names are `comment-start' `comment-end' etc. If some
+comment variable is nil, it will be set to some harmless value."
+  (if (null cs)                 (setq comment-start ""))
+  (if (null ce)                 (setq comment-end ""))
+  (if (not (integerp cc))       (setq comment-column 48))
+  (if (null css)                (setq comment-start-skip "")))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinycomment-indent-for-comment ()
+  "Alternative to standard `indent-for-comment'.
+Relies on file extension
+and doesn't need specific mode to be turned on. Temporary buffers
+that has no file name cannot be identified by this function, so
+it passes control directly to mode. There is a chance you might not
+even notice that this function is working on the background.
+
+Verbose warnings are enabled by `tinycomment--comment-notify'
+Special cases are handled by tinycomment--comment-extra* variables
+Version info is on \\[tinycomment-version]."
+  (interactive)
+  (let* ((warn          tinycomment--comment-notify) ;; shorter name
+         (no-list       tinycomment--adj-no-alist)
+         (com-col       48)         ;default comment column if not set
+         elt
+         (mode-desc     (or (ti::id-info nil 'variable-lookup)
+                            (concat
+                             "code-"
+                             (replace-regexp-in-string
+                              "-mode" "" (symbol-name major-mode))))))
+    (if mode-desc
+        (setq elt (ti::id-cnv-txt2comment mode-desc)))
+    (if warn
+        (setq warn warn))               ;XE 19.14 ByteComp silencer
+    (tinycomment-set-c-vars-maybe
+     comment-start comment-end comment-column comment-start-skip)
+    (cond
+     ;; ........................................ mode's own commenting ...
+     ((or (memq major-mode no-list)
+          (null mode-desc))
+      ;;   let mode handle comment classes, only IF NOT SET
+      ;;   but let's correct some user mistakes first...
+      (indent-for-comment))             ;mode call...)
+     (t
+      ;; ............................................... real engine ...
+      (if (ti::nil-p comment-start)     ;they are not defined.
+          (if elt                       ;we have comment info?
+              (setq comment-start (car elt) comment-end (or (cdr elt) ""))))
+      (tinycomment-set-c-vars-maybe
+       comment-start comment-end comment-column comment-start-skip)
+      ;;   if the position is NOT set use default comment position
+      (if (not (integerp comment-column))
+          (setq comment-column com-col))
+      ;;  - The indent-for-comment WON'T work if this is nill
+      ;;    See simple.el for function def.
+      ;;  - We don't set _right_ value, just sufficent replacement.
+      (setq comment-start-skip (concat comment-start "+"))
+      (tinycomment-adjust-comment)
+      (if (and warn (ti::nil-p comment-start))
+          (message
+           "TIC: unknown file, no comment syntax available")) ))))
+
+;;}}}
+
+;;{{{ example setup
+
+;;; ......................................................... &example ...
+
+;; (autoload 'turn-on-tinytab-mode "tinytab" "" t)
+;;
+;; (defun my-fundamental-mode ()
+;;   "my fundamental-mode"
+;;   (interactive)
+;;   (fundamental-mode)
+;;   (turn-on-tinytab-mode)
+;;   (setq tinytab-tt-mode nil)
+;;   (if (fboundp 'folding-mode)
+;;       (ti::funcall 'folding-mode))
+;;   (recenter)                                ;Show visible notification
+;;   ;; delete possible comment settings
+;;   (setq comment-start nil
+;;        comment-end    nil
+;;        comment-column nil
+;;     ;;   very important to restore this !! See simple.el
+;;         comment-indent-hook '(lambda () comment-column)))
+;;
+;; (add-hook 'c++-mode-hook  'my-c++-mode-hook)
+;;
+;; (defun my-c++-mode-hook ()
+;;   (setq comment-column nil   ;; When set to nil, tinycomment.el takes over.
+;;     comment-start nil
+;;     comment-end nil))
+
+;;}}}
+
+(provide 'tinycomment)
+(run-hooks 'tinycomment--load-hook)
+
+;;; tinycomment.el ends here
diff --git a/elisp/tiny/tinycompile.el b/elisp/tiny/tinycompile.el
new file mode 100644 (file)
index 0000000..0353174
--- /dev/null
@@ -0,0 +1,608 @@
+;;; tinycompile.el --- Compile buffer extras. Minor mode.
+
+;; This file is not part of Emacs
+
+;;{{{ Id
+
+;; Copyright (C)    1996-2012 Jari Aalto
+;; Keywords:        extensions
+;; Author:          Jari Aalto
+;; Maintainer:      Jari Aalto
+;;
+;; Look at the code with folding.el
+
+;; COPYRIGHT NOTICE
+;;
+;; This program 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 of the License, or (at your option)
+;; any later version.
+;;
+;; This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+;;
+;; Visit <http://www.gnu.org/copyleft/gpl.html> for more information
+
+;;}}}
+;;{{{ Install
+
+;; ....................................................... &t-install ...
+;;  Put this file on your Emacs-Lisp `load-path', add following into your
+;;  ~/.emacs startup file.
+;;
+;;      ;; You could also call M-x tinycompile-install / tinycompile-uninstall
+;;      (add-hook tinycompile--load-hook 'tinycompile-install)
+;;      (require 'tinycompile)
+;;
+;;  or use this autoload; your ~/.emacs loads quicker
+;;
+;;       (autoload 'tinycompile-mode            "tinycompile" "" t)
+;;       (autoload 'turn-on-tinycompile-mode    "tinycompile" "" t)
+;;       (add-hook 'compilation-mode-hook 'turn-on-tinycompile-mode 'append)
+;;
+;; If you find any incorrect behavior, please immediately
+;;
+;;      o   Turn on debug with `M-x' `tinycompile-debug-toggle'
+;;      o   Repeat the task
+;;      o   Send bug report with included debug buffer contents.
+
+;;}}}
+
+;;{{{ Documentation
+
+;; ..................................................... &t-commentary ...
+
+;;; Commentary:
+
+;;  Preface, mar 1997
+;;
+;;      When I was doing grepping over multiple files with igrep.el the
+;;      results that were inserted into buffer were too long: There were
+;;      2-6 directory paths which occupied 40 characters and the actual
+;;      grep hits were continued with \ character to the right. That was
+;;      awfull to read. I couldn't get clear look at the grep results. I
+;;      decided that there must be a way to clarify the results somehow, so
+;;      I started writing this package.
+;;
+;;  Overview of features
+;;
+;;      o   Shorten long directory paths (to the right hand)
+;;      o   Kill non-interesting files from the buffer
+;;      o   Hide selected lines from display
+
+;;}}}
+
+;;; Change Log:
+
+;;; Code:
+
+;;{{{ setup: misc
+
+;;; ......................................................... &require ...
+
+(require 'tinyliba)
+
+(eval-when-compile
+  (require 'cl)
+  (defvar mode-line-mode-menu)
+  (defvar tinyurl-mode))
+
+(ti::package-defgroup-tiny TinyCompile tinycompile-- tools
+  "Compile buffers additions.
+  Overview of features
+
+        o   Shorten long directory paths (to the right hand)
+        o   Kill non-interesting files from the buffer
+        o   Hide selected lines from display")
+
+;;; .......................................................... &v-menu ...
+
+(defcustom tinycompile--menu-use-flag t
+  "*Non-nil means to use echo-area menu."
+  :type  'boolean
+  :group 'TinyCompile)
+
+(defvar tinycompile--menu-main
+  (list
+   '(format
+     "%sTinyCompile: k)ill files s)horten SPC)hide rRU)egexp RET)parse x)mode off"
+     (if current-prefix-arg
+         (format "%s "  (prin1-to-string current-prefix-arg)) "" ))
+   '((?\177 . ( (tinycompile-kill-all-file-lines)))
+     (?\b   . ( (tinycompile-kill-all-file-lines)))
+     (?k    . ( (tinycompile-kill-all-file-lines)))
+     (?s    . ( (tinycompile-shorten-lines)))
+     (?\    . ( (tinycompile-show-hide-toggle)))
+     (?r    . ( (call-interactively 'tinycompile-hide-by-regexp-whole-line)))
+     (?R    . ( (call-interactively 'tinycompile-hide-by-regexp)))
+     (?U    . ( (call-interactively 'tinycompile-unhide)))
+     (?\C-m . ( (tinycompile-parse-line-goto-main)))
+     (?x    . ( (turn-off-tinycompile-mode)))))
+  "*TinyCompile echo menu.
+
+k    Kill/Delete all lines that referer to current file
+s    If possible, shorten long path names in display
+SPC  Toggle hiding lines on/off
+r    Hide whole line matching regexp
+R    Hide (partial) text matching regexp
+U    Unhide all
+RET  Goto current file and line
+x    Turn mode off.")
+
+;;; ............................................................ &mode ...
+
+;;;### (autoload 'tinycompile-debug-toggle "tinycompile" "" t)
+;;;### (autoload 'tinycompile-debug-show   "tinycompile" "" t)
+
+(eval-and-compile (ti::macrof-debug-standard "tinycompile" "--"))
+
+;;;###autoload (autoload 'turn-on-tinycompile-mode      "tinycompile" "" t)
+;;;###autoload (autoload 'turn-off-tinycompile-mode     "tinycompile" "" t)
+;;;###autoload (autoload 'tinycompile-mode              "tinycompile" "" t)
+;;;###autoload (autoload 'tinycompile-commentary        "tinycompile" "" t)
+
+(eval-and-compile
+  (ti::macrof-minor-mode-wizard
+   "tinycompile-" " Tco" "\C-c:" "Tco" 'TinyCompile "tinycompile--" ;1-6
+
+   "Additional commands to Compile buffer. You can kill lines or
+shorten the file names and hide comments.
+
+Defined keys:
+
+Prefix key to access the minor mode is defined in
+`tinycompile--mode-prefix-key'
+
+\\{tinycompile--mode-map}
+\\{tinycompile--mode-prefix-map}"
+
+   "TinyCompile"
+   (progn
+     (if (and tinycompile-mode verb
+              (not (string-match "compil" (symbol-name major-mode))))
+         (message "TinyCompile: Are you sure this is compile buffer?")))
+   "Compile buffer extras."
+   (list
+    tinycompile--mode-easymenu-name
+    ["Kill all matching file lines at point"  tinycompile-kill-all-file-lines t]
+    ["Shorten directory names"            tinycompile-shorten-lines           t]
+    ["Goto file at point"                 tinycompile-parse-line-goto-main    t]
+    "----"
+    ["Show or hide comments (toggle)"     tinycompile-show-hide-toggle        t]
+    ["Hide by regexp - partial"           tinycompile-hide-by-regexp          t]
+    ["Hide by regexp - whole line"        tinycompile-hide-by-regexp-whole-line t]
+    ["Unhide all"                         tinycompile-unhide                  t]
+    "----"
+    ["Keyboard menu"                      tinycompile-menu-main               t]
+    ["Package version"                    tinycompile-version                 t]
+    ["Package commentary"                 tinycompile-commentary              t]
+    ["Mode help"                          tinycompile-mode-help               t]
+    ["Mode off"                           tinycompile-mode                    t])
+
+   (progn
+     (if (ti::xemacs-p)
+         (define-key root-map [(button2)] 'tinycompile-parse-line-goto-main)
+       (define-key root-map [mouse-2]     'tinycompile-parse-line-goto-main))
+     (cond
+      (tinycompile--menu-use-flag
+       ;;  Using menu to remeber commands is easier if you don't use
+       ;;  menu bar at all.
+       (define-key root-map p 'tinycompile-menu-main))
+      (t
+       (define-key map  "k"      'tinycompile-kill-all-file-lines)
+       (define-key map  "s"      'tinycompile-shorten-lines)
+       (define-key map  " "      'tinycompile-show-hide-toggle)
+       (define-key map  "r"      'tinycompile-hide-by-regexp-whole-line)
+       (define-key map  "R"      'tinycompile-hide-by-regexp)
+       (define-key map  "U"      'tinycompile-unhide)
+       (define-key map  "x"      'turn-off-tinycompile-mode)
+       (define-key map  "?"      'tinycompile-mode-help)
+       (define-key map  "Hm"     'tinycompile-mode-help)
+       (define-key map  "Hc"     'tinycompile-commentary)
+       (define-key map  "Hv"     'tinycompile-version)
+       ;;  Overwrite {compilation-minor-mode|grep-mode} definition
+       (define-key root-map "\C-m" 'tinycompile-parse-line-goto-main))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-menu-main (&optional arg)
+  "Show echo area menu and pass ARG to `ti::menu-menu'."
+  (interactive "P")
+  (ti::menu-menu 'tinycompile--menu-main arg))
+
+;;; ......................................................... &v-hooks ...
+
+(defcustom tinycompile--load-hook nil
+  "*Hook that is run when package is loaded."
+  :type 'hook
+  :group 'TinyCompile)
+
+;;}}}
+;;{{{ setup: public
+
+;;; ........................................................ &v-public ...
+;;; User configurable
+
+(defcustom tinycompile--table-hide
+  '(("^.*\\.el:"                        ;lisp
+     "^.*:[ \t]*[;\"'].*")
+    ("^.*\\.\\([cC][cC]?\\|[hH][hH]?\\):" ;C/C++
+     ":[ \t]*/[/*].*"))
+  "*List of FILENAME and HIDE regexps.
+If filename in the beginning of line matches elt1 then
+show/hide all lines matching elt2.
+
+Format:
+ '((FILENAME-REGEXP HIDE-REGEXP)
+   (FILENAME-REGEXP HIDE-REGEXP)
+   ...)"
+  :type  '(repeat
+           (string :tag "File Regexp")
+           (string :tag "Hide Regexp"))
+  :group 'TinyCompile)
+
+;;}}}
+;;{{{ code: macros
+
+;;; ----------------------------------------------------------------------
+;;;
+(defsubst tinycompile-get-files  (&optional max-point)
+  "Return all filenames in compile buffer, optionally until MAX-POINT."
+  (beginning-of-line)
+  (tinycompile-get-error-lines max-point 'car))
+
+;;}}}
+;;{{{ code: support functions
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-install (&optional uninstall)
+  "Install or optinally UNINSTALL package with prefix arg."
+  (interactive "p")
+  (cond
+   (uninstall
+    (if (boundp 'grep-mode-hook)
+        (add-hook 'grep-mode-hook 'turn-on-tinycompile-mode 'append))
+    (add-hook 'compilation-mode-hook 'turn-on-tinycompile-mode 'append))
+   (t
+    (if (boundp 'grep-mode-hook)
+        (remove-hook 'grep-mode-hook 'turn-on-tinycompile-mode))
+    (remove-hook 'compilation-mode-hook 'turn-on-tinycompile-mode))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-uninstall ()
+  "Uninstall package."
+  (interactive)
+  (tinycompile-install 'remove))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-cd-directory ()
+  "Return the CD directory."
+  ;; Emacs 22 uses line like:
+  ;;      -*- mode: grep; default-directory: "~/elisp" -*-
+  (save-excursion
+    (goto-char (point-min))
+    (or (ti::buffer-match "^-[*]- mode: grep.*\"\\([^\"]+\\)" 1)
+        (ti::buffer-match "^cd +\\(.*\\)" 1))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-shorten-lines ()
+  "Shorten the filenames in compile buffer.
+
+Line format must be
+  FILE:LINE: results"
+  (interactive)
+  (let* ( ;;  About 1000 lines, with 70 characters
+         (treshold   (* 70 1000))
+         (indicator  (and (> (- (point-max)
+                                (point-min))
+                             treshold)
+                          t))
+         count
+         prev-point
+         dir
+         cd
+         path
+         prev
+         file)
+    (buffer-enable-undo)
+    (save-excursion
+      (ti::pmin)
+      (setq cd (tinycompile-cd-directory))
+      (while (re-search-forward "^\\([/.][^:]+\\):" nil t)
+        (setq path (match-string 1))
+        (when (and indicator
+                   ;;  count percentages only after 1000 chars.
+                   (> (point) (+ prev-point 1000)))
+          (setq count (/ (* 100 (point)) (point-max)))
+          (message "Tinycompile: Wait, processing %d %%" count))
+        ;; ./pie-mail/hypb.el --> {cd}/pie-mail/hypb.el
+        (if (char-equal (aref path 0) ?.)
+            (setq path (concat cd (substring path 2))))
+        (when path
+          (setq file (file-name-nondirectory path))
+          (setq path (file-name-directory path))
+          (ti::replace-match 1 file)
+          (when
+              (or (null prev)
+                  (null dir)
+                  (string= dir prev))
+            (setq dir path))
+          (unless
+              (string= dir prev)
+            (setq prev dir   dir path)
+            (beginning-of-line)
+            (insert "\ncd " dir "\n\n")))
+        (if indicator
+            (message "Tinycompile: Wait, processing done."))
+        (end-of-line)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defvar tinycompile--buffer-name nil
+  "Buffer name is asked from user.
+Varaible is made buffer local.
+See `tinycompile-parse-line-goto-guess'.")
+
+(defun tinycompile-parse-line-goto-guess ()
+  "Go to line under cursor by guessing context."
+  (interactive)
+  (let* ((elt  (ti::buffer-parse-line-col))
+        (line (and elt (string-to-number (car elt))))
+        (col  (and elt (string-to-number (nth 1 elt)))))
+    (when elt
+      (let ((buffer
+            (or tinycompile--buffer-name
+                (completing-read
+                 "TinyCompile, buffer to associate: "
+                 (ti::list-to-assoc-menu
+                  (mapcar 'buffer-name (buffer-list)))
+                 nil
+                 t))))
+       (make-local-variable 'tinycompile--buffer-name)
+       (setq tinycompile--buffer-name buffer)
+       (pop-to-buffer tinycompile--buffer-name)
+       (ti::goto-line line)
+       (unless (zerop col)
+         (setq col (1- col))           ;Emacs columns are zero based
+       (move-to-column col))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-parse-line-goto-basic ()
+  "Go to line under cursor.
+The found file is loaded to Emacs and cursor put on the line.
+This works like `compile-goto-error'.
+
+Note:
+
+  If `tinyurl' package is present and current point holds an overlay,
+  then it is called to handle the line."
+  (interactive)
+  ;;    If TinyUrl is present, try it to resolve the line.
+  ;;    If it marks anything, raise flag `tinyurl'
+  (let* ((fid "tinycompile-parse-line-goto:")
+         (elt        (ti::buffer-parse-line-main))
+         (file       (and elt (car elt)))
+         (absolute-p (and file (string-match "^[/\\~]" file)))
+         tinyurl
+         buffer
+         win)
+    (unless fid ;; XEmacs byte compiler silencer
+      (setq fid nil))
+    (when (and absolute-p
+               (file-exists-p file)
+               (ti::overlay-supported-p)
+               (boundp 'tinyurl-mode)
+               tinyurl-mode)
+      (when (tinyurl-overlay-get)       ;line already marked
+        (setq tinyurl t))
+      (tinycompile-debug fid 'TinyUrl tinyurl (ti::read-current-line)))
+    (cond
+     (tinyurl                           ;Let this handle url first
+      (tinyurl-dispatcher "\C-m" 'key)
+      nil)
+     (elt
+      (multiple-value-bind (file line)
+          elt
+        (setq file (ti::file-name-for-correct-system file 'emacs))
+        (setq buffer (or (find-buffer-visiting file)
+                         (get-buffer file)
+                         ;; We may have mistakenly grabbed 'cd' command and
+                         ;; stucked it with buffers name.
+                         ;; /users/foo/*scratch*  --> *scratch*
+                         (get-buffer (file-name-nondirectory file))))
+        ;;  If buffer exists and is diplayed in another frame, use it.
+        (if buffer
+            (setq win (get-buffer-window buffer t)))
+        (tinycompile-debug fid "interactive" buffer 'file file)
+        (cond
+         ((and buffer win)
+          (select-window win)
+          (raise-frame (window-frame win)))
+         (t
+          (ti::select-frame-non-dedicated)
+          (if (and buffer
+                   (not (file-exists-p file)))
+              (switch-to-buffer-other-window buffer)
+            (switch-to-buffer-other-window
+             (if (file-exists-p file)
+                 (find-file-noselect file)
+               (error "TinyCompile: file not found `%s'" file))))))
+        (when line
+         (ti::goto-line line)))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-parse-line-goto-pass ()
+  "Let the mode handle the line."
+  (message "TinyCompile: Can't read file/line information.")
+  (let (tinycompile-mode
+       func)
+    (when (current-local-map)
+      (setq func (lookup-key (current-local-map) "\C-m"))
+      (when (fboundp func)
+       (funcall func)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-parse-line-goto-main ()
+  "Main controller for goto."
+  (interactive)
+  (or (tinycompile-parse-line-goto-basic)
+      (tinycompile-parse-line-goto-guess)
+      (tinycompile-parse-line-goto-pass)))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-get-error-lines  (&optional max-point list-func)
+  "Get error lines in compile buffer from current point forward.
+Input:
+
+  MAX-POINT     max search point, defaults to `point-max'
+  LIST-FUNC     if given apply it to extract data member.
+                Eg 'car, gives you only list of filenames
+
+Return:
+
+ '((\"filename\" . NBR) ...)
+ or whatever format LIST-FUNC says."
+  (let ((max-point (or max-point
+                      (point-max)))
+       table
+       elt)
+    (save-excursion
+      (while (and (re-search-forward "^\\([^:]+\\):[0-9]+:" nil t)
+                  (< (point) max-point))
+        (setq elt (ti::buffer-parse-line-main))
+        (if list-func
+            (setq elt (funcall list-func elt)))
+        (if (null (member elt table))
+            (push elt table)))
+      (nreverse table))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-kill-all-file-lines ()
+  "Kill all lines associated with the file on the current line."
+  (interactive)
+  (let ((fid  'tinycompile-kill-all-file-lines)
+       (elt  (ti::buffer-parse-line-main))
+       (cd   (save-excursion
+               (goto-char (point-min))
+               (when (looking-at "^cd \\(.+\\)")
+                 (match-string-no-properties 1))))
+       file
+       file2
+       re
+       point)
+    (unless fid ;; XEmacs byte compiler silencer
+      (setq fid nil))
+    (if (null elt)
+        (message "TinyCompile: Can't find file name in this line.")
+      (beginning-of-line)
+      (setq file  (car elt)
+            file2 (when (and cd
+                             (string-match
+                              (concat (regexp-quote cd) "\\(.+\\)")
+                              file))
+                    (match-string 1 file))
+            re    (format "^%s:\\|^%s:\\|^%s:\\|^%s:"
+                          (file-name-nondirectory file)
+                          (regexp-quote file)
+                          (file-name-nondirectory file)
+                          (if file2
+                              file2
+                            "#cannot-match-anything")))
+      (tinycompile-debug fid 'file file 'RE re 'elt)
+      ;;  Search previous line that is not the same as the line we want
+      ;;  to kill
+      (while (re-search-backward re nil t))
+      (setq point (point))
+      (buffer-enable-undo)
+      (ti::pmin)
+      (with-buffer-modified
+       (delete-matching-lines re))
+      (if (< point (point-max))
+          (goto-char point)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-show-hide-toggle (&optional regexp)
+  "Hide or show comment lines matching REGEXP.
+References:
+ `tinycompile--table-hide'"
+  (interactive)
+  (let ((list tinycompile--table-hide)
+       search
+       show)
+    (save-excursion
+      (unless regexp                    ;Find right value
+        (setq show (y-or-n-p "Y = show, N = hide "))
+        (dolist (elt list)
+          (setq search (car elt))
+          (if (ti::re-search-check search)
+              (setq list   nil
+                    regexp (nth 1 elt)))))
+      (ti::pmin)
+      (cond
+       (show
+        (set-text-properties (point-min) (point-max) nil)
+        ;;  Won't update well otherwise
+        (redraw-display))
+       (t
+        (if (null regexp)
+            (message
+             "TinyCompile: No matching regexp in tinycompile--table-hide")
+          (ti::text-re-search
+           regexp nil nil nil
+           (if show
+               'null
+             '(owner tinycompile  invisible t)))))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-hide-by-regexp (regexp)
+  "Hide lines matching REGEXP."
+  (interactive "s[TinyCompile] Hide strings matching: ")
+  (tinycompile-show-hide-toggle regexp))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-hide-by-regexp-whole-line (regexp)
+  "If REGEXP is found, hide whole line."
+  (interactive "s[TinyCompile] Hide lines matching: ")
+  (tinycompile-show-hide-toggle
+   (format "^.*\\(%s\\).*[\r\n]+" regexp)))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinycompile-unhide ()
+  "UNhide all hidden text or lines.
+See `tinycompile-hide-by-regexp' and `tinycompile-hide-by-regexp-whole-line'."
+  (interactive)
+  (set-text-properties (point-min) (point-max) nil))
+
+;;}}}
+
+;; NOTE:  In some cases `tinycompile-mode' gets set globally
+;; to value `t'. Reset this, because it would take out mouse-2.
+;; Make sure that the global value is nil
+
+(if (default-value 'tinycompile-mode)
+    (setq-default tinycompile-mode nil))
+
+(add-hook 'tinycompile--mode-define-keys-hook  'tinycompile-mode-define-keys)
+
+(provide   'tinycompile)
+(run-hooks 'tinycompile--load-hook)
+
+;;; tinycompile.el ends here
diff --git a/elisp/tiny/tinycygwin.el b/elisp/tiny/tinycygwin.el
new file mode 100644 (file)
index 0000000..