Commits

lhonda committed 6ffb09c

anything new version

Comments (0)

Files changed (1)

-;;; anything.el --- open anything / QuickSilver-like candidate-selection framework
-
-;; Copyright (C) 2007              Tamas Patrovics
-;;               2008 ~ 2012       rubikitch <rubikitch@ruby-lang.org>
-;;               2011 ~ 2012       Thierry Volpiatto <thierry.volpiatto@gmail.com>
-
-;; Author: Tamas Patrovics
-
-;; Maintainers: rubikitch <rubikitch@ruby-lang.org>
-;;              Thierry Volpiatto <thierry.volpiatto@gmail.com>
-
-;; Keywords: files, frames, help, matching, outlines,
-;;           processes, tools, convenience, anything
-
-;; X-URL: <http://repo.or.cz/w/anything-config.git>
-
-;; Site: <http://www.emacswiki.org/cgi-bin/emacs/Anything>
-
-;; MailingList: <https://groups.google.com/group/emacs-anything?hl=en>
-
-
-;;; This file is NOT part of GNU Emacs
-
-;;; License
-;;
-;; This file is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
-
-;; This file is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING.  If not, write to the
-;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-;; Boston, MA 02110-1301, USA.
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>EmacsWiki: anything.el</title><link rel="alternate" type="application/wiki" title="Edit this page" href="http://www.emacswiki.org/emacs?action=edit;id=anything.el" />
+<link type="text/css" rel="stylesheet" href="http://netdna.bootstrapcdn.com/twitter-bootstrap/2.3.0/css/bootstrap-combined.min.css" />
+<link type="text/css" rel="stylesheet" href="/css/bootstrap.css" />
+<meta name="robots" content="INDEX,FOLLOW" /><link rel="alternate" type="application/rss+xml" title="EmacsWiki" href="http://www.emacswiki.org/emacs?action=rss" /><link rel="alternate" type="application/rss+xml" title="EmacsWiki: anything.el" href="http://www.emacswiki.org/emacs?action=rss;rcidonly=anything.el" />
+<link rel="alternate" type="application/rss+xml"
+      title="Emacs Wiki with page content"
+      href="http://www.emacswiki.org/emacs/full.rss" />
+<link rel="alternate" type="application/rss+xml"
+      title="Emacs Wiki with page content and diff"
+      href="http://www.emacswiki.org/emacs/full-diff.rss" />
+<link rel="alternate" type="application/rss+xml"
+      title="Emacs Wiki including minor differences"
+      href="http://www.emacswiki.org/emacs/minor-edits.rss" />
+<link rel="alternate" type="application/rss+xml"
+      title="Changes for anything.el only"
+      href="http://www.emacswiki.org/emacs?action=rss;rcidonly=anything.el" /><meta name="viewport" content="width=device-width" />
+<script type="text/javascript" src="/outliner.0.5.0.62-toc.js"></script>
+<script type="text/javascript">
+
+  function addOnloadEvent(fnc) {
+    if ( typeof window.addEventListener != "undefined" )
+      window.addEventListener( "load", fnc, false );
+    else if ( typeof window.attachEvent != "undefined" ) {
+      window.attachEvent( "onload", fnc );
+    }
+    else {
+      if ( window.onload != null ) {
+	var oldOnload = window.onload;
+	window.onload = function ( e ) {
+	  oldOnload( e );
+	  window[fnc]();
+	};
+      }
+      else
+	window.onload = fnc;
+    }
+  }
+
+  var initToc=function() {
+
+    var outline = HTML5Outline(document.body);
+    if (outline.sections.length == 1) {
+      outline.sections = outline.sections[0].sections;
+    }
+
+    if (outline.sections.length > 1
+	|| outline.sections.length == 1
+           && outline.sections[0].sections.length > 0) {
+
+      var toc = document.getElementById('toc');
+
+      if (!toc) {
+	var divs = document.getElementsByTagName('div');
+	for (var i = 0; i < divs.length; i++) {
+	  if (divs[i].getAttribute('class') == 'toc') {
+	    toc = divs[i];
+	    break;
+	  }
+	}
+      }
+
+      if (!toc) {
+	var h2 = document.getElementsByTagName('h2')[0];
+	if (h2) {
+	  toc = document.createElement('div');
+	  toc.setAttribute('class', 'toc');
+	  h2.parentNode.insertBefore(toc, h2);
+	}
+      }
+
+      if (toc) {
+        var html = outline.asHTML(true);
+        toc.innerHTML = html;
+      }
+    }
+  }
+
+  addOnloadEvent(initToc);
+  </script>
+
+<script src="http://code.jquery.com/jquery-1.9.1.min.js"></script>
+<script src="http://netdna.bootstrapcdn.com/twitter-bootstrap/2.3.0/js/bootstrap.min.js"></script>
+<script src="http://emacswiki.org/emacs/emacs-bootstrap.js"></script>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /></head><body class="http://www.emacswiki.org/emacs"><div class="header"><span class="gotobar bar"><a class="local" href="http://www.emacswiki.org/emacs/SiteMap">SiteMap</a> <a class="local" href="http://www.emacswiki.org/emacs/Search">Search</a> <a class="local" href="http://www.emacswiki.org/emacs/ElispArea">ElispArea</a> <a class="local" href="http://www.emacswiki.org/emacs/HowTo">HowTo</a> <a class="local" href="http://www.emacswiki.org/emacs/Glossary">Glossary</a> <a class="local" href="http://www.emacswiki.org/emacs/RecentChanges">RecentChanges</a> <a class="local" href="http://www.emacswiki.org/emacs/News">News</a> <a class="local" href="http://www.emacswiki.org/emacs/Problems">Problems</a> <a class="local" href="http://www.emacswiki.org/emacs/Suggestions">Suggestions</a> </span><br /><span class="specialdays">Uganda, Independence Day</span><h1><a title="Click to search for references to this page" rel="nofollow" href="http://www.emacswiki.org/emacs?search=%22anything%5c.el%22">anything.el</a></h1></div><div class="wrapper"><div class="content browse"><p class="download"><a href="http://www.emacswiki.org/emacs-fr/download/anything.el">Download</a></p><pre><span class="comment">;;; anything.el --- open anything / QuickSilver-like candidate-selection framework</span>
+
+<span class="comment">;; Copyright (C) 2007              Tamas Patrovics</span>
+<span class="comment">;;               2008 ~ 2012       rubikitch &lt;rubikitch@ruby-lang.org&gt;</span>
+<span class="comment">;;               2011 ~ 2012       Thierry Volpiatto &lt;thierry.volpiatto@gmail.com&gt;</span>
+
+<span class="comment">;; Author: Tamas Patrovics</span>
+
+<span class="comment">;; Maintainers: rubikitch &lt;rubikitch@ruby-lang.org&gt;</span>
+<span class="comment">;;              Thierry Volpiatto &lt;thierry.volpiatto@gmail.com&gt;</span>
+
+<span class="comment">;; Keywords: files, frames, help, matching, outlines,</span>
+<span class="comment">;;           processes, tools, convenience, anything</span>
+
+<span class="comment">;; X-URL: &lt;http<span class="builtin">://repo</span>.or.cz/w/anything-config.git&gt;</span>
+
+<span class="comment">;; Site: &lt;http<span class="builtin">://www</span>.emacswiki.org/cgi-bin/emacs/Anything&gt;</span>
+
+<span class="comment">;; MailingList: &lt;https<span class="builtin">://groups</span>.google.com/group/emacs-anything?hl=en&gt;</span>
+
+
+<span class="comment">;;; This file is NOT part of GNU Emacs</span>
+
+<span class="comment">;;; License</span>
+<span class="comment">;;</span>
+<span class="comment">;; This file is free software; you can redistribute it and/or modify</span>
+<span class="comment">;; it under the terms of the GNU General Public License as published by</span>
+<span class="comment">;; the Free Software Foundation; either version 2, or (at your option)</span>
+<span class="comment">;; any later version.</span>
+
+<span class="comment">;; This file is distributed in the hope that it will be useful,</span>
+<span class="comment">;; but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
+<span class="comment">;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
+
+<span class="comment">;; GNU General Public License for more details.</span>
+
+<span class="comment">;; You should have received a copy of the GNU General Public License</span>
+<span class="comment">;; along with GNU Emacs; see the file COPYING.  If not, write to the</span>
+<span class="comment">;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,</span>
+<span class="comment">;; Boston, MA 02110-1301, USA.</span>
 
  
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;;; Autodoc documentation:
-;;  ---------------------
-
-;;  * Commands defined here are:
-;; [EVAL] (autodoc-document-lisp-buffer :type 'command :prefix "anything" :docstring t)
-;; `anything-open-last-log'
-;; Open anything log file of last anything session.
-;; `anything'
-;; Main function to execute anything sources.
-;; `anything-resume'
-;; Resurrect previously invoked `anything'.
-;; `anything-resume-window-only'
-;; 
-;; `anything-at-point'
-;; Call anything with symbol at point as initial input.
-;; `anything-force-update'
-;; Force recalculation and update of candidates.
-;; `anything-select-action'
-;; Select an action for the currently selected candidate.
-;; `anything-previous-line'
-;; Move selection to the previous line.
-;; `anything-next-line'
-;; Move selection to the next line.
-;; `anything-previous-page'
-;; Move selection back with a pageful.
-;; `anything-next-page'
-;; Move selection forward with a pageful.
-;; `anything-beginning-of-buffer'
-;; Move selection at the top.
-;; `anything-end-of-buffer'
-;; Move selection at the bottom.
-;; `anything-previous-source'
-;; Move selection to the previous source.
-;; `anything-next-source'
-;; Move selection to the next source.
-;; `anything-select-with-prefix-shortcut'
-;; Invoke default action with prefix shortcut.
-;; `anything-select-with-digit-shortcut'
-;; Invoke default action with digit/alphabet shortcut.
-;; `anything-confirm-and-exit-minibuffer'
-;; Maybe ask for confirmation when exiting anything.
-;; `anything-exit-minibuffer'
-;; Select the current candidate by exiting the minibuffer.
-;; `anything-keyboard-quit'
-;; Quit minibuffer in anything.
-;; `anything-help'
-;; Help of `anything'.
-;; `anything-debug-output'
-;; Show all anything-related variables at this time.
-;; `anything-delete-current-selection'
-;; Delete the currently selected item.
-;; `anything-delete-minibuffer-contents'
-;; Same as `delete-minibuffer-contents' but this is a command.
-;; `anything-toggle-resplit-window'
-;; Toggle resplit anything window, vertically or horizontally.
-;; `anything-narrow-window'
-;; Narrow anything window.
-;; `anything-enlarge-window'
-;; Enlarge anything window.
-;; `anything-select-2nd-action'
-;; Select the 2nd action for the currently selected candidate.
-;; `anything-select-3rd-action'
-;; Select the 3rd action for the currently selected candidate.
-;; `anything-select-4th-action'
-;; Select the 4th action for the currently selected candidate.
-;; `anything-select-2nd-action-or-end-of-line'
-;; Select the 2nd action for the currently selected candidate.
-;; `anything-execute-persistent-action'
-;; Perform the associated action ATTR without quitting anything.
-;; `anything-scroll-other-window'
-;; Scroll other window (not *Anything* window) upward.
-;; `anything-scroll-other-window-down'
-;; Scroll other window (not *Anything* window) downward.
-;; `anything-toggle-visible-mark'
-;; Toggle anything visible mark at point.
-;; `anything-display-all-visible-marks'
-;; Show all `anything' visible marks strings.
-;; `anything-next-visible-mark'
-;; Move next anything visible mark.
-;; `anything-prev-visible-mark'
-;; Move previous anything visible mark.
-;; `anything-yank-selection'
-;; Set minibuffer contents to current selection.
-;; `anything-kill-selection-and-quit'
-;; Store current selection to kill ring.
-;; `anything-follow-mode'
-;; If this mode is on, persistent action is executed everytime the cursor is moved.
-;; `anything-migrate-sources'
-;; Help to migrate to new `anything' way.
-;; `anything-describe-anything-attribute'
-;; Display the full documentation of ANYTHING-ATTRIBUTE.
-;; `anything-send-bug-report'
-;; Send a bug report of anything.el.
-;; `anything-send-bug-report-from-anything'
-;; Send a bug report of anything.el in anything session.
-
-;;  * Variables defined here are:
-;; [EVAL] (autodoc-document-lisp-buffer :type 'internal-variable :prefix "anything-" :docstring t)
-;; `anything-version'
-;; Not documented.
-;; `anything-sources'
-;; A list of sources to use with `anything'.
-;; `anything-type-attributes'
-;; It's a list of                                      (TYPE ATTRIBUTES ...).
-;; `anything-enable-shortcuts'
-;; *Whether to use digit/alphabet shortcut to select the first nine matches.
-;; `anything-shortcut-keys-alist'
-;; Not documented.
-;; `anything-display-source-at-screen-top'
-;; *Display candidates at the top of screen.
-;; `anything-candidate-number-limit'
-;; Apply candidate-number-limit attribute value.
-;; `anything-idle-delay'
-;; *Be idle for this many seconds, before updating in delayed sources.
-;; `anything-input-idle-delay'
-;; Be idle for this many seconds, before updating.
-;; `anything-samewindow'
-;; Use current window to show the candidates.
-;; `anything-source-filter'
-;; A list of source names to be displayed.
-;; `anything-map'
-;; Keymap for anything.
-;; `anything-header-face'
-;; *Face for header lines in the anything buffer.
-;; `anything-selection-face'
-;; *Face for currently selected item.
-;; `anything-buffer'
-;; Buffer showing completions.
-;; `anything-action-buffer'
-;; Buffer showing actions.
-;; `anything-selection-overlay'
-;; Overlay used to highlight the currently selected item.
-;; `anything-digit-overlays'
-;; Overlays for digit shortcuts.  See `anything-enable-shortcuts'.
-;; `anything-candidate-cache'
-;; Holds the available candidate withing a single anything invocation.
-;; `anything-pattern'
-;; Not documented.
-;; `anything-input'
-;; Not documented.
-;; `anything-async-processes'
-;; List of information about asynchronous processes managed by anything.
-;; `anything-digit-shortcut-count'
-;; Number of digit shortcuts shown in the anything buffer.
-;; `anything-before-initialize-hook'
-;; Run before anything initialization.
-;; `anything-after-initialize-hook'
-;; Run after anything initialization.
-;; `anything-update-hook'
-;; Run after the anything buffer was updated according the new input pattern.
-;; `anything-after-update-hook'
-;; Run after the anything buffer was updated according the new input pattern.
-;; `anything-cleanup-hook'
-;; Run after anything minibuffer is closed.
-;; `anything-select-action-hook'
-;; Run when opening the action buffer.
-;; `anything-before-action-hook'
-;; Run before executing action.
-;; `anything-after-action-hook'
-;; Run after executing action.
-;; `anything-after-persistent-action-hook'
-;; Run after executing persistent action.
-;; `anything-move-selection-before-hook'
-;; Run before moving selection in `anything-buffer'.
-;; `anything-move-selection-after-hook'
-;; Run after moving selection in `anything-buffer'.
-;; `anything-restored-variables'
-;; Variables which are restored after `anything' invocation.
-;; `anything-saved-selection'
-;; Value of the currently selected object when the action list is shown.
-;; `anything-current-prefix-arg'
-;; Record `current-prefix-arg' when exiting minibuffer.
-;; `anything-candidate-separator'
-;; Candidates separator of `multiline' source.
-;; `anything-current-buffer'
-;; Current buffer when `anything' is invoked.
-;; `anything-buffer-file-name'
-;; Variable `buffer-file-name' when `anything' is invoked.
-;; `anything-saved-action'
-;; Saved value of the currently selected action by key.
-;; `anything-last-sources'
-;; OBSOLETE!! Sources of previously invoked `anything'.
-;; `anything-saved-current-source'
-;; Value of the current source when the action list is shown.
-;; `anything-compiled-sources'
-;; Compiled version of `anything-sources'.
-;; `anything-in-persistent-action'
-;; Flag whether in persistent-action or not.
-;; `anything-quick-update'
-;; If non-nil, suppress displaying sources which are out of screen at first.
-;; `anything-last-sources-local'
-;; Buffer local value of `anything-sources'.
-;; `anything-last-buffer'
-;; `anything-buffer' of previously `anything' session.
-;; `anything-save-configuration-functions'
-;; The functions used to restore/save window or frame configurations.
-;; `anything-persistent-action-use-special-display'
-;; If non-nil, use `special-display-function' in persistent action.
-;; `anything-execute-action-at-once-if-one'
-;; Execute default action and exit when only one candidate is remaining.
-;; `anything-quit-if-no-candidate'
-;; Quit when there is no candidates when non--nil.
-;; `anything-scroll-amount'
-;; Scroll amount when scrolling other window in an anything session.
-;; `anything-display-function'
-;; Function to display *anything* buffer.
-;; `anything-delayed-init-executed'
-;; Not documented.
-;; `anything-mode-line-string'
-;; Help string displayed in mode-line in `anything'.
-;; `anything-help-message'
-;; Detailed help message string for `anything'.
-;; `anything-source-in-each-line-flag'
-;; Non-nil means add anything-source text-property in each candidate.
-;; `anything-debug-forms'
-;; Forms to show in `anything-debug-output'.
-;; `anything-debug'
-;; If non-nil, write log message into *Anything Log* buffer.
-;; `anything-test-candidate-list'
-;; Not documented.
-;; `anything-test-mode'
-;; Not documented.
-;; `anything-source-name'
-;; Not documented.
-;; `anything-candidate-buffer-alist'
-;; Not documented.
-;; `anything-check-minibuffer-input-timer'
-;; Not documented.
-;; `anything-match-hash'
-;; Not documented.
-;; `anything-cib-hash'
-;; Not documented.
-;; `anything-tick-hash'
-;; Not documented.
-;; `anything-issued-errors'
-;; Not documented.
-;; `anything-shortcut-keys'
-;; Not documented.
-;; `anything-once-called-functions'
-;; Not documented.
-;; `anything-follow-mode'
-;; If this mode is on, persistent action is executed everytime the cursor is moved.
-;; `anything-let-variables'
-;; Not documented.
-;; `anything-split-window-state'
-;; Not documented.
-;; `anything-selection-point'
-;; Not documented.
-;; `anything-last-log-file'
-;; Not documented.
-;; `anything-compile-source-functions'
-;; Functions to compile elements of `anything-sources' (plug-in).
-;; `anything-quit'
-;; Not documented.
-;; `anything-additional-attributes'
-;; List of all `anything' attributes.
-;; `anything-buffers'
-;; All of `anything-buffer' in most recently used order.
-;; `anything-current-position'
-;; Restore or save current position in `anything-current-buffer'.
-;; `anything-last-frame-or-window-configuration'
-;; Used to store window or frame configuration when anything start.
-;; `anything-reading-pattern'
-;; Whether in `read-string' in anything or not.
-;; `anything-compile-source-functions-default'
-;; Plug-ins this file provides.
-;; `anything-input-local'
-;; Not documented.
-;; `anything-process-delayed-sources-timer'
-;; Not documented.
-;; `anything-mode-line-string-real'
-;; Not documented.
-;; `anything-exit-status'
-;; Flag to inform whether anything have exited or quitted.
-;; `anything-minibuffer-confirm-state'
-;; Not documented.
-;; `anything-types'
-;; Not documented.
-;; `anything-orig-enable-shortcuts'
-;; Not documented.
-;; `anything-persistent-action-display-window'
-;; Return the window that will be used for presistent action.
-;; `anything-visible-mark-face'
-;; Not documented.
-;; `anything-visible-mark-overlays'
-;; Not documented.
-;; `anything-marked-candidates'
-;; Return marked candidates of current source if any.
-;; `anything-maintainer-mail-address'
-;; Not documented.
-;; `anything-bug-report-salutation'
-;; Not documented.
-;; `anything-no-dump-variables'
-;; Variables not to dump in bug report.
-
-;;  *** END auto-documentation
-
-;; [EVAL] (autodoc-update-all)
+<span class="comment">;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;</span>
+<span class="comment">;;</span>
+<span class="comment">;;; Autodoc documentation<span class="builtin">:</span></span>
+<span class="comment">;;  ---------------------</span>
+
+<span class="comment">;;  * Commands defined here are<span class="builtin">:</span></span>
+<span class="comment">;; [EVAL] (autodoc-document-lisp-buffer <span class="builtin">:type</span> 'command <span class="builtin">:prefix</span> <span class="string">"anything"</span> <span class="builtin">:docstring</span> t)</span>
+<span class="comment">;; `<span class="constant important">anything-open-last-log</span>'</span>
+<span class="comment">;; Open anything log file of last anything session.</span>
+<span class="comment">;; `<span class="constant important">anything</span>'</span>
+<span class="comment">;; Main function to execute anything sources.</span>
+<span class="comment">;; `<span class="constant important">anything-resume</span>'</span>
+<span class="comment">;; Resurrect previously invoked `<span class="constant important">anything</span>'.</span>
+<span class="comment">;; `<span class="constant important">anything-resume-window-only</span>'</span>
+<span class="comment">;; </span>
+<span class="comment">;; `<span class="constant important">anything-at-point</span>'</span>
+<span class="comment">;; Call anything with symbol at point as initial input.</span>
+<span class="comment">;; `<span class="constant important">anything-force-update</span>'</span>
+<span class="comment">;; Force recalculation and update of candidates.</span>
+<span class="comment">;; `<span class="constant important">anything-select-action</span>'</span>
+<span class="comment">;; Select an action for the currently selected candidate.</span>
+<span class="comment">;; `<span class="constant important">anything-previous-line</span>'</span>
+<span class="comment">;; Move selection to the previous line.</span>
+<span class="comment">;; `<span class="constant important">anything-next-line</span>'</span>
+<span class="comment">;; Move selection to the next line.</span>
+<span class="comment">;; `<span class="constant important">anything-previous-page</span>'</span>
+<span class="comment">;; Move selection back with a pageful.</span>
+<span class="comment">;; `<span class="constant important">anything-next-page</span>'</span>
+<span class="comment">;; Move selection forward with a pageful.</span>
+<span class="comment">;; `<span class="constant important">anything-beginning-of-buffer</span>'</span>
+<span class="comment">;; Move selection at the top.</span>
+<span class="comment">;; `<span class="constant important">anything-end-of-buffer</span>'</span>
+<span class="comment">;; Move selection at the bottom.</span>
+<span class="comment">;; `<span class="constant important">anything-previous-source</span>'</span>
+<span class="comment">;; Move selection to the previous source.</span>
+<span class="comment">;; `<span class="constant important">anything-next-source</span>'</span>
+<span class="comment">;; Move selection to the next source.</span>
+<span class="comment">;; `<span class="constant important">anything-select-with-prefix-shortcut</span>'</span>
+<span class="comment">;; Invoke default action with prefix shortcut.</span>
+<span class="comment">;; `<span class="constant important">anything-select-with-digit-shortcut</span>'</span>
+<span class="comment">;; Invoke default action with digit/alphabet shortcut.</span>
+<span class="comment">;; `<span class="constant important">anything-confirm-and-exit-minibuffer</span>'</span>
+<span class="comment">;; Maybe ask for confirmation when exiting anything.</span>
+<span class="comment">;; `<span class="constant important">anything-exit-minibuffer</span>'</span>
+<span class="comment">;; Select the current candidate by exiting the minibuffer.</span>
+<span class="comment">;; `<span class="constant important">anything-keyboard-quit</span>'</span>
+<span class="comment">;; Quit minibuffer in anything.</span>
+<span class="comment">;; `<span class="constant important">anything-help</span>'</span>
+<span class="comment">;; Help of `<span class="constant important">anything</span>'.</span>
+<span class="comment">;; `<span class="constant important">anything-debug-output</span>'</span>
+<span class="comment">;; Show all anything-related variables at this time.</span>
+<span class="comment">;; `<span class="constant important">anything-delete-current-selection</span>'</span>
+<span class="comment">;; Delete the currently selected item.</span>
+<span class="comment">;; `<span class="constant important">anything-delete-minibuffer-contents</span>'</span>
+<span class="comment">;; Same as `<span class="constant important">delete-minibuffer-contents</span>' but this is a command.</span>
+<span class="comment">;; `<span class="constant important">anything-toggle-resplit-window</span>'</span>
+<span class="comment">;; Toggle resplit anything window, vertically or horizontally.</span>
+<span class="comment">;; `<span class="constant important">anything-narrow-window</span>'</span>
+<span class="comment">;; Narrow anything window.</span>
+<span class="comment">;; `<span class="constant important">anything-enlarge-window</span>'</span>
+<span class="comment">;; Enlarge anything window.</span>
+<span class="comment">;; `anything-select-2nd-action'</span>
+<span class="comment">;; Select the 2nd action for the currently selected candidate.</span>
+<span class="comment">;; `anything-select-3rd-action'</span>
+<span class="comment">;; Select the 3rd action for the currently selected candidate.</span>
+<span class="comment">;; `anything-select-4th-action'</span>
+<span class="comment">;; Select the 4th action for the currently selected candidate.</span>
+<span class="comment">;; `anything-select-2nd-action-or-end-of-line'</span>
+<span class="comment">;; Select the 2nd action for the currently selected candidate.</span>
+<span class="comment">;; `<span class="constant important">anything-execute-persistent-action</span>'</span>
+<span class="comment">;; Perform the associated action ATTR without quitting anything.</span>
+<span class="comment">;; `<span class="constant important">anything-scroll-other-window</span>'</span>
+<span class="comment">;; Scroll other window (not *Anything* window) upward.</span>
+<span class="comment">;; `<span class="constant important">anything-scroll-other-window-down</span>'</span>
+<span class="comment">;; Scroll other window (not *Anything* window) downward.</span>
+<span class="comment">;; `<span class="constant important">anything-toggle-visible-mark</span>'</span>
+<span class="comment">;; Toggle anything visible mark at point.</span>
+<span class="comment">;; `<span class="constant important">anything-display-all-visible-marks</span>'</span>
+<span class="comment">;; Show all `<span class="constant important">anything</span>' visible marks strings.</span>
+<span class="comment">;; `<span class="constant important">anything-next-visible-mark</span>'</span>
+<span class="comment">;; Move next anything visible mark.</span>
+<span class="comment">;; `<span class="constant important">anything-prev-visible-mark</span>'</span>
+<span class="comment">;; Move previous anything visible mark.</span>
+<span class="comment">;; `<span class="constant important">anything-yank-selection</span>'</span>
+<span class="comment">;; Set minibuffer contents to current selection.</span>
+<span class="comment">;; `<span class="constant important">anything-kill-selection-and-quit</span>'</span>
+<span class="comment">;; Store current selection to kill ring.</span>
+<span class="comment">;; `<span class="constant important">anything-follow-mode</span>'</span>
+<span class="comment">;; If this mode is on, persistent action is executed everytime the cursor is moved.</span>
+<span class="comment">;; `<span class="constant important">anything-migrate-sources</span>'</span>
+<span class="comment">;; Help to migrate to new `<span class="constant important">anything</span>' way.</span>
+<span class="comment">;; `<span class="constant important">anything-describe-anything-attribute</span>'</span>
+<span class="comment">;; Display the full documentation of ANYTHING-ATTRIBUTE.</span>
+<span class="comment">;; `<span class="constant important">anything-send-bug-report</span>'</span>
+<span class="comment">;; Send a bug report of anything.el.</span>
+<span class="comment">;; `<span class="constant important">anything-send-bug-report-from-anything</span>'</span>
+<span class="comment">;; Send a bug report of anything.el in anything session.</span>
+
+<span class="comment">;;  * Variables defined here are<span class="builtin">:</span></span>
+<span class="comment">;; [EVAL] (autodoc-document-lisp-buffer <span class="builtin">:type</span> 'internal-variable <span class="builtin">:prefix</span> <span class="string">"anything-"</span> <span class="builtin">:docstring</span> t)</span>
+<span class="comment">;; `<span class="constant important">anything-version</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-sources</span>'</span>
+<span class="comment">;; A list of sources to use with `<span class="constant important">anything</span>'.</span>
+<span class="comment">;; `<span class="constant important">anything-type-attributes</span>'</span>
+<span class="comment">;; It's a list of                                      (TYPE ATTRIBUTES ...).</span>
+<span class="comment">;; `<span class="constant important">anything-enable-shortcuts</span>'</span>
+<span class="comment">;; *Whether to use digit/alphabet shortcut to select the first nine matches.</span>
+<span class="comment">;; `<span class="constant important">anything-shortcut-keys-alist</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-display-source-at-screen-top</span>'</span>
+<span class="comment">;; *Display candidates at the top of screen.</span>
+<span class="comment">;; `<span class="constant important">anything-candidate-number-limit</span>'</span>
+<span class="comment">;; Apply candidate-number-limit attribute value.</span>
+<span class="comment">;; `<span class="constant important">anything-idle-delay</span>'</span>
+<span class="comment">;; *Be idle for this many seconds, before updating in delayed sources.</span>
+<span class="comment">;; `<span class="constant important">anything-input-idle-delay</span>'</span>
+<span class="comment">;; Be idle for this many seconds, before updating.</span>
+<span class="comment">;; `<span class="constant important">anything-samewindow</span>'</span>
+<span class="comment">;; Use current window to show the candidates.</span>
+<span class="comment">;; `<span class="constant important">anything-source-filter</span>'</span>
+<span class="comment">;; A list of source names to be displayed.</span>
+<span class="comment">;; `<span class="constant important">anything-map</span>'</span>
+<span class="comment">;; Keymap for anything.</span>
+<span class="comment">;; `<span class="constant important">anything-header-face</span>'</span>
+<span class="comment">;; *Face for header lines in the anything buffer.</span>
+<span class="comment">;; `<span class="constant important">anything-selection-face</span>'</span>
+<span class="comment">;; *Face for currently selected item.</span>
+<span class="comment">;; `<span class="constant important">anything-buffer</span>'</span>
+<span class="comment">;; Buffer showing completions.</span>
+<span class="comment">;; `<span class="constant important">anything-action-buffer</span>'</span>
+<span class="comment">;; Buffer showing actions.</span>
+<span class="comment">;; `<span class="constant important">anything-selection-overlay</span>'</span>
+<span class="comment">;; Overlay used to highlight the currently selected item.</span>
+<span class="comment">;; `<span class="constant important">anything-digit-overlays</span>'</span>
+<span class="comment">;; Overlays for digit shortcuts.  See `<span class="constant important">anything-enable-shortcuts</span>'.</span>
+<span class="comment">;; `<span class="constant important">anything-candidate-cache</span>'</span>
+<span class="comment">;; Holds the available candidate withing a single anything invocation.</span>
+<span class="comment">;; `<span class="constant important">anything-pattern</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-input</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-async-processes</span>'</span>
+<span class="comment">;; List of information about asynchronous processes managed by anything.</span>
+<span class="comment">;; `<span class="constant important">anything-digit-shortcut-count</span>'</span>
+<span class="comment">;; Number of digit shortcuts shown in the anything buffer.</span>
+<span class="comment">;; `<span class="constant important">anything-before-initialize-hook</span>'</span>
+<span class="comment">;; Run before anything initialization.</span>
+<span class="comment">;; `<span class="constant important">anything-after-initialize-hook</span>'</span>
+<span class="comment">;; Run after anything initialization.</span>
+<span class="comment">;; `<span class="constant important">anything-update-hook</span>'</span>
+<span class="comment">;; Run after the anything buffer was updated according the new input pattern.</span>
+<span class="comment">;; `<span class="constant important">anything-after-update-hook</span>'</span>
+<span class="comment">;; Run after the anything buffer was updated according the new input pattern.</span>
+<span class="comment">;; `<span class="constant important">anything-cleanup-hook</span>'</span>
+<span class="comment">;; Run after anything minibuffer is closed.</span>
+<span class="comment">;; `<span class="constant important">anything-select-action-hook</span>'</span>
+<span class="comment">;; Run when opening the action buffer.</span>
+<span class="comment">;; `<span class="constant important">anything-before-action-hook</span>'</span>
+<span class="comment">;; Run before executing action.</span>
+<span class="comment">;; `<span class="constant important">anything-after-action-hook</span>'</span>
+<span class="comment">;; Run after executing action.</span>
+<span class="comment">;; `<span class="constant important">anything-after-persistent-action-hook</span>'</span>
+<span class="comment">;; Run after executing persistent action.</span>
+<span class="comment">;; `<span class="constant important">anything-move-selection-before-hook</span>'</span>
+<span class="comment">;; Run before moving selection in `<span class="constant important">anything-buffer</span>'.</span>
+<span class="comment">;; `<span class="constant important">anything-move-selection-after-hook</span>'</span>
+<span class="comment">;; Run after moving selection in `<span class="constant important">anything-buffer</span>'.</span>
+<span class="comment">;; `<span class="constant important">anything-restored-variables</span>'</span>
+<span class="comment">;; Variables which are restored after `<span class="constant important">anything</span>' invocation.</span>
+<span class="comment">;; `<span class="constant important">anything-saved-selection</span>'</span>
+<span class="comment">;; Value of the currently selected object when the action list is shown.</span>
+<span class="comment">;; `<span class="constant important">anything-current-prefix-arg</span>'</span>
+<span class="comment">;; Record `<span class="constant important">current-prefix-arg</span>' when exiting minibuffer.</span>
+<span class="comment">;; `<span class="constant important">anything-candidate-separator</span>'</span>
+<span class="comment">;; Candidates separator of `<span class="constant important">multiline</span>' source.</span>
+<span class="comment">;; `<span class="constant important">anything-current-buffer</span>'</span>
+<span class="comment">;; Current buffer when `<span class="constant important">anything</span>' is invoked.</span>
+<span class="comment">;; `<span class="constant important">anything-buffer-file-name</span>'</span>
+<span class="comment">;; Variable `<span class="constant important">buffer-file-name</span>' when `<span class="constant important">anything</span>' is invoked.</span>
+<span class="comment">;; `<span class="constant important">anything-saved-action</span>'</span>
+<span class="comment">;; Saved value of the currently selected action by key.</span>
+<span class="comment">;; `<span class="constant important">anything-last-sources</span>'</span>
+<span class="comment">;; OBSOLETE!! Sources of previously invoked `<span class="constant important">anything</span>'.</span>
+<span class="comment">;; `<span class="constant important">anything-saved-current-source</span>'</span>
+<span class="comment">;; Value of the current source when the action list is shown.</span>
+<span class="comment">;; `<span class="constant important">anything-compiled-sources</span>'</span>
+<span class="comment">;; Compiled version of `<span class="constant important">anything-sources</span>'.</span>
+<span class="comment">;; `<span class="constant important">anything-in-persistent-action</span>'</span>
+<span class="comment">;; Flag whether in persistent-action or not.</span>
+<span class="comment">;; `<span class="constant important">anything-quick-update</span>'</span>
+<span class="comment">;; If non-nil, suppress displaying sources which are out of screen at first.</span>
+<span class="comment">;; `<span class="constant important">anything-last-sources-local</span>'</span>
+<span class="comment">;; Buffer local value of `<span class="constant important">anything-sources</span>'.</span>
+<span class="comment">;; `<span class="constant important">anything-last-buffer</span>'</span>
+<span class="comment">;; `<span class="constant important">anything-buffer</span>' of previously `<span class="constant important">anything</span>' session.</span>
+<span class="comment">;; `<span class="constant important">anything-save-configuration-functions</span>'</span>
+<span class="comment">;; The functions used to restore/save window or frame configurations.</span>
+<span class="comment">;; `<span class="constant important">anything-persistent-action-use-special-display</span>'</span>
+<span class="comment">;; If non-nil, use `<span class="constant important">special-display-function</span>' in persistent action.</span>
+<span class="comment">;; `<span class="constant important">anything-execute-action-at-once-if-one</span>'</span>
+<span class="comment">;; Execute default action and exit when only one candidate is remaining.</span>
+<span class="comment">;; `<span class="constant important">anything-quit-if-no-candidate</span>'</span>
+<span class="comment">;; Quit when there is no candidates when non--nil.</span>
+<span class="comment">;; `<span class="constant important">anything-scroll-amount</span>'</span>
+<span class="comment">;; Scroll amount when scrolling other window in an anything session.</span>
+<span class="comment">;; `<span class="constant important">anything-display-function</span>'</span>
+<span class="comment">;; Function to display *anything* buffer.</span>
+<span class="comment">;; `<span class="constant important">anything-delayed-init-executed</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-mode-line-string</span>'</span>
+<span class="comment">;; Help string displayed in mode-line in `<span class="constant important">anything</span>'.</span>
+<span class="comment">;; `<span class="constant important">anything-help-message</span>'</span>
+<span class="comment">;; Detailed help message string for `<span class="constant important">anything</span>'.</span>
+<span class="comment">;; `<span class="constant important">anything-source-in-each-line-flag</span>'</span>
+<span class="comment">;; Non-nil means add anything-source text-property in each candidate.</span>
+<span class="comment">;; `<span class="constant important">anything-debug-forms</span>'</span>
+<span class="comment">;; Forms to show in `<span class="constant important">anything-debug-output</span>'.</span>
+<span class="comment">;; `<span class="constant important">anything-debug</span>'</span>
+<span class="comment">;; If non-nil, write log message into *Anything Log* buffer.</span>
+<span class="comment">;; `<span class="constant important">anything-test-candidate-list</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-test-mode</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-source-name</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-candidate-buffer-alist</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-check-minibuffer-input-timer</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-match-hash</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-cib-hash</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-tick-hash</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-issued-errors</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-shortcut-keys</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-once-called-functions</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-follow-mode</span>'</span>
+<span class="comment">;; If this mode is on, persistent action is executed everytime the cursor is moved.</span>
+<span class="comment">;; `<span class="constant important">anything-let-variables</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-split-window-state</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-selection-point</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-last-log-file</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-compile-source-functions</span>'</span>
+<span class="comment">;; Functions to compile elements of `<span class="constant important">anything-sources</span>' (plug-in).</span>
+<span class="comment">;; `<span class="constant important">anything-quit</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-additional-attributes</span>'</span>
+<span class="comment">;; List of all `<span class="constant important">anything</span>' attributes.</span>
+<span class="comment">;; `<span class="constant important">anything-buffers</span>'</span>
+<span class="comment">;; All of `<span class="constant important">anything-buffer</span>' in most recently used order.</span>
+<span class="comment">;; `<span class="constant important">anything-current-position</span>'</span>
+<span class="comment">;; Restore or save current position in `<span class="constant important">anything-current-buffer</span>'.</span>
+<span class="comment">;; `<span class="constant important">anything-last-frame-or-window-configuration</span>'</span>
+<span class="comment">;; Used to store window or frame configuration when anything start.</span>
+<span class="comment">;; `<span class="constant important">anything-reading-pattern</span>'</span>
+<span class="comment">;; Whether in `<span class="constant important">read-string</span>' in anything or not.</span>
+<span class="comment">;; `<span class="constant important">anything-compile-source-functions-default</span>'</span>
+<span class="comment">;; Plug-ins this file provides.</span>
+<span class="comment">;; `<span class="constant important">anything-input-local</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-process-delayed-sources-timer</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-mode-line-string-real</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-exit-status</span>'</span>
+<span class="comment">;; Flag to inform whether anything have exited or quitted.</span>
+<span class="comment">;; `<span class="constant important">anything-minibuffer-confirm-state</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-types</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-orig-enable-shortcuts</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-persistent-action-display-window</span>'</span>
+<span class="comment">;; Return the window that will be used for presistent action.</span>
+<span class="comment">;; `<span class="constant important">anything-visible-mark-face</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-visible-mark-overlays</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-marked-candidates</span>'</span>
+<span class="comment">;; Return marked candidates of current source if any.</span>
+<span class="comment">;; `<span class="constant important">anything-maintainer-mail-address</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-bug-report-salutation</span>'</span>
+<span class="comment">;; Not documented.</span>
+<span class="comment">;; `<span class="constant important">anything-no-dump-variables</span>'</span>
+<span class="comment">;; Variables not to dump in bug report.</span>
+
+<span class="comment">;;  *** END auto-documentation</span>
+
+<span class="comment">;; [EVAL] (autodoc-update-all)</span>
 
  
-;;; Commentary:
-
-;;
-;; Start with M-x anything, narrow the list by typing some pattern,
-;; select with up/down/pgup/pgdown/C-p/C-n/C-v/M-v, choose with enter,
-;; left/right moves between sources.  With TAB actions can be selected
-;; if the selected candidate has more than one possible action.
-;;
-;; Note that anything.el provides only the framework and some example
-;; configurations for demonstration purposes.  See anything-config.el
-;; for practical, polished, easy to use configurations which can be
-;; used to assemble a custom personalized configuration.
-;;
-;; NOTE: What you find on Emacswiki is mostly deprecated and not maintained,
-;;       don't complain if you use such code or configuration and something
-;;       doesn't work.
-;;
-;; Here is Japanese translation of `anything-sources' attributes.  Thanks.
-;; http://d.hatena.ne.jp/sirocco634/20091012/1255336649
+<span class="comment">;;; Commentary<span class="builtin">:</span></span>
+
+<span class="comment">;;</span>
+<span class="comment">;; Start with M-x anything, narrow the list by typing some pattern,</span>
+<span class="comment">;; select with up/down/pgup/pgdown/C-p/C-n/C-v/M-v, choose with enter,</span>
+<span class="comment">;; left/right moves between sources.  With TAB actions can be selected</span>
+<span class="comment">;; if the selected candidate has more than one possible action.</span>
+<span class="comment">;;</span>
+<span class="comment">;; Note that anything.el provides only the framework and some example</span>
+<span class="comment">;; configurations for demonstration purposes.  See anything-config.el</span>
+<span class="comment">;; for practical, polished, easy to use configurations which can be</span>
+<span class="comment">;; used to assemble a custom personalized configuration.</span>
+<span class="comment">;;</span>
+<span class="comment">;; NOTE: What you find on Emacswiki is mostly deprecated and not maintained,</span>
+<span class="comment">;;       don't complain if you use such code or configuration and something</span>
+<span class="comment">;;       doesn't work.</span>
+<span class="comment">;;</span>
+<span class="comment">;; Here is Japanese translation of `<span class="constant important">anything-sources</span>' attributes.  Thanks.</span>
+<span class="comment">;; http<span class="builtin">://d</span>.hatena.ne.jp/sirocco634/20091012/1255336649</span>
 
  
-;;; Bug Report:
-;;
-;; If you have problems, send a bug report via C-c C-x C-b in anything session (best)
-;; or M-x anything-send-bug-report outside anything session.
-;; I implemented bug report feature because I want to know your current state.
-;; It helps me to solve problems easily.
-;; The step is:
-;;  0) Setup mail in Emacs, the easiest way is:
-;;       (setq user-mail-address "your@mail.address")
-;;       (setq user-full-name "Your Full Name")
-;;       (setq smtpmail-smtp-server "your.smtp.server.jp")
-;;       (setq mail-user-agent 'message-user-agent)
-;;       (setq message-send-mail-function 'message-smtpmail-send-it)
-;;  1) Be sure to use the LATEST version of anything.el.
-;;  2) Enable debugger. M-x toggle-debug-on-error or (setq debug-on-error t)
-;;  3) Use Lisp version instead of compiled one: (load "anything.el")
-;;  4) Do it!
-;;  5) If you got an error, please do not close *Backtrace* buffer.
-;;  6) Type C-c C-x C-b (anything session, best!)
-;;     or M-x anything-send-bug-report (outside)
-;;     then M-x insert-buffer *Backtrace* (if you got error)
-;;  7) Describe the bug using a precise recipe.
-;;  8) Type C-c C-c to send.
-;;
-;;  You can also just report bug to:
-;;  https://groups.google.com/group/emacs-anything?hl=en
+<span class="comment">;;; Bug Report<span class="builtin">:</span></span>
+<span class="comment">;;</span>
+<span class="comment">;; If you have problems, send a bug report via C-c C-x C-b in anything session (best)</span>
+<span class="comment">;; or M-x anything-send-bug-report outside anything session.</span>
+<span class="comment">;; I implemented bug report feature because I want to know your current state.</span>
+<span class="comment">;; It helps me to solve problems easily.</span>
+<span class="comment">;; The step is<span class="builtin">:</span></span>
+<span class="comment">;;  0) Setup mail in Emacs, the easiest way is<span class="builtin">:</span></span>
+<span class="comment">;;       (setq user-mail-address <span class="string">"your@mail.address"</span>)</span>
+<span class="comment">;;       (setq user-full-name <span class="string">"Your Full Name"</span>)</span>
+<span class="comment">;;       (setq smtpmail-smtp-server <span class="string">"your.smtp.server.jp"</span>)</span>
+<span class="comment">;;       (setq mail-user-agent 'message-user-agent)</span>
+<span class="comment">;;       (setq message-send-mail-function 'message-smtpmail-send-it)</span>
+<span class="comment">;;  1) Be sure to use the LATEST version of anything.el.</span>
+<span class="comment">;;  2) Enable debugger. M-x toggle-debug-on-error or (setq debug-on-error t)</span>
+<span class="comment">;;  3) Use Lisp version instead of compiled one: (load <span class="string">"anything.el"</span>)</span>
+<span class="comment">;;  4) Do it!</span>
+<span class="comment">;;  5) If you got an error, please do not close *Backtrace* buffer.</span>
+<span class="comment">;;  6) Type C-c C-x C-b (anything session, best!)</span>
+<span class="comment">;;     or M-x anything-send-bug-report (outside)</span>
+<span class="comment">;;     then M-x insert-buffer *Backtrace* (<span class="keyword elisp">if</span> you got error)</span>
+<span class="comment">;;  7) Describe the bug using a precise recipe.</span>
+<span class="comment">;;  8) Type C-c C-c to send.</span>
+<span class="comment">;;</span>
+<span class="comment">;;  You can also just report bug to<span class="builtin">:</span></span>
+<span class="comment">;;  https<span class="builtin">://groups</span>.google.com/group/emacs-anything?hl=en</span>
 
  
-;; You can extend `anything' by writing plug-ins. As soon as
-;; `anything' is invoked, `anything-sources' is compiled into basic
-;; attributes, then compiled one is used during invocation.
-;;
-;; The oldest built-in plug-in is `type' attribute: appends
-;; appropriate element of `anything-type-attributes'. Second built-in
-;; plug-in is `candidates-in-buffer': selecting a line from candidates
-;; buffer.
-;;
-;; To write a plug-in:
-;; 1. Define a compiler: anything-compile-source--*
-;; 2. Add compier function to `anything-compile-source-functions'.
-;; 3. (optional) Write helper functions.
-;
-;; Tested on Emacs 22/23/24.
-;;
-;;
-;; Thanks to Vagn Johansen for ideas.
-;; Thanks to Stefan Kamphausen for fixes and XEmacs support.
-;; Thanks to Tassilo Horn for fixes.
-;; Thanks to Drew Adams for various fixes
-;; Thanks to IMAKADO for candidates-in-buffer idea.
-;; Thanks to Tomohiro MATSUYAMA for multiline patch.
-;;
-
-;;; (@* "Index")
-
-;;  If you have library `linkd.el', load
-;;  `linkd.el' and turn on `linkd-mode' now.  It lets you easily
-;;  navigate around the sections  Linkd mode will
-;;  highlight this Index.  You can get `linkd.el' here:
-;;  http://www.emacswiki.org/cgi-bin/wiki/download/linkd.el
-;;
-
-
-;;; (@* "Tips")
-
-;;
-;; `anything' accepts keyword arguments. See docstring.
-;; [EVAL IT] (describe-function 'anything)
-
-;;
-;; `anything-enable-shortcuts' enables us to select candidate easily.
-;; If 'prefix then they can be selected using <prefix-key> <alnum>.
-;; The prefix key is `anything-select-with-prefix-shortcut'.
-;; If the <prefix-key> is a letter, pressing twice inputs the letter itself.
-;; e.g.
-;;  (setq anything-enable-shortcuts 'prefix)
-;;  (define-key anything-map \"@\" 'anything-select-with-prefix-shortcut)
-
-;;
-;; You can edit current selection using `anything-edit-current-selection'.
-;; It is useful after persistent-action.
-
-;;
-;; For `anything' users, setting `anything-sources' directly and
-;; invoke M-x anything is obsolete way for now. Try M-x
-;; `anything-migrate-sources'!
-
-;;
-;; If you want to create anything sources, yasnippet would help you.
-;; http://yasnippet.googlecode.com/
-;;
-;; Then get the snippet from
-;; http://www.emacswiki.org/cgi-bin/wiki/download/anything-source.yasnippet
-;;
-;; Put it in ~/.emacs.d/plugins/yasnippet/snippets/text-mode/emacs-lisp-mode/
-
-
-;;
-;; `anything-interpret-value' is useful function to interpret value
-;; like `candidates' attribute.
-;;
-;; (anything-interpret-value "literal")            ; => "literal"
-;; (anything-interpret-value (lambda () "lambda")) ; => "lambda"
-;; (let ((source '((name . "lambda with source name"))))
-;;   (anything-interpret-value
-;;    (lambda () anything-source-name)
-;;    source))                             ; => "lambda with source name"
-;; (flet ((f () "function symbol"))
-;;   (anything-interpret-value 'f))        ; => "function symbol"
-;; (let ((v "variable symbol"))
-;;   (anything-interpret-value 'v))        ; => "variable symbol"
-;; (anything-interpret-value 'unbounded-1) ; error
-
-;;
-;; Now symbols are acceptable as candidates. So you do not have to use
-;; `symbol-name' function. The source is much simpler. For example,
-;; `apropos-internal' returns a list of symbols.
-;;
-;;   (anything
-;;    '(((name . "Commands")
-;;       (candidates . (lambda () (apropos-internal anything-pattern 'commandp)))
-;;       (volatile)
-;;       (action . describe-function))))
-
-;;
-;; To mark a candidate, press C-SPC as normal Emacs marking. To go to
-;; marked candidate, press M-[ or M-].
-
-;;
-;; `anything-map' is now Emacs-standard key bindings by default.
-;;
-;; There are many `anything' applications, using `anything' for
-;; selecting candidate. In this case, if there is one candidate or no
-;; candidate, popping up *anything* buffer is irritating. If one
-;; candidate, you want to select it at once. If no candidate, you want
-;; to quit `anything'. Set `anything-execute-action-at-once-if-one'
-;; and `anything-quit-if-no-candidate' to non-nil to remedy it. Note
-;; that setting these variables GLOBALLY is bad idea because of
-;; delayed sources. These are meant to be let-binded.
-;;
-;; ex.
-;; (let ((anything-execute-action-at-once-if-one t)
-;;       (anything-quit-if-no-candidate (lambda () (message "No candidate"))))
-;;    (anything temporary-sources input))
-
-;;
-;; `set-frame-configuration' arises flickering. If you hate
-;; flickering, eval:
-;; (setq anything-save-configuration-functions
-;;    '(set-window-configuration . current-window-configuration))
-;; at the cost of restoring frame configuration (only window configuration).
-
-;;
-;; `anything-delete-current-selection' deletes the current line.
-;; It is useful when deleting a candidate in persistent action.
-;; eg. `kill-buffer'.
-;;
-;; [EVAL IT] (describe-function 'anything-delete-current-selection)
-
-;;
-;; `anything-attr' gets the attribute. `anything-attrset' sets the
-;; attribute. `anything-attr-defined' tests whether the attribute is
-;; defined. They handles source-local variables.
-;;
-;; [EVAL IT] (describe-function 'anything-attr)
-;; [EVAL IT] (describe-function 'anything-attrset)
-;; [EVAL IT] (describe-function 'anything-attr-defined)
-
-;;
-;; `anything-sources' accepts many attributes to make your life easier.
-;; Now `anything-sources' accepts a list of symbols.
-;;
-;; [EVAL IT] (describe-variable 'anything-sources)
-
-;;
-;; `anything' has optional arguments. Now you do not have to let-bind
-;; `anything-sources'.
-;;
-;; [EVAL IT] (describe-function 'anything)
-
-;;
-;; `anything-resume' resumes last `anything' session. Now you do not
-;; have to retype pattern.
-;;
-;; [EVAL IT] (describe-function 'anything-resume)
-
-;;
-;; `anything-execute-persistent-action' executes action without
-;; quitting `anything'. When popping up a buffer in other window by
-;; persistent action, you can scroll with `anything-scroll-other-window' and
-;; `anything-scroll-other-window-down'. See also `anything-sources' docstring.
-;;
-;; [EVAL IT] (describe-function 'anything-execute-persistent-action)
-;; [EVAL IT] (describe-variable 'anything-sources)
-
-;;
-;; `anything-select-2nd-action', `anything-select-3rd-action' and
-;; `anything-select-4th-action' select other than default action
-;; without pressing Tab.
-
-;;
-;; Using `anything-candidate-buffer' and the candidates-in-buffer
-;; attribute is much faster than traditional "candidates and match"
-;; way. And `anything-current-buffer-is-modified' avoids to
-;; recalculate candidates for unmodified buffer. See docstring of
-;; them.
-;;
-;; [EVAL IT] (describe-function 'anything-candidate-buffer)
-;; [EVAL IT] (describe-function 'anything-candidates-in-buffer)
-;; [EVAL IT] (describe-function 'anything-current-buffer-is-modified)
-
-;;
-;; `anything-current-buffer' and `anything-buffer-file-name' stores
-;; `(current-buffer)' and `buffer-file-name' in the buffer `anything'
-;; is invoked. Use them freely.
-;;
-;; [EVAL IT] (describe-variable 'anything-current-buffer)
-;; [EVAL IT] (describe-variable 'anything-buffer-file-name)
-
-;;
-;; `anything-completing-read' and `anything-read-file-name' are
-;; experimental implementation. If you are curious, type M-x
-;; anything-read-string-mode. It is a minor mode and toggles on/off.
-
-;;
-;; Use `anything-test-candidates' to test your handmade anything
-;; sources. It simulates contents of *anything* buffer with pseudo
-;; `anything-sources' and `anything-pattern', without side-effect. So
-;; you can unit-test your anything sources! Let's TDD!
-;;
-;; [EVAL IT] (describe-function 'anything-test-candidates)
-;;
-;; For anything developpers:
-;;
-;; There are many unit-testing framework in Emacs Lisp. See the EmacsWiki.
-;; http://www.emacswiki.org/cgi-bin/emacs/UnitTesting
-;; There is an unit-test by Emacs Lisp Expectations in developper-tools directory.
-;; http://www.emacswiki.org/cgi-bin/wiki/download/el-expectations.el
-;; http://www.emacswiki.org/cgi-bin/wiki/download/el-mock.el
-
-;;
-;; If you want to create anything sources, see anything-config.el.
-;; It is huge collection of sources. You can learn from examples.
-
-
-;; (@* "TODO")
-;;
-;;   - process status indication
-;;
-;;   - async sources doesn't honor digit-shortcut-count
-;;
-;;   - anything-candidate-number-limit can't be nil everywhere
-
-;; (@* "HISTORY")
-;;
-;;  Change log of this file is found at
-;;  http://repo.or.cz/w/anything-config.git/history/master:/anything.el
-;;
-;;  Change log of this project is found at
-;;  http://repo.or.cz/w/anything-config.git?a=shortlog
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+<span class="comment">;; You can extend `<span class="constant important">anything</span>' by writing plug-ins. As soon as</span>
+<span class="comment">;; `<span class="constant important">anything</span>' is invoked, `<span class="constant important">anything-sources</span>' is compiled into basic</span>
+<span class="comment">;; attributes, then compiled one is used during invocation.</span>
+<span class="comment">;;</span>
+<span class="comment">;; The oldest built-in plug-in is `<span class="constant important">type</span>' attribute: appends</span>
+<span class="comment">;; appropriate element of `<span class="constant important">anything-type-attributes</span>'. Second built-in</span>
+<span class="comment">;; plug-in is `<span class="constant important">candidates-in-buffer</span>': selecting a line from candidates</span>
+<span class="comment">;; buffer.</span>
+<span class="comment">;;</span>
+<span class="comment">;; To write a plug-in<span class="builtin">:</span></span>
+<span class="comment">;; 1. Define a compiler: anything-compile-source--*</span>
+<span class="comment">;; 2. Add compier function to `<span class="constant important">anything-compile-source-functions</span>'.</span>
+<span class="comment">;; 3. (optional) Write helper functions.</span>
+<span class="comment">;</span>
+<span class="comment">;; Tested on Emacs 22/23/24.</span>
+<span class="comment">;;</span>
+<span class="comment">;;</span>
+<span class="comment">;; Thanks to Vagn Johansen for ideas.</span>
+<span class="comment">;; Thanks to Stefan Kamphausen for fixes and XEmacs support.</span>
+<span class="comment">;; Thanks to Tassilo Horn for fixes.</span>
+<span class="comment">;; Thanks to Drew Adams for various fixes</span>
+<span class="comment">;; Thanks to IMAKADO for candidates-in-buffer idea.</span>
+<span class="comment">;; Thanks to Tomohiro MATSUYAMA for multiline patch.</span>
+<span class="comment">;;</span>
+
+<span class="comment">;;; (@* <span class="string">"Index"</span>)</span>
+
+<span class="comment">;;  If you have library `linkd.el', load</span>
+<span class="comment">;;  `linkd.el' and turn on `<span class="constant important">linkd-mode</span>' now.  It lets you easily</span>
+<span class="comment">;;  navigate around the sections  Linkd mode will</span>
+<span class="comment">;;  highlight this Index.  You can get `linkd.el' here<span class="builtin">:</span></span>
+<span class="comment">;;  http<span class="builtin">://www</span>.emacswiki.org/cgi-bin/wiki/download/linkd.el</span>
+<span class="comment">;;</span>
+
+
+<span class="comment">;;; (@* <span class="string">"Tips"</span>)</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; `<span class="constant important">anything</span>' accepts keyword arguments. See docstring.</span>
+<span class="comment">;; [EVAL IT] (describe-function 'anything)</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; `<span class="constant important">anything-enable-shortcuts</span>' enables us to select candidate easily.</span>
+<span class="comment">;; If 'prefix then they can be selected using &lt;prefix-key&gt; &lt;alnum&gt;.</span>
+<span class="comment">;; The prefix key is `<span class="constant important">anything-select-with-prefix-shortcut</span>'.</span>
+<span class="comment">;; If the &lt;prefix-key&gt; is a letter, pressing twice inputs the letter itself.</span>
+<span class="comment">;; e.g.</span>
+<span class="comment">;;  (setq anything-enable-shortcuts 'prefix)</span>
+<span class="comment">;;  (define-key anything-map \"@\" 'anything-select-with-prefix-shortcut)</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; You can edit current selection using `<span class="constant important">anything-edit-current-selection</span>'.</span>
+<span class="comment">;; It is useful after persistent-action.</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; For `<span class="constant important">anything</span>' users, setting `<span class="constant important">anything-sources</span>' directly and</span>
+<span class="comment">;; invoke M-x anything is obsolete way for now. Try M-x</span>
+<span class="comment">;; `<span class="constant important">anything-migrate-sources</span>'!</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; If you want to create anything sources, yasnippet would help you.</span>
+<span class="comment">;; http<span class="builtin">://yasnippet</span>.googlecode.com/</span>
+<span class="comment">;;</span>
+<span class="comment">;; Then get the snippet from</span>
+<span class="comment">;; http<span class="builtin">://www</span>.emacswiki.org/cgi-bin/wiki/download/anything-source.yasnippet</span>
+<span class="comment">;;</span>
+<span class="comment">;; Put it in ~/.emacs.d/plugins/yasnippet/snippets/text-mode/emacs-lisp-mode/</span>
+
+
+<span class="comment">;;</span>
+<span class="comment">;; `<span class="constant important">anything-interpret-value</span>' is useful function to interpret value</span>
+<span class="comment">;; like `<span class="constant important">candidates</span>' attribute.</span>
+<span class="comment">;;</span>
+<span class="comment">;; (anything-interpret-value <span class="string">"literal"</span>)            ; =&gt; <span class="string">"literal"</span></span>
+<span class="comment">;; (anything-interpret-value (<span class="keyword elisp">lambda</span> () <span class="string">"lambda"</span>)) ; =&gt; <span class="string">"lambda"</span></span>
+<span class="comment">;; (<span class="keyword elisp">let</span> ((source '((name . <span class="string">"lambda with source name"</span>))))</span>
+<span class="comment">;;   (anything-interpret-value</span>
+<span class="comment">;;    (<span class="keyword elisp">lambda</span> () anything-source-name)</span>
+<span class="comment">;;    source))                             ; =&gt; <span class="string">"lambda with source name"</span></span>
+<span class="comment">;; (<span class="keyword cl">flet</span> ((f () <span class="string">"function symbol"</span>))</span>
+<span class="comment">;;   (anything-interpret-value 'f))        ; =&gt; <span class="string">"function symbol"</span></span>
+<span class="comment">;; (<span class="keyword elisp">let</span> ((v <span class="string">"variable symbol"</span>))</span>
+<span class="comment">;;   (anything-interpret-value 'v))        ; =&gt; <span class="string">"variable symbol"</span></span>
+<span class="comment">;; (anything-interpret-value 'unbounded-1) ; error</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; Now symbols are acceptable as candidates. So you do not have to use</span>
+<span class="comment">;; `<span class="constant important">symbol-name</span>' function. The source is much simpler. For example,</span>
+<span class="comment">;; `<span class="constant important">apropos-internal</span>' returns a list of symbols.</span>
+<span class="comment">;;</span>
+<span class="comment">;;   (anything</span>
+<span class="comment">;;    '(((name . <span class="string">"Commands"</span>)</span>
+<span class="comment">;;       (candidates . (<span class="keyword elisp">lambda</span> () (apropos-internal anything-pattern 'commandp)))</span>
+<span class="comment">;;       (volatile)</span>
+<span class="comment">;;       (action . describe-function))))</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; To mark a candidate, press C-SPC as normal Emacs marking. To go to</span>
+<span class="comment">;; marked candidate, press M-[ or M-].</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; `<span class="constant important">anything-map</span>' is now Emacs-standard key bindings by default.</span>
+<span class="comment">;;</span>
+<span class="comment">;; There are many `<span class="constant important">anything</span>' applications, using `<span class="constant important">anything</span>' for</span>
+<span class="comment">;; selecting candidate. In this case, if there is one candidate or no</span>
+<span class="comment">;; candidate, popping up *anything* buffer is irritating. If one</span>
+<span class="comment">;; candidate, you want to select it at once. If no candidate, you want</span>
+<span class="comment">;; to quit `<span class="constant important">anything</span>'. Set `<span class="constant important">anything-execute-action-at-once-if-one</span>'</span>
+<span class="comment">;; and `<span class="constant important">anything-quit-if-no-candidate</span>' to non-nil to remedy it. Note</span>
+<span class="comment">;; that setting these variables GLOBALLY is bad idea because of</span>
+<span class="comment">;; delayed sources. These are meant to be let-binded.</span>
+<span class="comment">;;</span>
+<span class="comment">;; ex.</span>
+<span class="comment">;; (<span class="keyword elisp">let</span> ((anything-execute-action-at-once-if-one t)</span>
+<span class="comment">;;       (anything-quit-if-no-candidate (<span class="keyword elisp">lambda</span> () (message <span class="string">"No candidate"</span>))))</span>
+<span class="comment">;;    (anything temporary-sources input))</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; `<span class="constant important">set-frame-configuration</span>' arises flickering. If you hate</span>
+<span class="comment">;; flickering, eval<span class="builtin">:</span></span>
+<span class="comment">;; (setq anything-save-configuration-functions</span>
+<span class="comment">;;    '(set-window-configuration . current-window-configuration))</span>
+<span class="comment">;; at the cost of restoring frame configuration (only window configuration).</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; `<span class="constant important">anything-delete-current-selection</span>' deletes the current line.</span>
+<span class="comment">;; It is useful when deleting a candidate in persistent action.</span>
+<span class="comment">;; eg. `<span class="constant important">kill-buffer</span>'.</span>
+<span class="comment">;;</span>
+<span class="comment">;; [EVAL IT] (describe-function 'anything-delete-current-selection)</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; `<span class="constant important">anything-attr</span>' gets the attribute. `<span class="constant important">anything-attrset</span>' sets the</span>
+<span class="comment">;; attribute. `<span class="constant important">anything-attr-defined</span>' tests whether the attribute is</span>
+<span class="comment">;; defined. They handles source-local variables.</span>
+<span class="comment">;;</span>
+<span class="comment">;; [EVAL IT] (describe-function 'anything-attr)</span>
+<span class="comment">;; [EVAL IT] (describe-function 'anything-attrset)</span>
+<span class="comment">;; [EVAL IT] (describe-function 'anything-attr-defined)</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; `<span class="constant important">anything-sources</span>' accepts many attributes to make your life easier.</span>
+<span class="comment">;; Now `<span class="constant important">anything-sources</span>' accepts a list of symbols.</span>
+<span class="comment">;;</span>
+<span class="comment">;; [EVAL IT] (describe-variable 'anything-sources)</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; `<span class="constant important">anything</span>' has optional arguments. Now you do not have to let-bind</span>
+<span class="comment">;; `<span class="constant important">anything-sources</span>'.</span>
+<span class="comment">;;</span>
+<span class="comment">;; [EVAL IT] (describe-function 'anything)</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; `<span class="constant important">anything-resume</span>' resumes last `<span class="constant important">anything</span>' session. Now you do not</span>
+<span class="comment">;; have to retype pattern.</span>
+<span class="comment">;;</span>
+<span class="comment">;; [EVAL IT] (describe-function 'anything-resume)</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; `<span class="constant important">anything-execute-persistent-action</span>' executes action without</span>
+<span class="comment">;; quitting `<span class="constant important">anything</span>'. When popping up a buffer in other window by</span>
+<span class="comment">;; persistent action, you can scroll with `<span class="constant important">anything-scroll-other-window</span>' and</span>
+<span class="comment">;; `<span class="constant important">anything-scroll-other-window-down</span>'. See also `<span class="constant important">anything-sources</span>' docstring.</span>
+<span class="comment">;;</span>
+<span class="comment">;; [EVAL IT] (describe-function 'anything-execute-persistent-action)</span>
+<span class="comment">;; [EVAL IT] (describe-variable 'anything-sources)</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; `anything-select-2nd-action', `anything-select-3rd-action' and</span>
+<span class="comment">;; `anything-select-4th-action' select other than default action</span>
+<span class="comment">;; without pressing Tab.</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; Using `<span class="constant important">anything-candidate-buffer</span>' and the candidates-in-buffer</span>
+<span class="comment">;; attribute is much faster than traditional <span class="string">"candidates and match"</span></span>
+<span class="comment">;; way. And `<span class="constant important">anything-current-buffer-is-modified</span>' avoids to</span>
+<span class="comment">;; recalculate candidates for unmodified buffer. See docstring of</span>
+<span class="comment">;; them.</span>
+<span class="comment">;;</span>
+<span class="comment">;; [EVAL IT] (describe-function 'anything-candidate-buffer)</span>
+<span class="comment">;; [EVAL IT] (describe-function 'anything-candidates-in-buffer)</span>
+<span class="comment">;; [EVAL IT] (describe-function 'anything-current-buffer-is-modified)</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; `<span class="constant important">anything-current-buffer</span>' and `<span class="constant important">anything-buffer-file-name</span>' stores</span>
+<span class="comment">;; `(current-buffer)' and `<span class="constant important">buffer-file-name</span>' in the buffer `<span class="constant important">anything</span>'</span>
+<span class="comment">;; is invoked. Use them freely.</span>
+<span class="comment">;;</span>
+<span class="comment">;; [EVAL IT] (describe-variable 'anything-current-buffer)</span>
+<span class="comment">;; [EVAL IT] (describe-variable 'anything-buffer-file-name)</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; `<span class="constant important">anything-completing-read</span>' and `<span class="constant important">anything-read-file-name</span>' are</span>
+<span class="comment">;; experimental implementation. If you are curious, type M-x</span>
+<span class="comment">;; anything-read-string-mode. It is a minor mode and toggles on/off.</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; Use `<span class="constant important">anything-test-candidates</span>' to test your handmade anything</span>
+<span class="comment">;; sources. It simulates contents of *anything* buffer with pseudo</span>
+<span class="comment">;; `<span class="constant important">anything-sources</span>' and `<span class="constant important">anything-pattern</span>', without side-effect. So</span>
+<span class="comment">;; you can unit-test your anything sources! Let's TDD!</span>
+<span class="comment">;;</span>
+<span class="comment">;; [EVAL IT] (describe-function 'anything-test-candidates)</span>
+<span class="comment">;;</span>
+<span class="comment">;; For anything developpers<span class="builtin">:</span></span>
+<span class="comment">;;</span>
+<span class="comment">;; There are many unit-testing framework in Emacs Lisp. See the EmacsWiki.</span>
+<span class="comment">;; http<span class="builtin">://www</span>.emacswiki.org/cgi-bin/emacs/UnitTesting</span>
+<span class="comment">;; There is an unit-test by Emacs Lisp Expectations in developper-tools directory.</span>
+<span class="comment">;; http<span class="builtin">://www</span>.emacswiki.org/cgi-bin/wiki/download/el-expectations.el</span>
+<span class="comment">;; http<span class="builtin">://www</span>.emacswiki.org/cgi-bin/wiki/download/el-mock.el</span>
+
+<span class="comment">;;</span>
+<span class="comment">;; If you want to create anything sources, see anything-config.el.</span>
+<span class="comment">;; It is huge collection of sources. You can learn from examples.</span>
+
+
+<span class="comment">;; (@* <span class="string">"TODO"</span>)</span>
+<span class="comment">;;</span>
+<span class="comment">;;   - process status indication</span>
+<span class="comment">;;</span>
+<span class="comment">;;   - async sources doesn't honor digit-shortcut-count</span>
+<span class="comment">;;</span>
+<span class="comment">;;   - anything-candidate-number-limit can't be nil everywhere</span>
+
+<span class="comment">;; (@* <span class="string">"HISTORY"</span>)</span>
+<span class="comment">;;</span>
+<span class="comment">;;  Change log of this file is found at</span>
+<span class="comment">;;  http<span class="builtin">://repo</span>.or.cz/w/anything-config.git/history/master<span class="builtin">:/anything</span>.el</span>
+<span class="comment">;;</span>
+<span class="comment">;;  Change log of this project is found at</span>
+<span class="comment">;;  http<span class="builtin">://repo</span>.or.cz/w/anything-config.git?a=shortlog</span>
+<span class="comment">;;</span>
+<span class="comment">;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;</span>
 
  
-;;; Code:
+<span class="comment">;;; Code<span class="builtin">:</span></span>
 
-(require 'cl)
+(<span class="keyword">require</span> '<span class="constant">cl</span>)
 
-(defvar anything-version "1.3.9")
+(<span class="keyword">defvar</span> <span class="variable">anything-version</span> <span class="string">"1.3.9"</span>)
 
-;; (@* "User Configuration")
+<span class="comment">;; (@* <span class="string">"User Configuration"</span>)</span>
 
  
-;;; Variables
-;;
-;;
-;; [DEPRECATED]
-;; A default value is provided in anything-config.el
-(defvar anything-sources nil
-  "A list of sources to use with `anything'.
+<span class="comment">;;; Variables</span>
+<span class="comment">;;</span>
+<span class="comment">;;</span>
+<span class="comment">;; [DEPRECATED]</span>
+<span class="comment">;; A default value is provided in anything-config.el</span>
+(<span class="keyword">defvar</span> <span class="variable">anything-sources</span> nil
+  <span class="string">"A list of sources to use with `<span class="constant important">anything</span>'.
 It is deprecated, you should not use this.
-Use instead individual sources or list of sources of your choice.")
+Use instead individual sources or list of sources of your choice."</span>)
 
-;; Default values are provided in anything-config.el.
-(defvar anything-type-attributes nil
-  "It's a list of \(TYPE ATTRIBUTES ...\).
-ATTRIBUTES are the same as attributes for `anything-sources'.
+<span class="comment">;; Default values are provided in anything-config.el.</span>
+(<span class="keyword">defvar</span> <span class="variable">anything-type-attributes</span> nil
+  <span class="string">"It's a list of \(TYPE ATTRIBUTES ...\).
+ATTRIBUTES are the same as attributes for `<span class="constant important">anything-sources</span>'.
 TYPE connects the value to the appropriate sources.
-Don't set this directly, use instead `define-anything-type-attribute'.
+Don't set this directly, use instead `<span class="constant important">define-anything-type-attribute</span>'.
 
 This allows specifying common attributes for several sources.
 For example, sources which provide files can specify
-common attributes with a `file' type.")
+common attributes with a `<span class="constant important">file</span>' type."</span>)
 
-(defvaralias 'anything-enable-digit-shortcuts 'anything-enable-shortcuts
-  "Same as `anything-enable-shortcuts'.
-Alphabet shortcuts are available now in `anything-enable-shortcuts'.
-`anything-enable-digit-shortcuts' is retained for compatibility.")
+(<span class="keyword">defvaralias</span> '<span class="variable">anything-enable-digit-shortcuts</span> 'anything-enable-shortcuts
+  <span class="string">"Same as `<span class="constant important">anything-enable-shortcuts</span>'.
+Alphabet shortcuts are available now in `<span class="constant important">anything-enable-shortcuts</span>'.
+`<span class="constant important">anything-enable-digit-shortcuts</span>' is retained for compatibility."</span>)
 
-(defvar anything-enable-shortcuts nil
-  "*Whether to use digit/alphabet shortcut to select the first nine matches.
-If t then they can be selected using Ctrl+<number>.
+(<span class="keyword">defvar</span> <span class="variable">anything-enable-shortcuts</span> nil
+  <span class="string">"*Whether to use digit/alphabet shortcut to select the first nine matches.
+If t then they can be selected using Ctrl+&lt;number&gt;.
 
-If 'prefix then they can be selected using <prefix-key> <alnum>.
-The prefix key is `anything-select-with-prefix-shortcut'.
-If the <prefix-key> is a letter, pressing twice inputs the letter itself.
+If 'prefix then they can be selected using &lt;prefix-key&gt; &lt;alnum&gt;.
+The prefix key is `<span class="constant important">anything-select-with-prefix-shortcut</span>'.
+If the &lt;prefix-key&gt; is a letter, pressing twice inputs the letter itself.
 e.g.
  (setq anything-enable-shortcuts 'prefix)
  (define-key anything-map \"@\" 'anything-select-with-prefix-shortcut)
 
-If 'alphabet then they can be selected using Shift+<alphabet> (deprecated).
+If 'alphabet then they can be selected using Shift+&lt;alphabet&gt; (deprecated).
 It is not recommended because you cannot input capital letters in pattern.
 
-Keys (digit/alphabet) are listed in `anything-shortcut-keys-alist'.")
+Keys (digit/alphabet) are listed in `<span class="constant important">anything-shortcut-keys-alist</span>'."</span>)
 
-(defvar anything-shortcut-keys-alist
-  '((alphabet . "asdfghjklzxcvbnmqwertyuiop")
-    (prefix   . "asdfghjklzxcvbnmqwertyuiop1234567890")
-    (t        . "123456789")))
+(<span class="keyword">defvar</span> <span class="variable">anything-shortcut-keys-alist</span>
+  '((alphabet . <span class="string">"asdfghjklzxcvbnmqwertyuiop"</span>)
+    (prefix   . <span class="string">"asdfghjklzxcvbnmqwertyuiop1234567890"</span>)
+    (t        . <span class="string">"123456789"</span>)))
 
-(defvar anything-display-source-at-screen-top t
-  "*Display candidates at the top of screen.
-This happen when using `anything-next-source' and `anything-previous-source'.")
+(<span class="keyword">defvar</span> <span class="variable">anything-display-source-at-screen-top</span> t
+  <span class="string">"*Display candidates at the top of screen.
+This happen when using `<span class="constant important">anything-next-source</span>' and `<span class="constant important">anything-previous-source</span>'."</span>)
 
-(defvar anything-candidate-number-limit 50
-  "*Limit candidate number globally.
+(<span class="keyword">defvar</span> <span class="variable">anything-candidate-number-limit</span> 50
+  <span class="string">"*Limit candidate number globally.
 Do not show more candidates than this limit from individual sources.
 It is usually pointless to show hundreds of matches
 when the pattern is empty, because it is much simpler to type a
 few characters to narrow down the list of potential candidates.
 
-Set it to nil if you don't want this limit.")
+Set it to nil if you don't want this limit."</span>)
 
-(defvar anything-idle-delay 0.3
-  "*Be idle for this many seconds, before updating in delayed sources.
+(<span class="keyword">defvar</span> <span class="variable">anything-idle-delay</span> 0.3
+  <span class="string">"*Be idle for this many seconds, before updating in delayed sources.
 This is useful for sources involving heavy operations
 \(like launching external programs\), so that candidates
 from the source are not retrieved unnecessarily if the user keeps typing.
 
 It also can be used to declutter the results anything displays,
 so that results from certain sources are not shown with every
-character typed, only if the user hesitates a bit.")
+character typed, only if the user hesitates a bit."</span>)
 
-(defvar anything-input-idle-delay 0.3
-  "Be idle for this many seconds, before updating.
+(<span class="keyword">defvar</span> <span class="variable">anything-input-idle-delay</span> 0.3
+  <span class="string">"Be idle for this many seconds, before updating.
 
-Unlike `anything-idle-delay', it is also effective for non-delayed sources.
+Unlike `<span class="constant important">anything-idle-delay</span>', it is also effective for non-delayed sources.
 If nil, candidates are collected immediately.
 
-Note:  If this value is too low compared to `anything-idle-delay',
+Note:  If this value is too low compared to `<span class="constant important">anything-idle-delay</span>',
 you may have duplicated sources when using multiples sources.
-Safe value is always >= `anything-idle-delay'.
-Default settings are equal value for both.")
+Safe value is always &gt;= `<span class="constant important">anything-idle-delay</span>'.
+Default settings are equal value for both."</span>)
 
-(defvar anything-samewindow nil
-  "Use current window to show the candidates.
-If t then Anything doesn't pop up a new window.")
+(<span class="keyword">defvar</span> <span class="variable">anything-samewindow</span> nil
+  <span class="string">"Use current window to show the candidates.
+If t then Anything doesn't pop up a new window."</span>)
 
-(defvar anything-source-filter nil
-  "A list of source names to be displayed.
+(<span class="keyword">defvar</span> <span class="variable">anything-source-filter</span> nil
+  <span class="string">"A list of source names to be displayed.
 Other sources won't appear in the search results.
 If nil then there is no filtering.
-See also `anything-set-source-filter'.")
+See also `<span class="constant important">anything-set-source-filter</span>'."</span>)
 
  
-(defvar anything-map
-  (let ((map (copy-keymap minibuffer-local-map)))
-    (define-key map (kbd "<down>")          'anything-next-line)
-    (define-key map (kbd "<up>")            'anything-previous-line)
-    (define-key map (kbd "C-n")             'anything-next-line)
-    (define-key map (kbd "C-p")             'anything-previous-line)
-    (define-key map (kbd "<prior>")         'anything-previous-page)
-    (define-key map (kbd "<next>")          'anything-next-page)
-    (define-key map (kbd "M-v")             'anything-previous-page)
-    (define-key map (kbd "C-v")             'anything-next-page)
-    (define-key map (kbd "M-<")             'anything-beginning-of-buffer)
-    (define-key map (kbd "M->")             'anything-end-of-buffer)
-    (define-key map (kbd "C-g")             'anything-keyboard-quit)
-    (define-key map (kbd "<right>")         'anything-next-source)
-    (define-key map (kbd "<left>")          'anything-previous-source)
-    (define-key map (kbd "<RET>")           'anything-exit-minibuffer)
-    (define-key map (kbd "C-1")             'anything-select-with-digit-shortcut)
-    (define-key map (kbd "C-2")             'anything-select-with-digit-shortcut)
-    (define-key map (kbd "C-3")             'anything-select-with-digit-shortcut)
-    (define-key map (kbd "C-4")             'anything-select-with-digit-shortcut)
-    (define-key map (kbd "C-5")             'anything-select-with-digit-shortcut)
-    (define-key map (kbd "C-6")             'anything-select-with-digit-shortcut)
-    (define-key map (kbd "C-7")             'anything-select-with-digit-shortcut)
-    (define-key map (kbd "C-8")             'anything-select-with-digit-shortcut)
-    (define-key map (kbd "C-9")             'anything-select-with-digit-shortcut)
-    (loop for c from ?A to ?Z do
+(<span class="keyword">defvar</span> <span class="variable">anything-map</span>
+  (<span class="keyword elisp">let</span> ((map (copy-keymap minibuffer-local-map)))
+    (define-key map (kbd <span class="string">"&lt;down&gt;"</span>)          'anything-next-line)
+    (define-key map (kbd <span class="string">"&lt;up&gt;"</span>)            'anything-previous-line)
+    (define-key map (kbd <span class="string">"C-n"</span>)             'anything-next-line)
+    (define-key map (kbd <span class="string">"C-p"</span>)             'anything-previous-line)
+    (define-key map (kbd <span class="string">"&lt;prior&gt;"</span>)         'anything-previous-page)
+    (define-key map (kbd <span class="string">"&lt;next&gt;"</span>)          'anything-next-page)
+    (define-key map (kbd <span class="string">"M-v"</span>)             'anything-previous-page)
+    (define-key map (kbd <span class="string">"C-v"</span>)             'anything-next-page)
+    (define-key map (kbd <span class="string">"M-&lt;"</span>)             'anything-beginning-of-buffer)
+    (define-key map (kbd <span class="string">"M-&gt;"</span>)             'anything-end-of-buffer)
+    (define-key map (kbd <span class="string">"C-g"</span>)             'anything-keyboard-quit)
+    (define-key map (kbd <span class="string">"&lt;right&gt;"</span>)         'anything-next-source)
+    (define-key map (kbd <span class="string">"&lt;left&gt;"</span>)          'anything-previous-source)
+    (define-key map (kbd <span class="string">"&lt;RET&gt;"</span>)           'anything-exit-minibuffer)
+    (define-key map (kbd <span class="string">"C-1"</span>)             'anything-select-with-digit-shortcut)
+    (define-key map (kbd <span class="string">"C-2"</span>)             'anything-select-with-digit-shortcut)
+    (define-key map (kbd <span class="string">"C-3"</span>)             'anything-select-with-digit-shortcut)
+    (define-key map (kbd <span class="string">"C-4"</span>)             'anything-select-with-digit-shortcut)
+    (define-key map (kbd <span class="string">"C-5"</span>)             'anything-select-with-digit-shortcut)
+    (define-key map (kbd <span class="string">"C-6"</span>)             'anything-select-with-digit-shortcut)
+    (define-key map (kbd <span class="string">"C-7"</span>)             'anything-select-with-digit-shortcut)
+    (define-key map (kbd <span class="string">"C-8"</span>)             'anything-select-with-digit-shortcut)
+    (define-key map (kbd <span class="string">"C-9"</span>)             'anything-select-with-digit-shortcut)
+    (<span class="keyword cl">loop</span> for c from ?A to ?Z do
           (define-key map (make-string 1 c) 'anything-select-with-digit-shortcut))
-    (define-key map (kbd "C-i")             'anything-select-action)
-    (define-key map (kbd "C-z")             'anything-execute-persistent-action)
-    (define-key map (kbd "C-e")             'anything-select-2nd-action-or-end-of-line)
-    (define-key map (kbd "C-j")             'anything-select-3rd-action)
-    (define-key map (kbd "C-o")             'anything-next-source)
-    (define-key map (kbd "C-M-v")           'anything-scroll-other-window)
-    (define-key map (kbd "M-<next>")        'anything-scroll-other-window)
-    (define-key map (kbd "C-M-y")           'anything-scroll-other-window-down)
-    (define-key map (kbd "C-M-S-v")         'anything-scroll-other-window-down)
-    (define-key map (kbd "M-<prior>")       'anything-scroll-other-window-down)
-    (define-key map (kbd "<C-M-down>")      'anything-scroll-other-window)
-    (define-key map (kbd "<C-M-up>")        'anything-scroll-other-window-down)
-    (define-key map (kbd "C-SPC")           'anything-toggle-visible-mark)
-    (define-key map (kbd "M-SPC")           'anything-toggle-visible-mark)
-    (define-key map (kbd "M-[")             'anything-prev-visible-mark)
-    (define-key map (kbd "M-]")             'anything-next-visible-mark)
-    (define-key map (kbd "C-k")             'anything-delete-minibuffer-contents)
-
-    (define-key map (kbd "C-r")             'undefined)
-    (define-key map (kbd "C-t")             'anything-toggle-resplit-window)
-    (define-key map (kbd "C-}")             'anything-narrow-window)
-    (define-key map (kbd "C-{")             'anything-enlarge-window)
+    (define-key map (kbd <span class="string">"C-i"</span>)             'anything-select-action)
+    (define-key map (kbd <span class="string">"C-z"</span>)             'anything-execute-persistent-action)
+    (define-key map (kbd <span class="string">"C-e"</span>)             'anything-select-2nd-action-or-end-of-line)
+    (define-key map (kbd <span class="string">"C-j"</span>)             'anything-select-3rd-action)
+    (define-key map (kbd <span class="string">"C-o"</span>)             'anything-next-source)
+    (define-key map (kbd <span class="string">"C-M-v"</span>)           'anything-scroll-other-window)
+    (define-key map (kbd <span class="string">"M-&lt;next&gt;"</span>)        'anything-scroll-other-window)
+    (define-key map (kbd <span class="string">"C-M-y"</span>)           'anything-scroll-other-window-down)
+    (define-key map (kbd <span class="string">"C-M-S-v"</span>)         'anything-scroll-other-window-down)
+    (define-key map (kbd <span class="string">"M-&lt;prior&gt;"</span>)       'anything-scroll-other-window-down)
+    (define-key map (kbd <span class="string">"&lt;C-M-down&gt;"</span>)      'anything-scroll-other-window)
+    (define-key map (kbd <span class="string">"&lt;C-M-up&gt;"</span>)        'anything-scroll-other-window-down)
+    (define-key map (kbd <span class="string">"C-SPC"</span>)           'anything-toggle-visible-mark)
+    (define-key map (kbd <span class="string">"M-SPC"</span>)           'anything-toggle-visible-mark)
+    (define-key map (kbd <span class="string">"M-["</span>)             'anything-prev-visible-mark)
+    (define-key map (kbd <span class="string">"M-]"</span>)             'anything-next-visible-mark)
+    (define-key map (kbd <span class="string">"C-k"</span>)             'anything-delete-minibuffer-contents)
+
+    (define-key map (kbd <span class="string">"C-r"</span>)             'undefined)
+    (define-key map (kbd <span class="string">"C-t"</span>)             'anything-toggle-resplit-window)
+    (define-key map (kbd <span class="string">"C-}"</span>)             'anything-narrow-window)
+    (define-key map (kbd <span class="string">"C-{"</span>)             'anything-enlarge-window)
     
-    (define-key map (kbd "C-c C-d")         'anything-delete-current-selection)
-    (define-key map (kbd "C-c C-y")         'anything-yank-selection)
-    (define-key map (kbd "C-c C-k")         'anything-kill-selection-and-quit)
-    (define-key map (kbd "C-c C-f")         'anything-follow-mode)
-    (define-key map (kbd "C-c C-u")         'anything-force-update)
-    (define-key map (kbd "M-p")             'previous-history-element)
-    (define-key map (kbd "M-n")             'next-history-element)
-    ;; Debugging command
-    (define-key map "\C-c\C-x\C-d"          'anything-debug-output)
-    (define-key map "\C-c\C-x\C-m"          'anything-display-all-visible-marks)
-    (define-key map "\C-c\C-x\C-b"          'anything-send-bug-report-from-anything)
-    ;; Use `describe-mode' key in `global-map'.
-    (define-key map [f1] nil) ; Allow to eval keymap whithout errors.
-    (dolist (k (where-is-internal 'describe-mode global-map))
+    (define-key map (kbd <span class="string">"C-c C-d"</span>)         'anything-delete-current-selection)
+    (define-key map (kbd <span class="string">"C-c C-y"</span>)         'anything-yank-selection)
+    (define-key map (kbd <span class="string">"C-c C-k"</span>)         'anything-kill-selection-and-quit)
+    (define-key map (kbd <span class="string">"C-c C-f"</span>)         'anything-follow-mode)
+    (define-key map (kbd <span class="string">"C-c C-u"</span>)         'anything-force-update)
+    (define-key map (kbd <span class="string">"M-p"</span>)             'previous-history-element)
+    (define-key map (kbd <span class="string">"M-n"</span>)             'next-history-element)
+    <span class="comment">;; Debugging command</span>
+    (define-key map <span class="string">"\C-c\C-x\C-d"</span>          'anything-debug-output)
+    (define-key map <span class="string">"\C-c\C-x\C-m"</span>          'anything-display-all-visible-marks)
+    (define-key map <span class="string">"\C-c\C-x\C-b"</span>          'anything-send-bug-report-from-anything)
+    <span class="comment">;; Use `<span class="constant important">describe-mode</span>' key in `<span class="constant important">global-map</span>'.</span>
+    (define-key map [f1] nil) <span class="comment">; Allow to eval keymap whithout errors.</span>
+    (<span class="keyword cl">dolist</span> (k (where-is-internal 'describe-mode global-map))
       (define-key map k 'anything-help))
     map)
-  "Keymap for anything.")
+  <span class="string">"Keymap for anything."</span>)
 
  
-(defgroup anything nil
-  "Open anything."
-  :prefix "anything-" :group 'convenience)
+(<span class="keyword">defgroup</span> <span class="type">anything</span> nil
+  <span class="string">"Open anything."</span>
+  <span class="builtin">:prefix</span> <span class="string">"anything-"</span> <span class="builtin">:group</span> 'convenience)
 
-(defface anything-header
-    '((t (:inherit header-line)))
-  "Face for header lines in the anything buffer."
-  :group 'anything)
+(<span class="keyword">defface</span> <span class="variable">anything-header</span>
+    '((t (<span class="builtin">:inherit</span> header-line)))
+  <span class="string">"Face for header lines in the anything buffer."</span>
+  <span class="builtin">:group</span> 'anything)
 
-(defvar anything-header-face 'anything-header
-  "*Face for header lines in the anything buffer.")
+(<span class="keyword">defvar</span> <span class="variable">anything-header-face</span> 'anything-header
+  <span class="string">"*Face for header lines in the anything buffer."</span>)
 
-(defface anything-candidate-number
-    '((t (:background "Yellow" :foreground "black")))
-  "Face for candidate number in mode-line." :group 'anything)
+(<span class="keyword">defface</span> <span class="variable">anything-candidate-number</span>
+    '((t (<span class="builtin">:background</span> <span class="string">"Yellow"</span> <span class="builtin">:foreground</span> <span class="string">"black"</span>)))
+  <span class="string">"Face for candidate number in mode-line."</span> <span class="builtin">:group</span> 'anything)
 
-(defvar anything-selection-face 'highlight
-  "*Face for currently selected item.")
+(<span class="keyword">defvar</span> <span class="variable">anything-selection-face</span> 'highlight
+  <span class="string">"*Face for currently selected item."</span>)
 
-(defvar anything-buffer "*anything*"
-  "Buffer showing completions.")
+(<span class="keyword">defvar</span> <span class="variable">anything-buffer</span> <span class="string">"*anything*"</span>
+  <span class="string">"Buffer showing completions."</span>)
 
-(defvar anything-action-buffer "*anything action*"
-  "Buffer showing actions.")
+(<span class="keyword">defvar</span> <span class="variable">anything-action-buffer</span> <span class="string">"*anything action*"</span>
+  <span class="string">"Buffer showing actions."</span>)
 
-(defvar anything-selection-overlay nil
-  "Overlay used to highlight the currently selected item.")
+(<span class="keyword">defvar</span> <span class="variable">anything-selection-overlay</span> nil
+  <span class="string">"Overlay used to highlight the currently selected item."</span>)
 
-(defvar anything-digit-overlays nil
-  "Overlays for digit shortcuts.  See `anything-enable-shortcuts'.")
+(<span class="keyword">defvar</span> <span class="variable">anything-digit-overlays</span> nil
+  <span class="string">"Overlays for digit shortcuts.  See `<span class="constant important">anything-enable-shortcuts</span>'."</span>)
 
-(defvar anything-candidate-cache nil
-  "Holds the available candidate withing a single anything invocation.")
+(<span class="keyword">defvar</span> <span class="variable">anything-candidate-cache</span> nil
+  <span class="string">"Holds the available candidate withing a single anything invocation."</span>)
 
-(defvar anything-pattern
-  "The input pattern used to update the anything buffer.")
+(<span class="keyword">defvar</span> <span class="variable">anything-pattern</span>
+  <span class="string">"The input pattern used to update the anything buffer."</span>)
 
-(defvar anything-input
-  "The input typed in the candidates panel.")
+(<span class="keyword">defvar</span> <span class="variable">anything-input</span>
+  <span class="string">"The input typed in the candidates panel."</span>)
 
-(defvar anything-async-processes nil
-  "List of information about asynchronous processes managed by anything.")
+(<span class="keyword">defvar</span> <span class="variable">anything-async-processes</span> nil
+  <span class="string">"List of information about asynchronous processes managed by anything."</span>)
 
-(defvar anything-digit-shortcut-count 0
-  "Number of digit shortcuts shown in the anything buffer.")
+(<span class="keyword">defvar</span> <span class="variable">anything-digit-shortcut-count</span> 0
+  <span class="string">"Number of digit shortcuts shown in the anything buffer."</span>)
 
-(defvar anything-before-initialize-hook nil
-  "Run before anything initialization.
-This hook is run before init functions in `anything-sources'.")
+(<span class="keyword">defvar</span> <span class="variable">anything-before-initialize-hook</span> nil
+  <span class="string">"Run before anything initialization.
+This hook is run before init functions in `<span class="constant important">anything-sources</span>'."</span>)
 
-(defvar anything-after-initialize-hook nil
-  "Run after anything initialization.
+(<span class="keyword">defvar</span> <span class="variable">anything-after-initialize-hook</span> nil
+  <span class="string">"Run after anything initialization.
 Global variables are initialized and the anything buffer is created.
-But the anything buffer has no contents.")
+But the anything buffer has no contents."</span>)
 
-(defvar anything-update-hook nil
-  "Run after the anything buffer was updated according the new input pattern.
+(<span class="keyword">defvar</span> <span class="variable">anything-update-hook</span> nil
+  <span class="string">"Run after the anything buffer was updated according the new input pattern.
 This hook is run at the beginning of buffer.
 The first candidate is selected after running this hook.
-See also `anything-after-update-hook'.")
+See also `<span class="constant important">anything-after-update-hook</span>'."</span>)
 
-(defvar anything-after-update-hook nil
-  "Run after the anything buffer was updated according the new input pattern.
-This is very similar to `anything-update-hook' but selection is not moved.
-It is useful to select a particular object instead of the first one.")
+(<span class="keyword">defvar</span> <span class="variable">anything-after-update-hook</span> nil
+  <span class="string">"Run after the anything buffer was updated according the new input pattern.
+This is very similar to `<span class="constant important">anything-update-hook</span>' but selection is not moved.
+It is useful to select a particular object instead of the first one."</span>)
 
-(defvar anything-cleanup-hook nil
-  "Run after anything minibuffer is closed.
-IOW this hook is executed BEFORE performing action.")
+(<span class="keyword">defvar</span> <span class="variable">anything-cleanup-hook</span> nil
+  <span class="string">"Run after anything minibuffer is closed.
+IOW this hook is executed BEFORE performing action."</span>)
 
-(defvar anything-select-action-hook nil
-  "Run when opening the action buffer.")
+(<span class="keyword">defvar</span> <span class="variable">anything-select-action-hook</span> nil
+  <span class="string">"Run when opening the action buffer."</span>)
 
-(defvar anything-before-action-hook nil
-  "Run before executing action.
-Contrarily to `anything-cleanup-hook',
+(<span class="keyword">defvar</span> <span class="variable">anything-before-action-hook</span> nil
+  <span class="string">"Run before executing action.
+Contrarily to `<span class="constant important">anything-cleanup-hook</span>',
 this hook run before anything minibuffer is closed
-and before performing action.")
+and before performing action."</span>)
 
-(defvar anything-after-action-hook nil
-  "Run after executing action.")
+(<span class="keyword">defvar</span> <span class="variable">anything-after-action-hook</span> nil
+  <span class="string">"Run after executing action."</span>)
 
-(defvar anything-after-persistent-action-hook nil
-  "Run after executing persistent action.")
+(<span class="keyword">defvar</span> <span class="variable">anything-after-persistent-action-hook</span> nil
+  <span class="string">"Run after executing persistent action."</span>)
 
-(defvar anything-move-selection-before-hook nil
-  "Run before moving selection in `anything-buffer'.")
+(<span class="keyword">defvar</span> <span class="variable">anything-move-selection-before-hook</span> nil
+  <span class="string">"Run before moving selection in `<span class="constant important">anything-buffer</span>'."</span>)
 
-(defvar anything-move-selection-after-hook nil
-  "Run after moving selection in `anything-buffer'.")
+(<span class="keyword">defvar</span> <span class="variable">anything-move-selection-after-hook</span> nil
+  <span class="string">"Run after moving selection in `<span class="constant important">anything-buffer</span>'."</span>)
 
-(defvar anything-restored-variables
+(<span class="keyword">defvar</span> <span class="variable">anything-restored-variables</span>
   '(anything-candidate-number-limit
     anything-source-filter
     anything-source-in-each-line-flag
     anything-map
     anything-sources)
-  "Variables which are restored after `anything' invocation.")
+  <span class="string">"Variables which are restored after `<span class="constant important">anything</span>' invocation."</span>)
 
-(defvar anything-saved-selection nil
-  "Value of the currently selected object when the action list is shown.")
+(<span class="keyword">defvar</span> <span class="variable">anything-saved-selection</span> nil
+  <span class="string">"Value of the currently selected object when the action list is shown."</span>)
 
-(defvar anything-current-prefix-arg nil
-  "Record `current-prefix-arg' when exiting minibuffer.")
+(<span class="keyword">defvar</span> <span class="variable">anything-current-prefix-arg</span> nil
+  <span class="string">"Record `<span class="constant important">current-prefix-arg</span>' when exiting minibuffer."</span>)
 
-(defvar anything-candidate-separator
-  "--------------------"
-  "Candidates separator of `multiline' source.")
+(<span class="keyword">defvar</span> <span class="variable">anything-candidate-separator</span>
+  <span class="string">"--------------------"</span>
+  <span class="string">"Candidates separator of `<span class="constant important">multiline</span>' source."</span>)
 
-(defvar anything-current-buffer nil
-  "Current buffer when `anything' is invoked.")
+(<span class="keyword">defvar</span> <span class="variable">anything-current-buffer</span> nil
+  <span class="string">"Current buffer when `<span class="constant important">anything</span>' is invoked."</span>)
 
-(defvar anything-buffer-file-name nil
-  "Variable `buffer-file-name' when `anything' is invoked.")
+(<span class="keyword">defvar</span> <span class="variable">anything-buffer-file-name</span> nil
+  <span class="string">"Variable `<span class="constant important">buffer-file-name</span>' when `<span class="constant important">anything</span>' is invoked."</span>)
 
-(defvar anything-saved-action nil
-  "Saved value of the currently selected action by key.")
+(<span class="keyword">defvar</span> <span class="variable">anything-saved-action</span> nil
+  <span class="string">"Saved value of the currently selected action by key."</span>)
 
-(defvar anything-last-sources nil
-  "OBSOLETE!! Sources of previously invoked `anything'.")
+(<span class="keyword">defvar</span> <span class="variable">anything-last-sources</span> nil
+  <span class="string">"OBSOLETE!! Sources of previously invoked `<span class="constant important">anything</span>'."</span>)
 
-(defvar anything-saved-current-source nil
-  "Value of the current source when the action list is shown.")
+(<span class="keyword">defvar</span> <span class="variable">anything-saved-current-source</span> nil
+  <span class="string">"Value of the current source when the action list is shown."</span>)
 
-(defvar anything-compiled-sources nil
-  "Compiled version of `anything-sources'.")
+(<span class="keyword">defvar</span> <span class="variable">anything-compiled-sources</span> nil
+  <span class="string">"Compiled version of `<span class="constant important">anything-sources</span>'."</span>)
 
-(defvar anything-in-persistent-action nil
-  "Flag whether in persistent-action or not.")
+(<span class="keyword">defvar</span> <span class="variable">anything-in-persistent-action</span> nil
+  <span class="string">"Flag whether in persistent-action or not."</span>)
 
-(defvar anything-quick-update nil
-  "If non-nil, suppress displaying sources which are out of screen at first.
+(<span class="keyword">defvar</span> <span class="variable">anything-quick-update</span> nil
+  <span class="string">"If non-nil, suppress displaying sources which are out of screen at first.
 They are treated as delayed sources at this input.
-This flag makes `anything' a bit faster with many sources.")
+This flag makes `<span class="constant important">anything</span>' a bit faster with many sources."</span>)
 
-(defvar anything-last-sources-local nil
-  "Buffer local value of `anything-sources'.")
+(<span class="keyword">defvar</span> <span class="variable">anything-last-sources-local</span> nil
+  <span class="string">"Buffer local value of `<span class="constant important">anything-sources</span>'."</span>)
 
-(defvar anything-last-buffer nil
-  "`anything-buffer' of previously `anything' session.")
+(<span class="keyword">defvar</span> <span class="variable">anything-last-buffer</span> nil
+  <span class="string">"`<span class="constant important">anything-buffer</span>' of previously `<span class="constant important">anything</span>' session."</span>)
 
-(defvar anything-save-configuration-functions
+(<span class="keyword">defvar</span> <span class="variable">anything-save-configuration-functions</span>
   '(set-window-configuration . current-window-configuration)
-  "The functions used to restore/save window or frame configurations.
+  <span class="string">"The functions used to restore/save window or frame configurations.
 It is a pair where the car is the function to restore window or frame config,
 and the cdr is the function to save the window or frame config.
 
  '\(set-frame-configuration . current-frame-configuration\)
 
 Older version saves/restores frame configuration, but the default is changed now
-because flickering can occur in some environment. ")
+because flickering can occur in some environment. "</span>)
 
-(defvar anything-persistent-action-use-special-display nil
-  "If non-nil, use `special-display-function' in persistent action.")
+(<span class="keyword">defvar</span> <span class="variable">anything-persistent-action-use-special-display</span> nil
+  <span class="string">"If non-nil, use `<span class="constant important">special-display-function</span>' in persistent action."</span>)
 
-(defvar anything-execute-action-at-once-if-one nil
-  "Execute default action and exit when only one candidate is remaining.
-It is useful for `anything' applications.")
+(<span class="keyword">defvar</span> <span class="variable">anything-execute-action-at-once-if-one</span> nil
+  <span class="string">"Execute default action and exit when only one candidate is remaining.
+It is useful for `<span class="constant important">anything</span>' applications."</span>)
 
-(defvar anything-quit-if-no-candidate nil
-  "Quit when there is no candidates when non--nil.
+(<span class="keyword">defvar</span> <span class="variable">anything-quit-if-no-candidate</span> nil
+  <span class="string">"Quit when there is no candidates when non--nil.
 This variable accepts a function, which is executed if no candidate.
 
-It is useful for `anything' applications.")
+It is useful for `<span class="constant important">anything</span>' applications."</span>)
 
-(defvar anything-scroll-amount nil
-  "Scroll amount when scrolling other window in an anything session.
-It is used by `anything-scroll-other-window'
-and `anything-scroll-other-window-down'.
+(<span class="keyword">defvar</span> <span class="variable">anything-scroll-amount</span> nil
+  <span class="string">"Scroll amount when scrolling other window in an anything session.
+It is used by `<span class="constant important">anything-scroll-other-window</span>'
+and `<span class="constant important">anything-scroll-other-window-down</span>'.
 
-If you prefer scrolling line by line, set this value to 1.")
+If you prefer scrolling line by line, set this value to 1."</span>)
 
-(defvar anything-display-function 'anything-default-display-buffer
-  "Function to display *anything* buffer.
-It is `anything-default-display-buffer' by default,
-which affects `anything-samewindow'.")
+(<span class="keyword">defvar</span> <span class="variable">anything-display-function</span> 'anything-default-display-buffer
+  <span class="string">"Function to display *anything* buffer.
+It is `<span class="constant important">anything-default-display-buffer</span>' by default,
+which affects `<span class="constant important">anything-samewindow</span>'."</span>)
 
-(defvar anything-delayed-init-executed nil)
+(<span class="keyword">defvar</span> <span class="variable">anything-delayed-init-executed</span> nil)
 
-(defvar anything-mode-line-string nil
-  "Help string displayed in mode-line in `anything'.
+(<span class="keyword">defvar</span> <span class="variable">anything-mode-line-string</span> nil
+  <span class="string">"Help string displayed in mode-line in `<span class="constant important">anything</span>'.
 It can be a string or a list of two args, in this case,
 first arg is a string that will be used as name for candidates number,
 second arg any string to display in mode line.
-If nil, use default `mode-line-format'.")
+If nil, use default `<span class="constant important">mode-line-format</span>'."</span>)
 
-(defvar anything-help-message
-  "\\<anything-map>The keys that are defined for `anything' are:
-       \\{anything-map}"
-  "Detailed help message string for `anything'.
-It also accepts function or variable symbol.")
+(<span class="keyword">defvar</span> <span class="variable">anything-help-message</span>
+  <span class="string">"\\&lt;anything-map&gt;The keys that are defined for `<span class="constant important">anything</span>' are:
+       \\{anything-map}"</span>
+  <span class="string">"Detailed help message string for `<span class="constant important">anything</span>'.
+It also accepts function or variable symbol."</span>)
 
-(defvar anything-source-in-each-line-flag nil
-  "Non-nil means add anything-source text-property in each candidate.
-experimental feature.")
+(<span class="keyword">defvar</span> <span class="variable">anything-source-in-each-line-flag</span> nil
+  <span class="string">"Non-nil means add anything-source text-property in each candidate.
+experimental feature."</span>)
 
-(defvaralias 'anything-debug-variables 'anything-debug-forms)
+(<span class="keyword">defvaralias</span> '<span class="variable">anything-debug-variables</span> 'anything-debug-forms)
 
-(defvar anything-debug-forms nil
-  "Forms to show in `anything-debug-output'.
-Otherwise all variables started with `anything-' are shown.
-It is useful for debug.")
+(<span class="keyword">defvar</span> <span class="variable">anything-debug-forms</span> nil
+  <span class="string">"Forms to show in `<span class="constant important">anything-debug-output</span>'.
+Otherwise all variables started with `<span class="constant important">anything-</span>' are shown.
+It is useful for debug."</span>)
 
-(defvar anything-debug nil
-  "If non-nil, write log message into *Anything Log* buffer.
-If `debug-on-error' is non-nil, write log message regardless of this variable.
-It is disabled by default because *Anything Log* grows quickly.")
+(<span class="keyword">defvar</span> <span class="variable">anything-debug</span> nil
+  <span class="string">"If non-nil, write log message into *Anything Log* buffer.
+If `<span class="constant important">debug-on-error</span>' is non-nil, write log message regardless of this variable.
+It is disabled by default because *Anything Log* grows quickly."</span>)
 
-(defcustom anything-local-map-override-anything-map t
-  "Override `anything-map' keys with the corresponding ones in source local map.
-When non--nil keys in source local map will override same keys in `anything-map'
-otherwise same keys in `anything-map' will take precedence."
-  :group 'anything
-  :type  'boolean)
+(<span class="keyword">defcustom</span> <span class="variable">anything-local-map-override-anything-map</span> t
+  <span class="string">"Override `<span class="constant important">anything-map</span>' keys with the corresponding ones in source local map.
+When non--nil keys in source local map will override same keys in `<span class="constant important">anything-map</span>'
+otherwise same keys in `<span class="constant important">anything-map</span>' will take precedence."</span>
+  <span class="builtin">:group</span> 'anything
+  <span class="builtin">:type</span>  'boolean)
 
  
-;; (@* "Internal Variables")
-(defvar anything-test-candidate-list nil)
-(defvar anything-test-mode nil)
-(defvar anything-source-name nil)
-(defvar anything-candidate-buffer-alist nil)
-(defvar anything-check-minibuffer-input-timer nil)
-(defvar anything-match-hash (make-hash-table :test 'equal))
-(defvar anything-cib-hash (make-hash-table :test 'equal))
-(defvar anything-tick-hash (make-hash-table :test 'equal))
-(defvar anything-issued-errors nil)
-(defvar anything-shortcut-keys nil)
-(defvar anything-once-called-functions nil)
-(defvar anything-follow-mode nil)
-(defvar anything-let-variables nil)
-(defvar anything-split-window-state nil)
-(defvar anything-selection-point nil)
-(defvar anything-alive-p nil)
+<span class="comment">;; (@* <span class="string">"Internal Variables"</span>)</span>
+(<span class="keyword">defvar</span> <span class="variable">anything-test-candidate-list</span> nil)
+(<span class="keyword">defvar</span> <span class="variable">anything-test-mode</span> nil)
+(<span class="keyword">defvar</span> <span class="variable">anything-source-name</span> nil)
+(<span class="keyword">defvar</span> <span class="variable">anything-candidate-buffer-alist</span> nil)
+(<span class="keyword">defvar</span> <span class="variable">anything-check-minibuffer-input-timer</span> nil)
+(<span class="keyword">defvar</span> <span class="variable">anything-match-hash</span> (make-hash-table <span class="builtin">:test</span> 'equal))
+(<span class="keyword">defvar</span> <span class="variable">anything-cib-hash</span> (make-hash-table <span class="builtin">:test</span> 'equal))
+(<span class="keyword">defvar</span> <span class="variable">anything-tick-hash</span> (make-hash-table <span class="builtin">:test</span> 'equal))
+(<span class="keyword">defvar</span> <span class="variable">anything-issued-errors</span> nil)
+(<span class="keyword">defvar</span> <span class="variable">anything-shortcut-keys</span> nil)
+(<span class="keyword">defvar</span> <span class="variable">anything-once-called-functions</span> nil)
+(<span class="keyword">defvar</span> <span class="variable">anything-follow-mode</span> nil)
+(<span class="keyword">defvar</span> <span class="variable">anything-let-variables</span> nil)
+(<span class="keyword">defvar</span> <span class="variable">anything-split-window-state</span> nil)
+(<span class="keyword">defvar</span> <span class="variable">anything-selection-point</span> nil)
+(<span class="keyword">defvar</span> <span class="variable">anything-alive-p</span> nil)
 
  
-;; (@* "Utility: logging")
-(defun anything-log (format-string &rest args)
-  "Log message if `debug-on-error' or `anything-debug' is non-nil.
+<span class="comment">;; (@* <span class="string">"Utility: logging"</span>)</span>
+(<span class="keyword">defun</span> <span class="function">anything-log</span> (format-string <span class="type">&amp;rest</span> args)
+  <span class="string">"Log message if `<span class="constant important">debug-on-error</span>' or `<span class="constant important">anything-debug</span>' is non-nil.
 Messages are written to the *Anything Log* buffer.
 
-Argument FORMAT-STRING is a string to use with `format'.
-Use optional arguments ARGS like in `format'."
-  (when (or debug-on-error anything-debug)
-    (with-current-buffer (get-buffer-create "*Anything Log*")
+Argument FORMAT-STRING is a string to use with `<span class="constant important">format</span>'.
+Use optional arguments ARGS like in `<span class="constant important">format</span>'."</span>
+  (<span class="keyword cl">when</span> (or debug-on-error anything-debug)
+    (<span class="keyword elisp">with-current-buffer</span> (get-buffer-create <span class="string">"*Anything Log*"</span>)
       (buffer-disable-undo)
       (set (make-local-variable 'inhibit-read-only) t)
       (goto-char (point-max))
-      (insert (let ((tm (current-time)))
-                (format "%s.%06d (%s) %s\n"
-                        (format-time-string "%H:%M:%S" tm)
+      (insert (<span class="keyword elisp">let</span> ((tm (current-time)))
+                (format <span class="string">"%s.%06d (%s) %s\n"</span>
+                        (format-time-string <span class="string">"%H<span class="builtin">:%M:%S</span>"</span> tm)
                         (nth 2 tm)
                         (anything-log-get-current-function)
                         (apply #'format (cons format-string args))))))))
 
-(defmacro anything-log-eval (&rest exprs)
-  "Write each EXPRS evaluation result to the *Anything Log* buffer."
+(<span class="keyword">defmacro</span> <span class="function">anything-log-eval</span> (<span class="type">&amp;rest</span> exprs)
+  <span class="string">"Write each EXPRS evaluation result to the *Anything Log* buffer."</span>
   `(anything-log-eval-internal ',exprs))
 
-(defun anything-log-run-hook (hook)
-  "Run HOOK like `run-hooks' but write these actions to anything log buffer."
-  (anything-log "executing %s" hook)
-  (when (boundp hook)
+(<span class="keyword">defun</span> <span class="function">anything-log-run-hook</span> (hook)
+  <span class="string">"Run HOOK like `<span class="constant important">run-hooks</span>' but write these actions to anything log buffer."</span>
+  (anything-log <span class="string">"executing %s"</span> hook)
+  (<span class="keyword cl">when</span> (boundp hook)
     (anything-log-eval (symbol-value hook))
     (anything-log-eval (default-value hook)))
   (run-hooks hook)
-  (anything-log "executed %s" hook))
-
-(defun anything-log-eval-internal (exprs)
-  "Eval EXPRS and write results to anything log buffer."
-  (dolist (expr exprs)
-    (condition-case err
-        (anything-log "%S = %S" expr (eval expr))
-      (error (anything-log "%S = ERROR!" expr)))))
-
-(defun anything-log-get-current-function ()
-  "Get function name calling `anything-log'.
-The original idea is from `tramp-debug-message'."
-  (loop with exclude-func-re = "^anything-\\(?:interpret\\|log\\|.*funcall\\)"
-        for btn from 1 to 40            ;avoid inf-loop
+  (anything-log <span class="string">"executed %s"</span> hook))
+
+(<span class="keyword">defun</span> <span class="function">anything-log-eval-internal</span> (exprs)
+  <span class="string">"Eval EXPRS and write results to anything log buffer."</span>
+  (<span class="keyword cl">dolist</span> (expr exprs)
+    (<span class="keyword elisp">condition-case</span> err
+        (anything-log <span class="string">"%S = %S"</span> expr (eval expr))
+      (<span class="warning">error</span> (anything-log <span class="string">"%S = ERROR!"</span> expr)))))
+
+(<span class="keyword">defun</span> <span class="function">anything-log-get-current-function</span> ()
+  <span class="string">"Get function name calling `<span class="constant important">anything-log</span>'.
+The original idea is from `<span class="constant important">tramp-debug-message</span>'."</span>
+  (<span class="keyword cl">loop</span> with exclude-func-re = <span class="string">"^anything-\\(?<span class="builtin">:interpret</span>\\|log\\|.*funcall\\)"</span>
+        for btn from 1 to 40            <span class="comment">;avoid inf-loop</span>
         for btf = (second (backtrace-frame btn))
-        for fn  = (if (symbolp btf) (symbol-name btf) "")
-        if (and (string-match "^anything" fn)
+        for fn  = (<span class="keyword elisp">if</span> (symbolp btf) (symbol-name btf) <span class="string">""</span>)
+        if (and (string-match <span class="string">"^anything"</span> fn)
                 (not (string-match exclude-func-re fn)))
         return fn))
 
-(defun anything-log-error (&rest args)
-  "Accumulate error messages into `anything-issued-errors'.
-ARGS are args given to `format'."
-  (apply 'anything-log (concat "ERROR: " (car args)) (cdr args))
-  (let ((msg (apply 'format args)))
-    (unless (member msg anything-issued-errors)
+(<span class="keyword">defun</span> <span class="function">anything-log-error</span> (<span class="type">&amp;rest</span> args)
+  <span class="string">"Accumulate error messages into `<span class="constant important">anything-issued-errors</span>'.
+ARGS are args given to `<span class="constant important">format</span>'."</span>
+  (apply 'anything-log (concat <span class="string">"ERROR: "</span> (car args)) (cdr args))
+  (<span class="keyword elisp">let</span> ((msg (apply 'format args)))
+    (<span class="keyword cl">unless</span> (member msg anything-issued-errors)
       (add-to-list 'anything-issued-errors msg))))
 
-(defvar anything-last-log-file nil)
-(defun anything-log-save-maybe ()
-  "May be save log buffer to `anything-last-log-file'."
-  (when (stringp anything-debug)
-    (let ((logdir (expand-file-name (format-time-string "%Y%m%d")
+(<span class="keyword">defvar</span> <span class="variable">anything-last-log-file</span> nil)
+(<span class="keyword">defun</span> <span class="function">anything-log-save-maybe</span> ()
+  <span class="string">"May be save log buffer to `<span class="constant important">anything-last-log-file</span>'."</span>
+  (<span class="keyword cl">when</span> (stringp anything-debug)
+    (<span class="keyword elisp">let</span> ((logdir (expand-file-name (format-time-string <span class="string">"%Y%m%d"</span>)
                                     anything-debug)))
       (make-directory logdir t)
-      (with-current-buffer (get-buffer-create "*Anything Log*")