update
authorJoerg Jaspert <joerg@debian.org>
Thu, 29 Sep 2016 20:58:17 +0000 (22:58 +0200)
committerJoerg Jaspert <joerg@debian.org>
Thu, 29 Sep 2016 20:58:17 +0000 (22:58 +0200)
.config/systemd/user/emacs.service
.emacs.d/config/emacs.org
.emacs.d/elisp/local/bind-key.el
.emacs.d/elisp/local/diff-mode-.el
.emacs.d/elisp/local/loaddefs.el
.emacs.d/elisp/local/use-package.el
.emacs.d/init.el

index ca7e29b..d69acf3 100644 (file)
@@ -6,7 +6,6 @@ Type=forking
 ExecStart=/usr/bin/emacs --daemon
 ExecStop=/usr/bin/emacsclient --eval "(kill-emacs)"
 Environment=TMPDIR=%h/tmp
-EnvironmentFile=%h/.gnupg/.gpg-agent.info
 Restart=always
 
 [Install]
index 7f86fcd..71de932 100644 (file)
@@ -89,7 +89,7 @@ And Paradox is a nicer interface for it
 (use-package paradox
   :ensure t
   :commands (paradox-list-packages paradox-install paradox-upgrade-packages)
-  :idle
+  :config
   (progn
     ;(paradox-enable)
     (setq paradox-github-token t)
@@ -237,8 +237,8 @@ shell. Consistent look is great.
 )
 #+END_SRC
 #+BEGIN_SRC emacs-lisp
-(use-package solarized
-  :load-path "elisp/solarized-emacs"
+(use-package color-theme-solarized
+  :ensure solarized-theme
   :init
   (progn
     (defun jj-init-theme ()
@@ -368,7 +368,7 @@ modeline in red as soon as you are over the defined limit.
 
 (use-package modeline-posn
   :ensure t
-  :idle
+  :config
   (progn
     (set-face-foreground 'modelinepos-column-warning "grey20")
     (set-face-background 'modelinepos-column-warning "red")
@@ -417,7 +417,7 @@ character(s).
   ☃⌕☥
   ")
 
-  (add-hook 'after-change-major-mode-hook 'clean-mode-line)
+;  (add-hook 'after-change-major-mode-hook 'clean-mode-line)
 
 #+END_SRC
 Unfortunately icicles breaks this with the way it adds/removes itself,
@@ -510,6 +510,16 @@ From [[http://endlessparentheses.com/faster-pop-to-mark-command.html?source=rss]
       (when (= p (point)) ad-do-it))))
 (setq set-mark-command-repeat-pop t)
 #+END_SRC
+**** Don't kill-buffer, kill-this-buffer instead
+From [[http://pragmaticemacs.com/emacs/dont-kill-buffer-kill-this-buffer-instead/][Pragmatic Emacs]]: By default C-x k runs the command kill-buffer
+which prompts you for which buffer you want to kill, defaulting to the
+current active buffer. I don’t know about you, but I rarely want to
+kill a different buffer than the one I am looking at, so I rebind C-x
+k to kill-this-buffer which just kills the current buffer without
+prompting (unless there are unsaved changes).
+#+BEGIN_SRC emacs-lisp :tangle yes
+(global-set-key (kbd "C-x k") 'kill-this-buffer)
+#+END_SRC
 ** Miscellaneous stuff
 Searches and matches should ignore case.
 #+BEGIN_SRC emacs-lisp
@@ -562,7 +572,7 @@ From https://raw.github.com/qdot/conf_emacs/master/emacs_conf.org
 #+END_SRC
 
 Hilight annotations in comments, like FIXME/TODO/...
-#+BEGIN_SRC emacs-lisp
+#+BEGIN_SRC emacs-lisp :tangle no
 (add-hook 'prog-mode-hook 'font-lock-comment-annotations)
 #+END_SRC
 
@@ -656,8 +666,6 @@ ways.
 (use-package abbrev
   :commands abbrev-mode
   :diminish abbrev-mode
-  :idle
-  (hook-into-modes #'abbrev-mode '(text-mode-hook))
   :config
   (progn
     (setq save-abbrevs 'silently)
@@ -665,6 +673,7 @@ ways.
     (if (file-exists-p abbrev-file-name)
         (quietly-read-abbrev-file))
 
+    (hook-into-modes #'abbrev-mode '(text-mode-hook))
     (add-hook 'expand-load-hook
               (lambda ()
                 (add-hook 'expand-expand-hook 'indent-according-to-mode)
@@ -776,12 +785,10 @@ information in the mode-line in various search modes.
   :ensure anzu
   :diminish anzu-mode
   :defer t
-  :idle
-  (progn
-    (global-anzu-mode 1))
   :config
   (progn
     (setq anzu-search-threshold 1000)
+    (global-anzu-mode 1)
     (set-face-attribute 'anzu-mode-line nil :foreground "yellow" :weight 'bold)))
 #+END_SRC
 ** ascii
@@ -817,10 +824,9 @@ already had typed.
 #+BEGIN_SRC emacs-lisp
 (use-package auto-complete-config
   :ensure auto-complete
-  :idle
-  (ac-config-default)
   :config
   (progn
+    (ac-config-default)
     ;; hook AC into completion-at-point
     (defun sanityinc/auto-complete-at-point ()
       (when (and (not (minibufferp))
@@ -903,7 +909,7 @@ with it. Not to have to revert buffers myself
 (use-package autorevert
   :commands auto-revert-mode
   :diminish auto-revert-mode
-  :idle
+  :config
   (progn
     (setq global-auto-revert-mode t)
     (setq global-auto-revert-non-file-buffers t)
@@ -1020,7 +1026,7 @@ want it to using just two commands.
 #+BEGIN_SRC emacs-lisp
 (use-package corral
   :ensure corral
-  :idle
+  :config
   (progn
     ; Interpret # and * as part of the word
     (setq corral-syntax-entries '((?# "_")
@@ -1109,9 +1115,7 @@ movement keys.
 #+BEGIN_SRC emacs-lisp
 (use-package diff-mode
   :commands diff-mode
-  :mode (("\\.diff" . diff-mode))
-  :config
-  (use-package diff-mode-))
+  :mode (("\\.diff" . diff-mode)))
 #+END_SRC
 
 ** dired & co
@@ -1307,7 +1311,7 @@ Bookmark: [[http://www.emacswiki.org/emacs/EasyPG][EmacsWiki: Easy PG]]
 ediff - don't start another frame
 #+BEGIN_SRC emacs-lisp
 (use-package ediff
-  :pre-init
+  :init
   (progn
     (defvar ctl-period-equals-map)
     (define-prefix-command 'ctl-period-equals-map)
@@ -1336,7 +1340,8 @@ Allows chromium to "send" files (textbox inputs) to emacs to edit.
 #+BEGIN_SRC emacs-lisp
 (use-package edit-server
   :ensure t
-  :idle
+  :if window-system
+  :config
   (progn
     (setq edit-server-new-frame t)
     (edit-server-start)))
@@ -1638,7 +1643,7 @@ In the past I had a long function that just recreated them, but the
 =keep-buffers= package is easier.
 #+BEGIN_SRC emacs-lisp
 (use-package keep-buffers
-  :init
+  :config
   (progn
     (keep-buffers-mode 1)
     (push '("\\`*scratch" . erase) keep-buffers-protected-alist)
@@ -1673,7 +1678,7 @@ While I do have the nifty shortcut to jump to the other parentheses,
 hilighting them makes it obvious where they are.
 #+BEGIN_SRC emacs-lisp
 (use-package mic-paren
-  :init
+  :config
   (paren-activate))
 #+END_SRC
 *** Kill other buffers
@@ -2058,7 +2063,7 @@ bullet points like “1.” or “*”.
 #+BEGIN_SRC emacs-lisp
 (use-package filladapt
   :diminish filladapt-mode
-  :idle
+  :config
   (setq-default filladapt-mode t))
 #+END_SRC
 ** flycheck
@@ -2072,12 +2077,6 @@ understand for me.
   :diminish flycheck-mode
   :bind (("M-n" . next-error)
          ("M-p" . previous-error))
-  :idle
-  (progn
-    (add-hook 'find-file-hook
-          (lambda ()
-            (when (not (equal 'emacs-lisp-mode major-mode))
-              (flycheck-mode)))))
   :config
   (progn
     (use-package flycheck-color-mode-line
@@ -2086,6 +2085,10 @@ understand for me.
     (setq flycheck-flake8-maximum-line-length '150)
     (add-hook 'flycheck-mode-hook 'flycheck-color-mode-line-mode)
     (setq flycheck-sh-shellcheck-executable "/usr/bin/shellcheck -e 2086")
+    (add-hook 'find-file-hook
+          (lambda ()
+            (when (not (equal 'emacs-lisp-mode major-mode))
+              (flycheck-mode))))
     ))
 #+END_SRC
 ** font-lock
@@ -2133,12 +2136,10 @@ Display nice lines instead of page breaks
          ("C-x s" . git-gutter+-stage-hunks)
          ("C-x c" . git-gutter+-commit)
          )
-  :idle
-  (progn
-    (setq git-gutter+-disabled-modes '(org-mode))
-    (global-git-gutter+-mode 1))
   :config
   (progn
+    (setq git-gutter+-disabled-modes '(org-mode))
+    (global-git-gutter+-mode 1)
     (use-package git-gutter-fringe+
       :ensure git-gutter-fringe+
       :config
@@ -2741,7 +2742,7 @@ _l_ linum-mode:         % 4`linum-mode     _k_ linum relative:    %`linum-format
 #+BEGIN_SRC emacs-lisp
 (use-package icicles
   :ensure icicles
-  :idle
+  :config
   (icy-mode 1))
 #+END_SRC
 ** icomplete
@@ -2815,6 +2816,7 @@ gnus, so we have a list of modes where we don't want to see it.
   :init
   (global-linum-mode 1))
 (use-package hlinum
+  :ensure t
   :config
   (progn
     (hlinum-activate)))
@@ -2960,7 +2962,7 @@ magit is a mode for interacting with git.
 ** message
 #+BEGIN_SRC emacs-lisp
 (use-package message
-  :idle
+  :config
   (progn
     (setq message-kill-buffer-on-exit t)))
 #+END_SRC
@@ -3092,12 +3094,11 @@ A emacs tree plugin
   :commands (neotree-find
              neotree-toggle
              neotree)
-  :idle
-  (progn
-    (setq neo-smart-open t))
   :config
   (progn
-    (bind-key "^" 'neotree-select-up-node neotree-mode-map)))
+    (bind-key "^" 'neotree-select-up-node neotree-mode-map)
+    (setq neo-smart-open t)))
+
 #+END_SRC
 ** nxml
 [2013-05-22 Wed 22:02]
@@ -3797,7 +3798,7 @@ A new exporter created by Nicolas Goaziou was introduced in org 8.0.
 (require 'ox-html)
 (require 'ox-latex)
 (require 'ox-ascii)
-(require 'ox-reveal)
+;(require 'ox-reveal)
 ;; FIXME, check the following two
 ;(require 'ox-icalendar)
 ;(require 'ox-odt)
@@ -4191,7 +4192,7 @@ up here to be used.
 #+BEGIN_SRC emacs-lisp
 (use-package cperl-mode
   :commands cperl-mode
-  :idle
+  :config
   (progn
     (defalias 'perl-mode 'cperl-mode)
     (add-auto-mode 'cperl-mode "\\.\\([pP][Llm]\\|al\\)\\'")
@@ -4200,9 +4201,6 @@ up here to be used.
     (add-to-list 'interpreter-mode-alist '("perl" . cperl-mode))
     (add-to-list 'interpreter-mode-alist '("perl5" . cperl-mode))
     (add-to-list 'interpreter-mode-alist '("miniperl" . cperl-mode))
-    )
-  :config
-  (progn
     (setq cperl-invalid-face nil
           cperl-close-paren-offset -4
           cperl-continued-statement-offset 0
@@ -4239,13 +4237,11 @@ up here to be used.
 (use-package puppet-mode
   :mode ("\\.pp\\'" . puppet-mode)
   :commands puppet-mode
-  :idle
+  :config
   (progn
     (defun my-puppet-mode-hook ()
       (setq require-final-newline nil))
-    (add-hook 'puppet-mode-hook 'my-puppet-mode-hook))
-  :config
-  (progn
+    (add-hook 'puppet-mode-hook 'my-puppet-mode-hook)
     (use-package puppet-ext
       :init
       (progn
@@ -4256,7 +4252,7 @@ up here to be used.
 ** python
 Use elpy for the emacs python fun, but dont let it initialize all the
 various variables. Elpy author may like them, but I'm not him...
-#+BEGIN_SRC emacs-lisp
+#+BEGIN_SRC emacs-lisp :tangle no
 (use-package elpy
   :defer t
   :mode ("\.py" . python-mode)
@@ -4471,7 +4467,7 @@ then, like for example the [[*multiple%20cursors][multiple cursors]] mode I load
 #+BEGIN_SRC emacs-lisp tangle no
 (use-package region-bindings-mode
   :ensure region-bindings-mode
-  :init
+  :config
   (region-bindings-mode-enable))
 #+END_SRC
 ** ruby
@@ -4643,10 +4639,8 @@ Store at which point I have been in files.
   :defer t
   :config
   (progn
-    (setq save-place-file (expand-file-name "saved-places" jj-cache-dir)))
-  :idle
-  (progn
-    (save-place-mode)))
+    (setq save-place-file (expand-file-name "saved-places" jj-cache-dir)
+    (save-place-mode))))
 #+END_SRC
 ** simple-httpd
 [2014-06-10 Tue 22:05]
@@ -4691,7 +4685,7 @@ Make =M-n= and =M-p= go forward/backword to the symbol at point.
 (use-package smartscan
   :ensure smartscan
   :defer t
-  :idle (global-smartscan-mode t))
+  :config (global-smartscan-mode t))
 #+END_SRC
 ** timestamp
 By default, Emacs can update the time stamp for the following two
@@ -4701,12 +4695,10 @@ formats if one exists in the first 8 lines of the file.
 #+BEGIN_SRC emacs-lisp
 (use-package time-stamp
   :commands time-stamp
-  :idle
-  (progn
-    (add-hook 'write-file-hooks 'time-stamp)
-    (setq time-stamp-active t))
   :config
   (progn
+    (add-hook 'write-file-hooks 'time-stamp)
+    (setq time-stamp-active t)
     (setq time-stamp-format "%02H:%02M:%02S (%z) - %02d.%02m.%:y from %u (%U) on %s")
     (setq time-stamp-old-format-warn nil)
     (setq time-stamp-time-zone nil)))
@@ -4830,7 +4822,7 @@ your operation actually changed in the buffer.
 #+BEGIN_SRC emacs-lisp
 (use-package volatile-highlights
   :ensure volatile-highlights
-  :idle
+  :config
   (volatile-highlights-mode t)
   :diminish volatile-highlights-mode)
 #+END_SRC
@@ -4839,7 +4831,7 @@ your operation actually changed in the buffer.
 #+BEGIN_SRC emacs-lisp
 (use-package wgrep
   :ensure wgrep
-  :idle
+  :config
   (progn
     (setq wgrep-auto-save-buffer t)
     (setq wgrep-enable-key "r")
@@ -4868,7 +4860,7 @@ you were working on. When you're done, press =C-c <left>=.
 (use-package winner
   :ensure t
   :defer t
-  :idle (winner-mode 1))
+  :config (winner-mode 1))
 #+END_SRC
 ** writegood
 This highlights some /weaselwords/, a mode to /aid in finding common
@@ -4925,6 +4917,7 @@ others, this one works by just using the existing indentation of the
 file, so basically works in every halfway structured file.
 #+BEGIN_SRC emacs-lisp
 (use-package yafolding
+  :ensure t
   :bind (("C-#" . yafolding)
          ("C-c C-f" . yafolding-toggle-all-by-current-level))
   :commands (yafolding yafolding-toggle-all-by-current-level)
@@ -4953,7 +4946,7 @@ whatever the snippet holds.
   :defer t
   :diminish yas-minor-mode
   :commands yas-global-mode
-  :idle
+  :config
   (progn
     ;; Integrate hippie-expand with ya-snippet
     (add-to-list 'hippie-expand-try-functions-list
index fd14388..995e481 100644 (file)
@@ -1,33 +1,34 @@
 ;;; bind-key.el --- A simple way to manage personal keybindings
 
-;; Copyright (C) 2012 John Wiegley
+;; Copyright (c) 2012-2015 john wiegley
 
 ;; Author: John Wiegley <jwiegley@gmail.com>
+;; Maintainer: John Wiegley <jwiegley@gmail.com>
 ;; Created: 16 Jun 2012
 ;; Version: 1.0
 ;; Keywords: keys keybinding config dotemacs
 ;; URL: https://github.com/jwiegley/use-package
 
 ;; This program is free software; you can redistribute it and/or
-;; modify it under the terms of the GNU General Public License as
-;; published by the Free Software Foundation; either version 2, or (at
+;; 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 program is distributed in the hope that it will be useful, but
-;; WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-;; General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING.  If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; without any warranty; without even the implied warranty of
+;; merchantability or fitness for a particular purpose.  see the gnu
+;; general public license for more details.
+
+;; You should have received a copy of the gnu general public license
+;; along with gnu emacs; see the file copying.  if not, write to the
+;; free software foundation, inc., 59 temple place - suite 330,
+;; boston, ma 02111-1307, usa.
 \f
 ;;; Commentary:
 
 ;; If you have lots of keybindings set in your .emacs file, it can be hard to
 ;; know which ones you haven't set yet, and which may now be overriding some
-;; new default in a new Emacs version.  This module aims to solve that
+;; new default in a new emacs version.  This module aims to solve that
 ;; problem.
 ;;
 ;; Bind keys as follows in your .emacs:
@@ -51,9 +52,9 @@
 ;;
 ;;   (unbind-key "C-c x" some-other-mode-map)
 ;;
-;; To bind multiple keys at once, or set up a prefix map, a
-;; `bind-keys' macro is provided.  It accepts keyword arguments, see
-;; its documentation for detailed description.
+;; To bind multiple keys at once, or set up a prefix map, a `bind-keys' macro
+;; is provided.  It accepts keyword arguments, please see its documentation
+;; for a detailed description.
 ;;
 ;; To add keys into a specific map, use :map argument
 ;;
 ;;               ("o" . dired-omit-mode)
 ;;               ("a" . some-custom-dired-function))
 ;;
-;; To set up a prefix map, use :prefix-map and :prefix
-;; arguments (both are required)
+;; To set up a prefix map, use `:prefix-map' and `:prefix' arguments (both are
+;; required)
 ;;
 ;;    (bind-keys :prefix-map my-customize-prefix-map
 ;;               :prefix "C-c c"
 ;;               ("f" . customize-face)
 ;;               ("v" . customize-variable))
 ;;
-;; You can combine all the keywords together.
-;; Additionally, :prefix-docstring can be specified to set
-;; documentation of created :prefix-map variable.
+;; You can combine all the keywords together.  Additionally,
+;; `:prefix-docstring' can be specified to set documentation of created
+;; `:prefix-map' variable.
 ;;
 ;; To bind multiple keys in a `bind-key*' way (to be sure that your bindings
 ;; will not be overridden by other modes), you may use `bind-keys*' macro:
@@ -90,6 +91,7 @@
 ;; what the default was.  Also, it will tell you if the key was rebound after
 ;; your binding it with `bind-key', and what it was rebound it to.
 
+(require 'cl-lib)
 (require 'easy-mmode)
 
 (defgroup bind-key nil
 
 Elements have the form ((KEY . [MAP]) CMD ORIGINAL-CMD)")
 
-(defmacro bind-key (key-name command &optional keymap)
+;;;###autoload
+(defmacro bind-key (key-name command &optional keymap predicate)
   "Bind KEY-NAME to COMMAND in KEYMAP (`global-map' if not passed).
 
 KEY-NAME may be a vector, in which case it is passed straight to
 `define-key'. Or it may be a string to be interpreted as
 spelled-out keystrokes, e.g., \"C-c C-z\". See documentation of
-`edmacro-mode' for details."
+`edmacro-mode' for details.
+
+If PREDICATE is non-nil, it is a form evaluated to determine when
+a key should be bound. It must return non-nil in such cases.
+Emacs can evaluate this form at any time that it does redisplay
+or operates on menu data structures, so you should write it so it
+can safely be called at any time."
   (let ((namevar (make-symbol "name"))
         (keyvar (make-symbol "key"))
         (kdescvar (make-symbol "kdesc"))
-        (bindingvar (make-symbol "binding"))
-        (entryvar (make-symbol "entry")))
+        (bindingvar (make-symbol "binding")))
     `(let* ((,namevar ,key-name)
             (,keyvar (if (vectorp ,namevar) ,namevar
                        (read-kbd-macro ,namevar)))
             (,kdescvar (cons (if (stringp ,namevar) ,namevar
                                (key-description ,namevar))
                              (quote ,keymap)))
-            (,bindingvar (lookup-key (or ,keymap global-map)
-                                     ,keyvar))
-            (,entryvar (assoc ,kdescvar personal-keybindings)))
-       (when ,entryvar
-         (setq personal-keybindings
-               (delq ,entryvar personal-keybindings)))
-       (push (list ,kdescvar ,command
-                   (unless (numberp ,bindingvar) ,bindingvar))
-             personal-keybindings)
-       (define-key (or ,keymap global-map) ,keyvar ,command))))
+            (,bindingvar (lookup-key (or ,keymap global-map) ,keyvar)))
+       (add-to-list 'personal-keybindings
+                    (list ,kdescvar ,command
+                          (unless (numberp ,bindingvar) ,bindingvar)))
+       ,(if predicate
+            `(define-key (or ,keymap global-map) ,keyvar
+               '(menu-item "" nil :filter (lambda (&optional _)
+                                            (when ,predicate
+                                              ,command))))
+          `(define-key (or ,keymap global-map) ,keyvar ,command)))))
 
+;;;###autoload
 (defmacro unbind-key (key-name &optional keymap)
-  `(bind-key ,key-name nil ,keymap))
-
-(defmacro bind-key* (key-name command)
+  "Unbind the given KEY-NAME, within the KEYMAP (if specified).
+See `bind-key' for more details."
   `(progn
-     (bind-key ,key-name ,command)
-     (define-key override-global-map ,(read-kbd-macro key-name) ,command)))
+     (bind-key ,key-name nil ,keymap)
+     (setq personal-keybindings
+           (cl-delete-if #'(lambda (k)
+                             ,(if keymap
+                                  `(and (consp (car k))
+                                        (string= (caar k) ,key-name)
+                                        (eq (cdar k) ',keymap))
+                                `(and (stringp (car k))
+                                      (string= (car k) ,key-name))))
+                         personal-keybindings))))
 
-(defmacro bind-keys (&rest args)
+;;;###autoload
+(defmacro bind-key* (key-name command &optional predicate)
+  "Similar to `bind-key', but overrides any mode-specific bindings."
+  `(bind-key ,key-name ,command override-global-map ,predicate))
+
+(defun bind-keys-form (args)
   "Bind multiple keys at once.
 
 Accepts keyword arguments:
-:map - a keymap into which the keybindings should be added
-:prefix-map - name of the prefix map that should be created for
-              these bindings
-:prefix - prefix key for these bindings
-:prefix-docstring - docstring for the prefix-map variable
-:menu-name - optional menu string for prefix map
+:map MAP               - a keymap into which the keybindings should be
+                         added
+:prefix KEY            - prefix key for these bindings
+:prefix-map MAP        - name of the prefix map that should be created
+                         for these bindings
+:prefix-docstring STR  - docstring for the prefix-map variable
+:menu-name NAME        - optional menu string for prefix map
+:filter FORM           - optional form to determine when bindings apply
 
 The rest of the arguments are conses of keybinding string and a
 function symbol (unquoted)."
-  (let ((map (plist-get args :map))
-        (doc (plist-get args :prefix-docstring))
-        (prefix-map (plist-get args :prefix-map))
-        (prefix (plist-get args :prefix))
-        (menu-name (plist-get args :menu-name))
-        (key-bindings (progn
-                        (while (keywordp (car args))
-                          (pop args)
-                          (pop args))
-                        args)))
-    (when (or (and prefix-map
-                   (not prefix))
-              (and prefix
-                   (not prefix-map)))
+  ;; jww (2016-02-26): This is a hack; this whole function needs to be
+  ;; rewritten to normalize arguments the way that use-package.el does.
+  (if (and (eq (car args) :package)
+           (not (eq (car (cdr (cdr args))) :map)))
+      (setq args (cons :map (cons 'global-map args))))
+  (let* ((map (plist-get args :map))
+         (doc (plist-get args :prefix-docstring))
+         (prefix-map (plist-get args :prefix-map))
+         (prefix (plist-get args :prefix))
+         (filter (plist-get args :filter))
+         (menu-name (plist-get args :menu-name))
+         (pkg (plist-get args :package))
+         (key-bindings (progn
+                         (while (keywordp (car args))
+                           (pop args)
+                           (pop args))
+                         args)))
+    (when (or (and prefix-map (not prefix))
+              (and prefix (not prefix-map)))
       (error "Both :prefix-map and :prefix must be supplied"))
     (when (and menu-name (not prefix))
       (error "If :menu-name is supplied, :prefix must be too"))
-    `(progn
-       ,@(when prefix-map
+    (let ((args key-bindings)
+          saw-map first next)
+      (while args
+        (if (keywordp (car args))
+            (progn
+              (setq next args)
+              (setq args nil))
+          (if first
+              (nconc first (list (car args)))
+            (setq first (list (car args))))
+          (setq args (cdr args))))
+      (cl-flet
+          ((wrap (map bindings)
+                 (if (and map pkg (not (eq map 'global-map)))
+                     (if (boundp map)
+                         bindings
+                       `((eval-after-load
+                             ,(if (symbolp pkg) `',pkg pkg)
+                           '(progn ,@bindings))))
+                   bindings)))
+        (append
+         (when prefix-map
            `((defvar ,prefix-map)
              ,@(when doc `((put ',prefix-map 'variable-documentation ,doc)))
              ,@(if menu-name
                    `((define-prefix-command ',prefix-map nil ,menu-name))
-                   `((define-prefix-command ',prefix-map)))
-             (bind-key ,prefix ',prefix-map ,map)))
-       ,@(mapcar (lambda (form)
-                   `(bind-key ,(car form) ',(cdr form)
-                              ,(or prefix-map map)))
-                 key-bindings))))
+                 `((define-prefix-command ',prefix-map)))
+             ,@(if (and map (not (eq map 'global-map)))
+                   (wrap map `((bind-key ,prefix ',prefix-map ,map ,filter)))
+                 `((bind-key ,prefix ',prefix-map nil ,filter)))))
+         (wrap map
+               (cl-mapcan
+                (lambda (form)
+                  (if prefix-map
+                      `((bind-key ,(car form) ',(cdr form) ,prefix-map ,filter))
+                    (if (and map (not (eq map 'global-map)))
+                        `((bind-key ,(car form) ',(cdr form) ,map ,filter))
+                      `((bind-key ,(car form) ',(cdr form) nil ,filter)))))
+                first))
+         (when next
+           (bind-keys-form
+            (if pkg
+                (cons :package (cons pkg next))
+              next))))))))
+
+;;;###autoload
+(defmacro bind-keys (&rest args)
+  "Bind multiple keys at once.
+
+Accepts keyword arguments:
+:map MAP               - a keymap into which the keybindings should be
+                         added
+:prefix KEY            - prefix key for these bindings
+:prefix-map MAP        - name of the prefix map that should be created
+                         for these bindings
+:prefix-docstring STR  - docstring for the prefix-map variable
+:menu-name NAME        - optional menu string for prefix map
+:filter FORM           - optional form to determine when bindings apply
 
+The rest of the arguments are conses of keybinding string and a
+function symbol (unquoted)."
+  (macroexp-progn (bind-keys-form args)))
+
+;;;###autoload
 (defmacro bind-keys* (&rest args)
-  `(bind-keys :map override-global-map
-              ,@args))
+  (macroexp-progn
+   (bind-keys-form `(:map override-global-map ,@args))))
 
 (defun get-binding-description (elem)
   (cond
@@ -234,12 +313,10 @@ function symbol (unquoted)."
       "#<keymap>")
      (t
       elem)))
-   ((keymapp elem)
-    (if (and bind-key-describe-special-forms
-             (symbolp elem)
-             (get elem 'variable-documentation))
-        (format "%s" (get elem 'variable-documentation))
-      "#<keymap>"))
+   ;; must be a symbol, non-symbol keymap case covered above
+   ((and bind-key-describe-special-forms (keymapp elem))
+    (let ((doc (get elem 'variable-documentation)))
+      (if (stringp doc) doc elem)))
    ((symbolp elem)
     elem)
    (t
@@ -272,11 +349,13 @@ function symbol (unquoted)."
      (t
       (cons (string< (caar l) (caar r)) nil)))))
 
+;;;###autoload
 (defun describe-personal-keybindings ()
   "Display all the personal keybindings defined by `bind-key'."
   (interactive)
   (with-output-to-temp-buffer "*Personal Keybindings*"
-    (princ (format "Key name%s Command%s Comments\n%s %s ---------------------\n"
+    (princ (format (concat "Key name%s Command%s Comments\n%s %s "
+                           "---------------------\n")
                    (make-string (- (car bind-key-column-widths) 9) ? )
                    (make-string (- (cdr bind-key-column-widths) 8) ? )
                    (make-string (1- (car bind-key-column-widths)) ?-)
@@ -287,15 +366,16 @@ function symbol (unquoted)."
                      (sort personal-keybindings
                            (lambda (l r)
                              (car (compare-keybindings l r))))))
-        
+
         (if (not (eq (cdar last-binding) (cdar binding)))
             (princ (format "\n\n%s\n%s\n\n"
                            (cdar binding)
-                           (make-string (+ 21 (car bind-key-column-widths) (cdr bind-key-column-widths)) ?-)))
+                           (make-string (+ 21 (car bind-key-column-widths)
+                                           (cdr bind-key-column-widths)) ?-)))
           (if (and last-binding
                    (cdr (compare-keybindings last-binding binding)))
               (princ "\n")))
-        
+
         (let* ((key-name (caar binding))
                (at-present (lookup-key (or (symbol-value (cdar binding))
                                            (current-global-map))
@@ -309,7 +389,8 @@ function symbol (unquoted)."
                )
           (let ((line
                  (format
-                  (format "%%-%ds%%-%ds%%s\n" (car bind-key-column-widths) (cdr bind-key-column-widths))
+                  (format "%%-%ds%%-%ds%%s\n" (car bind-key-column-widths)
+                          (cdr bind-key-column-widths))
                   key-name (format "`%s\'" command-desc)
                   (if (string= command-desc at-present-desc)
                       (if (or (null was-command)
@@ -320,11 +401,13 @@ function symbol (unquoted)."
             (princ (if (string-match "[ \t]+\n" line)
                        (replace-match "\n" t t line)
                      line))))
-        
+
         (setq last-binding binding)))))
 
 (provide 'bind-key)
+
 ;; Local Variables:
 ;; indent-tabs-mode: nil
 ;; End:
+
 ;;; bind-key.el ends here
index 4d2600d..8ffa8c5 100644 (file)
@@ -4,17 +4,17 @@
 ;; Description: Extensions to `diff-mode.el'.
 ;; Author: Drew Adams
 ;; Maintainer: Drew Adams (concat "drew.adams" "@" "oracle" ".com")
-;; Copyright (C) 2004-2014, Drew Adams, all rights reserved.
+;; Copyright (C) 2004-2016, Drew Adams, all rights reserved.
 ;; Created: Mon Nov 08 16:36:09 2004
 ;; Version: 0
 ;; Package-Requires: ()
-;; Last-Updated: Thu Dec 26 08:51:41 2013 (-0800)
+;; Last-Updated: Thu Dec 31 12:54:01 2015 (-0800)
 ;;           By: dradams
-;;     Update #: 709
+;;     Update #: 712
 ;; URL: http://www.emacswiki.org/diff-mode-.el
 ;; Doc URL: http://www.emacswiki.org/DiffEnhancements
 ;; Keywords: data, matching, tools, unix, local, font, face
-;; Compatibility: GNU Emacs: 21.x, 22.x, 23.x, 24.x
+;; Compatibility: GNU Emacs: 21.x, 22.x, 23.x, 24.x, 25.x
 ;;
 ;; Features that might be required by this library:
 ;;
index d5d6ffa..ff0b0e7 100644 (file)
 ;;
 \f
-;;;### (autoloads (ace-jump-mode ace-jump-line-mode ace-jump-word-mode
-;;;;;;  ace-jump-char-mode ace-jump-mode-pop-mark) "ace-jump-mode"
-;;;;;;  "ace-jump-mode.el" (20860 60137 783821 671000))
-;;; Generated autoloads from ace-jump-mode.el
+;;;### (autoloads nil "bind-key" "bind-key.el" (0 0 0 0))
+;;; Generated autoloads from bind-key.el
 
-(autoload 'ace-jump-mode-pop-mark "ace-jump-mode" "\
-Pop up a postion from `ace-jump-mode-mark-ring', and jump back to that position
+(autoload 'bind-key "bind-key" "\
+Bind KEY-NAME to COMMAND in KEYMAP (`global-map' if not passed).
 
-\(fn)" t nil)
-
-(autoload 'ace-jump-char-mode "ace-jump-mode" "\
-AceJump char mode
-
-\(fn QUERY-CHAR)" t nil)
-
-(autoload 'ace-jump-word-mode "ace-jump-mode" "\
-AceJump word mode.
-You can set `ace-jump-word-mode-use-query-char' to nil to prevent
-asking for a head char, that will mark all the word in current
-buffer.
+KEY-NAME may be a vector, in which case it is passed straight to
+`define-key'. Or it may be a string to be interpreted as
+spelled-out keystrokes, e.g., \"C-c C-z\". See documentation of
+`edmacro-mode' for details.
 
-\(fn HEAD-CHAR)" t nil)
+If PREDICATE is non-nil, it is a form evaluated to determine when
+a key should be bound. It must return non-nil in such cases.
+Emacs can evaluate this form at any time that it does redisplay
+or operates on menu data structures, so you should write it so it
+can safely be called at any time.
 
-(autoload 'ace-jump-line-mode "ace-jump-mode" "\
-AceJump line mode.
-Marked each no empty line and move there
+\(fn KEY-NAME COMMAND &optional KEYMAP PREDICATE)" nil t)
 
-\(fn)" t nil)
-
-(autoload 'ace-jump-mode "ace-jump-mode" "\
-AceJump mode is a minor mode for you to quick jump to a
-position in the curret view.
-   There is three submode now:
-     `ace-jump-char-mode'
-     `ace-jump-word-mode'
-     `ace-jump-line-mode'
+(autoload 'unbind-key "bind-key" "\
+Unbind the given KEY-NAME, within the KEYMAP (if specified).
+See `bind-key' for more details.
 
-You can specify the sequence about which mode should enter
-by customize `ace-jump-mode-submode-list'.
+\(fn KEY-NAME &optional KEYMAP)" nil t)
 
-If you do not want to query char for word mode, you can change
-`ace-jump-word-mode-use-query-char' to nil.
+(autoload 'bind-key* "bind-key" "\
+Similar to `bind-key', but overrides any mode-specific bindings.
 
-If you don't like the default move keys, you can change it by
-setting `ace-jump-mode-move-keys'.
+\(fn KEY-NAME COMMAND &optional PREDICATE)" nil t)
 
-You can constrol whether use the case sensitive via
-`ace-jump-mode-case-fold'.
+(autoload 'bind-keys "bind-key" "\
+Bind multiple keys at once.
 
-\(fn &optional PREFIX)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (color-theme-initialize color-theme-submit color-theme-install
-;;;;;;  color-theme-compare color-theme-make-snapshot color-theme-analyze-defun
-;;;;;;  color-theme-print color-theme-install-at-point-for-current-frame
-;;;;;;  color-theme-install-at-mouse color-theme-describe color-theme-select)
-;;;;;;  "color-theme" "color-theme.el" (20865 12472 116424 798000))
-;;; Generated autoloads from color-theme.el
-
-(autoload 'color-theme-select "color-theme" "\
-Displays a special buffer for selecting and installing a color theme.
-With optional prefix ARG, this buffer will include color theme libraries
-as well.  A color theme library is in itself not complete, it must be
-used as part of another color theme to be useful.  Thus, color theme
-libraries are mainly useful for color theme authors.
+Accepts keyword arguments:
+:map MAP               - a keymap into which the keybindings should be
+                         added
+:prefix KEY            - prefix key for these bindings
+:prefix-map MAP        - name of the prefix map that should be created
+                         for these bindings
+:prefix-docstring STR  - docstring for the prefix-map variable
+:menu-name NAME        - optional menu string for prefix map
+:filter FORM           - optional form to determine when bindings apply
 
-\(fn &optional ARG)" t nil)
+The rest of the arguments are conses of keybinding string and a
+function symbol (unquoted).
 
-(autoload 'color-theme-describe "color-theme" "\
-Describe color theme listed at point.
-This shows the documentation of the value of text-property color-theme
-at point.  The text-property color-theme should be a color theme
-function.  See `color-themes'.
+\(fn &rest ARGS)" nil t)
 
-\(fn)" t nil)
+(autoload 'bind-keys* "bind-key" "\
 
-(autoload 'color-theme-install-at-mouse "color-theme" "\
-Install color theme clicked upon using the mouse.
-First argument EVENT is used to set point.  Then
-`color-theme-install-at-point' is called.
 
-\(fn EVENT)" t nil)
+\(fn &rest ARGS)" nil t)
 
-(autoload 'color-theme-install-at-point-for-current-frame "color-theme" "\
-Install color theme at point for current frame only.
-Binds `color-theme-is-global' to nil and calls
-`color-theme-install-at-point'.
+(autoload 'describe-personal-keybindings "bind-key" "\
+Display all the personal keybindings defined by `bind-key'.
 
 \(fn)" t nil)
 
-(autoload 'color-theme-print "color-theme" "\
-Print the current color theme function.
-
-You can contribute this function to <URL:news:gnu.emacs.sources> or
-paste it into your .emacs file and call it.  That should recreate all
-the settings necessary for your color theme.
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "bind-key" '("compare-keybindings" "get-binding-description" "bind-key" "personal-keybindings" "override-global-m")))
 
-Example:
+;;;***
+\f
+;;;### (autoloads nil "ganneff" "ganneff.el" (0 0 0 0))
+;;; Generated autoloads from ganneff.el
 
-    (require 'color-theme)
-    (defun my-color-theme ()
-      \"Color theme by Alex Schroeder, created 2000-05-17.\"
-      (interactive)
-      (color-theme-install
-       '(...
-        ...
-        ...)))
-    (my-color-theme)
+(autoload 'ido-disable-line-trucation "ganneff" "\
 
-If you want to use a specific color theme function, you can call the
-color theme function in your .emacs directly.
 
-Example:
+\(fn)" nil nil)
 
-    (require 'color-theme)
-    (color-theme-gnome2)
+(autoload 'match-paren "ganneff" "\
+Go to the matching parenthesis if on parenthesis otherwise insert %.
 
-\(fn &optional BUF)" t nil)
+\(fn ARG)" t nil)
 
-(autoload 'color-theme-analyze-defun "color-theme" "\
-Once you have a color-theme printed, check for missing faces.
-This is used by maintainers who receive a color-theme submission
-and want to make sure it follows the guidelines by the color-theme
-author.
+(autoload 'sacha/isearch-yank-current-word "ganneff" "\
+Pull current word from buffer into search string.
 
 \(fn)" t nil)
 
-(autoload 'color-theme-make-snapshot "color-theme" "\
-Return the definition of the current color-theme.
-The function returned will recreate the color-theme in use at the moment.
-
-\(fn)" nil nil)
-
-(autoload 'color-theme-compare "color-theme" "\
-Compare two color themes.
-This will print the differences between installing THEME-A and
-installing THEME-B.  Note that the order is important: If a face is
-defined in THEME-A and not in THEME-B, then this will not show up as a
-difference, because there is no reset before installing THEME-B.  If a
-face is defined in THEME-B and not in THEME-A, then this will show up as
-a difference.
+(autoload 'sacha/search-word-backward "ganneff" "\
+Find the previous occurrence of the current word.
 
-\(fn THEME-A THEME-B)" t nil)
+\(fn)" t nil)
 
-(autoload 'color-theme-install "color-theme" "\
-Install a color theme defined by frame parameters, variables and faces.
+(autoload 'sacha/search-word-forward "ganneff" "\
+Find the next occurrance of the current word.
 
-The theme is installed for all present and future frames; any missing
-faces are created.  See `color-theme-install-faces'.
+\(fn)" t nil)
 
-THEME is a color theme definition.  See below for more information.
+(autoload 'sacha/increase-font-size "ganneff" "\
 
-If you want to install a color theme from your .emacs, use the output
-generated by `color-theme-print'.  This produces color theme function
-which you can copy to your .emacs.
 
-A color theme definition is a list:
-\([FUNCTION] FRAME-PARAMETERS VARIABLE-SETTINGS FACE-DEFINITIONS)
+\(fn)" t nil)
 
-FUNCTION is the color theme function which called `color-theme-install'.
-This is no longer used.  There was a time when this package supported
-automatic factoring of color themes.  This has been abandoned.
+(autoload 'sacha/decrease-font-size "ganneff" "\
 
-FRAME-PARAMETERS is an alist of frame parameters.  These are installed
-with `color-theme-install-frame-params'.  These are installed last such
-that any changes to the default face can be changed by the frame
-parameters.
 
-VARIABLE-DEFINITIONS is an alist of variable settings.  These are
-installed with `color-theme-install-variables'.
+\(fn)" t nil)
 
-FACE-DEFINITIONS is an alist of face definitions.  These are installed
-with `color-theme-install-faces'.
+(autoload 'epa-dired-mode-hook "ganneff" "\
 
-If `color-theme-is-cumulative' is nil, a color theme will undo face and
-frame-parameter settings of previous color themes.
 
-\(fn THEME)" nil nil)
+\(fn)" nil nil)
 
-(autoload 'color-theme-submit "color-theme" "\
-Submit your color-theme to the maintainer.
+(autoload 'my-c-return "ganneff" "\
+When in minibuffer use `icicle-candidate-action', otherwise use `cua-set-rectangle-mark'.
 
 \(fn)" t nil)
 
-(autoload 'color-theme-initialize "color-theme" "\
-Initialize the color theme package by loading color-theme-libraries.
+(autoload 'revert-all-buffers "ganneff" "\
+Refreshes all open buffers from their respective files.
 
 \(fn)" t nil)
 
-;;;***
-\f
-;;;### (autoloads (crontab-get crontab-mode) "crontab-mode" "crontab-mode.el"
-;;;;;;  (20891 58911 0 0))
-;;; Generated autoloads from crontab-mode.el
-
-(autoload 'crontab-mode "crontab-mode" "\
-Major mode for editing crontabs.
-Defines commands for getting and applying crontabs for hosts.
-Sets up command `font-lock-mode'.
-
-\\{crontab-mode-map}
+(autoload 'move-line-up "ganneff" "\
+Move up the current line.
 
 \(fn)" t nil)
 
-(autoload 'crontab-get "crontab-mode" "\
-Get the crontab for the HOST into a buffer.
+(autoload 'move-line-down "ganneff" "\
+Move down the current line.
 
-\(fn HOST)" t nil)
+\(fn)" t nil)
 
-;;;***
-\f
-;;;### (autoloads (diminished-modes diminish-undo diminish) "diminish"
-;;;;;;  "diminish.el" (20865 30363 579223 949000))
-;;; Generated autoloads from diminish.el
-
-(autoload 'diminish "diminish" "\
-Diminish mode-line display of minor mode MODE to TO-WHAT (default \"\").
-
-Interactively, enter (with completion) the name of any minor mode, followed
-on the next line by what you want it diminished to (default empty string).
-The response to neither prompt should be quoted.  However, in Lisp code,
-both args must be quoted, the first as a symbol, the second as a string,
-as in (diminish 'jiggle-mode \" Jgl\").
-
-The mode-line displays of minor modes usually begin with a space, so
-the modes' names appear as separate words on the mode line.  However, if
-you're having problems with a cramped mode line, you may choose to use single
-letters for some modes, without leading spaces.  Capitalizing them works
-best; if you then diminish some mode to \"X\" but have abbrev-mode enabled as
-well, you'll get a display like \"AbbrevX\".  This function prepends a space
-to TO-WHAT if it's > 1 char long & doesn't already begin with a space.
-
-\(fn MODE &optional TO-WHAT)" t nil)
-
-(autoload 'diminish-undo "diminish" "\
-Restore mode-line display of diminished mode MODE to its minor-mode value.
-Do nothing if the arg is a minor mode that hasn't been diminished.
-
-Interactively, enter (with completion) the name of any diminished mode (a
-mode that was formerly a minor mode on which you invoked M-x diminish).
-To restore all diminished modes to minor status, answer `diminished-modes'.
-The response to the prompt shouldn't be quoted.  However, in Lisp code,
-the arg must be quoted as a symbol, as in (diminish-undo 'diminished-modes).
-
-\(fn MODE)" t nil)
-
-(autoload 'diminished-modes "diminish" "\
-Echo all active diminished or minor modes as if they were minor.
-The display goes in the echo area; if it's too long even for that,
-you can see the whole thing in the *Messages* buffer.
-This doesn't change the status of any modes; it just lets you see
-what diminished modes would be on the mode-line if they were still minor.
+(autoload 'jj-untabify-buffer "ganneff" "\
+Get rid of all tabs
 
 \(fn)" t nil)
 
-;;;***
-\f
-;;;### (autoloads (diredp-send-bug-report diredp-dired-plus-help
-;;;;;;  diredp-describe-mode diredp-mouse-do-chmod diredp-mouse-do-load
-;;;;;;  diredp-mouse-do-byte-compile diredp-mouse-do-compress diredp-mouse-do-grep
-;;;;;;  diredp-mouse-do-print diredp-mouse-do-hardlink diredp-mouse-do-symlink
-;;;;;;  diredp-mouse-do-shell-command diredp-mouse-do-delete diredp-mouse-downcase
-;;;;;;  diredp-mouse-upcase diredp-mouse-do-rename diredp-mouse-do-copy
-;;;;;;  diredp-mouse-flag-file-deletion diredp-mouse-mark/unmark-mark-region-files
-;;;;;;  diredp-mouse-mark-region-files diredp-mouse-mark/unmark diredp-mouse-unmark
-;;;;;;  diredp-mouse-mark diredp-mouse-backup-diff diredp-mouse-diff
-;;;;;;  diredp-mouse-ediff diredp-mouse-view-file diredp-mouse-find-file
-;;;;;;  dired-mouse-find-file-other-window diredp-mouse-find-file-other-frame
-;;;;;;  diredp-find-file-other-frame diredp-mouse-3-menu diredp-toggle-marks-in-region
-;;;;;;  diredp-flag-region-files-for-deletion diredp-unmark-region-files
-;;;;;;  diredp-mark-region-files dired-mark-sexp diredp-chmod-this-file
-;;;;;;  diredp-load-this-file diredp-byte-compile-this-file diredp-mouse-describe-file
-;;;;;;  diredp-describe-file diredp-mouse-copy-tags diredp-copy-tags-this-file
-;;;;;;  diredp-set-tag-value-this-file diredp-paste-replace-tags-this-file
-;;;;;;  diredp-paste-add-tags-this-file diredp-remove-all-tags-this-file
-;;;;;;  diredp-untag-this-file diredp-tag-this-file diredp-bookmark-this-file
-;;;;;;  diredp-shell-command-this-file diredp-compress-this-file
-;;;;;;  diredp-grep-this-file diredp-print-this-file diredp-hardlink-this-file
-;;;;;;  diredp-symlink-this-file diredp-relsymlink-this-file diredp-copy-this-file
-;;;;;;  diredp-rename-this-file diredp-upcase-this-file diredp-downcase-this-file
-;;;;;;  diredp-capitalize-this-file diredp-delete-this-file diredp-capitalize
-;;;;;;  dired-mark-files-regexp dired-do-delete dired-do-flagged-delete
-;;;;;;  dired-goto-file dired-up-directory dired-do-find-marked-files
-;;;;;;  dired-maybe-insert-subdir dired-do-load dired-do-byte-compile
-;;;;;;  dired-do-compress diredp-ediff diredp-omit-unmarked diredp-omit-marked
-;;;;;;  diredp-toggle-find-file-reuse-dir diredp-mouse-find-file-reuse-dir-buffer
-;;;;;;  diredp-find-file-reuse-dir-buffer diredp-do-bookmark-in-bookmark-file
-;;;;;;  diredp-set-bookmark-file-bookmark-for-marked diredp-mouse-do-bookmark
-;;;;;;  diredp-do-bookmark diredp-mouse-do-set-tag-value diredp-do-set-tag-value
-;;;;;;  diredp-mouse-do-paste-replace-tags diredp-do-paste-replace-tags
-;;;;;;  diredp-mouse-do-paste-add-tags diredp-do-paste-add-tags diredp-mouse-do-remove-all-tags
-;;;;;;  diredp-do-remove-all-tags diredp-mouse-do-untag diredp-do-untag
-;;;;;;  diredp-mouse-do-tag diredp-do-tag diredp-unmark-files-tagged-not-all
-;;;;;;  diredp-unmark-files-tagged-some diredp-unmark-files-tagged-none
-;;;;;;  diredp-unmark-files-tagged-all diredp-unmark-files-tagged-regexp
-;;;;;;  diredp-mark-files-tagged-regexp diredp-mark-files-tagged-not-all
-;;;;;;  diredp-mark-files-tagged-some diredp-mark-files-tagged-none
-;;;;;;  diredp-mark-files-tagged-all diredp-mark/unmark-extension
-;;;;;;  diredp-marked-other-window diredp-marked diredp-do-redisplay-recursive
-;;;;;;  diredp-do-touch-recursive diredp-do-chmod-recursive diredp-do-copy-recursive
-;;;;;;  diredp-do-move-recursive diredp-downcase-recursive diredp-upcase-recursive
-;;;;;;  diredp-capitalize-recursive diredp-copy-filename-as-kill-recursive
-;;;;;;  diredp-list-marked-recursive diredp-marked-recursive-other-window
-;;;;;;  diredp-marked-recursive diredp-do-grep-recursive diredp-do-query-replace-regexp-recursive
-;;;;;;  diredp-do-find-marked-files-recursive diredp-set-bookmark-file-bookmark-for-marked-recursive
-;;;;;;  diredp-do-bookmark-in-bookmark-file-recursive diredp-do-bookmark-recursive
-;;;;;;  diredp-image-dired-comment-files-recursive diredp-image-dired-delete-tag-recursive
-;;;;;;  diredp-image-dired-tag-files-recursive diredp-image-dired-display-thumbs-recursive
-;;;;;;  diredp-do-print-recursive diredp-do-hardlink-recursive diredp-do-symlink-recursive
-;;;;;;  diredp-do-shell-command-recursive diredp-insert-subdirs-recursive
-;;;;;;  diredp-insert-subdirs diredp-dired-inserted-subdirs diredp-dired-this-subdir
-;;;;;;  diredp-fileset diredp-dired-union-other-window diredp-dired-union
-;;;;;;  diredp-dired-for-files-other-window diredp-dired-for-files
-;;;;;;  diredp-dired-files-other-window diredp-dired-files diredp-w32-local-drives
-;;;;;;  diredp-prompt-for-bookmark-prefix-flag diff-switches) "dired+"
-;;;;;;  "dired+.el" (20858 49922 429890 970000))
-;;; Generated autoloads from dired+.el
-
-(defvar diff-switches "-c" "\
-*A string or list of strings specifying switches to be passed to diff.")
-
-(custom-autoload 'diff-switches "dired+" t)
-
-(defvar diredp-prompt-for-bookmark-prefix-flag nil "\
-*Non-nil means prompt for a prefix string for bookmark names.")
-
-(custom-autoload 'diredp-prompt-for-bookmark-prefix-flag "dired+" t)
-
-(defvar diredp-w32-local-drives '(("C:" "Local disk")) "\
-*Local MS Windows drives that you want to use for `diredp-w32-drives'.
-Each entry is a list (DRIVE DESCRIPTION), where DRIVE is the drive
-name and DESCRIPTION describes DRIVE.")
-
-(custom-autoload 'diredp-w32-local-drives "dired+" t)
-
-(autoload 'diredp-dired-files "dired+" "\
-Like `dired', but non-positive prefix arg prompts for files to list.
-This is like `dired' unless you use a non-positive prefix arg.
-In that case, you are prompted for names of files and directories to
-list, and then you are prompted for the name of the Dired buffer that
-lists them.  Use `C-g' when you are done entering file names to list.
-
-In all cases, when inputting a file or directory name you can use
-shell wildcards.
-
-If you use Icicles, then in Icicle mode the following keys are bound
-in the minibuffer during completion (`*' means the key requires
-library `Bookmark+'):
-
-  M-|       - Open Dired on the file names matching your input
-  C-c +     - Create a new directory
- *C-x a +   - Add tags to the current-candidate file
- *C-x a -   - Remove tags from the current-candidate file
- *C-x m     - Access file bookmarks (not just autofiles)
-
-\(fn ARG &optional SWITCHES)" t nil)
-
-(autoload 'diredp-dired-files-other-window "dired+" "\
-Same as `diredp-dired-files' except uses another window.
-
-\(fn ARG &optional SWITCHES)" t nil)
-
-(autoload 'diredp-dired-for-files "dired+" "\
-Like `dired', but prompts for the specific files to list.
-You are prompted for names of files and directories to list, and then
-you are prompted for the name of the Dired buffer that lists them.
-Use `C-g' when you are done entering file names to list.
-
-In all cases, when inputting a file or directory name you can use
-shell wildcards.
-
-If you use Icicles, then in Icicle mode the following keys are bound
-in the minibuffer during completion (`*' means the key requires
-library `Bookmark+'):
-
-  M-|       - Open Dired on the file names matching your input
-  C-c +     - Create a new directory
- *C-x a +   - Add tags to the current-candidate file
- *C-x a -   - Remove tags from the current-candidate file
- *C-x m     - Access file bookmarks (not just autofiles)
-
-\(fn ARG &optional SWITCHES)" t nil)
-
-(autoload 'diredp-dired-for-files-other-window "dired+" "\
-Same as `diredp-dired-for-files' except uses another window.
-
-\(fn ARG &optional SWITCHES)" t nil)
-
-(autoload 'diredp-dired-union "dired+" "\
-Create a Dired buffer that is the union of some existing Dired buffers.
-With a prefix arg, read `ls' switches.
-You are prompted for the Dired buffers.  Use `C-g' when done choosing
-them.  Then you are prompted for the name of the new Dired buffer.
-Its `default-directory' is the same as the `default-directory' before
-invoking the command.
-
-The selected Dired listings are included in the order that you choose
-them, and each entry is listed only once in the new Dired buffer.  The
-new Dired listing respects the markings, subdirectory insertions, and
-hidden subdirectories of the selected Dired listings.
+(autoload 'prelude-sudo-edit "ganneff" "\
+Edit currently visited file as root.
 
-However, in case of conflict between marked or unmarked status for the
-same entry, the entry is marked.  Similarly, in case of conflict over
-an included subdirectory between it being hidden or shown, it is
-hidden, but its contained files are also listed.
+With a prefix ARG prompt for a file to visit.
+Will also prompt for a file to visit if current
+buffer is not visiting a file.
 
-\(fn DIRBUFS &optional SWITCHES)" t nil)
+\(fn &optional ARG)" t nil)
 
-(autoload 'diredp-dired-union-other-window "dired+" "\
-Same as `diredp-dired-union' but uses another window.
+(autoload 'lisp-coding-defaults "ganneff" "\
 
-\(fn DIRBUFS &optional SWITCHES)" t nil)
 
-(autoload 'diredp-fileset "dired+" "\
-Open Dired on the files in fileset FLSET-NAME.
+\(fn)" nil nil)
 
-\(fn FLSET-NAME)" t nil)
+(autoload 'interactive-lisp-coding-defaults "ganneff" "\
 
-(autoload 'diredp-dired-this-subdir "dired+" "\
-Open Dired for the subdir at or above point.
-If point is not on a subdir line, but is in an inserted subdir
-listing, then use that subdir.
 
-With a prefix arg:
- If the subdir is inserted and point is in the inserted listing then
- remove that listing and move to the ordinary subdir line.  In other
- words, when in an inserted listing, a prefix arg tears off the
- inserted subdir to its own Dired buffer.
+\(fn)" nil nil)
 
-\(fn &optional TEAR-OFF-P MSGP)" t nil)
+(autoload 'prelude-remove-elc-on-save "ganneff" "\
+If you're saving an elisp file, likely the .elc is no longer valid.
 
-(autoload 'diredp-dired-inserted-subdirs "dired+" "\
-Open Dired for each of the subdirs inserted in this Dired buffer.
-With a prefix arg, create the Dired buffers but do not display them.
-Markings and current Dired switches are preserved.
+\(fn)" nil nil)
 
-\(fn &optional NO-SHOW-P MSGP)" t nil)
+(autoload 'prelude-emacs-lisp-mode-defaults "ganneff" "\
 
-(autoload 'diredp-insert-subdirs "dired+" "\
-Insert the marked subdirectories.
-Like using \\<dired-mode-map>`\\[dired-maybe-insert-subdir]' at each marked directory line.
 
-\(fn &optional SWITCHES)" t nil)
+\(fn)" nil nil)
 
-(autoload 'diredp-insert-subdirs-recursive "dired+" "\
-Insert the marked subdirs, including those in marked subdirs.
-Like `diredp-insert-subdirs', but act recursively on subdirs.
-The subdirs inserted are those that are marked in the current Dired
-buffer, or all subdirs in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way (their marked
-subdirs are inserted...).
+(autoload 'clean-mode-line "ganneff" "\
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
+\(fn)" t nil)
 
-(autoload 'diredp-do-shell-command-recursive "dired+" "\
-Run shell COMMAND on the marked files, including those in marked subdirs.
-Like `dired-do-shell-command', but act recursively on subdirs.
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+(autoload 'force-backup-of-buffer "ganneff" "\
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
 
-\(fn COMMAND &optional IGNORE-MARKS-P)" t nil)
+\(fn)" nil nil)
 
-(autoload 'diredp-do-symlink-recursive "dired+" "\
-Make symbolic links to marked files, including those in marked subdirs.
-Like `dired-do-symlink', but act recursively on subdirs to pick up the
-files to link.
+(autoload 'prelude-kill-other-buffers "ganneff" "\
+Kill all buffers but the current one.
+Doesn't mess with special buffers.
 
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+\(fn)" t nil)
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+(autoload 'just-one-space-with-newline "ganneff" "\
+Call just-one-space with a negative argument
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
+\(fn)" t nil)
 
-(autoload 'diredp-do-hardlink-recursive "dired+" "\
-Add hard links for marked files, including those in marked subdirs.
-Like `dired-do-hardlink', but act recursively on subdirs to pick up the
-files to link.
+(autoload 'font-lock-comment-annotations "ganneff" "\
+Highlight a bunch of well known comment annotations.
 
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+This functions should be added to the hooks of major modes for programming.
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+\(fn)" nil nil)
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
+(autoload 'jj-open-shell "ganneff" "\
+Open a shell in the directory of the current buffer file
 
-(autoload 'diredp-do-print-recursive "dired+" "\
-Print the marked files, including those in marked subdirs.
-Like `dired-do-print', but act recursively on subdirs to pick up the
-files to print.
+\(fn)" t nil)
 
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+(autoload 'url-humanify "ganneff" "\
+Take the URL at point and make it human readable.
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+\(fn)" t nil)
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
+(autoload 'url-decode-region "ganneff" "\
+Replace a region with the same contents, only URL decoded.
 
-(autoload 'diredp-image-dired-display-thumbs-recursive "dired+" "\
-Display thumbnails of marked files, including those in marked subdirs.
-Like `image-dired-display-thumbs', but act recursively on subdirs.
-Optional arguments APPEND and DO-NOT-POP are as for
-`image-dired-display-thumbs'.
+\(fn START END)" t nil)
 
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+(autoload 'align-code "ganneff" "\
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
 
-\(fn &optional IGNORE-MARKS-P APPEND DO-NOT-POP)" t nil)
+\(fn BEG END &optional ARG)" t nil)
 
-(autoload 'diredp-image-dired-tag-files-recursive "dired+" "\
-Tag marked file(s) in dired, including those in marked subdirs
-Like `image-dired-tag-files', but act recursively on subdirs.
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+(autoload 'insert-date "ganneff" "\
+Insert the current date. With prefix-argument, use ISO format. With
+   two prefix arguments, write out the day and month name.
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+\(fn PREFIX)" t nil)
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
+(autoload 'occur-dwim "ganneff" "\
+Call `occur' with a sane default.
 
-(autoload 'diredp-image-dired-delete-tag-recursive "dired+" "\
-Remove tag for selected file(s), including those in marked subdirs.
-Like `image-dired-delete-tag', but act recursively on subdirs.
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+\(fn)" t nil)
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+(autoload 'toggle-letter-case "ganneff" "\
+Toggle the letter case of current word or text selection.
+Toggles between: “all lower”, “Init Caps”, “ALL CAPS”.
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
+\(fn)" t nil)
 
-(autoload 'diredp-image-dired-comment-files-recursive "dired+" "\
-Add comment to marked files in dired, including those in marked subdirs.
-Like `image-dired-dired-comment-files' but act recursively on subdirs.
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+;;;***
+\f
+;;;### (autoloads nil "ganneff-gnus" "ganneff-gnus.el" (0 0 0 0))
+;;; Generated autoloads from ganneff-gnus.el
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+(autoload 'gnus-nnimap-count-format "ganneff-gnus" "\
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
 
-(autoload 'diredp-do-bookmark-recursive "dired+" "\
-Bookmark the marked files, including those in marked subdirs.
-Like `diredp-do-bookmark', but act recursively on subdirs.
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+\(fn N)" nil nil)
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+(autoload 'gnus-user-format-function-t "ganneff-gnus" "\
 
-\(fn &optional IGNORE-MARKS-P PREFIX)" t nil)
 
-(autoload 'diredp-do-bookmark-in-bookmark-file-recursive "dired+" "\
-Bookmark files here and below in BOOKMARK-FILE and save BOOKMARK-FILE.
-Like `diredp-do-bookmark-in-bookmark-file', but act recursively on
-subdirs.  The files included are those that are marked in the current
-Dired buffer, or all files in the directory if none are marked.
-Marked subdirectories are handled recursively in the same way.
+\(fn DUMMY)" nil nil)
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+(autoload 'gnus-user-format-function-x "ganneff-gnus" "\
 
-\(fn BOOKMARK-FILE &optional PREFIX IGNORE-MARKS-P BFILE-BOOKMARKP)" t nil)
 
-(autoload 'diredp-set-bookmark-file-bookmark-for-marked-recursive "dired+" "\
-Bookmark the marked files and create a bookmark-file bookmark for them.
-Like `diredp-set-bookmark-file-bookmark-for-marked', but act
-recursively on subdirs.
+\(fn DUMMY)" nil nil)
 
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+(autoload 'empty-common-prefix "ganneff-gnus" "\
+Given `left' '(\"foo\" \"bar\" \"fie\") and `right' '(\"foo\"
+    \"bar\" \"fum\"), return '(\"   \" \"   \" \"fum\").
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+\(fn LEFT RIGHT)" nil nil)
 
-\(fn BOOKMARK-FILE &optional PREFIX ARG)" t nil)
+(autoload 'gnus-user-format-function-g "ganneff-gnus" "\
+The full group name, but if it starts with a previously seen
+    prefix, empty that prefix.
 
-(autoload 'diredp-do-find-marked-files-recursive "dired+" "\
-Find marked files simultaneously, including those in marked subdirs.
-Like `dired-do-find-marked-files', but act recursively on subdirs.
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+\(fn ARG)" nil nil)
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+(autoload 'nnimap-message-count-cache-clear "ganneff-gnus" "\
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
 
-(autoload 'diredp-do-query-replace-regexp-recursive "dired+" "\
-Do `query-replace-regexp' of FROM with TO, on all marked files.
-If you exit (\\[keyboard-quit], RET or q), you can resume the query replace
-with the command \\[tags-loop-continue].
+\(fn)" nil nil)
 
-\(fn FROM TO &optional IGNORE-MARKS-P)" t nil)
+(autoload 'nnimap-message-count-cache-get "ganneff-gnus" "\
 
-(autoload 'diredp-do-grep-recursive "dired+" "\
-Run `grep' on marked files, including those in marked subdirs.
-Like `diredp-do-grep', but act recursively on subdirs.
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+\(fn GROUP)" nil nil)
 
-\(fn COMMAND-ARGS &optional IGNORE-MARKS-P)" t nil)
+(autoload 'nnimap-message-count-cache-set "ganneff-gnus" "\
 
-(autoload 'diredp-marked-recursive "dired+" "\
-Open Dired on marked files, including those in marked subdirs.
-Like `diredp-marked', but act recursively on subdirs.
 
-See `diredp-do-find-marked-files-recursive' for a description of the
-files included.  In particular, if no files are marked here or in a
-marked subdir, then all files in the directory are included.
+\(fn GROUP COUNT)" nil nil)
 
-\(fn DIRNAME &optional IGNORE-MARKED-P)" t nil)
+(autoload 'nnimap-request-message-counts "ganneff-gnus" "\
 
-(autoload 'diredp-marked-recursive-other-window "dired+" "\
-Same as `diredp-marked-recursive', but uses a different window.
 
-\(fn DIRNAME &optional IGNORE-MARKED-P)" t nil)
+\(fn GROUP METHOD)" nil nil)
 
-(autoload 'diredp-list-marked-recursive "dired+" "\
-List the files marked here and in marked subdirs, recursively.
-See `diredp-do-find-marked-files-recursive' for a description of the
-files included.  In particular, if no files are marked here or in a
-marked subdir, then all files in the directory are included.
+(autoload 'nnimap-fetch-message-counts "ganneff-gnus" "\
 
-Non-interactively, non-nil PREDICATE is a file-name predicate.  List
-only the files for which it returns non-nil.
 
-\(fn &optional IGNORE-MARKS-P PREDICATE)" t nil)
+\(fn GROUP METHOD)" nil nil)
 
-(autoload 'diredp-copy-filename-as-kill-recursive "dired+" "\
-Copy names of marked files here and in marked subdirs, to `kill-ring'.
-The names are separated by a space.
+(autoload 'jj-forward-spam "ganneff-gnus" "\
 
-Like `dired-copy-filename-as-kill', but act recursively on subdirs.
-\(Do not copy subdir names themselves.)
 
-With no prefix arg, use relative file names.
-With a zero prefix arg, use absolute file names.
-With a plain prefix arg (`C-u'), use names relative to the current
-Dired directory.  (This might contain slashes if in a subdirectory.)
+\(fn)" t nil)
 
-If on a subdir headerline, use absolute subdir name instead - prefix
-arg and marked files are ignored in this case.
+(autoload 'jj-forward-ham-lists-debconf "ganneff-gnus" "\
 
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
 
-\(fn &optional ARG)" t nil)
+\(fn)" t nil)
 
-(autoload 'diredp-capitalize-recursive "dired+" "\
-Rename marked files, including in marked subdirs, by capitalizing them.
-Like `diredp-capitalize', but act recursively on subdirs.
+(autoload 'jj-forward-spam-lists-debconf "ganneff-gnus" "\
 
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+\(fn)" t nil)
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
+(autoload 'jj-forward-ham-lists-oftc "ganneff-gnus" "\
 
-(autoload 'diredp-upcase-recursive "dired+" "\
-Rename marked files, including in marked subdirs, making them uppercase.
-Like `dired-upcase', but act recursively on subdirs.
 
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+\(fn)" t nil)
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+(autoload 'jj-forward-spam-lists-oftc "ganneff-gnus" "\
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
 
-(autoload 'diredp-downcase-recursive "dired+" "\
-Rename marked files, including in marked subdirs, making them lowercase.
-Like `dired-downcase', but act recursively on subdirs.
+\(fn)" t nil)
 
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+(autoload 'jj-forward-ham-lists-spi "ganneff-gnus" "\
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
+\(fn)" t nil)
 
-(autoload 'diredp-do-move-recursive "dired+" "\
-Move marked files, including in marked subdirs, to a given directory.
-Like `dired-do-rename', but act recursively on subdirs to pick up the
-files to move.
+(autoload 'jj-forward-spam-lists-spi "ganneff-gnus" "\
 
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
 
-This means move the marked files of marked subdirs and their marked
-subdirs, etc.  It does not mean move or rename the subdirs themselves
-recursively.
+\(fn)" t nil)
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+(autoload 'jj-forward-issue "ganneff-gnus" "\
 
-Renames any buffers that are visiting the files.
 
-The default suggested for the target directory depends on the value of
-`dired-dwim-target', which see.
+\(fn)" t nil)
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
+(autoload 'jj-move-mail-spambox "ganneff-gnus" "\
 
-(autoload 'diredp-do-copy-recursive "dired+" "\
-Copy marked files, including in marked subdirs, to a given directory.
-Like `dired-do-copy', but act recursively on subdirs to pick up the
-files to copy.
 
-The files included are those that are marked in the current Dired
-buffer, or all files in the directory if none are marked.  Marked
-subdirectories are handled recursively in the same way.
+\(fn)" t nil)
 
-This means copy the marked files of marked subdirs and their marked
-subdirs, etc.  It does not mean copy the subdirs themselves
-recursively.
+(autoload 'jj-copy-mail-hambox "ganneff-gnus" "\
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
 
-Preserves the last-modified date when copying, unless
-`dired-copy-preserve-time' is nil.
+\(fn)" t nil)
 
-The default suggested for the target directory depends on the value of
-`dired-dwim-target', which see.
+(autoload 'gnus-user-format-function-y "ganneff-gnus" "\
+Convert the DATE to DD.MM.YYYY, HH:MM.
 
-This command copies symbolic links by creating new ones, like UNIX
-command `cp -d'.
+\(fn HEADER)" nil nil)
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
+(autoload 'my-message-add-content "ganneff-gnus" "\
 
-(autoload 'diredp-do-chmod-recursive "dired+" "\
-Change the mode of the marked files, including those in marked subdirs.
-Symbolic modes like `g+w' are allowed.
 
-Note that marked subdirs are not changed.  Their markings are used only
-to indicate that some of their files are to be changed.
+\(fn)" nil nil)
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
+(autoload 'my-message-header-setup-hook "ganneff-gnus" "\
 
-(autoload 'diredp-do-touch-recursive "dired+" "\
-Change the timestamp of marked files, including those in marked subdirs.
-This calls `touch'.  Like `dired-do-touch', but act recursively on
-subdirs.  The subdirs inserted are those that are marked in the
-current Dired buffer, or all subdirs in the directory if none are
-marked.  Marked subdirectories are handled recursively in the same
-way.
 
-With a prefix argument, ignore all marks - include all files in this
-Dired buffer and all subdirs, recursively.
+\(fn)" nil nil)
 
-\(fn &optional IGNORE-MARKS-P)" t nil)
+(autoload 'us-get-only-mail "ganneff-gnus" "\
+Fetch new mails
 
-(autoload 'diredp-do-redisplay-recursive "dired+" "\
-Redisplay marked file lines, including those in marked subdirs.
-Like `dired-do-redisplay' with no args, but act recursively on
-subdirs.
+\(fn)" nil nil)
 
-\(fn &optional MSGP)" t nil)
+(autoload 'september-citation-line "ganneff-gnus" "\
 
-(autoload 'diredp-marked "dired+" "\
-Open Dired on only the marked files or the next N files.
-With a non-zero numeric prefix arg N, use the next abs(N) files.
-A plain (`C-u'), zero, or negative prefix arg prompts for listing
-switches as in command `dired'.
 
-Note that the marked files can include files in inserted
-subdirectories, so the Dired buffer that is opened can contain files
-from multiple directories in the same tree.
+\(fn)" t nil)
 
-\(fn DIRNAME &optional N SWITCHES)" t nil)
+(autoload 'gnus-decay-score "ganneff-gnus" "\
+Decay SCORE.
+     This is done according to `gnus-score-decay-constant'
+     and `gnus-score-decay-scale'.
 
-(autoload 'diredp-marked-other-window "dired+" "\
-Same as `diredp-marked', but uses a different window.
+\(fn SCORE)" nil nil)
 
-\(fn DIRNAME &optional N SWITCHES)" t nil)
+(autoload 'message-utils-setup "ganneff-gnus" "\
+Add menu-entries for message-utils.
 
-(autoload 'diredp-mark/unmark-extension "dired+" "\
-Mark all files with a certain EXTENSION for use in later commands.
-A `.' is not automatically prepended to the string entered.
-Non-nil prefix argument UNMARK-P means unmark instead of mark.
+\(fn)" nil nil)
 
-\(fn EXTENSION &optional UNMARK-P)" t nil)
+(autoload 'gnus-scum-expunge "ganneff-gnus" "\
+Remove this spammer from existance as much as possible.
 
-(autoload 'diredp-mark-files-tagged-all "dired+" "\
-Mark all files that are tagged with *each* tag in TAGS.
-As a special case, if TAGS is empty, then mark the files that have
- any tags at all (i.e., at least one tag).
-With a prefix arg, mark all that are *not* tagged with *any* TAGS.
-You need library `bookmark+.el' to use this command.
+\(fn)" t nil)
 
-\(fn TAGS &optional NONE-P PREFIX)" t nil)
+(autoload 'lld-notmuch-shortcut "ganneff-gnus" "\
 
-(autoload 'diredp-mark-files-tagged-none "dired+" "\
-Mark all files that are not tagged with *any* tag in TAGS.
-As a special case, if TAGS is empty, then mark the files that have
- no tags at all.
-With a prefix arg, mark all that are tagged with *each* tag in TAGS.
-You need library `bookmark+.el' to use this command.
 
-\(fn TAGS &optional ALLP PREFIX)" t nil)
+\(fn)" nil nil)
 
-(autoload 'diredp-mark-files-tagged-some "dired+" "\
-Mark all files that are tagged with *some* tag in TAGS.
-As a special case, if TAGS is empty, then mark the files that have
- any tags at all (i.e., at least one tag).
-With a prefix arg, mark all that are *not* tagged with *all* TAGS.
-You need library `bookmark+.el' to use this command.
+(autoload 'lld-notmuch-file-to-group "ganneff-gnus" "\
+Calculate the Gnus group name from the given file name.
 
-\(fn TAGS &optional SOMENOTP PREFIX)" t nil)
+\(fn FILE)" nil nil)
 
-(autoload 'diredp-mark-files-tagged-not-all "dired+" "\
-Mark all files that are not tagged with *all* TAGS.
-As a special case, if TAGS is empty, then mark the files that have
- no tags at all.
-With a prefix arg, mark all that are tagged with *some* TAGS.
-You need library `bookmark+.el' to use this command.
+(autoload 'lld-notmuch-goto-message-in-gnus "ganneff-gnus" "\
+Open a summary buffer containing the current notmuch article.
 
-\(fn TAGS &optional SOMEP PREFIX)" t nil)
+\(fn)" t nil)
 
-(autoload 'diredp-mark-files-tagged-regexp "dired+" "\
-Mark files that have at least one tag that matches REGEXP.
-With a prefix arg, mark all that are tagged but have no matching tags.
-You need library `bookmark+.el' to use this command.
+(autoload 'gnus-user-format-function-topic-line "ganneff-gnus" "\
 
-\(fn REGEXP &optional NOTP PREFIX)" t nil)
 
-(autoload 'diredp-unmark-files-tagged-regexp "dired+" "\
-Unmark files that have at least one tag that matches REGEXP.
-With a prefix arg, unmark all that are tagged but have no matching tags.
-You need library `bookmark+.el' to use this command.
+\(fn DUMMY)" nil nil)
 
-\(fn REGEXP &optional NOTP PREFIX)" t nil)
+(autoload 'sign-or-crypt "ganneff-gnus" "\
 
-(autoload 'diredp-unmark-files-tagged-all "dired+" "\
-Unmark all files that are tagged with *each* tag in TAGS.
-As a special case, if TAGS is empty, then unmark the files that have
- any tags at all (i.e., at least one tag).
-With a prefix arg, unmark all that are *not* tagged with *any* TAGS.
-You need library `bookmark+.el' to use this command.
 
-\(fn TAGS &optional NONE-P PREFIX)" t nil)
+\(fn)" t nil)
 
-(autoload 'diredp-unmark-files-tagged-none "dired+" "\
-Unmark all files that are *not* tagged with *any* tag in TAGS.
-As a special case, if TAGS is empty, then unmark the files that have
- no tags at all.
-With a prefix arg, unmark all that are tagged with *each* tag in TAGS.
-You need library `bookmark+.el' to use this command.
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ganneff-gnus" '("nnimap-message-count-cache-alist" "gnus-user-format-function-g-prev")))
 
-\(fn TAGS &optional ALLP PREFIX)" t nil)
+;;;***
+\f
+;;;### (autoloads nil "ganneff-org" "ganneff-org.el" (21044 6542
+;;;;;;  817600 508000))
+;;; Generated autoloads from ganneff-org.el
 
-(autoload 'diredp-unmark-files-tagged-some "dired+" "\
-Unmark all files that are tagged with *some* tag in TAGS.
-As a special case, if TAGS is empty, then unmark the files that have
- any tags at all.
-With a prefix arg, unmark all that are *not* tagged with *all* TAGS.
-You need library `bookmark+.el' to use this command.
+(autoload 'bh/show-org-agenda "ganneff-org" "\
+Show org-modes agenda.
 
-\(fn TAGS &optional SOMENOTP PREFIX)" t nil)
+\(fn)" t nil)
 
-(autoload 'diredp-unmark-files-tagged-not-all "dired+" "\
-Unmark all files that are *not* tagged with *all* TAGS.
-As a special case, if TAGS is empty, then unmark the files that have
- no tags at all.
-With a prefix arg, unmark all that are tagged with *some* TAGS.
-You need library `bookmark+.el' to use this command.
+(autoload 'bh/verify-refile-target "ganneff-org" "\
+Exclude todo keywords with a done state from refile targets.
 
-\(fn TAGS &optional SOMEP PREFIX)" t nil)
+\(fn)" nil nil)
 
-(autoload 'diredp-do-tag "dired+" "\
-Tag the marked (or the next prefix argument) files.
-You need library `bookmark+.el' to use this command.
+(autoload 'bh/agenda-sort-test "ganneff-org" "\
+Test for agenda sort.
 
-Hit `RET' to enter each tag, then hit `RET' again after the last tag.
-You can use completion to enter each tag.  Completion is lax: you are
-not limited to existing tags.
+\(fn FN A B)" nil t)
 
-TAGS is a list of strings.  PREFIX is as for `diredp-do-bookmark'.
+(autoload 'bh/agenda-sort-test-num "ganneff-org" "\
 
-A prefix argument ARG specifies files to use instead of those marked.
- An integer means use the next ARG files (previous -ARG, if < 0).
- `C-u': Use the current file (whether or not any are marked).
- `C-u C-u': Use all files in Dired, except directories.
- `C-u C-u C-u': Use all files and directories, except `.' and `..'.
- `C-u C-u C-u C-u': Use all files and all directories.
 
-\(fn TAGS &optional PREFIX ARG)" t nil)
+\(fn FN COMPFN A B)" nil t)
 
-(autoload 'diredp-mouse-do-tag "dired+" "\
-In Dired, add some tags to this file.
-You need library `bookmark+.el' to use this command.
+(autoload 'bh/agenda-sort "ganneff-org" "\
+Sorting strategy for agenda items.
+Late deadlines first, then scheduled, then non-late deadlines
 
-\(fn EVENT)" t nil)
+\(fn A B)" nil nil)
 
-(autoload 'diredp-do-untag "dired+" "\
-Remove some tags from the marked (or the next prefix arg) files.
-You need library `bookmark+.el' to use this command.
+(autoload 'bh/is-not-scheduled-or-deadline "ganneff-org" "\
 
-Hit `RET' to enter each tag, then hit `RET' again after the last tag.
-You can use completion to enter each tag.  Completion is lax: you are
-not limited to existing tags.
 
-TAGS is a list of strings.  PREFIX is as for `diredp-do-bookmark'.
+\(fn DATE-STR)" nil nil)
 
-A prefix argument ARG specifies files to use instead of those marked.
- An integer means use the next ARG files (previous -ARG, if < 0).
- `C-u': Use the current file (whether or not any are marked).
- `C-u C-u': Use all files in Dired, except directories.
- `C-u C-u C-u': Use all files and directories, except `.' and `..'.
- `C-u C-u C-u C-u': Use all files and all directories.
+(autoload 'bh/is-due-deadline "ganneff-org" "\
 
-\(fn TAGS &optional PREFIX ARG)" t nil)
 
-(autoload 'diredp-mouse-do-untag "dired+" "\
-In Dired, remove some tags from this file.
-You need library `bookmark+.el' to use this command.
+\(fn DATE-STR)" nil nil)
 
-\(fn EVENT)" t nil)
+(autoload 'bh/is-late-deadline "ganneff-org" "\
 
-(autoload 'diredp-do-remove-all-tags "dired+" "\
-Remove all tags from the marked (or the next prefix arg) files.
-You need library `bookmark+.el' to use this command.
 
-PREFIX is as for `diredp-do-bookmark'.
+\(fn DATE-STR)" nil nil)
 
-A prefix argument ARG specifies files to use instead of those marked.
- An integer means use the next ARG files (previous -ARG, if < 0).
- `C-u': Use the current file (whether or not any are marked).
- `C-u C-u': Use all files in Dired, except directories.
- `C-u C-u C-u': Use all files and directories, except `.' and `..'.
- `C-u C-u C-u C-u': Use all files and all directories.
+(autoload 'bh/is-pending-deadline "ganneff-org" "\
 
-\(fn &optional PREFIX ARG)" t nil)
 
-(autoload 'diredp-mouse-do-remove-all-tags "dired+" "\
-In Dired, remove all tags from the marked (or next prefix arg) files.
-You need library `bookmark+.el' to use this command.
+\(fn DATE-STR)" nil nil)
 
-\(fn EVENT)" t nil)
+(autoload 'bh/is-deadline "ganneff-org" "\
 
-(autoload 'diredp-do-paste-add-tags "dired+" "\
-Add previously copied tags to the marked (or next prefix arg) files.
-The tags were previously copied from a file to `bmkp-copied-tags'.
-You need library `bookmark+.el' to use this command.
-
-A prefix argument ARG specifies files to use instead of those marked.
- An integer means use the next ARG files (previous -ARG, if < 0).
- `C-u': Use the current file (whether or not any are marked).
- `C-u C-u': Use all files in Dired, except directories.
- `C-u C-u C-u': Use all files and directories, except `.' and `..'.
- `C-u C-u C-u C-u': Use all files and all directories.
-
-\(fn &optional PREFIX ARG)" t nil)
-
-(autoload 'diredp-mouse-do-paste-add-tags "dired+" "\
-In Dired, add previously copied tags to this file.
-The tags were previously copied from a file to `bmkp-copied-tags'.
-You need library `bookmark+.el' to use this command.
 
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-do-paste-replace-tags "dired+" "\
-Replace tags for marked (or next prefix arg) files with copied tags.
-The tags were previously copied from a file to `bmkp-copied-tags'.
-You need library `bookmark+.el' to use this command.
-
-A prefix argument ARG specifies files to use instead of those marked.
- An integer means use the next ARG files (previous -ARG, if < 0).
- `C-u': Use the current file (whether or not any are marked).
- `C-u C-u': Use all files in Dired, except directories.
- `C-u C-u C-u': Use all files and directories, except `.' and `..'.
- `C-u C-u C-u C-u': Use all files and all directories.
+\(fn DATE-STR)" nil nil)
 
-\(fn &optional PREFIX ARG)" t nil)
+(autoload 'bh/is-scheduled "ganneff-org" "\
 
-(autoload 'diredp-mouse-do-paste-replace-tags "dired+" "\
-In Dired, replace tags for this file with tags copied previously.
-The tags were previously copied from a file to `bmkp-copied-tags'.
-You need library `bookmark+.el' to use this command.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-do-set-tag-value "dired+" "\
-Set TAG value to VALUE, for the marked (or next prefix arg) files.
-This does not change the TAG name.
-You need library `bookmark+.el' to use this command.
-
-PREFIX is as for `diredp-do-bookmark'.
-
-A prefix argument ARG specifies files to use instead of those marked.
- An integer means use the next ARG files (previous -ARG, if < 0).
- `C-u': Use the current file (whether or not any are marked).
- `C-u C-u': Use all files in Dired, except directories.
- `C-u C-u C-u': Use all files and directories, except `.' and `..'.
- `C-u C-u C-u C-u': Use all files and all directories.
-
-\(fn TAG VALUE &optional PREFIX ARG)" t nil)
-
-(autoload 'diredp-mouse-do-set-tag-value "dired+" "\
-In Dired, set the value of a tag for this file.
-This does not change the tag name.
-You need library `bookmark+.el' to use this command.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-do-bookmark "dired+" "\
-Bookmark the marked (or the next prefix argument) files.
-Each bookmark name is the non-directory portion of the file name,
- prefixed by PREFIX if it is non-nil.
-Interactively, you are prompted for the PREFIX if
- `diredp-prompt-for-bookmark-prefix-flag' is non-nil.
-The bookmarked position is the beginning of the file.
-If you use library `bookmark+.el' then the bookmark is an autofile.
-
-A prefix argument ARG specifies files to use instead of those marked.
- An integer means use the next ARG files (previous -ARG, if < 0).
- `C-u': Use the current file (whether or not any are marked).
- `C-u C-u': Use all files in Dired, except directories.
- `C-u C-u C-u': Use all files and directories, except `.' and `..'.
- `C-u C-u C-u C-u': Use all files and all directories.
-
-\(fn &optional PREFIX ARG)" t nil)
-
-(autoload 'diredp-mouse-do-bookmark "dired+" "\
-In Dired, bookmark this file.  See `diredp-do-bookmark'.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-set-bookmark-file-bookmark-for-marked "dired+" "\
-Bookmark the marked files and create a bookmark-file bookmark for them.
-The bookmarked position is the beginning of the file.
-Jumping to the bookmark-file bookmark loads the set of file bookmarks.
-You need library `bookmark+.el' to use this command.
-
-Each bookmark name is the non-directory portion of the file name,
- prefixed by PREFIX if it is non-nil.
-Interactively, you are prompted for PREFIX if
- `diredp-prompt-for-bookmark-prefix-flag' is non-nil.
-
-A prefix argument ARG specifies files to use instead of those marked.
- An integer means use the next ARG files (previous -ARG, if < 0).
- `C-u': Use the current file (whether or not any are marked).
- `C-u C-u': Use all files in Dired, except directories.
- `C-u C-u C-u': Use all files and directories, except `.' and `..'.
- `C-u C-u C-u C-u': Use all files and all directories.
-
-You are also prompted for the bookmark file, BOOKMARK-FILE.  The
-default is `.emacs.bmk' in the current directory, but you can enter
-any file name, anywhere.
-
-The marked-file bookmarks are added to file BOOKMARK-FILE, but this
-command does not make BOOKMARK-FILE the current bookmark file.  To
-make it current, just jump to the bookmark-file bookmark created by
-this command.  That bookmark (which bookmarks BOOKMARK-FILE) is
-defined in that current bookmark file.
-
-Example:
-
- Bookmark file `~/.emacs.bmk' is current before invoking this command.
- The current (Dired) directory is `/foo/bar'.
- The marked files are bookmarked in the (possibly new) bookmark file
-   `/foo/bar/.emacs.bmk'.
- The bookmarks for the marked files have names prefixed by `FOOBAR '.
- The name of the bookmark-file bookmark is `Foobar Files'.
- Bookmark `Foobar Files' is itself in bookmark file `~/.emacs.bmk'.
- Bookmark file `~/.emacs.bmk' is current after invoking this command.
-
-You are prompted for the name of the bookmark-file bookmark, the
-BOOKMARK-FILE for the marked-file bookmarks, and a PREFIX string for
-each of the marked-file bookmarks.
-
-See also command `diredp-do-bookmark-in-bookmark-file'.
-
-\(fn BOOKMARK-FILE &optional PREFIX ARG)" t nil)
-
-(autoload 'diredp-do-bookmark-in-bookmark-file "dired+" "\
-Bookmark files in BOOKMARK-FILE and save BOOKMARK-FILE.
-The files bookmarked are the marked files, by default.
-The bookmarked position is the beginning of the file.
-You are prompted for BOOKMARK-FILE.  The default is `.emacs.bmk' in
-the current directory, but you can enter any file name, anywhere.
-You need library `bookmark+.el' to use this command.
-
-The marked files are bookmarked in file BOOKMARK-FILE, but this
-command does not make BOOKMARK-FILE the current bookmark file.  To
-make it current, use `\\[bmkp-switch-bookmark-file]' (`bmkp-switch-bookmark-file').
-
-Each bookmark name is the non-directory portion of the file name,
- prefixed by PREFIX if it is non-nil.
-Interactively, you are prompted for PREFIX if
- `diredp-prompt-for-bookmark-prefix-flag' is non-nil.
-
-Interactively, a prefix argument ARG specifies the files to use
-instead of those marked.
-
- An integer means use the next ARG files (previous -ARG, if < 0).
- `C-u': Use the current file (whether or not any are marked).
- `C-u C-u': Use all files in Dired, except directories.
- `C-u C-u C-u': Use all files and directories, except `.' and `..'.
- `C-u C-u C-u C-u': Use all files and all directories.
-
-See also command `diredp-set-bookmark-file-bookmark-for-marked'.
-
-Non-interactively:
-
- * Non-nil BFILE-BOOKMARKP means create a bookmark-file bookmark for
-   BOOKMARK-FILE.
- * Non-nil FILES is the list of files to bookmark.
-
-\(fn BOOKMARK-FILE &optional PREFIX ARG BFILE-BOOKMARKP FILES)" t nil)
-
-(autoload 'diredp-find-file-reuse-dir-buffer "dired+" "\
-Like `dired-find-file', but reuse Dired buffers.
-Unlike `dired-find-alternate-file' this does not use
-`find-alternate-file' if the target is not a directory.
 
-\(fn)" t nil)
+\(fn DATE-STR)" nil nil)
 
-(autoload 'diredp-mouse-find-file-reuse-dir-buffer "dired+" "\
-Like `diredp-mouse-find-file', but reuse Dired buffers.
-Unlike `dired-find-alternate-file' this does not use
-`find-alternate-file' if the target is not a directory.
+(autoload 'bh/is-scheduled-today "ganneff-org" "\
 
-\(fn EVENT)" t nil)
 
-(defalias 'toggle-diredp-find-file-reuse-dir 'diredp-toggle-find-file-reuse-dir)
+\(fn DATE-STR)" nil nil)
 
-(autoload 'diredp-toggle-find-file-reuse-dir "dired+" "\
-Toggle whether Dired `find-file' commands reuse directories.
-A prefix arg specifies directly whether or not to reuse.
- If its numeric value is non-negative then reuse; else do not reuse.
+(autoload 'bh/is-scheduled-late "ganneff-org" "\
 
-To set the behavior as a preference (default behavior), put this in
-your ~/.emacs, where VALUE is 1 to reuse or -1 to not reuse:
 
- (diredp-toggle-find-file-reuse-dir VALUE)
+\(fn DATE-STR)" nil nil)
 
-\(fn FORCE-P)" t nil)
+(autoload 'bh/hide-other "ganneff-org" "\
 
-(autoload 'diredp-omit-marked "dired+" "\
-Omit lines of marked files.  Return the number of lines omitted.
 
 \(fn)" t nil)
 
-(autoload 'diredp-omit-unmarked "dired+" "\
-Omit lines of unmarked files.  Return the number of lines omitted.
+(autoload 'bh/set-truncate-lines "ganneff-org" "\
+Toggle value of truncate-lines and refresh window display.
 
 \(fn)" t nil)
 
-(autoload 'diredp-ediff "dired+" "\
-Compare file at cursor with file FILE2 using `ediff'.
-FILE2 defaults to the file at the cursor as well.  If you enter just a
-directory name for FILE2, then the file at the cursor is compared with
-a file of the same name in that directory.  FILE2 is the second file
-given to `ediff'; the file at the cursor is the first.
-
-Try to guess a useful default value for FILE2, as follows:
-
-* If the mark is active, use the file at mark.
-* Else if the file at cursor is a autosave file or a backup file, use
-  the corresponding base file.
-* Else if there is any backup file for the file at point, use the
-  newest backup file for it.
-* Else use the file at point.
-
-\(fn FILE2)" t nil)
-
-(autoload 'dired-do-compress "dired+" "\
-Compress or uncompress marked (or next prefix argument) files.
-A prefix argument ARG specifies files to use instead of marked.
- An integer means use the next ARG files (previous -ARG, if < 0).
- `C-u': Use the current file (whether or not any are marked).
- `C-u C-u': Use all files in Dired, except directories.
- `C-u C-u C-u': Use all files and directories, except `.' and `..'.
- `C-u C-u C-u C-u': Use all files and all directories.
+(autoload 'bh/skip-non-archivable-tasks "ganneff-org" "\
+Skip trees that are not available for archiving
 
-\(fn &optional ARG)" t nil)
+\(fn)" nil nil)
 
-(autoload 'dired-do-byte-compile "dired+" "\
-Byte compile marked (or next prefix argument) Emacs Lisp files.
-A prefix argument ARG specifies files to use instead of marked.
- An integer means use the next ARG files (previous -ARG, if < 0).
- `C-u': Use the current file (whether or not any are marked).
- `C-u C-u': Use all files in Dired, except directories.
- `C-u C-u C-u': Use all files and directories, except `.' and `..'.
- `C-u C-u C-u C-u': Use all files and all directories.
+(autoload 'bh/make-org-scratch "ganneff-org" "\
 
-\(fn &optional ARG)" t nil)
 
-(autoload 'dired-do-load "dired+" "\
-Load the marked (or next prefix argument) Emacs Lisp files.
-A prefix argument ARG specifies files to use instead of marked.
- An integer means use the next ARG files (previous -ARG, if < 0).
- `C-u': Use the current file (whether or not any are marked).
- `C-u C-u': Use all files in Dired, except directories.
- `C-u C-u C-u': Use all files and directories, except `.' and `..'.
- `C-u C-u C-u C-u': Use all files and all directories.
+\(fn)" t nil)
 
-\(fn &optional ARG)" t nil)
+(autoload 'bh/switch-to-scratch "ganneff-org" "\
 
-(autoload 'dired-maybe-insert-subdir "dired+" "\
-Move to Dired subdirectory line or subdirectory listing.
-This bounces you back and forth between a subdirectory line and its
-inserted listing header line.  Using it on a non-directory line in a
-subdirectory listing acts the same as using it on the subdirectory
-header line.
 
-* If on a subdirectory line, then go to the subdirectory's listing,
-  creating it if not yet present.
+\(fn)" t nil)
 
-* If on a subdirectory listing header line or a non-directory file in
-  a subdirectory listing, then go to the line for the subdirectory in
-  the parent directory listing.
+(autoload 'bh/org-todo "ganneff-org" "\
 
-* If on a non-directory file in the top Dired directory listing, do
-  nothing.
 
-Subdirectories are listed in the same position as for `ls -lR' output.
+\(fn ARG)" t nil)
 
-With a prefix arg, you can edit the `ls' switches used for this
-listing.  Add `R' to the switches to expand the directory tree under a
-subdirectory.
+(autoload 'bh/widen "ganneff-org" "\
 
-Dired remembers the switches you specify with a prefix arg, so
-reverting the buffer does not reset them.  However, you might
-sometimes need to reset some subdirectory switches after a
-`dired-undo'.  You can reset all subdirectory switches to the
-default value using \\<dired-mode-map>\\[dired-reset-subdir-switches].  See Info node
-`(emacs)Subdir switches' for more details.
 
-\(fn DIRNAME &optional SWITCHES NO-ERROR-IF-NOT-DIR-P)" t nil)
+\(fn)" t nil)
 
-(autoload 'dired-do-find-marked-files "dired+" "\
-Find marked files, displaying all of them simultaneously.
-With a prefix ARG >= 0, just find files but do not select them.
+(autoload 'bh/insert-inactive-timestamp "ganneff-org" "\
 
-If no prefix ARG, and variable `pop-up-frames' is non-nil, or
-if prefix ARG < 0, then each file is displayed in a separate frame.
 
-Otherwise (no prefix ARG and nil `pop-up-frames'), the current window
-is split across all marked files, as evenly as possible.  Remaining
-lines go to the bottom-most window.  The number of files that can be
-displayed this way is restricted by the height of the current window
-and `window-min-height'.
+\(fn)" t nil)
 
-A prefix argument also behaves according to the ARG argument of
-`dired-get-marked-files'.  In particular, `C-u C-u' operates on all
-files in the Dired buffer.
+(autoload 'bh/insert-heading-inactive-timestamp "ganneff-org" "\
 
-To keep the Dired buffer displayed, type \\[split-window-vertically] first.
-To display just the marked files, type \\[delete-other-windows] first.
 
-\(fn &optional ARG)" t nil)
+\(fn)" nil nil)
 
-(autoload 'dired-up-directory "dired+" "\
-Run Dired on parent directory of current directory.
-Find the parent directory either in this buffer or another buffer.
-Creates a buffer if necessary.
+(autoload 'bh/remove-empty-drawer-on-clock-out "ganneff-org" "\
 
-On MS Windows, if you already at the root directory, invoke
-`diredp-w32-drives' to visit a navigable list of Windows drives.
 
-\(fn &optional OTHER-WINDOW)" t nil)
+\(fn)" t nil)
 
-(autoload 'dired-goto-file "dired+" "\
-Go to line describing file FILE in this dired buffer.
+(autoload 'bh/prepare-meeting-notes "ganneff-org" "\
+Prepare meeting notes for email
+   Take selected region and convert tabs to spaces, mark TODOs with leading >>>, and copy to kill ring for pasting
 
-\(fn FILE)" t nil)
+\(fn)" t nil)
 
-(autoload 'dired-do-flagged-delete "dired+" "\
-In Dired, delete the files flagged for deletion.
-NOTE: This deletes flagged, not marked, files.
-If arg NO-MSG is non-nil, no message is displayed.
+(autoload 'bh/phone-call "ganneff-org" "\
+Return name and company info for caller from bbdb lookup
 
-User option `dired-recursive-deletes' controls whether deletion of
-non-empty directories is allowed.
+\(fn)" t nil)
 
-\(fn &optional NO-MSG)" t nil)
+(autoload 'org-my-archive-done-tasks "ganneff-org" "\
 
-(autoload 'dired-do-delete "dired+" "\
-Delete all marked (or next ARG) files.
-NOTE: This deletes marked, not flagged, files.
-`dired-recursive-deletes' controls whether deletion of
-non-empty directories is allowed.
 
-\(fn &optional ARG)" t nil)
+\(fn)" t nil)
 
-(autoload 'dired-mark-files-regexp "dired+" "\
-Mark all files matching REGEXP for use in later commands.
-A prefix argument means to unmark them instead.
-`.' and `..' are never marked.
+(defalias 'archive-done-tasks 'org-my-archive-done-tasks)
 
-REGEXP is an Emacs regexp, not a shell wildcard.  Thus, use `\\.o$' for
-object files--just `.o' will mark more than you might think.
+(autoload 'bh/is-project-p "ganneff-org" "\
+Any task with a todo keyword subtask
 
-REGEXP is added to `regexp-search-ring', for regexp search.
+\(fn)" nil nil)
 
-\(fn REGEXP &optional MARKER-CHAR)" t nil)
+(autoload 'bh/is-project-subtree-p "ganneff-org" "\
+Any task with a todo keyword that is in a project subtree.
+Callers of this function already widen the buffer view.
 
-(autoload 'diredp-capitalize "dired+" "\
-Rename all marked (or next ARG) files by capitalizing them.
-Makes the first char of the name uppercase and the others lowercase.
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'diredp-delete-this-file "dired+" "\
-In Dired, delete the file on the cursor line, upon confirmation.
-
-\(fn)" t nil)
-
-(autoload 'diredp-capitalize-this-file "dired+" "\
-In Dired, rename the file on the cursor line by capitalizing it.
-Makes the first char of the name uppercase and the others lowercase.
-
-\(fn)" t nil)
-
-(autoload 'diredp-downcase-this-file "dired+" "\
-In Dired, rename the file on the cursor line to lower case.
-
-\(fn)" t nil)
-
-(autoload 'diredp-upcase-this-file "dired+" "\
-In Dired, rename the file on the cursor line to upper case.
-
-\(fn)" t nil)
-
-(autoload 'diredp-rename-this-file "dired+" "\
-In Dired, rename the file on the cursor line.
-
-\(fn)" t nil)
-
-(autoload 'diredp-copy-this-file "dired+" "\
-In Dired, copy the file on the cursor line.
-
-\(fn)" t nil)
-
-(autoload 'diredp-relsymlink-this-file "dired+" "\
-In Dired, make a relative symbolic link to file on cursor line.
-
-\(fn)" t nil)
-
-(autoload 'diredp-symlink-this-file "dired+" "\
-In Dired, make a symbolic link to the file on the cursor line.
-
-\(fn)" t nil)
-
-(autoload 'diredp-hardlink-this-file "dired+" "\
-In Dired, add a name (hard link) to the file on the cursor line.
-
-\(fn)" t nil)
-
-(autoload 'diredp-print-this-file "dired+" "\
-In Dired, print the file on the cursor line.
-
-\(fn)" t nil)
-
-(autoload 'diredp-grep-this-file "dired+" "\
-In Dired, grep the file on the cursor line.
-
-\(fn)" t nil)
-
-(autoload 'diredp-compress-this-file "dired+" "\
-In Dired, compress or uncompress the file on the cursor line.
-
-\(fn)" t nil)
-
-(autoload 'diredp-shell-command-this-file "dired+" "\
-In Dired, run a shell COMMAND on the file on the cursor line.
-
-\(fn COMMAND)" t nil)
-
-(autoload 'diredp-bookmark-this-file "dired+" "\
-In Dired, bookmark the file on the cursor line.
-See `diredp-do-bookmark'.
-
-\(fn &optional PREFIX)" t nil)
-
-(autoload 'diredp-tag-this-file "dired+" "\
-In Dired, add some tags to the file on the cursor line.
-You need library `bookmark+.el' to use this command.
-
-\(fn TAGS &optional PREFIX)" t nil)
-
-(autoload 'diredp-untag-this-file "dired+" "\
-In Dired, remove some tags from the file on the cursor line.
-With a prefix arg, remove all tags from the file.
-You need library `bookmark+.el' to use this command.
-
-\(fn TAGS &optional PREFIX ARG)" t nil)
-
-(autoload 'diredp-remove-all-tags-this-file "dired+" "\
-In Dired, remove all tags from this file.
-You need library `bookmark+.el' to use this command.
-
-\(fn &optional PREFIX MSGP)" t nil)
-
-(autoload 'diredp-paste-add-tags-this-file "dired+" "\
-In Dired, add previously copied tags to this file.
-See `diredp-paste-add-tags'.
-You need library `bookmark+.el' to use this command.
-
-\(fn &optional PREFIX MSGP)" t nil)
-
-(autoload 'diredp-paste-replace-tags-this-file "dired+" "\
-In Dired, replace tags for this file with previously copied tags.
-See `diredp-paste-replace-tags'.
-You need library `bookmark+.el' to use this command.
-
-\(fn &optional PREFIX MSGP)" t nil)
-
-(autoload 'diredp-set-tag-value-this-file "dired+" "\
-In Dired, Set value of TAG to VALUE for this file.
-See `diredp-set-tag-value'.
-You need library `bookmark+.el' to use this command.
-
-\(fn TAG VALUE &optional PREFIX MSGP)" t nil)
-
-(autoload 'diredp-copy-tags-this-file "dired+" "\
-In Dired, copy the tags from this file, so you can paste them to another.
-See `diredp-copy-tags'.
-You need library `bookmark+.el' to use this command.
-
-\(fn &optional PREFIX MSGP)" t nil)
-
-(autoload 'diredp-mouse-copy-tags "dired+" "\
-In Dired, copy the tags from this file, so you can paste them to another.
-You need library `bookmark+.el' to use this command.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-describe-file "dired+" "\
-In Dired, describe this file or directory.
-You need library `help-fns+.el' to use this command.
-If the file has an autofile bookmark and you use library `Bookmark+',
-then show also the bookmark information (tags etc.).  In this case, a
-prefix arg shows the internal form of the bookmark.
-
-\(fn &optional INTERNAL-FORM-P)" t nil)
-
-(autoload 'diredp-mouse-describe-file "dired+" "\
-Describe the clicked file.
-You need library `help-fns+.el' to use this command.
-If the file has an autofile bookmark and you use library `Bookmark+',
-then show also the bookmark information (tags etc.).  In this case, a
-prefix arg shows the internal form of the bookmark.
-
-\(fn EVENT &optional INTERNAL-FORM-P)" t nil)
-
-(autoload 'diredp-byte-compile-this-file "dired+" "\
-In Dired, byte compile the (Lisp source) file on the cursor line.
-
-\(fn)" t nil)
-
-(autoload 'diredp-load-this-file "dired+" "\
-In Dired, load the file on the cursor line.
-
-\(fn)" t nil)
-
-(autoload 'diredp-chmod-this-file "dired+" "\
-In Dired, change the mode of the file on the cursor line.
-
-\(fn)" t nil)
-
-(autoload 'dired-mark-sexp "dired+" "\
-Mark files for which PREDICATE returns non-nil.
-With non-nil prefix arg UNMARK-P, unmark those files instead.
-
-PREDICATE is a lisp sexp that can refer to the following variables:
-
-    `mode'   [string]  file permission bits, e.g. \"-rw-r--r--\"
-    `nlink'  [integer] number of links to file
-    `size'   [integer] file size in bytes
-    `uid'    [string]  owner
-    `gid'    [string]  group (If the gid is not displayed by `ls',
-                       this will still be set (to the same as uid))
-    `time'   [string]  the time that `ls' displays, e.g. \"Feb 12 14:17\"
-    `name'   [string]  the name of the file
-    `sym'    [string]  if file is a symbolic link, the linked-to name,
-                       else \"\"
-    `inode'  [integer] the inode of the file (only for `ls -i' output)
-    `blks'   [integer] the size of the file for `ls -s' output
-                       (ususally in blocks or, with `-k', in Kbytes)
-Examples:
-  Mark zero-length files: `(equal 0 size)'
-  Mark files last modified on Feb 2: `(string-match \"Feb  2\" time)'
-  Mark uncompiled Emacs Lisp files (`.el' file without a `.elc' file):
-     First, dired just the source files: `dired *.el'.
-     Then, use \\[dired-mark-sexp] with this sexp:
-          (not (file-exists-p (concat name \"c\")))
-
-\(fn PREDICATE &optional UNMARK-P)" t nil)
-
-(autoload 'diredp-mark-region-files "dired+" "\
-Mark all of the files in the current region (if it is active).
-With non-nil prefix arg, unmark them instead.
-
-\(fn &optional UNMARK-P)" t nil)
-
-(autoload 'diredp-unmark-region-files "dired+" "\
-Unmark all of the files in the current region (if it is active).
-With non-nil prefix arg, mark them instead.
-
-\(fn &optional MARK-P)" t nil)
-
-(autoload 'diredp-flag-region-files-for-deletion "dired+" "\
-Flag all of the files in the current region (if it is active) for deletion.
-
-\(fn)" t nil)
-
-(autoload 'diredp-toggle-marks-in-region "dired+" "\
-Toggle marks in the region.
-
-\(fn START END)" t nil)
-
-(autoload 'diredp-mouse-3-menu "dired+" "\
-Dired pop-up `mouse-3' menu, for files in selection or current line.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-find-file-other-frame "dired+" "\
-In Dired, visit this file or directory in another frame.
-
-\(fn)" t nil)
-
-(autoload 'diredp-mouse-find-file-other-frame "dired+" "\
-In Dired, visit file or directory clicked on in another frame.
-
-\(fn EVENT)" t nil)
-
-(autoload 'dired-mouse-find-file-other-window "dired+" "\
-In Dired, visit the file or directory name you click on.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-find-file "dired+" "\
-Replace dired in its window by this file or directory.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-view-file "dired+" "\
-Examine this file in view mode, returning to dired when done.
-When file is a directory, show it in this buffer if it is inserted;
-otherwise, display it in another buffer.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-ediff "dired+" "\
-Compare this file (pointed by mouse) with file FILE2 using `ediff'.
-FILE2 defaults to this file as well.  If you enter just a directory
-name for FILE2, then this file is compared with a file of the same
-name in that directory.  FILE2 is the second file given to `ediff';
-this file is the first given to it.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-diff "dired+" "\
-Compare this file (pointed by mouse) with file FILE2 using `diff'.
-FILE2 defaults to the file at the mark.  This file is the first file
-given to `diff'.  With prefix arg, prompt for second arg SWITCHES,
-which are options for `diff'.
-
-\(fn EVENT &optional SWITCHES)" t nil)
-
-(autoload 'diredp-mouse-backup-diff "dired+" "\
-Diff this file with its backup file or vice versa.
-Use the latest backup, if there are several numerical backups.
-If this file is a backup, diff it with its original.
-The backup file is the first file given to `diff'.
-With prefix arg, prompt for SWITCHES which are the options for `diff'.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-mark "dired+" "\
-In Dired, mark this file.
-If on a subdir headerline, mark all its files except `.' and `..'.
-
-Use \\[dired-unmark-all-files] to remove all marks,
-and \\[dired-unmark] on a subdir to remove the marks in this subdir.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-unmark "dired+" "\
-In Dired, unmark this file.
-If looking at a subdir, unmark all its files except `.' and `..'.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-mark/unmark "dired+" "\
-Mark/unmark file or directory at mouse EVENT.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-mark-region-files "dired+" "\
-Mark files between point and the mouse.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-mark/unmark-mark-region-files "dired+" "\
-Mark/unmark file or mark files in region.
-If the file the cursor is on is marked, then mark all files between it
- and the line clicked (included).
-Otherwise (cursor's file is unmarked):
- If the file clicked is marked, then unmark it.
- If it is unmarked, then mark it.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-flag-file-deletion "dired+" "\
-In Dired, flag this file for deletion.
-If on a subdir headerline, mark all its files except `.' and `..'.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-do-copy "dired+" "\
-In Dired, copy this file.
-This normally preserves the last-modified date when copying.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-do-rename "dired+" "\
-In Dired, rename this file.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-upcase "dired+" "\
-In Dired, rename this file to upper case.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-downcase "dired+" "\
-In Dired, rename this file to lower case.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-do-delete "dired+" "\
-In Dired, delete this file, upon confirmation.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-do-shell-command "dired+" "\
-Run a shell COMMAND on this file.
-If there is output, it goes to a separate buffer.
-
-No automatic redisplay of dired buffers is attempted, as there's no
-telling what files the command may have changed.  Type
-\\[dired-do-redisplay] to redisplay.
-
-The shell command has the top level directory as working directory, so
-output files usually are created there instead of in a subdir.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-do-symlink "dired+" "\
-Make symbolic link to this file.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-do-hardlink "dired+" "\
-Make hard link (alias) to this file.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-do-print "dired+" "\
-Print this file.
-Uses the shell command coming from variables `lpr-command' and
-`lpr-switches' as default.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-do-grep "dired+" "\
-Run grep against this file.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-do-compress "dired+" "\
-Compress or uncompress this file.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-do-byte-compile "dired+" "\
-Byte compile this file.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-do-load "dired+" "\
-Load this Emacs Lisp file.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-mouse-do-chmod "dired+" "\
-Change the mode of this file.
-This calls chmod, so symbolic modes like `g+w' are allowed.
-
-\(fn EVENT)" t nil)
-
-(autoload 'diredp-describe-mode "dired+" "\
-Describe Dired mode, including Dired+ features.
-This is `describe-mode' plus a description of Dired+ features.
-For just the latter, use \\<dired-mode-map>`\\[diredp-dired-plus-help]'.
-
-\(fn &optional BUFFER)" t nil)
-
-(autoload 'diredp-dired-plus-help "dired+" "\
-Describe Dired+.
-
-\(fn)" t nil)
-
-(autoload 'diredp-send-bug-report "dired+" "\
-Send a bug report about a Dired+ problem.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (dired-single-toggle-buffer-name dired-single-magic-buffer
-;;;;;;  dired-single-buffer-mouse dired-single-buffer) "dired-single"
-;;;;;;  "dired-single.el" (20858 49922 429890 970000))
-;;; Generated autoloads from dired-single.el
-
-(autoload 'dired-single-buffer "dired-single" "\
-Visit selected directory in current buffer.
-
-Visits the selected directory in the current buffer, replacing the
-   current contents with the contents of the new directory.  This doesn't
-   prevent you from having more than one dired buffer.  The main difference
-   is that a given dired buffer will not spawn off a new buffer every time
-   a new directory is visited.
-
-If the variable `dired-single-use-magic-buffer' is non-nil, and the current
-   buffer's name is the same as that specified by the variable
-`dired-single-magic-buffer-name', then the new directory's buffer will retain
-   that same name (i.e. not only will dired only use a single buffer, but
-its name will not change every time a new directory is entered).
-
-Optional argument DEFAULT-DIRNAME specifies the directory to visit; if not
-specified, the directory or file on the current line is used (assuming it's
-a dired buffer).  If the current line represents a file, the file is visited
-in another window.
-
-\(fn &optional DEFAULT-DIRNAME)" t nil)
-
-(autoload 'dired-single-buffer-mouse "dired-single" "\
-Mouse-initiated version of `dired-single-buffer' (which see).
-
-Argument CLICK is the mouse-click event.
-
-\(fn CLICK)" t nil)
-
-(autoload 'dired-single-magic-buffer "dired-single" "\
-Switch to buffer whose name is the value of `dired-single-magic-buffer-name'.
-
-If no such buffer exists, launch dired in a new buffer and rename that buffer
-to the value of `dired-single-magic-buffer-name'.  If the current buffer is the
-magic buffer, it will prompt for a new directory to visit.
-
-Optional argument DEFAULT-DIRNAME specifies the directory to visit (defaults to
-the currently displayed directory).
-
-\(fn &optional DEFAULT-DIRNAME)" t nil)
-
-(autoload 'dired-single-toggle-buffer-name "dired-single" "\
-Toggle between the 'magic' buffer name and the 'real' dired buffer name.
-
-Will also seek to uniquify the 'real' buffer name.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (flycheck-info flycheck-def-option-var flycheck-def-config-file-var
-;;;;;;  flycheck-declare-checker global-flycheck-mode flycheck-mode)
-;;;;;;  "flycheck" "flycheck.el" (20861 33952 0 0))
-;;; Generated autoloads from flycheck.el
-
-(defconst flycheck-mode-line-lighter " FlyC" "\
-The standard lighter for flycheck mode.")
-
-(autoload 'flycheck-mode "flycheck" "\
-Minor mode for on-the-fly syntax checking.
-
-When called interactively, toggle `flycheck-mode'.  With prefix
-ARG, enable `flycheck-mode' if ARG is positive, otherwise disable
-it.
-
-When called from Lisp, enable `flycheck-mode' if ARG is omitted,
-nil or positive.  If ARG is `toggle', toggle `flycheck-mode'.
-Otherwise behave as if called interactively.
-
-In `flycheck-mode' the buffer is automatically syntax-checked
-using the first suitable syntax checker from `flycheck-checkers'.
-Use `flycheck-select-checker' to select a checker for the current
-buffer manually.
-
-\\{flycheck-mode-map}
-
-\(fn &optional ARG)" t nil)
-
-(defvar global-flycheck-mode nil "\
-Non-nil if Global-Flycheck mode is enabled.
-See the command `global-flycheck-mode' for a description of this minor mode.
-Setting this variable directly does not take effect;
-either customize it (see the info node `Easy Customization')
-or call the function `global-flycheck-mode'.")
-
-(custom-autoload 'global-flycheck-mode "flycheck" nil)
-
-(autoload 'global-flycheck-mode "flycheck" "\
-Toggle Flycheck mode in all buffers.
-With prefix ARG, enable Global-Flycheck mode if ARG is positive;
-otherwise, disable it.  If called from Lisp, enable the mode if
-ARG is omitted or nil.
-
-Flycheck mode is enabled in all buffers where
-`flycheck-mode-on-safe' would do it.
-See `flycheck-mode' for more information on Flycheck mode.
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'flycheck-declare-checker "flycheck" "\
-Declare SYMBOL as syntax checker with DOCSTRING and PROPERTIES.
-
-DOCSTRING provides documentation for the new checker.  Use
-`flycheck-checker-documentation' to access the documentation
-string of a checker, and `flycheck-describe-checker' to get help
-about a checker.
-
-The following PROPERTIES are understood:
-
-`:command' A list with the executable (in `car') and the
-arguments (in `cdr') of the syntax checker.  The executable is
-checked for existence with `executable-find' before executing the
-checker.  The arguments are substituted with
-`flycheck-substitute-argument' before execution, see the
-documentation of this function for a list of special tags allowed
-in arguments.
-
-`:error-patterns' A list of error patterns to parse the output of
-the checker.  Each pattern is a list (REGEXP LEVEL).  REGEXP is a
-regular expression that matches an error.  This regular
-expression may contain match groups extracting specific
-information about the error.  The 1st group is the file name, the
-2nd group the line number, the 3rd group the column number and
-the 4th group the error message.  A group is ignored if it did
-not match or the match returned an empty string.  LEVEL is either
-warning or error and determines the severity of the error message
-parsed with the pattern.
-
-`:error-parser' A function symbol to parse errors with.  The
-function must accept three arguments OUTPUT CHECKER BUFFER, where
-OUTPUT is the output as string and CHECKER the checker symbol
-that was used to check BUFFER.  The function must return a list
-of `flycheck-error' objects parsed from OUTPUT.
-
-`:modes' A major mode symbol or a list thereof.  If present the
-checker is only used in these modes.
-
-`:predicate' An Emacs Lisp form.  If present the checker is only
-used if the form evaluates to a non-nil result in the buffer to
-check.
-
-`:next-checkers' A list where each element is either a checker
-symbol to run after this checker or a cons cell (PREDICATE
-. CHECKER).  In the latter case, CHECKER is the checker symbol to
-run, and the PREDICATE symbol specifies when to run the checker:
-If PREDICATE is `no-errors' run the next checker only if this
-checker returned no errors at all.  If PREDICATE is
-`warnings-only', run the next checker only if this checker
-returned only warnings.  Only the first usable and
-registered (see `flycheck-registered-checker-p') is run.
-
-A checker must have a `:command' property, either
-`:error-patterns' or `:error-parser' (but not both), and at least
-one of `:predicate' and `:modes'.  If `:predicate' and `:modes'
-are present, both must match for the checker to be used.
-
-\(fn SYMBOL DOCSTRING &rest PROPERTIES)" nil t)
-
-(put 'flycheck-declare-checker 'lisp-indent-function '1)
-
-(put 'flycheck-declare-checker 'doc-string-elt '2)
-
-(autoload 'flycheck-def-config-file-var "flycheck" "\
-Define SYMBOL as config file variable for CHECKER, with default FILE-NAME.
-
-SYMBOL is declared as customizable variable (see `defcustom`)
-providing a configuration file for CHECKER.  The CHECKER argument
-is used for documentation purposes only.  If given use FILE-NAME
-as initial value.
-
-Use this together with the `config-file' cell in syntax checker
-commands.
-
-\(fn SYMBOL CHECKER &optional FILE-NAME)" nil t)
-
-(put 'flycheck-def-config-file-var 'lisp-indent-function '3)
-
-(autoload 'flycheck-def-option-var "flycheck" "\
-Define SYMBOL as option variable with INIT-VALUE for CHECKER.
-
-INIT-VALUE is the initial value for the new variable.  DOCSTRING
-is its docstring.
-
-The variable is declared with `defcustom', and declared
-buffer-local.  CUSTOM-ARGS are forwarded to `defcustom'.
-
-Use this together with the `option' cell in syntax checker
-commands.
-
-\(fn SYMBOL INIT-VALUE CHECKER DOCSTRING &rest CUSTOM-ARGS)" nil t)
-
-(put 'flycheck-def-option-var 'lisp-indent-function '3)
-
-(put 'flycheck-def-option-var 'doc-string-elt '4)
-
-(autoload 'flycheck-info "flycheck" "\
-Open the Flycheck manual.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (flymake-css-load flymake-css-lint-command) "flymake-css"
-;;;;;;  "flymake-css.el" (20891 59932 137784 394000))
-;;; Generated autoloads from flymake-css.el
-
-(defvar flymake-css-lint-command "csslint" "\
-Name (and optionally full path) of csslint executable.")
-
-(custom-autoload 'flymake-css-lint-command "flymake-css" t)
-
-(autoload 'flymake-css-load "flymake-css" "\
-Configure flymake mode to check the current buffer's css syntax.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "ganneff" "ganneff.el" (21384 28184 770775
-;;;;;;  56000))
-;;; Generated autoloads from ganneff.el
-
-(autoload 'ido-disable-line-trucation "ganneff" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'match-paren "ganneff" "\
-Go to the matching parenthesis if on parenthesis otherwise insert %.
-
-\(fn ARG)" t nil)
-
-(autoload 'sacha/isearch-yank-current-word "ganneff" "\
-Pull current word from buffer into search string.
-
-\(fn)" t nil)
-
-(autoload 'sacha/search-word-backward "ganneff" "\
-Find the previous occurrence of the current word.
-
-\(fn)" t nil)
-
-(autoload 'sacha/search-word-forward "ganneff" "\
-Find the next occurrance of the current word.
-
-\(fn)" t nil)
-
-(autoload 'sacha/increase-font-size "ganneff" "\
-
-
-\(fn)" t nil)
-
-(autoload 'sacha/decrease-font-size "ganneff" "\
-
-
-\(fn)" t nil)
-
-(autoload 'epa-dired-mode-hook "ganneff" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'my-c-return "ganneff" "\
-When in minibuffer use `icicle-candidate-action', otherwise use `cua-set-rectangle-mark'.
-
-\(fn)" t nil)
-
-(autoload 'revert-all-buffers "ganneff" "\
-Refreshes all open buffers from their respective files.
-
-\(fn)" t nil)
-
-(autoload 'move-line-up "ganneff" "\
-Move up the current line.
-
-\(fn)" t nil)
-
-(autoload 'move-line-down "ganneff" "\
-Move down the current line.
-
-\(fn)" t nil)
-
-(autoload 'jj-untabify-buffer "ganneff" "\
-Get rid of all tabs
-
-\(fn)" t nil)
-
-(autoload 'prelude-sudo-edit "ganneff" "\
-Edit currently visited file as root.
-
-With a prefix ARG prompt for a file to visit.
-Will also prompt for a file to visit if current
-buffer is not visiting a file.
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'lisp-coding-defaults "ganneff" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'interactive-lisp-coding-defaults "ganneff" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'prelude-remove-elc-on-save "ganneff" "\
-If you're saving an elisp file, likely the .elc is no longer valid.
-
-\(fn)" nil nil)
-
-(autoload 'prelude-emacs-lisp-mode-defaults "ganneff" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'clean-mode-line "ganneff" "\
-
-
-\(fn)" t nil)
-
-(autoload 'force-backup-of-buffer "ganneff" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'prelude-kill-other-buffers "ganneff" "\
-Kill all buffers but the current one.
-Doesn't mess with special buffers.
-
-\(fn)" t nil)
-
-(autoload 'just-one-space-with-newline "ganneff" "\
-Call just-one-space with a negative argument
-
-\(fn)" t nil)
-
-(autoload 'font-lock-comment-annotations "ganneff" "\
-Highlight a bunch of well known comment annotations.
-
-This functions should be added to the hooks of major modes for programming.
-
-\(fn)" nil nil)
-
-(autoload 'jj-open-shell "ganneff" "\
-Open a shell in the directory of the current buffer file
-
-\(fn)" t nil)
-
-(autoload 'url-humanify "ganneff" "\
-Take the URL at point and make it human readable.
-
-\(fn)" t nil)
-
-(autoload 'url-decode-region "ganneff" "\
-Replace a region with the same contents, only URL decoded.
-
-\(fn START END)" t nil)
-
-(autoload 'align-code "ganneff" "\
-
-
-\(fn BEG END &optional ARG)" t nil)
-
-(autoload 'insert-date "ganneff" "\
-Insert the current date. With prefix-argument, use ISO format. With
-   two prefix arguments, write out the day and month name.
-
-\(fn PREFIX)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "ganneff-gnus" "ganneff-gnus.el" (20899 48839
-;;;;;;  153473 636000))
-;;; Generated autoloads from ganneff-gnus.el
-
-(autoload 'gnus-nnimap-count-format "ganneff-gnus" "\
-
-
-\(fn N)" nil nil)
-
-(autoload 'gnus-user-format-function-t "ganneff-gnus" "\
-
-
-\(fn DUMMY)" nil nil)
-
-(autoload 'gnus-user-format-function-x "ganneff-gnus" "\
-
-
-\(fn DUMMY)" nil nil)
-
-(autoload 'nnimap-message-count-cache-clear "ganneff-gnus" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'nnimap-message-count-cache-get "ganneff-gnus" "\
-
-
-\(fn GROUP)" nil nil)
-
-(autoload 'nnimap-message-count-cache-set "ganneff-gnus" "\
-
-
-\(fn GROUP COUNT)" nil nil)
-
-(autoload 'nnimap-request-message-counts "ganneff-gnus" "\
-
-
-\(fn GROUP METHOD)" nil nil)
-
-(autoload 'nnimap-fetch-message-counts "ganneff-gnus" "\
-
-
-\(fn GROUP METHOD)" nil nil)
-
-(autoload 'jj-forward-spam "ganneff-gnus" "\
-
-
-\(fn)" t nil)
-
-(autoload 'jj-forward-ham-lists-debconf "ganneff-gnus" "\
-
-
-\(fn)" t nil)
-
-(autoload 'jj-forward-spam-lists-debconf "ganneff-gnus" "\
-
-
-\(fn)" t nil)
-
-(autoload 'jj-forward-ham-lists-oftc "ganneff-gnus" "\
-
-
-\(fn)" t nil)
-
-(autoload 'jj-forward-spam-lists-oftc "ganneff-gnus" "\
-
-
-\(fn)" t nil)
-
-(autoload 'jj-forward-ham-lists-spi "ganneff-gnus" "\
-
-
-\(fn)" t nil)
-
-(autoload 'jj-forward-spam-lists-spi "ganneff-gnus" "\
-
-
-\(fn)" t nil)
-
-(autoload 'jj-forward-issue "ganneff-gnus" "\
-
-
-\(fn)" t nil)
-
-(autoload 'jj-move-mail-spambox "ganneff-gnus" "\
-
-
-\(fn)" t nil)
-
-(autoload 'jj-copy-mail-hambox "ganneff-gnus" "\
-
-
-\(fn)" t nil)
-
-(autoload 'gnus-user-format-function-y "ganneff-gnus" "\
-Convert the DATE to DD.MM.YYYY, HH:MM.
-
-\(fn HEADER)" nil nil)
-
-(autoload 'my-message-add-content "ganneff-gnus" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'my-message-header-setup-hook "ganneff-gnus" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'us-get-only-mail "ganneff-gnus" "\
-Fetch new mails
-
-\(fn)" nil nil)
-
-(autoload 'september-citation-line "ganneff-gnus" "\
-
-
-\(fn)" t nil)
-
-(autoload 'gnus-decay-score "ganneff-gnus" "\
-Decay SCORE.
-     This is done according to `gnus-score-decay-constant'
-     and `gnus-score-decay-scale'.
-
-\(fn SCORE)" nil nil)
-
-(autoload 'message-utils-setup "ganneff-gnus" "\
-Add menu-entries for message-utils.
-
-\(fn)" nil nil)
-
-(autoload 'gnus-scum-expunge "ganneff-gnus" "\
-Remove this spammer from existance as much as possible.
-
-\(fn)" t nil)
-
-(autoload 'lld-notmuch-shortcut "ganneff-gnus" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'lld-notmuch-file-to-group "ganneff-gnus" "\
-Calculate the Gnus group name from the given file name.
-
-\(fn FILE)" nil nil)
-
-(autoload 'lld-notmuch-goto-message-in-gnus "ganneff-gnus" "\
-Open a summary buffer containing the current notmuch article.
-
-\(fn)" t nil)
-
-(autoload 'gnus-user-format-function-topic-line "ganneff-gnus" "\
-
-
-\(fn DUMMY)" nil nil)
-
-(autoload 'sign-or-crypt "ganneff-gnus" "\
-
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "ganneff-org" "ganneff-org.el" (21044 6542
-;;;;;;  817600 508000))
-;;; Generated autoloads from ganneff-org.el
-
-(autoload 'bh/show-org-agenda "ganneff-org" "\
-Show org-modes agenda.
-
-\(fn)" t nil)
-
-(autoload 'bh/verify-refile-target "ganneff-org" "\
-Exclude todo keywords with a done state from refile targets.
-
-\(fn)" nil nil)
-
-(autoload 'bh/agenda-sort-test "ganneff-org" "\
-Test for agenda sort.
-
-\(fn FN A B)" nil t)
-
-(autoload 'bh/agenda-sort-test-num "ganneff-org" "\
-
-
-\(fn FN COMPFN A B)" nil t)
-
-(autoload 'bh/agenda-sort "ganneff-org" "\
-Sorting strategy for agenda items.
-Late deadlines first, then scheduled, then non-late deadlines
-
-\(fn A B)" nil nil)
-
-(autoload 'bh/is-not-scheduled-or-deadline "ganneff-org" "\
-
-
-\(fn DATE-STR)" nil nil)
-
-(autoload 'bh/is-due-deadline "ganneff-org" "\
-
-
-\(fn DATE-STR)" nil nil)
-
-(autoload 'bh/is-late-deadline "ganneff-org" "\
-
-
-\(fn DATE-STR)" nil nil)
-
-(autoload 'bh/is-pending-deadline "ganneff-org" "\
-
-
-\(fn DATE-STR)" nil nil)
-
-(autoload 'bh/is-deadline "ganneff-org" "\
-
-
-\(fn DATE-STR)" nil nil)
-
-(autoload 'bh/is-scheduled "ganneff-org" "\
-
-
-\(fn DATE-STR)" nil nil)
-
-(autoload 'bh/is-scheduled-today "ganneff-org" "\
-
-
-\(fn DATE-STR)" nil nil)
-
-(autoload 'bh/is-scheduled-late "ganneff-org" "\
-
-
-\(fn DATE-STR)" nil nil)
-
-(autoload 'bh/hide-other "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'bh/set-truncate-lines "ganneff-org" "\
-Toggle value of truncate-lines and refresh window display.
-
-\(fn)" t nil)
-
-(autoload 'bh/skip-non-archivable-tasks "ganneff-org" "\
-Skip trees that are not available for archiving
-
-\(fn)" nil nil)
-
-(autoload 'bh/make-org-scratch "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'bh/switch-to-scratch "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'bh/org-todo "ganneff-org" "\
-
-
-\(fn ARG)" t nil)
-
-(autoload 'bh/widen "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'bh/insert-inactive-timestamp "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'bh/insert-heading-inactive-timestamp "ganneff-org" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'bh/remove-empty-drawer-on-clock-out "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'bh/prepare-meeting-notes "ganneff-org" "\
-Prepare meeting notes for email
-   Take selected region and convert tabs to spaces, mark TODOs with leading >>>, and copy to kill ring for pasting
-
-\(fn)" t nil)
-
-(autoload 'bh/phone-call "ganneff-org" "\
-Return name and company info for caller from bbdb lookup
-
-\(fn)" t nil)
-
-(autoload 'org-my-archive-done-tasks "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(defalias 'archive-done-tasks 'org-my-archive-done-tasks)
-
-(autoload 'bh/is-project-p "ganneff-org" "\
-Any task with a todo keyword subtask
-
-\(fn)" nil nil)
-
-(autoload 'bh/is-project-subtree-p "ganneff-org" "\
-Any task with a todo keyword that is in a project subtree.
-Callers of this function already widen the buffer view.
-
-\(fn)" nil nil)
-
-(autoload 'bh/is-task-p "ganneff-org" "\
-Any task with a todo keyword and no subtask
-
-\(fn)" nil nil)
-
-(autoload 'bh/is-subproject-p "ganneff-org" "\
-Any task which is a subtask of another project
-
-\(fn)" nil nil)
-
-(autoload 'bh/list-sublevels-for-projects-indented "ganneff-org" "\
-Set org-tags-match-list-sublevels so when restricted to a subtree we list all subtasks.
-  This is normally used by skipping functions where this variable is already local to the agenda.
-
-\(fn)" nil nil)
-
-(autoload 'bh/list-sublevels-for-projects "ganneff-org" "\
-Set org-tags-match-list-sublevels so when restricted to a subtree we list all subtasks.
-  This is normally used by skipping functions where this variable is already local to the agenda.
-
-\(fn)" nil nil)
-
-(autoload 'bh/skip-stuck-projects "ganneff-org" "\
-Skip trees that are not stuck projects
-
-\(fn)" nil nil)
-
-(autoload 'bh/skip-non-stuck-projects "ganneff-org" "\
-Skip trees that are not stuck projects
-
-\(fn)" nil nil)
-
-(autoload 'bh/skip-non-projects "ganneff-org" "\
-Skip trees that are not projects
-
-\(fn)" nil nil)
-
-(autoload 'bh/skip-project-trees-and-habits "ganneff-org" "\
-Skip trees that are projects
-
-\(fn)" nil nil)
-
-(autoload 'bh/skip-projects-and-habits-and-single-tasks "ganneff-org" "\
-Skip trees that are projects, tasks that are habits, single non-project tasks
-
-\(fn)" nil nil)
-
-(autoload 'bh/skip-project-tasks-maybe "ganneff-org" "\
-Show tasks related to the current restriction.
-When restricted to a project, skip project and sub project tasks, habits, NEXT tasks, and loose tasks.
-When not restricted, skip project and sub-project tasks, habits, and project related tasks.
-
-\(fn)" nil nil)
-
-(autoload 'bh/skip-projects-and-habits "ganneff-org" "\
-Skip trees that are projects and tasks that are habits
-
-\(fn)" nil nil)
-
-(autoload 'bh/skip-non-subprojects "ganneff-org" "\
-Skip trees that are not projects
-
-\(fn)" nil nil)
-
-(autoload 'bh/org-agenda-to-appt "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'bh/restrict-to-file-or-follow "ganneff-org" "\
-Set agenda restriction to 'file or with argument invoke follow mode.
-I don't use follow mode very often but I restrict to file all the time
-so change the default 'F' binding in the agenda to allow both
-
-\(fn ARG)" t nil)
-
-(autoload 'bh/narrow-to-org-subtree "ganneff-org" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'bh/narrow-to-subtree "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'bh/narrow-up-one-org-level "ganneff-org" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'bh/narrow-up-one-level "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'bh/narrow-to-org-project "ganneff-org" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'bh/narrow-to-project "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'bh/clock-in-to-next "ganneff-org" "\
-Switch a task from TODO to NEXT when clocking in.
-  Skips capture tasks, projects, and subprojects.
-  Switch projects and subprojects from NEXT back to TODO
-
-\(fn KW)" nil nil)
-
-(autoload 'bh/find-project-task "ganneff-org" "\
-Move point to the parent (project) task if any
-
-\(fn)" nil nil)
-
-(autoload 'bh/punch-in "ganneff-org" "\
-Start continuous clocking and set the default task to the
-  selected task.  If no task is selected set the Organization task
-  as the default task.
-
-\(fn ARG)" t nil)
-
-(autoload 'bh/punch-out "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'bh/clock-in-default-task "ganneff-org" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'bh/clock-in-parent-task "ganneff-org" "\
-Move point to the parent (project) task if any and clock in
-
-\(fn)" nil nil)
-
-(autoload 'bh/clock-in-organization-task-as-default "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'bh/clock-out-maybe "ganneff-org" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'bh/clock-in-last-task "ganneff-org" "\
-Clock in the interrupted task if there is one
-  Skip the default task and get the next one.
-  A prefix arg forces clock in of the default task.
-
-\(fn ARG)" t nil)
-
-(autoload 'bh/set-agenda-restriction-lock "ganneff-org" "\
-Set restriction lock to current task subtree or file if prefix is specified
-
-\(fn ARG)" t nil)
-
-(autoload 'bh/get-pom-from-agenda-restriction-or-point "ganneff-org" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'bh/view-next-project "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'bh/display-inline-images "ganneff-org" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'bh/save-then-publish "ganneff-org" "\
-
-
-\(fn &optional FORCE)" t nil)
-
-(autoload 'org-mycal-export-limit "ganneff-org" "\
-Limit the export to items that have a date, time and a range. Also exclude certain categories.
-
-\(fn)" nil nil)
-
-(autoload 'mycal-export-limit "ganneff-org" "\
-Limit the export to items that don't match an unwanted category 
-
-\(fn)" nil nil)
-
-(autoload 'org-mycal-export "ganneff-org" "\
-
-
-\(fn)" t nil)
-
-(autoload 'jj/punch-in-hw "ganneff-org" "\
-Start clocking the hwmigration task
-
-\(fn ARG)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (gnus-alias-determine-identity gnus-alias-use-identity
-;;;;;;  gnus-alias-select-identity gnus-alias-init) "gnus-alias"
-;;;;;;  "gnus-alias.el" (20858 49922 453891 89000))
-;;; Generated autoloads from gnus-alias.el
-
-(autoload 'gnus-alias-init "gnus-alias" "\
-Add gnus-alias call to message mode hook.
-
-\(fn)" t nil)
-
-(autoload 'gnus-alias-select-identity "gnus-alias" "\
-Prompt user for an identity and use it.
-
-\(fn)" t nil)
-
-(autoload 'gnus-alias-use-identity "gnus-alias" "\
-Use an Identity defined in `gnus-alias-identity-alist'.
-
-IDENTITY must be a valid entry in `gnus-alias-identity-alist',
-otherwise an error will occur (NOTE: this behavior has changed
-significantly from that found in 'gnus-pers').
-
-If called interactively with no identity, user will be prompted for
-one.
-
-\(fn &optional IDENTITY)" t nil)
-
-(autoload 'gnus-alias-determine-identity "gnus-alias" "\
-Function that chooses a Identity based on message headers.
-
-See `gnus-alias-identity-rules' for more information.  Optional
-LOOKUP-ONLY is a boolean that, when non-nil, says to determine the
-Identity, but don't actually use it (just return it)
-
-\(fn &optional LOOKUP-ONLY)" nil nil)
-
-;;;***
-\f
-;;;### (autoloads (describe-keymap describe-file describe-option-of-type
-;;;;;;  describe-option describe-command describe-function) "help-fns+"
-;;;;;;  "help-fns+.el" (20858 49922 453891 89000))
-;;; Generated autoloads from help-fns+.el
-
-(autoload 'describe-function "help-fns+" "\
-Display the full documentation of FUNCTION (a symbol).
-FUNCTION names an Emacs Lisp function, possibly a user command.
-With a prefix argument, candidates are commands (interactive) only.
-Default candidate is: preferably the `symbol-nearest-point', or else
-the innermost function call surrounding point
-\(`function-called-at-point').
-Return the description that was displayed, as a string.
-
-\(fn FUNCTION &optional COMMANDP)" t nil)
-
-(autoload 'describe-command "help-fns+" "\
-Describe an Emacs command (interactive function).
-Same as using a prefix arg with `describe-function'.
-
-\(fn FUNCTION)" t nil)
-
-(autoload 'describe-option "help-fns+" "\
-Describe an Emacs user variable (option).
-Same as using a prefix arg with `describe-variable'.
-
-\(fn VARIABLE &optional BUFFER)" t nil)
-
-(autoload 'describe-option-of-type "help-fns+" "\
-Describe an Emacs user OPTION (variable) of a given `defcustom' TYPE.
-A prefix argument determines the type-checking behavior:
- - None:         OPTION is defined with TYPE or a subtype of TYPE.
- - Plain `C-u':  OPTION is defined with TYPE or a subtype of TYPE,
-                 or its current value is compatible with TYPE.
- - Negative:     OPTION is defined with TYPE (exact match).
- - Non-negative: OPTION is defined with TYPE (exact match),
-                 or its current value is compatible with TYPE.
-
-If TYPE is nil (default value) then *all* `defcustom' variables are
-potential candidates.  That is different from using `describe-option',
-because `describe-option' includes user-variable candidates not
-defined with `defcustom' (with `*'-prefixed doc strings).
-
-\(fn TYPE OPTION)" t nil)
-
-(autoload 'describe-file "help-fns+" "\
-Describe the file named FILENAME.
-If FILENAME is nil, describe current directory (`default-directory').
-
-Starting with Emacs 22, if the file is an image file then:
- * Show a thumbnail of the image as well.
- * If you have command-line tool `exiftool' installed and in your
-   `$PATH' or `exec-path', then show EXIF data (metadata) about the
-   image.  See standard Emacs library `image-dired.el' for more
-   information about `exiftool'.
-
-If FILENAME is the name of an autofile bookmark and you use library
-`Bookmark+', then show also the bookmark information (tags etc.).  In
-this case, a prefix arg shows the internal form of the bookmark.
-
-\(fn FILENAME &optional INTERNAL-FORM-P)" t nil)
-
-(autoload 'describe-keymap "help-fns+" "\
-Describe bindings in KEYMAP, a variable whose value is a keymap.
-Completion is available for the keymap name.
-
-\(fn KEYMAP)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "highlight-indentation" "highlight-indentation.el"
-;;;;;;  (21286 762 0 0))
-;;; Generated autoloads from highlight-indentation.el
-
-(autoload 'highlight-indentation-mode "highlight-indentation" "\
-Highlight indentation minor mode highlights indentation based
-on spaces
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'highlight-indentation-set-offset "highlight-indentation" "\
-Set indentation offset localy in buffer, will prevent
-highlight-indentation from trying to guess indentation offset
-from major mode
-
-\(fn OFFSET)" t nil)
-
-(autoload 'highlight-indentation-current-column-mode "highlight-indentation" "\
-Hilight Indentation minor mode displays
-a vertical bar corresponding to the indentation of the current line
-
-\(fn &optional ARG)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (highline-split-window-horizontally highline-split-window-vertically
-;;;;;;  highline-view-mode highline-mode global-highline-mode highline-customize)
-;;;;;;  "highline" "highline.el" (20858 49922 457891 109000))
-;;; Generated autoloads from highline.el
-
-(autoload 'highline-customize "highline" "\
-Customize highline group.
-
-\(fn)" t nil)
-
-(defvar global-highline-mode nil "\
-Non-nil if Global-Highline mode is enabled.
-See the command `global-highline-mode' for a description of this minor mode.
-Setting this variable directly does not take effect;
-either customize it (see the info node `Easy Customization')
-or call the function `global-highline-mode'.")
-
-(custom-autoload 'global-highline-mode "highline" nil)
-
-(autoload 'global-highline-mode "highline" "\
-Toggle global minor mode to highlight line about point (HL on modeline).
-
-If ARG is null, toggle global highline mode.
-If ARG is a number and is greater than zero, turn on
-global highline mode; otherwise, turn off global highline mode.
-Only useful with a windowing system.
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'highline-mode "highline" "\
-Toggle local minor mode to highlight the line about point (hl on modeline).
-
-If ARG is null, toggle local highline mode.
-If ARG is a number and is greater than zero, turn on
-local highline mode; otherwise, turn off local highline mode.
-Only useful with a windowing system.
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'highline-view-mode "highline" "\
-Toggle indirect mode to highlight current line in buffer (Ihl on modeline).
-
-If ARG is null, toggle indirect highline mode.
-If ARG is a number and is greater than zero, turn on
-indirect highline mode; otherwise, turn off indirect highline mode.
-Only useful with a windowing system.
-
-Indirect highline (`highline-view-mode') is useful when you wish
-to have various \"visions\" of the same buffer.
-
-Indirect highline uses an indirect buffer to get the \"vision\" of the buffer.
-So, if you kill an indirect buffer, the base buffer is not affected; if you
-kill the base buffer, all indirect buffer related with the base buffer is
-automagically killed.  Also, any text insertion/deletion in any indirect or base
-buffer is updated in all related buffers.
-
-See `highline-view-prefix'.
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'highline-split-window-vertically "highline" "\
-Split window vertically then turn on indirect highline mode.
-
-See `split-window-vertically' for explanation about ARG and for
-documentation.
-
-See also `highline-view-mode' for documentation.
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'highline-split-window-horizontally "highline" "\
-Split window horizontally then turn on indirect highline mode.
-
-See `split-window-horizontally' for explanation about ARG and for
-documentation.
-
-See also `highline-view-mode' for documentation.
-
-\(fn &optional ARG)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (ido-better-flex/match ido-better-flex/score ido-better-flex/disable
-;;;;;;  ido-better-flex/enable) "ido-better-flex" "ido-better-flex.el"
-;;;;;;  (20858 49922 457891 109000))
-;;; Generated autoloads from ido-better-flex.el
-
-(autoload 'ido-better-flex/enable "ido-better-flex" "\
-
-
-\(fn)" t nil)
-
-(autoload 'ido-better-flex/disable "ido-better-flex" "\
-
-
-\(fn)" t nil)
-
-(autoload 'ido-better-flex/score "ido-better-flex" "\
-Computes the score of matching string with abbreviation.
-   The return value is in the range 0.0 to 1.0 the later being full-match.
-
-\(fn STRING ABBREVIATION)" nil nil)
-
-(autoload 'ido-better-flex/match "ido-better-flex" "\
-Returns an ordered list (higher score first) of items that match the
-   current `ido-text'. Items are included only if their score is greater than zero.
-
-\(fn ITEMS)" nil nil)
-
-(defadvice ido-set-matches-1 (around ido-better-flex-match) "\
-An advice using `ido-better-flex' for IDO matching." (setq ad-return-value (ido-better-flex/match (ad-get-arg 0))))
-
-(ido-better-flex/enable)
-
-;;;***
-\f
-;;;### (autoloads nil "inf-ruby" "inf-ruby.el" (21228 61058 260804
-;;;;;;  592000))
-;;; Generated autoloads from inf-ruby.el
-
-(defvar ruby-source-modes '(ruby-mode enh-ruby-mode) "\
-Used to determine if a buffer contains Ruby source code.
-If it's loaded into a buffer that is in one of these major modes, it's
-considered a ruby source file by `ruby-load-file'.
-Used by these commands to determine defaults.")
-
-(autoload 'inf-ruby-setup-keybindings "inf-ruby" "\
-Hook up `inf-ruby-minor-mode' to each of `ruby-source-modes'.
-
-\(fn)" nil nil)
-
-(autoload 'inf-ruby-minor-mode "inf-ruby" "\
-Minor mode for interacting with the inferior process buffer.
-
-The following commands are available:
-
-\\{inf-ruby-minor-mode-map}
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'inf-ruby "inf-ruby" "\
-Run an inferior Ruby process in a buffer.
-With prefix argument, prompts for which Ruby implementation
-\(from the list `inf-ruby-implementations') to use.  Runs the
-hooks `inf-ruby-mode-hook' (after the `comint-mode-hook' is
-run).
-
-\(fn &optional IMPL)" t nil)
-
-(autoload 'run-ruby "inf-ruby" "\
-Run an inferior Ruby process, input and output via buffer `*NAME*'.
-If there is a process already running in `*NAME*', switch to that buffer.
-
-NAME defaults to \"ruby\". COMMAND defaults to the default entry
-in `inf-ruby-implementations'.
-
-\(Type \\[describe-mode] in the process buffer for the list of commands.)
-
-\(fn &optional COMMAND NAME)" t nil)
-
-(autoload 'inf-ruby-switch-setup "inf-ruby" "\
-Modify `rspec-compilation-mode' and `ruby-compilation-mode'
-keymaps to bind `inf-ruby-switch-from-compilation' to `С-x C-q'.
-
-\(fn)" nil nil)
-
-(autoload 'inf-ruby-console-auto "inf-ruby" "\
-Run the appropriate Ruby console command.
-The command and and the directory to run it from are detected
-automatically.
-
-\(fn)" t nil)
-
-(autoload 'inf-ruby-console-rails "inf-ruby" "\
-Run Rails console in DIR.
-
-\(fn DIR)" t nil)
-
-(autoload 'inf-ruby-console-gem "inf-ruby" "\
-Run IRB console for the gem in DIR.
-The main module should be loaded automatically.  If DIR contains a
-Gemfile, it should use the `gemspec' instruction.
-
-\(fn DIR)" t nil)
-
-(autoload 'inf-ruby-console-default "inf-ruby" "\
-Run racksh, custom console.rb, or just IRB, in DIR.
-
-\(fn DIR)" t nil)
- (dolist (mode ruby-source-modes) (add-hook (intern (format "%s-hook" mode)) 'inf-ruby-minor-mode))
-
-;;;***
-\f
-;;;### (autoloads (json-mode) "json-mode" "json-mode.el" (20858 49922
-;;;;;;  477891 208000))
-;;; Generated autoloads from json-mode.el
-
-(autoload 'json-mode "json-mode" "\
-Major mode for editing JSON files
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (keep-buffers-query) "keep-buffers" "keep-buffers.el"
-;;;;;;  (20858 49922 477891 208000))
-;;; Generated autoloads from keep-buffers.el
-
-(autoload 'keep-buffers-query "keep-buffers" "\
-The query function that disable deletion of buffers we protect.
-
-\(fn)" nil nil)
-
-;;;***
-\f
-;;;### (autoloads (keyfreq-autosave-mode keyfreq-mode) "keyfreq"
-;;;;;;  "keyfreq.el" (20870 14397 870087 510000))
-;;; Generated autoloads from keyfreq.el
-
-(defvar keyfreq-mode nil "\
-Non-nil if Keyfreq mode is enabled.
-See the command `keyfreq-mode' for a description of this minor mode.
-Setting this variable directly does not take effect;
-either customize it (see the info node `Easy Customization')
-or call the function `keyfreq-mode'.")
-
-(custom-autoload 'keyfreq-mode "keyfreq" nil)
-
-(autoload 'keyfreq-mode "keyfreq" "\
-Keyfreq mode records number of times each command was
-called making it possible to access usage statistics through
-various keyfreq-* functions.
-
-\(fn &optional ARG)" t nil)
-
-(defvar keyfreq-autosave-mode nil "\
-Non-nil if Keyfreq-Autosave mode is enabled.
-See the command `keyfreq-autosave-mode' for a description of this minor mode.
-Setting this variable directly does not take effect;
-either customize it (see the info node `Easy Customization')
-or call the function `keyfreq-autosave-mode'.")
-
-(custom-autoload 'keyfreq-autosave-mode "keyfreq" nil)
-
-(autoload 'keyfreq-autosave-mode "keyfreq" "\
-Keyfreq Autosave mode automatically saves
-`keyfreq-table' every `keyfreq-autosave-timeout' seconds
-and when emacs is killed.
-
-\(fn &optional ARG)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (mpd-libmpdee-submit-bug-report mpd-output-disable
-;;;;;;  mpd-output-enable mpd-update mpd-set-password mpd-set-crossfade
-;;;;;;  mpd-adjust-volume mpd-set-volume mpd-toggle-repeat mpd-toggle-random
-;;;;;;  mpd-seek mpd-swap mpd-move mpd-prev mpd-next mpd-pause mpd-stop
-;;;;;;  mpd-play mpd-clear-playlist mpd-shuffle-playlist mpd-remove-playlist
-;;;;;;  mpd-load-playlist mpd-save-playlist mpd-delete mpd-enqueue
-;;;;;;  mpd-get-outputs mpd-get-handled-remote-url-prefixes mpd-get-artist-albums
-;;;;;;  mpd-get-artists mpd-search mpd-list-directory-recursive mpd-get-directory-info
-;;;;;;  mpd-get-directory-songs mpd-get-current-song mpd-get-playlist-entry
-;;;;;;  mpd-get-playlist mpd-set-connection-timeout) "libmpdee" "libmpdee.el"
-;;;;;;  (20858 49922 477891 208000))
-;;; Generated autoloads from libmpdee.el
-
-(autoload 'mpd-set-connection-timeout "libmpdee" "\
-Set the timeout of mpd connection object CONN to TIMEOUT.
-See also `mpd-new-connection'.
-
-\(fn CONN TIMEOUT)" t nil)
-
-(autoload 'mpd-get-playlist "libmpdee" "\
-Get all songs in the current playlist managed by the mpd server.
-CONN and FOREACH are as in `mpd-get-songs'.
-
-\(fn CONN &optional FOREACH)" t nil)
-
-(autoload 'mpd-get-playlist-entry "libmpdee" "\
-Get song data for entr(y/ies) ITEM in the current mpd playlist.
-CONN, FOREACH and the return value are as in `mpd-get-songs'.
-ITEM is the item position/id or a list of it. Note that ITEM as nil fetches
-data for all entries in the current playlist rather than not doing anything.
-Interpret ITEM as song id(s) iff USE-ID is non-nil.
-
-\(fn CONN &optional ITEM FOREACH USE-ID)" t nil)
-
-(autoload 'mpd-get-current-song "libmpdee" "\
-Get song data for the current song in mpd.
-CONN and FOREACH are as in `mpd-get-songs'. Return FOREACH if specified, and
-the current song (see `mpd-get-songs' for how a song is represented) otherwise.
-
-\(fn CONN &optional FOREACH)" t nil)
-
-(autoload 'mpd-get-directory-songs "libmpdee" "\
-Get all songs in a directory of the mpd database.
-CONN, FOREACH and the return value are as in `mpd-get-songs'.
-DIRECTORY is the relative directory path wrt the database root.
-DIRECTORY could be a list as well, the action then corresponds to all songs
-in all the directories. Note that the nil value for DIRECTORY corresponds
-to the database toplevel rather than an empty list.
-
-\(fn CONN &optional DIRECTORY FOREACH)" t nil)
-
-(autoload 'mpd-get-directory-info "libmpdee" "\
-Get directory info for DIRECTORY in the mpd database.
-Use CONN as the mpd connection for the purpose and call function FOREACH,
-if specified, with each information field. The arguments passed to FOREACH is a
-song object, directory string or playlist string and one of the symbols 'file,
-'playlist or 'directory describing the data sent. DIRECTORY could be a list as
-well, the action then corresponds information for all the directories. Note that
-a nil for DIRECTORY corresponds to the database toplevel rather than an empty
-list. Return FOREACH, if non-nil; else a vector of three elements: a list of
-songs in the directory (see `mpd-get-songs' for how a song is represented),
-a list of playlists and a list of subdirectories.
-
-\(fn CONN &optional DIRECTORY FOREACH)" t nil)
-
-(autoload 'mpd-list-directory-recursive "libmpdee" "\
-Get the file-directory hierarchy of a directory in the mpd database.
-Use CONN for the connection and use function FOREACH to report each entry,
-along with a non-nil second argument if the entry is a directory. DIRECTORY
-could be a list as well, the action then corresponds to listing of all the
-directories. Note that the nil value for DIRECTORY corresponds to the
-database toplevel rather than an empty list.
-
-\(fn CONN FOREACH &optional DIRECTORY)" t nil)
-
-(autoload 'mpd-search "libmpdee" "\
-Search for songs in the mpd database.
-CONN, FOREACH and the return values are as in `mpd-get-songs'.
-The valid values for BY are 'artist, 'album and 'title;
-indicating the field to search for; and FOR is the search string.
-If FOR is a non-empty list, search by BY for all FOR.
-
-\(fn CONN BY FOR &optional FOREACH)" t nil)
-
-(autoload 'mpd-get-artists "libmpdee" "\
-Get the names of all artists whose songs are in the mpd database.
-Use CONN for the connection, and call function FOREACH, if specified, with
-each name. If FOREACH is a function, return FOREACH, else return a list of
-artist names.
-
-\(fn CONN &optional FOREACH)" t nil)
-
-(autoload 'mpd-get-artist-albums "libmpdee" "\
-Get all albums in the mpd database featuring artist(s) ARTIST.
-Get all albums if ARTIST is not specified. If ARTIST is a list, find the albums
-of all the artists in the list. Use CONN for the connection, and call function
-FOREACH, if specified, with each name. If FOREACH is a function, return FOREACH,
-else return the list of albums.
-
-\(fn CONN &optional ARTIST FOREACH)" t nil)
-
-(autoload 'mpd-get-handled-remote-url-prefixes "libmpdee" "\
-Use CONN to query remote URL prefixes handled by the mpd server.
-Call function FOREACH, if specified, with each prefix.
-If FOREACH is a function, return FOREACH, else return the URL prefixes.
-
-\(fn CONN &optional FOREACH)" t nil)
-
-(autoload 'mpd-get-outputs "libmpdee" "\
-Get output descriptions from the mpd server using connection CONN.
-Call function FOREACH, if specified, for each output, with the output provided
-as the argument. Return list of all outputs if FOREACH is not specified and
-FOREACH otherwise. When a list is returned, each element of the list is a
-property list, some known keys being `outputid' (integer), `outputname' (string)
-and `outputenabled' (boolean).
-
-\(fn CONN &optional FOREACH)" t nil)
-
-(autoload 'mpd-enqueue "libmpdee" "\
-Enqueue resource RES (or list of RES) to the mpd playlist.
-Each of RES can be a file or a directory in the mpd database, or an URL.
-
-\(fn CONN RES)" t nil)
-
-(autoload 'mpd-delete "libmpdee" "\
-Delete song at position/id POS from the mpd playlist.
-Interpret POS as a list of song id's if USE-ID is non-nil. POS could be a list
-to delete as well. If POS is a list and USE-ID is nil, sort it in descending
-order and remove duplicates before proceeding, unless NEVER-SORT is non-nil.
-Note that this is necessary for the correctness of the deletion, and NEVER-SORT
-is only provided in case the arguments already satisfy the condition.
-
-\(fn CONN POS &optional USE-ID NEVER-SORT)" t nil)
-
-(autoload 'mpd-save-playlist "libmpdee" "\
-Save current mpd playlist to FILE (or list of FILE).
-
-\(fn CONN FILE)" t nil)
-
-(autoload 'mpd-load-playlist "libmpdee" "\
-Load playlist PLNAME (or list of PLNAME) to the mpd server.
-
-\(fn CONN PLNAME)" t nil)
-
-(autoload 'mpd-remove-playlist "libmpdee" "\
-Remove playlist PLNAME from the mpd playlist directory.
-PLNAME could as well be a list of playlist names.
-
-\(fn CONN PLNAME)" t nil)
-
-(autoload 'mpd-shuffle-playlist "libmpdee" "\
-Shuffle current mpd playlist using connection CONN.
-
-\(fn CONN)" t nil)
-
-(autoload 'mpd-clear-playlist "libmpdee" "\
-Clear current mpd playlist using connection CONN.
-
-\(fn CONN)" t nil)
-
-(autoload 'mpd-play "libmpdee" "\
-Play song at position/id POS (default first) in the mpd playlist.
-Interpret POS as a song id iff USE-ID is non-nil.
-
-\(fn CONN &optional POS USE-ID)" t nil)
-
-(autoload 'mpd-stop "libmpdee" "\
-Stop playing the current mpd playlist.
-
-\(fn CONN)" t nil)
-
-(autoload 'mpd-pause "libmpdee" "\
-Toggle the pause state of the current mpd playlist.
-If prefix argument ARG is non-nil, pause iff ARG is positive
-and resume playing otherwise.
-
-\(fn CONN &optional ARG)" t nil)
-
-(autoload 'mpd-next "libmpdee" "\
-Play next song in the current mpd playlist.
-
-\(fn CONN)" t nil)
-
-(autoload 'mpd-prev "libmpdee" "\
-Play previous song in the current mpd playlist.
-
-\(fn CONN)" t nil)
-
-(autoload 'mpd-move "libmpdee" "\
-Move item from position/id FROM in the current mpd playlist to TO.
-For lists of FROM and TO, do action in that order for each pair of items.
-Interpret FROM as a list of song ids iff USE-ID is non-nil. Retain TO as a list
-of positions irrespective of the value of USE-ID. If sending a list for FROM and
-TO, note that every move changes the order of items in the playlist.
-
-\(fn CONN FROM TO &optional USE-ID)" t nil)
-
-(autoload 'mpd-swap "libmpdee" "\
-Swap positions/ids FIRST and SECOND in the current mpd playlist.
-For lists of FROM and TO, do action in that order for each pair of items.
-Interpret FIRST and SECOND as song ids iff USE-ID is non-nil.
-See also `mpd-move'.
-
-\(fn CONN FIRST SECOND &optional USE-ID)" t nil)
-
-(autoload 'mpd-seek "libmpdee" "\
-Seek to song position/id SONG and time TIME in the mpd playlist.
-Take TIME to be 0 by default. Interpret SONG as a song id
-iff USE-ID is non-nil.
-
-\(fn CONN SONG &optional TIME USE-ID)" t nil)
-
-(autoload 'mpd-toggle-random "libmpdee" "\
-Change random mode of mpd using connection CONN.
-With ARG, set random on iff ARG is positive.
-
-\(fn CONN &optional ARG)" t nil)
-
-(autoload 'mpd-toggle-repeat "libmpdee" "\
-Change repeat mode of mpd using connection CONN.
-With ARG, set repeat on iff ARG is positive.
-
-\(fn CONN &optional ARG)" t nil)
-
-(autoload 'mpd-set-volume "libmpdee" "\
-Set the volume for the mpd player to volume VOL.
-
-\(fn CONN VOL)" t nil)
-
-(autoload 'mpd-adjust-volume "libmpdee" "\
-Adjust the volume for the mpd player by volume VOL.
-If VOL is positive, increase the volume, and decrease otherwise.
-
-\(fn CONN VOL)" t nil)
-
-(autoload 'mpd-set-crossfade "libmpdee" "\
-Set cross-fading time for the mpd player to TIME in seconds.
-Turn off cross-fading if TIME is 0.
-
-\(fn CONN TIME)" t nil)
-
-(autoload 'mpd-set-password "libmpdee" "\
-Set the password for access to the mpd server.
-*WARNING* The password is sent to the server in plaintext. The processing done
-by libmpdee to send the command for setting the password also has its data as
-plaintext. When called interactively, offer to store and set the password on
-reconnection. Note that this is not done when the call is not interactive.
-Use hooked automatic mode (see `mpd-set-automatic-mode') to achieve the same.
-
-\(fn CONN PASS)" t nil)
-
-(autoload 'mpd-update "libmpdee" "\
-Instruct the mpd server using CONN to update its database.
-PATH is the path or a list of paths to be updated. Note that PATH as nil updates
-the root directory rather than not updating at all. Ignore connection timeout,
-if IGNORE-TIMEOUT is non-nil and the connection is not in command list mode.
-Return update job id on success.
-
-\(fn CONN &optional PATH IGNORE-TIMEOUT)" t nil)
-
-(autoload 'mpd-output-enable "libmpdee" "\
-Use connection CONN to enable mpd output ID.
-
-\(fn CONN ID)" t nil)
-
-(autoload 'mpd-output-disable "libmpdee" "\
-Use connection CONN to disable mpd output ID.
-
-\(fn CONN ID)" t nil)
-
-(autoload 'mpd-libmpdee-submit-bug-report "libmpdee" "\
-Interactively submit a bug report about `libmpdee'.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (global-linum-mode linum-mode linum-format) "linum"
-;;;;;;  "linum.el" (20858 49922 481891 228000))
-;;; Generated autoloads from linum.el
-
-(defvar linum-format 'dynamic "\
-Format used to display line numbers. Either a format string
-like \"%7d\", 'dynamic to adapt the width as needed, or a
-function that is called with a line number as its argument and
-should evaluate to a string to be shown on that line. See also
-`linum-before-numbering-hook'.")
-
-(custom-autoload 'linum-format "linum" t)
-
-(autoload 'linum-mode "linum" "\
-Toggle display of line numbers in the left marginal area.
-
-\(fn &optional ARG)" t nil)
-
-(defvar global-linum-mode nil "\
-Non-nil if Global-Linum mode is enabled.
-See the command `global-linum-mode' for a description of this minor mode.
-Setting this variable directly does not take effect;
-either customize it (see the info node `Easy Customization')
-or call the function `global-linum-mode'.")
-
-(custom-autoload 'global-linum-mode "linum" nil)
-
-(autoload 'global-linum-mode "linum" "\
-Toggle Linum mode in all buffers.
-With prefix ARG, enable Global-Linum mode if ARG is positive;
-otherwise, disable it.  If called from Lisp, enable the mode if
-ARG is omitted or nil.
-
-Linum mode is enabled in all buffers where
-`linum-on' would do it.
-See `linum-mode' for more information on Linum mode.
-
-\(fn &optional ARG)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (linum-version linum-mode linum-format) "linum-old"
-;;;;;;  "linum-old.el" (20858 49922 477891 208000))
-;;; Generated autoloads from linum-old.el
-
-(defvar linum-format "%6d " "\
-Format used to display line numbers. Either a format string like \"%6d  \",
-or the symbol 'dynamic to adapt the width as needed. 'dynamic or
-a format string that does not expand to a multiple of 8 can make
-indentations look different if you indent using tab characters.")
-
-(custom-autoload 'linum-format "linum-old" t)
-
-(autoload 'linum-mode "linum-old" "\
-Toggle display of line numbers.
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'linum-version "linum-old" "\
-Display version of linum.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (lua-mode) "lua-mode" "lua-mode.el" (20858 49922
-;;;;;;  485891 248000))
-;;; Generated autoloads from lua-mode.el
-
-(autoload 'lua-mode "lua-mode" "\
-Major mode for editing Lua code.
-
-\(fn)" t nil)
-
-(add-to-list 'auto-mode-alist '("\\.lua$" . lua-mode))
-
-(add-to-list 'interpreter-mode-alist '("lua" . lua-mode))
-
-;;;***
-\f
-;;;### (autoloads nil "magit-filenotify" "magit-filenotify.el" (21359
-;;;;;;  23649 0 0))
-;;; Generated autoloads from magit-filenotify.el
-
-(autoload 'magit-filenotify-mode "magit-filenotify" "\
-Refresh status buffer if source tree changes.
-
-\(fn &optional ARG)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "magit-find-file" "magit-find-file.el" (21359
-;;;;;;  23648 0 0))
-;;; Generated autoloads from magit-find-file.el
-
-(autoload 'magit-find-file-completing-read "magit-find-file" "\
-Uses a completing read to open a file from git ls-files
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (gfm-mode markdown-mode) "markdown-mode" "markdown-mode.el"
-;;;;;;  (20858 49922 485891 248000))
-;;; Generated autoloads from markdown-mode.el
-
-(autoload 'markdown-mode "markdown-mode" "\
-Major mode for editing Markdown files.
-
-\(fn)" t nil)
-
-(autoload 'gfm-mode "markdown-mode" "\
-Major mode for editing GitHub Flavored Markdown files.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (markdown-copy-paste-html markdown-copy-rtf markdown-code-copy
-;;;;;;  markdown-export-pandoc-pdf markdown-export-pdf markdown-export-latex)
-;;;;;;  "markdown-mode+" "markdown-mode+.el" (20858 49922 485891
-;;;;;;  248000))
-;;; Generated autoloads from markdown-mode+.el
-
-(autoload 'markdown-export-latex "markdown-mode+" "\
-Output the Markdown file as LaTeX.
-
-\(fn)" t nil)
-
-(autoload 'markdown-export-pdf "markdown-mode+" "\
-Output the Markdown file as LaTeX.
-
-\(fn)" t nil)
-
-(autoload 'markdown-export-pandoc-pdf "markdown-mode+" "\
-Output the Markdown file as LaTeX.
-
-\(fn)" t nil)
-
-(autoload 'markdown-code-copy "markdown-mode+" "\
-Copy region from BEGIN to END to the clipboard with four spaces indenteded on each line.
-
-Taken from
-http://stackoverflow.com/questions/3519244/emacs-command-to-indent-code-by-4-spaces-to-format-for-paste-into-stackoverflow.
-
-\(fn BEGIN END)" t nil)
-
-(autoload 'markdown-copy-rtf "markdown-mode+" "\
-Render markdown and copy as RTF.
-
-\(fn)" t nil)
-
-(autoload 'markdown-copy-paste-html "markdown-mode+" "\
-Process file with multimarkdown, copy it to the clipboard, and paste in safari's selected textarea.
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (message-xpost-fup2 message-change-subject message-strip-subject-was
-;;;;;;  message-mark-insert-file message-mark-inserted-region) "message-utils"
-;;;;;;  "message-utils.el" (20858 49922 485891 248000))
-;;; Generated autoloads from message-utils.el
-
-(autoload 'message-mark-inserted-region "message-utils" "\
-Mark some region in the current article with enclosing tags.
-See `message-begin-inserted-text-mark' and `message-end-inserted-text-mark'.
-
-\(fn BEG END)" t nil)
-
-(autoload 'message-mark-insert-file "message-utils" "\
-Inserts FILE at point, marking it with enclosing tags.
-See `message-begin-inserted-text-mark' and `message-end-inserted-text-mark'.
-
-\(fn FILE)" t nil)
-
-(autoload 'message-strip-subject-was "message-utils" "\
-Remove trailing \"(Was: <old subject>)\" from subject lines.
-
-\(fn)" nil nil)
-
-(autoload 'message-change-subject "message-utils" "\
-Ask for new Subject: header, append (was: <Old Subject>).
-
-\(fn NEW-SUBJECT)" t nil)
-
-(autoload 'message-xpost-fup2 "message-utils" "\
-Crossposts message and sets Followup-To to TARGET-GROUP.
-With prefix-argument just set Follow-Up, don't cross-post.
-
-\(fn TARGET-GROUP)" t nil)
-
-;;;***
-\f
-;;;### (autoloads (mgp-mode) "mgp-mode-cd" "mgp-mode-cd.el" (20858
-;;;;;;  49922 485891 248000))
-;;; Generated autoloads from mgp-mode-cd.el
-
-(autoload 'mgp-mode "mgp-mode-cd" "\
-Major mode for editing mgp2 source.
-Comments etc. are highlighted with font-lock. There are also a 
-number of commands that make editing and working with MGP files 
-more convenient. These commands are available from the main menu 
-`MGP' or via the following shortcuts:
-
-\\[mgp-preview-file]   - Run mgp on the current file.
-\\[mgp-comment-region] - Comments out the current region.
-\\[mgp-uncomment-region]       - Uncomments the current region.
-\\[mgp-mark-page]      - Marks the current page (== paragraph).
-
-\(fn)" t nil)
-
-;;;***
-\f
-;;;### (autoloads nil "mic-paren" "mic-paren.el" (21371 48996 661720
-;;;;;;  507000))
-;;; Generated autoloads from mic-paren.el
-
-(autoload 'paren-activate "mic-paren" "\
-Activate mic-paren parenthesis highlighting.
-Note: This also deactivates the paren.el
-and stig-paren.el packages if they are active!
-
-The following options are available via the customize-feature:
-  `paren-priority'
-  `paren-overlay-priority'
-  `paren-sexp-mode'
-  `paren-highlight-at-point'
-  `paren-highlight-offscreen'
-  `paren-display-message'
-  `paren-message-linefeed-display'
-  `paren-message-no-match'
-  `paren-message-show-linenumber'
-  `paren-message-truncate-lines'
-  `paren-ding-unmatched'
-  `paren-delay'
-  `paren-dont-touch-blink'
-  `paren-match-face'
-  `paren-mismatch-face'
-  `paren-no-match-face'
-  `paren-bind-modified-sexp-functions'
-
-The following options are settable via toggling functions (look at the
-documentation of these options for the names of these functions):
-  `paren-match-quoted-paren'
-  `paren-match-paired-delimiter'
-  `paren-open-paren-context-backward'
-
-\(fn)" t nil)
-
-(autoload 'paren-deactivate "mic-paren" "\
-Deactivate mic-paren parenthesis highlighting.
-
-\(fn)" t nil)
-
-(autoload 'paren-toggle-matching-paired-delimiter "mic-paren" "\
-Toggle matching paired delimiter.
-Force on with positive ARG.  Use this in mode hooks to activate or
-deactivate paired delimiter matching.  If optional second argument
-NO-MESSAGE is non-nil then don't display a message about the
-current activation state of the paired-delimiter-matching feature.
-
-\(fn ARG &optional NO-MESSAGE)" t nil)
-
-(autoload 'paren-toggle-matching-quoted-paren "mic-paren" "\
-Toggle matching quoted parens.
-Force on with positive ARG.  Use this in mode hooks to activate or
-deactivate quoted paren matching.  If optional second argument
-NO-MESSAGE is non-nil then don't display a message about the
-current activation state of the quoted-paren-matching feature.
-
-\(fn ARG &optional NO-MESSAGE)" t nil)
-
-(autoload 'paren-toggle-open-paren-context "mic-paren" "\
-Toggle whether or not to determine context of the matching open-paren.
-Force backward context with positive ARG.  Use this in mode-hooks.
-See `paren-open-paren-context-backward'.
-
-\(fn ARG)" t nil)
+\(fn)" nil nil)
 
-(autoload 'paren-forward-sexp "mic-paren" "\
-Act like `forward-sexp' but also handle quoted parens.
-See `paren-match-quoted-paren'.
+(autoload 'bh/is-task-p "ganneff-org" "\
+Any task with a todo keyword and no subtask
 
-\(fn &optional ARG)" t nil)
+\(fn)" nil nil)
 
-(autoload 'paren-backward-sexp "mic-paren" "\
-Act like `backward-sexp' but also match quoted parens.
-See `paren-match-quoted-paren'.
+(autoload 'bh/is-subproject-p "ganneff-org" "\
+Any task which is a subtask of another project
 
-\(fn &optional ARG)" t nil)
+\(fn)" nil nil)
 
-;;;***
-\f
-;;;### (autoloads (miniedit-install-for-xemacs miniedit-install miniedit
-;;;;;;  miniedit-new-features miniedit-commentary miniedit-introduction
-;;;;;;  miniedit-quick-start) "miniedit" "miniedit.el" (20858 49922
-;;;;;;  489891 267000))
-;;; Generated autoloads from miniedit.el
+(autoload 'bh/list-sublevels-for-projects-indented "ganneff-org" "\
+Set org-tags-match-list-sublevels so when restricted to a subtree we list all subtasks.
+  This is normally used by skipping functions where this variable is already local to the agenda.
 
-(autoload 'miniedit-quick-start "miniedit" "\
-Provides electric help for function `miniedit-quick-start'.
+\(fn)" nil nil)
 
-\(fn)" t nil)
+(autoload 'bh/list-sublevels-for-projects "ganneff-org" "\
+Set org-tags-match-list-sublevels so when restricted to a subtree we list all subtasks.
+  This is normally used by skipping functions where this variable is already local to the agenda.
 
-(autoload 'miniedit-introduction "miniedit" "\
-Provides electric help for function `miniedit-introduction'.
+\(fn)" nil nil)
 
-\(fn)" t nil)
+(autoload 'bh/skip-stuck-projects "ganneff-org" "\
+Skip trees that are not stuck projects
 
-(autoload 'miniedit-commentary "miniedit" "\
-Provides electric help for function `miniedit-commentary'.
+\(fn)" nil nil)
 
-\(fn)" t nil)
+(autoload 'bh/skip-non-stuck-projects "ganneff-org" "\
+Skip trees that are not stuck projects
 
-(autoload 'miniedit-new-features "miniedit" "\
-Provides electric help for function `miniedit-new-features'.
+\(fn)" nil nil)
 
-\(fn)" t nil)
+(autoload 'bh/skip-non-projects "ganneff-org" "\
+Skip trees that are not projects
 
-(autoload 'miniedit "miniedit" "\
-The main function.
+\(fn)" nil nil)
 
-\(fn)" t nil)
+(autoload 'bh/skip-project-trees-and-habits "ganneff-org" "\
+Skip trees that are projects
 
-(autoload 'miniedit-install "miniedit" "\
-Install miniedit by frobbing your miniedit-local maps.
+\(fn)" nil nil)
 
-\(fn)" t nil)
+(autoload 'bh/skip-projects-and-habits-and-single-tasks "ganneff-org" "\
+Skip trees that are projects, tasks that are habits, single non-project tasks
 
-(autoload 'miniedit-install-for-xemacs "miniedit" "\
-Try to Install miniedit for Xemacs.
+\(fn)" nil nil)
 
-\(fn)" t nil)
+(autoload 'bh/skip-project-tasks-maybe "ganneff-org" "\
+Show tasks related to the current restriction.
+When restricted to a project, skip project and sub project tasks, habits, NEXT tasks, and loose tasks.
+When not restricted, skip project and sub-project tasks, habits, and project related tasks.
 
-;;;***
-\f
-;;;### (autoloads (size-indication-mode modelinepos-column-limit)
-;;;;;;  "modeline-posn" "modeline-posn.el" (20858 49922 489891 267000))
-;;; Generated autoloads from modeline-posn.el
+\(fn)" nil nil)
 
-(defface modelinepos-column-warning '((t (:foreground "Red"))) "\
-*Face used to highlight the modeline column number.
-This is used when the current column number is greater than
-`modelinepos-column-limit'." :group (quote Modeline) :group (quote Convenience) :group (quote Help) :group (quote faces))
+(autoload 'bh/skip-projects-and-habits "ganneff-org" "\
+Skip trees that are projects and tasks that are habits
 
-(defvar modelinepos-column-limit 70 "\
-Current column greater than this means highlight column in mode-line.")
+\(fn)" nil nil)
 
-(custom-autoload 'modelinepos-column-limit "modeline-posn" t)
+(autoload 'bh/skip-non-subprojects "ganneff-org" "\
+Skip trees that are not projects
 
-(defvar size-indication-mode nil "\
-Non-nil if Size-Indication mode is enabled.
-See the command `size-indication-mode' for a description of this minor mode.")
+\(fn)" nil nil)
 
-(custom-autoload 'size-indication-mode "modeline-posn" nil)
+(autoload 'bh/org-agenda-to-appt "ganneff-org" "\
 
-(autoload 'size-indication-mode "modeline-posn" "\
-Toggle Size Indication mode.
-With arg, turn Size Indication mode on iff arg is positive.
-When Size Indication mode is enabled, the buffer or region size
-appears in the mode line.  If Transient Mark mode is enabled, the
-region size is shown; otherwise, the size of the accessible part
-of the buffer is shown.
 
-\(fn &optional ARG)" t nil)
+\(fn)" t nil)
 
-;;;***
-\f
-;;;### (autoloads (org-google-weather) "org-google-weather" "org-google-weather.el"
-;;;;;;  (20858 49922 493891 287000))
-;;; Generated autoloads from org-google-weather.el
+(autoload 'bh/restrict-to-file-or-follow "ganneff-org" "\
+Set agenda restriction to 'file or with argument invoke follow mode.
+I don't use follow mode very often but I restrict to file all the time
+so change the default 'F' binding in the agenda to allow both
 
-(autoload 'org-google-weather "org-google-weather" "\
-Return Org entry with the weather for LOCATION in LANGUAGE.
-If LOCATION is not set, use org-google-weather-location.
+\(fn ARG)" t nil)
 
-\(fn &optional LOCATION LANGUAGE)" nil nil)
+(autoload 'bh/narrow-to-org-subtree "ganneff-org" "\
 
-;;;***
-\f
-;;;### (autoloads (paredit-mode) "paredit" "paredit.el" (20858 49922
-;;;;;;  493891 287000))
-;;; Generated autoloads from paredit.el
-
-(autoload 'paredit-mode "paredit" "\
-Minor mode for pseudo-structurally editing Lisp code.
-With a prefix argument, enable Paredit Mode even if there are
-  unbalanced parentheses in the buffer.
-Paredit behaves badly if parentheses are unbalanced, so exercise
-  caution when forcing Paredit Mode to be enabled, and consider
-  fixing unbalanced parentheses instead.
-\\<paredit-mode-map>
 
-\(fn &optional ARG)" t nil)
+\(fn)" nil nil)
 
-;;;***
-\f
-;;;### (autoloads (global-rainbow-delimiters-mode rainbow-delimiters-mode-disable
-;;;;;;  rainbow-delimiters-mode-enable rainbow-delimiters-mode) "rainbow-delimiters"
-;;;;;;  "rainbow-delimiters.el" (20858 49922 497891 307000))
-;;; Generated autoloads from rainbow-delimiters.el
+(autoload 'bh/narrow-to-subtree "ganneff-org" "\
 
-(autoload 'rainbow-delimiters-mode "rainbow-delimiters" "\
-Highlight nested parentheses, brackets, and braces according to their depth.
 
-\(fn &optional ARG)" t nil)
+\(fn)" t nil)
 
-(autoload 'rainbow-delimiters-mode-enable "rainbow-delimiters" "\
+(autoload 'bh/narrow-up-one-org-level "ganneff-org" "\
 
 
 \(fn)" nil nil)
 
-(autoload 'rainbow-delimiters-mode-disable "rainbow-delimiters" "\
+(autoload 'bh/narrow-up-one-level "ganneff-org" "\
 
 
-\(fn)" nil nil)
+\(fn)" t nil)
 
-(defvar global-rainbow-delimiters-mode nil "\
-Non-nil if Global-Rainbow-Delimiters mode is enabled.
-See the command `global-rainbow-delimiters-mode' for a description of this minor mode.
-Setting this variable directly does not take effect;
-either customize it (see the info node `Easy Customization')
-or call the function `global-rainbow-delimiters-mode'.")
+(autoload 'bh/narrow-to-org-project "ganneff-org" "\
 
-(custom-autoload 'global-rainbow-delimiters-mode "rainbow-delimiters" nil)
 
-(autoload 'global-rainbow-delimiters-mode "rainbow-delimiters" "\
-Toggle Rainbow-Delimiters mode in all buffers.
-With prefix ARG, enable Global-Rainbow-Delimiters mode if ARG is positive;
-otherwise, disable it.  If called from Lisp, enable the mode if
-ARG is omitted or nil.
+\(fn)" nil nil)
 
-Rainbow-Delimiters mode is enabled in all buffers where
-`rainbow-delimiters-mode-enable' would do it.
-See `rainbow-delimiters-mode' for more information on Rainbow-Delimiters mode.
+(autoload 'bh/narrow-to-project "ganneff-org" "\
 
-\(fn &optional ARG)" t nil)
 
-;;;***
-\f
-;;;### (autoloads (rainbow-mode) "rainbow-mode" "rainbow-mode.el"
-;;;;;;  (20858 49922 497891 307000))
-;;; Generated autoloads from rainbow-mode.el
+\(fn)" t nil)
 
-(autoload 'rainbow-mode "rainbow-mode" "\
-Colorize strings that represent colors.
-This will fontify with colors the string like \"#aabbcc\" or \"blue\".
+(autoload 'bh/clock-in-to-next "ganneff-org" "\
+Switch a task from TODO to NEXT when clocking in.
+  Skips capture tasks, projects, and subprojects.
+  Switch projects and subprojects from NEXT back to TODO
 
-\(fn &optional ARG)" t nil)
+\(fn KW)" nil nil)
 
-;;;***
-\f
-;;;### (autoloads (register-list) "register-list" "register-list.el"
-;;;;;;  (20858 49922 501891 327000))
-;;; Generated autoloads from register-list.el
+(autoload 'bh/find-project-task "ganneff-org" "\
+Move point to the parent (project) task if any
 
-(autoload 'register-list "register-list" "\
-Display a list of registers.
-An optional argument TYPE defines a regexp to restrict the
-register menu to.  A second optional argument FONTIFICATION
-decides if the display preserves original fontification for
-values.
+\(fn)" nil nil)
 
-The default types are defined in `register-list-default-types',
-which see.
+(autoload 'bh/punch-in "ganneff-org" "\
+Start continuous clocking and set the default task to the
+  selected task.  If no task is selected set the Organization task
+  as the default task.
 
-The list is displayed in a buffer named `*Register List*' in
-`register-list-mode', which see.
+\(fn ARG)" t nil)
 
-\(fn &optional TYPE FONTIFY)" t nil)
+(autoload 'bh/punch-out "ganneff-org" "\
 
-;;;***
-\f
-;;;### (autoloads nil "ruby-hash-syntax" "ruby-hash-syntax.el" (21228
-;;;;;;  61058 260804 592000))
-;;; Generated autoloads from ruby-hash-syntax.el
 
-(autoload 'ruby-toggle-hash-syntax "ruby-hash-syntax" "\
-Toggle syntax of ruby hash literal in region from BEG to END between ruby 1.8 and 1.9 styles.
+\(fn)" t nil)
 
-\(fn BEG END)" t nil)
+(autoload 'bh/clock-in-default-task "ganneff-org" "\
 
-;;;***
-\f
-;;;### (autoloads (turn-off-screen-lines-mode turn-on-screen-lines-mode
-;;;;;;  screen-lines-mode) "screen-lines" "screen-lines.el" (20858
-;;;;;;  49922 501891 327000))
-;;; Generated autoloads from screen-lines.el
 
-(autoload 'screen-lines-mode "screen-lines" "\
-Toggle Screen Lines minor mode for the current buffer.
-With ARG, turn the mode on if ARG is positive, off otherwise.
+\(fn)" nil nil)
 
-\(fn &optional ARG)" t nil)
+(autoload 'bh/clock-in-parent-task "ganneff-org" "\
+Move point to the parent (project) task if any and clock in
 
-(autoload 'turn-on-screen-lines-mode "screen-lines" "\
-Turn on Screen Lines minor mode for the current buffer.
+\(fn)" nil nil)
 
-\(fn)" t nil)
+(autoload 'bh/clock-in-organization-task-as-default "ganneff-org" "\
 
-(autoload 'turn-off-screen-lines-mode "screen-lines" "\
-Turn off Screen Lines minor mode for the current buffer.
 
 \(fn)" t nil)
 
-;;;***
-\f
-;;;### (autoloads nil "sh-toggle" "sh-toggle.el" (21369 2951 0 0))
-;;; Generated autoloads from sh-toggle.el
-
-(autoload 'shell-toggle-cd "sh-toggle" "\
-Calls `shell-toggle' with a prefix argument.
-See the command `shell-toggle'
-
-\(fn)" t nil)
+(autoload 'bh/clock-out-maybe "ganneff-org" "\
 
-(autoload 'shell-toggle "sh-toggle" "\
-Toggles between the *shell* buffer and the current buffer.
-With a prefix ARG also insert a \"cd DIR\" command into the shell,
-where DIR is the directory of the current buffer.
 
-Call twice in a row to get a full screen window for the *shell*
-buffer.
+\(fn)" nil nil)
 
-When called in the *shell* buffer returns you to the buffer you were
-editing before caling the first time.
+(autoload 'bh/clock-in-last-task "ganneff-org" "\
+Clock in the interrupted task if there is one
+  Skip the default task and get the next one.
+  A prefix arg forces clock in of the default task.
 
-Options: `shell-toggle-goto-eob'
+\(fn ARG)" t nil)
 
-\(fn MAKE-CD)" t nil)
+(autoload 'bh/set-agenda-restriction-lock "ganneff-org" "\
+Set restriction lock to current task subtree or file if prefix is specified
 
-;;;***
-\f
-;;;### (autoloads nil "solarized" "solarized.el" (20894 2195 0 0))
-;;; Generated autoloads from solarized.el
+\(fn ARG)" t nil)
 
-(when (and (boundp 'custom-theme-load-path) load-file-name) (add-to-list 'custom-theme-load-path (file-name-as-directory (file-name-directory load-file-name))))
+(autoload 'bh/get-pom-from-agenda-restriction-or-point "ganneff-org" "\
 
-;;;***
-\f
-;;;### (autoloads (tidy-buffer tidy-save-settings tidy-parse-config-file
-;;;;;;  tidy-build-menu) "tidy" "tidy.el" (20893 10149 0 0))
-;;; Generated autoloads from tidy.el
 
-(autoload 'tidy-build-menu "tidy" "\
-Set up the tidy menu in MAP. Used to set up a Tidy menu in your
-favourite mode.
+\(fn)" nil nil)
 
-\(fn &optional MAP)" t nil)
+(autoload 'bh/view-next-project "ganneff-org" "\
 
-(autoload 'tidy-parse-config-file "tidy" "\
-If `tidy-config-file' is non-nil parse that file setting variables accordingly.
 
 \(fn)" t nil)
 
-(autoload 'tidy-save-settings "tidy" "\
-Query saving the current settings to your `tidy-config-file'.
-Perhaps put this on your `kill-buffer-hook'.
-
-\(fn &optional CONFIG-FILE)" t nil)
-
-(autoload 'tidy-buffer "tidy" "\
-Run the HTML Tidy program on the current buffer.
-If PREFIX is non-nil, or if called interactively with a prefix argument,
-then Tidy is applied to the currently selected region.  Any error messages
-generated by that program are sent to \"*tidy-errors*\" buffer.
+(autoload 'bh/display-inline-images "ganneff-org" "\
 
-\(fn &optional PREFIX)" t nil)
 
-;;;***
-\f
-;;;### (autoloads (global-undo-tree-mode undo-tree-mode) "undo-tree"
-;;;;;;  "undo-tree.el" (20858 49922 501891 327000))
-;;; Generated autoloads from undo-tree.el
+\(fn)" nil nil)
 
-(autoload 'undo-tree-mode "undo-tree" "\
-Toggle undo-tree mode.
-With no argument, this command toggles the mode.
-A positive prefix argument turns the mode on.
-A negative prefix argument turns it off.
+(autoload 'bh/save-then-publish "ganneff-org" "\
 
-Undo-tree-mode replaces Emacs' standard undo feature with a more
-powerful yet easier to use version, that treats the undo history
-as what it is: a tree.
 
-The following keys are available in `undo-tree-mode':
+\(fn &optional FORCE)" t nil)
 
-  \\{undo-tree-map}
+(autoload 'org-mycal-export-limit "ganneff-org" "\
+Limit the export to items that have a date, time and a range. Also exclude certain categories.
 
-Within the undo-tree visualizer, the following keys are available:
+\(fn)" nil nil)
 
-  \\{undo-tree-visualizer-map}
+(autoload 'mycal-export-limit "ganneff-org" "\
+Limit the export to items that don't match an unwanted category 
 
-\(fn &optional ARG)" t nil)
+\(fn)" nil nil)
 
-(defvar global-undo-tree-mode nil "\
-Non-nil if Global-Undo-Tree mode is enabled.
-See the command `global-undo-tree-mode' for a description of this minor mode.
-Setting this variable directly does not take effect;
-either customize it (see the info node `Easy Customization')
-or call the function `global-undo-tree-mode'.")
+(autoload 'org-mycal-export "ganneff-org" "\
 
-(custom-autoload 'global-undo-tree-mode "undo-tree" nil)
 
-(autoload 'global-undo-tree-mode "undo-tree" "\
-Toggle Undo-Tree mode in all buffers.
-With prefix ARG, enable Global-Undo-Tree mode if ARG is positive;
-otherwise, disable it.  If called from Lisp, enable the mode if
-ARG is omitted or nil.
+\(fn)" t nil)
 
-Undo-Tree mode is enabled in all buffers where
-`turn-on-undo-tree-mode' would do it.
-See `undo-tree-mode' for more information on Undo-Tree mode.
+(autoload 'jj/punch-in-hw "ganneff-org" "\
+Start clocking the hwmigration task
 
-\(fn &optional ARG)" t nil)
+\(fn ARG)" t nil)
 
 ;;;***
 \f
-;;;### (autoloads (update-autoloads-for-file-in-package-area update-autoloads-in-package-area)
-;;;;;;  "update-autoloads" "update-autoloads.el" (20858 49922 545891
-;;;;;;  545000))
-;;; Generated autoloads from update-autoloads.el
-
-(setq load-path (cons (file-name-directory load-file-name) load-path))
-
-(autoload 'update-autoloads-in-package-area "update-autoloads" "\
-Update autoloads for files in the diretory containing this file.
-
-\(fn &optional FILE)" t nil)
-
-(autoload 'update-autoloads-for-file-in-package-area "update-autoloads" "\
+;;;### (autoloads (keep-buffers-query) "keep-buffers" "keep-buffers.el"
+;;;;;;  (20858 49922 477891 208000))
+;;; Generated autoloads from keep-buffers.el
 
+(autoload 'keep-buffers-query "keep-buffers" "\
+The query function that disable deletion of buffers we protect.
 
-\(fn FILE)" t nil)
+\(fn)" nil nil)
 
 ;;;***
 \f
-;;;### (autoloads (uptimes-this uptimes) "uptimes" "uptimes.el" (20858
-;;;;;;  49922 545891 545000))
-;;; Generated autoloads from uptimes.el
+;;;### (autoloads nil "use-package" "use-package.el" (0 0 0 0))
+;;; Generated autoloads from use-package.el
 
-(autoload 'uptimes "uptimes" "\
-Display the last and top `uptimes-keep-count' uptimes.
-
-\(fn)" t nil)
+(autoload 'use-package "use-package" "\
+Declare an Emacs package by specifying a group of configuration options.
 
-(autoload 'uptimes-this "uptimes" "\
-Display the uptime for the current emacs session.
+For full documentation, please see the README file that came with
+this file.  Usage:
 
-\(fn)" t nil)
+  (use-package package-name
+     [:keyword [option]]...)
 
-;;;***
-\f
-;;;### (autoloads (wdired-change-to-wdired-mode) "wdired" "wdired.el"
-;;;;;;  (20858 49922 561891 624000))
-;;; Generated autoloads from wdired.el
+:init          Code to run before PACKAGE-NAME has been loaded.
+:config        Code to run after PACKAGE-NAME has been loaded.  Note that if
+               loading is deferred for any reason, this code does not execute
+               until the lazy load has occurred.
+:preface       Code to be run before everything except `:disabled'; this can
+               be used to define functions for use in `:if', or that should be
+               seen by the byte-compiler.
 
-(autoload 'wdired-change-to-wdired-mode "wdired" "\
-Put a dired buffer in a mode in which filenames are editable.
-\\<wdired-mode-map>
-This mode allows the user to change the names of the files, and after
-typing \\[wdired-finish-edit] Emacs renames the files and directories
-in disk.
+:mode          Form to be added to `auto-mode-alist'.
+:interpreter   Form to be added to `interpreter-mode-alist'.
 
-See `wdired-mode'.
+:commands      Define autoloads for commands that will be defined by the
+               package.  This is useful if the package is being lazily loaded,
+               and you wish to conditionally call functions in your `:init'
+               block that are defined in the package.
 
-\(fn)" t nil)
+:bind          Bind keys, and define autoloads for the bound commands.
+:bind*         Bind keys, and define autoloads for the bound commands,
+               *overriding all minor mode bindings*.
+:bind-keymap   Bind a key prefix to an auto-loaded keymap defined in the
+               package.  This is like `:bind', but for keymaps.
+:bind-keymap*  Like `:bind-keymap', but overrides all minor mode bindings
 
-;;;***
-\f
-;;;### (autoloads (worklog-summarize-tasks worklog-task-done worklog-task-stop
-;;;;;;  worklog-task-begin worklog-do-task) "worklog" "worklog.el"
-;;;;;;  (20858 49922 561891 624000))
-;;; Generated autoloads from worklog.el
+:defer         Defer loading of a package -- this is implied when using
+               `:commands', `:bind', `:bind*', `:mode' or `:interpreter'.
+               This can be an integer, to force loading after N seconds of
+               idle time, if the package has not already been loaded.
 
-(autoload 'worklog-do-task "worklog" "\
-Append TASK to the worklog.
-If there is an ongoing task, you are given the option to declare it done or
-stopped, or to cancel the operation.
+:after         Defer loading of a package until after any of the named
+               features are loaded.
 
-`worklog-do-task' allows you to insert tasks into your worklog without
-the need to interactively call it.
+:demand        Prevent deferred loading in all cases.
 
-If autostop is set to non-nil, any running task will automatically be stopped.
+:if EXPR       Initialize and load only if EXPR evaluates to a non-nil value.
+:disabled      The package is ignored completely if this keyword is present.
+:defines       Declare certain variables to silence the byte-compiler.
+:functions     Declare certain functions to silence the byte-compiler.
+:load-path     Add to the `load-path' before attempting to load the package.
+:diminish      Support for diminish.el (if installed).
+:ensure        Loads the package using package.el if necessary.
+:pin           Pin the package to an archive.
 
-\(fn TASK &optional AUTOSTOP)" nil nil)
+\(fn NAME &rest ARGS)" nil t)
 
-(autoload 'worklog-task-begin "worklog" "\
-Convenience function for `worklog-do-task'.
+(function-put 'use-package 'lisp-indent-function '1)
 
-Does the same as calling`worklog-do-task' with a string parameter.
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "use-package" '("use-package-")))
 
-\(fn TASK)" t nil)
+;;;***
+\f
+;;;### (autoloads nil "mic-paren" "mic-paren.el" (21371 48996 661720
+;;;;;;  507000))
+;;; Generated autoloads from mic-paren.el
 
-(autoload 'worklog-task-stop "worklog" "\
-Append a \"stop\" entry to the worklog.
+(autoload 'paren-activate "mic-paren" "\
+Activate mic-paren parenthesis highlighting.
+Note: This also deactivates the paren.el
+and stig-paren.el packages if they are active!
 
-\(fn)" t nil)
+The following options are available via the customize-feature:
+  `paren-priority'
+  `paren-overlay-priority'
+  `paren-sexp-mode'
+  `paren-highlight-at-point'
+  `paren-highlight-offscreen'
+  `paren-display-message'
+  `paren-message-linefeed-display'
+  `paren-message-no-match'
+  `paren-message-show-linenumber'
+  `paren-message-truncate-lines'
+  `paren-ding-unmatched'
+  `paren-delay'
+  `paren-dont-touch-blink'
+  `paren-match-face'
+  `paren-mismatch-face'
+  `paren-no-match-face'
+  `paren-bind-modified-sexp-functions'
 
-(autoload 'worklog-task-done "worklog" "\
-Append a \"done\" entry to the worklog.
+The following options are settable via toggling functions (look at the
+documentation of these options for the names of these functions):
+  `paren-match-quoted-paren'
+  `paren-match-paired-delimiter'
+  `paren-open-paren-context-backward'
 
 \(fn)" t nil)
 
-(autoload 'worklog-summarize-tasks "worklog" "\
-Display a summary of the worklog in two sections.
-The first section is a reverse-chronological list of tasks and their durations,
-and the second is an unsorted compendium of all tasks and total durations.
-Durations are measured in hours.  If invoked non-interactively (i.e., \"emacs
---batch\"), the display buffer is sent to `message'.
+(autoload 'paren-deactivate "mic-paren" "\
+Deactivate mic-paren parenthesis highlighting.
 
 \(fn)" t nil)
 
-;;;***
-\f
-;;;### (autoloads (writegood-mode) "writegood-mode" "writegood-mode.el"
-;;;;;;  (20860 17206 775129 367000))
-;;; Generated autoloads from writegood-mode.el
-
-(autoload 'writegood-mode "writegood-mode" "\
-Colorize issues with the writing in the buffer.
-
-\(fn &optional ARG)" t nil)
+(autoload 'paren-toggle-matching-paired-delimiter "mic-paren" "\
+Toggle matching paired delimiter.
+Force on with positive ARG.  Use this in mode hooks to activate or
+deactivate paired delimiter matching.  If optional second argument
+NO-MESSAGE is non-nil then don't display a message about the
+current activation state of the paired-delimiter-matching feature.
 
-;;;***
-\f
-;;;### (autoloads (yaml-mode yaml) "yaml-mode" "yaml-mode.el" (20859
-;;;;;;  57200 0 0))
-;;; Generated autoloads from yaml-mode.el
+\(fn ARG &optional NO-MESSAGE)" t nil)
 
-(let ((loads (get 'yaml 'custom-loads))) (if (member '"yaml-mode" loads) nil (put 'yaml 'custom-loads (cons '"yaml-mode" loads))))
+(autoload 'paren-toggle-matching-quoted-paren "mic-paren" "\
+Toggle matching quoted parens.
+Force on with positive ARG.  Use this in mode hooks to activate or
+deactivate quoted paren matching.  If optional second argument
+NO-MESSAGE is non-nil then don't display a message about the
+current activation state of the quoted-paren-matching feature.
 
-(autoload 'yaml-mode "yaml-mode" "\
-Simple mode to edit YAML.
+\(fn ARG &optional NO-MESSAGE)" t nil)
 
-\\{yaml-mode-map}
+(autoload 'paren-toggle-open-paren-context "mic-paren" "\
+Toggle whether or not to determine context of the matching open-paren.
+Force backward context with positive ARG.  Use this in mode-hooks.
+See `paren-open-paren-context-backward'.
 
-\(fn)" t nil)
+\(fn ARG)" t nil)
 
-(add-to-list 'auto-mode-alist '("\\.ya?ml$" . yaml-mode))
+(autoload 'paren-forward-sexp "mic-paren" "\
+Act like `forward-sexp' but also handle quoted parens.
+See `paren-match-quoted-paren'.
 
-;;;***
-\f
-;;;### (autoloads nil nil ("beamer.el" "bind-key.el" "buildd-gnus.el"
-;;;;;;  "crypt++.el" "dash.el" "filladapt.el" "flymake-easy.el" "ldap-mode.el"
-;;;;;;  "mingus-stays-home.el" "mingus.el" "moinmoin-mode.el" "nnir.el"
-;;;;;;  "nntodo.el" "puppet-ext.el" "randomsig.el" "region-bindings-mode.el"
-;;;;;;  "s.el" "smartscan.el" "typing.el" "use-package.el" "volatile-highlights.el"
-;;;;;;  "yafolding.el") (21387 41519 637747 783000))
+\(fn &optional ARG)" t nil)
 
-;;;***
-\f
-;;;### (autoloads (bbdb-utilities-pgp) "bbdb-pgp" "bbdb-pgp.el" (20858
-;;;;;;  49922 393890 791000))
-;;; Generated autoloads from bbdb-pgp.el
+(autoload 'paren-backward-sexp "mic-paren" "\
+Act like `backward-sexp' but also match quoted parens.
+See `paren-match-quoted-paren'.
 
-(let ((loads (get 'bbdb-utilities-pgp 'custom-loads))) (if (member '"bbdb-pgp" loads) nil (put 'bbdb-utilities-pgp 'custom-loads (cons '"bbdb-pgp" loads))))
+\(fn &optional ARG)" t nil)
 
 ;;;***
index 28d8587..427945f 100644 (file)
@@ -3,11 +3,13 @@
 ;; Copyright (C) 2012 John Wiegley
 
 ;; Author: John Wiegley <jwiegley@gmail.com>
+;; Maintainer: John Wiegley <jwiegley@gmail.com>
 ;; Created: 17 Jun 2012
-;; Version: 1.0
+;; Modified: 6 Jul 2016
+;; Version: 2.2
 ;; Package-Requires: ((bind-key "1.0") (diminish "0.44"))
 ;; Keywords: dotemacs startup speed config package
-;; X-URL: https://github.com/jwiegley/use-package
+;; URL: https://github.com/jwiegley/use-package
 
 ;; This program is free software; you can redistribute it and/or
 ;; modify it under the terms of the GNU General Public License as
@@ -23,7 +25,7 @@
 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 ;; Boston, MA 02111-1307, USA.
-\f
+
 ;;; Commentary:
 
 ;; The `use-package' declaration macro allows you to isolate package
 ;; functionality!
 ;;
 ;; Please see README.md from the same repository for documentation.
-\f
+
 ;;; Code:
 
 (require 'bind-key)
 (require 'bytecomp)
 (require 'diminish nil t)
+(require 'bytecomp)
+(eval-when-compile (require 'cl))
+(eval-when-compile (require 'regexp-opt))
 
-(declare-function package-installed-p 'package)
+(declare-function package-installed-p "package")
 
 (defgroup use-package nil
   "A use-package declaration for simplifying your `.emacs'."
   "Whether to report about loading and configuration details.
 
 If you customize this, then you should require the `use-package'
-feature in files that use one of the macros `use-package' or
-`use-package-with-elapsed-timer', even if these files only
+feature in files that use `use-package', even if these files only
 contain compiled expansions of the macros.  If you don't do so,
 then the expanded macros do their job silently."
+  :type '(choice (const :tag "Quiet" nil) (const :tag "Verbose" t)
+                 (const :tag "Debug" debug))
+  :group 'use-package)
+
+(defcustom use-package-debug nil
+  "Whether to display use-package expansions in a *use-package* buffer."
+  :type 'boolean
+  :group 'use-package)
+
+(defcustom use-package-check-before-init nil
+  "If non-nil, check that package exists before executing its `:init' block.
+The check is performed by looking for the module using `locate-library'."
+  :type 'boolean
+  :group 'use-package)
+
+(defcustom use-package-always-defer nil
+  "If non-nil, assume `:defer t` unless `:demand t` is given."
   :type 'boolean
   :group 'use-package)
 
-(defcustom use-package-minimum-reported-time 0.01
+(defcustom use-package-always-ensure nil
+  "Treat every package as though it had specified `:ensure SEXP`."
+  :type 'sexp
+  :group 'use-package)
+
+(defcustom use-package-always-pin nil
+  "Treat every package as though it had specified `:pin SYM."
+  :type 'symbol
+  :group 'use-package)
+
+(defcustom use-package-minimum-reported-time 0.1
   "Minimal load time that will be reported.
 
 Note that `use-package-verbose' has to be set to t, for anything
 to be reported at all.
 
 If you customize this, then you should require the `use-package'
-feature in files that use one of the macros `use-package' or
-`use-package-with-elapsed-timer', even if these files only
+feature in files that use `use-package', even if these files only
 contain compiled expansions of the macros.  If you don't do so,
 then the expanded macros do their job silently."
   :type 'number
   :group 'use-package)
 
-(defcustom use-package-idle-interval 3
-  "Time to wait when using :idle in a `use-package' specification."
-  :type 'number
+(defcustom use-package-inject-hooks nil
+  "If non-nil, add hooks to the `:init' and `:config' sections.
+In particular, for a given package `foo', the following hooks
+become available:
+
+  `use-package--foo--pre-init-hook'
+  `use-package--foo--post-init-hook'
+  `use-package--foo--pre-config-hook'
+  `use-package--foo--post-config-hook'
+
+This way, you can add to these hooks before evalaution of a
+`use-package` declaration, and exercise some control over what
+happens.
+
+Note that if either `pre-init' hooks returns a nil value, that
+block's user-supplied configuration is not evaluated, so be
+certain to return `t' if you only wish to add behavior to what
+the user specified."
+  :type 'boolean
+  :group 'use-package)
+
+(defcustom use-package-keywords
+  '(:disabled
+    :pin
+    :ensure
+    :if
+    :when
+    :unless
+    :requires
+    :load-path
+    :preface
+    :no-require
+    :bind
+    :bind*
+    :bind-keymap
+    :bind-keymap*
+    :interpreter
+    :mode
+    :commands
+    :defines
+    :functions
+    :defer
+    :init
+    :after
+    :demand
+    :config
+    :diminish
+    :delight)
+  "Establish which keywords are valid, and the order they are processed in.
+
+Note that `:disabled' is special, in that it causes nothing at all to happen,
+even if the rest of the use-package declaration is incorrect."
+  :type '(repeat symbol)
+  :group 'use-package)
+
+(defcustom use-package-expand-minimally nil
+  "If non-nil, make the expanded code as minimal as possible.
+This disables:
+  - Printing to the *Messages* buffer of slowly-evaluating forms
+  - Capture of load errors (normally redisplayed as warnings)
+  - Conditional loading of packages (load failures become errors)
+The only advantage is that, if you know your configuration works,
+then your byte-compiled init file is as minimal as possible."
+  :type 'boolean
+  :group 'use-package)
+
+(defcustom use-package-enable-imenu-support nil
+  "If non-nil, adjust `lisp-imenu-generic-expression' to include
+support for finding `use-package' and `require' forms.
+
+Must be set before loading use-package."
+  :type 'boolean
   :group 'use-package)
 
-(defmacro use-package-with-elapsed-timer (text &rest body)
+(when use-package-enable-imenu-support
+  ;; Not defined in Emacs 24
+  (defvar lisp-mode-symbol-regexp
+    "\\(?:\\sw\\|\\s_\\|\\\\.\\)+")
+  (add-to-list
+   'lisp-imenu-generic-expression
+   (list "Package"
+         (purecopy (concat "^\\s-*("
+                           (eval-when-compile
+                             (regexp-opt
+                              '("use-package" "require")
+                              t))
+                           "\\s-+\\(" lisp-mode-symbol-regexp "\\)"))
+         2)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Utility functions
+;;
+
+(defun use-package-as-symbol (string-or-symbol)
+  "If STRING-OR-SYMBOL is already a symbol, return it.  Otherwise
+convert it to a symbol and return that."
+  (if (symbolp string-or-symbol) string-or-symbol
+    (intern string-or-symbol)))
+
+(defun use-package-as-string (string-or-symbol)
+  "If STRING-OR-SYMBOL is already a string, return it.  Otherwise
+convert it to a string and return that."
+  (if (stringp string-or-symbol) string-or-symbol
+    (symbol-name string-or-symbol)))
+
+(defun use-package-load-name (name &optional noerror)
+  "Return a form which will load or require NAME depending on
+whether it's a string or symbol."
+  (if (stringp name)
+      `(load ,name ',noerror)
+    `(require ',name nil ',noerror)))
+
+(defun use-package-expand (name label form)
+  "FORM is a list of forms, so `((foo))' if only `foo' is being called."
   (declare (indent 1))
-  (let ((nowvar (make-symbol "now")))
-    `(if (bound-and-true-p use-package-verbose)
-         (let ((,nowvar (current-time)))
-           (message "%s..." ,text)
-           (prog1 (progn ,@body)
-             (let ((elapsed
-                    (float-time (time-subtract (current-time) ,nowvar))))
-               (if (> elapsed
-                      (or (bound-and-true-p use-package-minimum-reported-time)
-                          "0.01"))
-                   (message "%s...done (%.3fs)" ,text elapsed)
-                 (message "%s...done" ,text)))))
-       ,@body)))
-
-(put 'use-package-with-elapsed-timer 'lisp-indent-function 1)
-
-(defvar use-package-idle-timer nil)
-(defvar use-package-idle-forms (make-hash-table))
-
-(defun use-package-start-idle-timer ()
-  "Ensure that the idle timer is running."
-  (unless use-package-idle-timer
-    (setq use-package-idle-timer
-          (run-with-idle-timer
-           use-package-idle-interval t
-           'use-package-idle-eval))))
-
-(defun use-package-init-on-idle (form priority)
-  "Add a new form to the idle queue."
-  (use-package-start-idle-timer)
-  (puthash priority
-           (append (gethash priority use-package-idle-forms)
-                   (list form))
-           use-package-idle-forms))
-
-(defun use-package-idle-priorities ()
-  "Get a list of all priorities in the idle queue.
-The list is sorted in the order forms should be run."
-  (let ((priorities nil))
-    (maphash (lambda (priority forms)
-               (setq priorities (cons priority priorities)))
-             use-package-idle-forms)
-    (sort priorities '<)))
-
-(defun use-package-idle-pop ()
-  "Pop the top-priority task from the idle queue.
-Return nil when the queue is empty."
-  (let* ((priority        (car (use-package-idle-priorities)))
-         (forms           (gethash priority use-package-idle-forms))
-         (first-form      (car forms))
-         (forms-remaining (cdr forms)))
-    (if forms-remaining
-        (puthash priority forms-remaining use-package-idle-forms)
-      (remhash priority use-package-idle-forms))
-    first-form))
-
-(defun use-package-idle-eval()
-  "Start to eval idle-commands from the idle queue."
-  (let ((next (use-package-idle-pop)))
-    (if next
-        (progn
-          (when use-package-verbose
-            (message "use-package idle:%s" next))
-
-          (condition-case e
-              (funcall next)
+  (when form
+    (if use-package-expand-minimally
+        form
+      (let ((err (make-symbol "err")))
+        (list
+         `(condition-case-unless-debug ,err
+              ,(macroexp-progn form)
             (error
-             (message
-              "Failure on use-package idle. Form: %s, Error: %s"
-              next e)))
-          ;; recurse after a bit
-          (when (sit-for use-package-idle-interval)
-            (use-package-idle-eval)))
-      ;; finished (so far!)
-      (cancel-timer use-package-idle-timer)
-      (setq use-package-idle-timer nil))))
+             (ignore
+              (display-warning 'use-package
+                               (format "%s %s: %s"
+                                       ,name ,label (error-message-string ,err))
+                               :error)))))))))
+
+(put 'use-package-expand 'lisp-indent-function 'defun)
+
+(defun use-package-hook-injector (name-string keyword body)
+  "Wrap pre/post hook injections around a given keyword form.
+ARGS is a list of forms, so `((foo))' if only `foo' is being called."
+  (if (not use-package-inject-hooks)
+      (use-package-expand name-string (format "%s" keyword) body)
+    (let ((keyword-name (substring (format "%s" keyword) 1)))
+      (when body
+        `((when ,(macroexp-progn
+                  (use-package-expand name-string (format "pre-%s hook" keyword)
+                    `((run-hook-with-args-until-failure
+                       ',(intern (concat "use-package--" name-string
+                                         "--pre-" keyword-name "-hook"))))))
+            ,(macroexp-progn
+              (use-package-expand name-string (format "%s" keyword) body))
+            ,(macroexp-progn
+              (use-package-expand name-string (format "post-%s hook" keyword)
+                `((run-hooks
+                   ',(intern (concat "use-package--" name-string
+                                     "--post-" keyword-name "-hook"))))))))))))
+
+(defun use-package--with-elapsed-timer (text body)
+  "BODY is a list of forms, so `((foo))' if only `foo' is being called."
+  (declare (indent 1))
+  (if use-package-expand-minimally
+      body
+    (let ((nowvar (make-symbol "now")))
+      (if (bound-and-true-p use-package-verbose)
+          `((let ((,nowvar (current-time)))
+              (message "%s..." ,text)
+              (prog1
+                  ,(macroexp-progn body)
+                (let ((elapsed
+                       (float-time (time-subtract (current-time) ,nowvar))))
+                  (if (> elapsed ,use-package-minimum-reported-time)
+                      (message "%s...done (%.3fs)" ,text elapsed)
+                    (message "%s...done" ,text))))))
+        body))))
+
+(put 'use-package--with-elapsed-timer 'lisp-indent-function 1)
+
+(defsubst use-package-error (msg)
+  "Report MSG as an error, so the user knows it came from this package."
+  (error "use-package: %s" msg))
+
+(defsubst use-package-plist-maybe-put (plist property value)
+  "Add a VALUE for PROPERTY to PLIST, if it does not already exist."
+  (if (plist-member plist property)
+      plist
+    (plist-put plist property value)))
+
+(defsubst use-package-plist-cons (plist property value)
+  "Cons VALUE onto the head of the list at PROPERTY in PLIST."
+  (plist-put plist property (cons value (plist-get plist property))))
+
+(defsubst use-package-plist-append (plist property value)
+  "Append VALUE onto the front of the list at PROPERTY in PLIST."
+  (plist-put plist property (append value (plist-get plist property))))
+
+(defun use-package-plist-delete (plist property)
+  "Delete PROPERTY from PLIST.
+This is in contrast to merely setting it to 0."
+  (let (p)
+    (while plist
+      (if (not (eq property (car plist)))
+          (setq p (plist-put p (car plist) (nth 1 plist))))
+      (setq plist (cddr plist)))
+    p))
+
+(defun use-package-split-list (pred xs)
+  (let ((ys (list nil)) (zs (list nil)) flip)
+    (dolist (x xs)
+      (if flip
+          (nconc zs (list x))
+        (if (funcall pred x)
+            (progn
+              (setq flip t)
+              (nconc zs (list x)))
+          (nconc ys (list x)))))
+    (cons (cdr ys) (cdr zs))))
+
+(defun use-package-keyword-index (keyword)
+  (loop named outer
+        with index = 0
+        for k in use-package-keywords do
+        (if (eq k keyword)
+            (return-from outer index))
+        (incf index)))
+
+(defun use-package-sort-keywords (plist)
+  (let (plist-grouped)
+    (while plist
+      (push (cons (car plist) (cadr plist))
+            plist-grouped)
+      (setq plist (cddr plist)))
+    (let (result)
+      (dolist (x
+               (nreverse
+                (sort plist-grouped
+                      #'(lambda (l r) (< (use-package-keyword-index (car l))
+                                    (use-package-keyword-index (car r)))))))
+        (setq result (cons (car x) (cons (cdr x) result))))
+      result)))
+
+(defsubst use-package-concat (&rest elems)
+  "Delete all empty lists from ELEMS (nil or (list nil)), and append them."
+  (apply #'nconc (delete nil (delete (list nil) elems))))
 
-(defun use-package-pin-package (package archive)
-  "Pin PACKAGE to ARCHIVE."
-  (unless (boundp 'package-pinned-packages)
-    (setq package-pinned-packages ()))
-  (let ((archive-symbol (if (symbolp archive) archive (intern archive)))
-        (archive-name   (if (stringp archive) archive (symbol-name archive))))
-    (if (use-package--archive-exists-p archive-symbol)
-        (add-to-list 'package-pinned-packages (cons package archive-name))
-      (error (message  "Archive '%s' requested for package '%s' is not available." archive-name package)))
-    (package-initialize t)))
+(defconst use-package-font-lock-keywords
+  '(("(\\(use-package\\)\\_>[ \t']*\\(\\(?:\\sw\\|\\s_\\)+\\)?"
+     (1 font-lock-keyword-face)
+     (2 font-lock-constant-face nil t))))
+
+(font-lock-add-keywords 'emacs-lisp-mode use-package-font-lock-keywords)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Keyword processing
+;;
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Normalization functions
+;;
+
+(defun use-package-normalize-plist (name input)
+  "Given a pseudo-plist, normalize it to a regular plist."
+  (unless (null input)
+    (let* ((keyword (car input))
+           (xs (use-package-split-list #'keywordp (cdr input)))
+           (args (car xs))
+           (tail (cdr xs))
+           (normalizer (intern (concat "use-package-normalize/"
+                                       (symbol-name keyword))))
+           (arg
+            (cond
+             ((eq keyword :disabled)
+              (use-package-normalize-plist name tail))
+             ((functionp normalizer)
+              (funcall normalizer name keyword args))
+             ((= (length args) 1)
+              (car args))
+             (t
+              args))))
+      (if (memq keyword use-package-keywords)
+          (cons keyword
+                (cons arg (use-package-normalize-plist name tail)))
+        (use-package-error (format "Unrecognized keyword: %s" keyword))))))
+
+(defun use-package-process-keywords (name plist &optional state)
+  "Process the next keyword in the free-form property list PLIST.
+The values in the PLIST have each been normalized by the function
+use-package-normalize/KEYWORD (minus the colon).
+
+STATE is a property list that the function may modify and/or
+query.  This is useful if a package defines multiple keywords and
+wishes them to have some kind of stateful interaction.
+
+Unless the KEYWORD being processed intends to ignore remaining
+keywords, it must call this function recursively, passing in the
+plist with its keyword and argument removed, and passing in the
+next value for the STATE."
+  (declare (indent 1))
+  (unless (null plist)
+    (let* ((keyword (car plist))
+           (arg (cadr plist))
+           (rest (cddr plist)))
+      (unless (keywordp keyword)
+        (use-package-error (format "%s is not a keyword" keyword)))
+      (let* ((handler (concat "use-package-handler/" (symbol-name keyword)))
+             (handler-sym (intern handler)))
+        (if (functionp handler-sym)
+            (funcall handler-sym name keyword arg rest state)
+          (use-package-error
+           (format "Keyword handler not defined: %s" handler)))))))
+
+(put 'use-package-process-keywords 'lisp-indent-function 'defun)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :pin
+;;
+
+(defun use-package-only-one (label args f)
+  "Call F on the first member of ARGS if it has exactly one element."
+  (declare (indent 1))
+  (cond
+   ((and (listp args) (listp (cdr args))
+         (= (length args) 1))
+    (funcall f label (car args)))
+   (t
+    (use-package-error
+     (concat label " wants exactly one argument")))))
+
+(put 'use-package-only-one 'lisp-indent-function 'defun)
+
+(defun use-package-normalize/:pin (name keyword args)
+  (use-package-only-one (symbol-name keyword) args
+    (lambda (label arg)
+      (cond
+       ((stringp arg) arg)
+       ((symbolp arg) (symbol-name arg))
+       (t
+        (use-package-error
+         ":pin wants an archive name (a string)"))))))
+
+(eval-when-compile
+  (defvar package-pinned-packages)
+  (defvar package-archives))
 
 (defun use-package--archive-exists-p (archive)
   "Check if a given ARCHIVE is enabled.
 
-ARCHIVE can be a string or a symbol or 'manual to indicate a manually updated package."
+ARCHIVE can be a string or a symbol or 'manual to indicate a
+manually updated package."
   (if (member archive '(manual "manual"))
       't
     (let ((valid nil))
@@ -179,393 +456,739 @@ ARCHIVE can be a string or a symbol or 'manual to indicate a manually updated pa
           (setq valid 't)))
       valid)))
 
-(defun use-package-ensure-elpa (package)
-  (when (not (package-installed-p package))
-    (package-install package)))
+(defun use-package-pin-package (package archive)
+  "Pin PACKAGE to ARCHIVE."
+  (unless (boundp 'package-pinned-packages)
+    (setq package-pinned-packages ()))
+  (let ((archive-symbol (if (symbolp archive) archive (intern archive)))
+        (archive-name   (if (stringp archive) archive (symbol-name archive))))
+    (if (use-package--archive-exists-p archive-symbol)
+        (add-to-list 'package-pinned-packages (cons package archive-name))
+      (error "Archive '%s' requested for package '%s' is not available."
+             archive-name package))
+    (unless (bound-and-true-p package--initialized)
+      (package-initialize t))))
+
+(defun use-package-handler/:pin (name keyword archive-name rest state)
+  (let ((body (use-package-process-keywords name rest state))
+        (pin-form (if archive-name
+                      `(use-package-pin-package ',(use-package-as-symbol name)
+                                                ,archive-name))))
+    ;; Pinning should occur just before ensuring
+    ;; See `use-package-handler/:ensure'.
+    (if (bound-and-true-p byte-compile-current-file)
+        (eval pin-form)              ; Eval when byte-compiling,
+      (push pin-form body))          ; or else wait until runtime.
+    body))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :ensure
+;;
+(defvar package-archive-contents)
+(defun use-package-normalize/:ensure (name keyword args)
+  (if (null args)
+      t
+    (use-package-only-one (symbol-name keyword) args
+      (lambda (label arg)
+        (if (symbolp arg)
+            arg
+          (use-package-error
+           (concat ":ensure wants an optional package name "
+                   "(an unquoted symbol name)")))))))
+
+(defun use-package-ensure-elpa (package &optional no-refresh)
+  (if (package-installed-p package)
+      t
+    (if (and (not no-refresh)
+             (assoc package (bound-and-true-p package-pinned-packages)))
+        (package-read-all-archive-contents))
+    (if (or (assoc package package-archive-contents) no-refresh)
+        (package-install package)
+      (progn
+        (package-refresh-contents)
+        (use-package-ensure-elpa package t)))))
+
+(defun use-package-handler/:ensure (name keyword ensure rest state)
+  (let* ((body (use-package-process-keywords name rest state))
+         (package-name (or (and (eq ensure t) (use-package-as-symbol name)) ensure))
+         (ensure-form (if package-name
+                          `(progn (require 'package)
+                                  (use-package-ensure-elpa ',package-name)))))
+    ;; We want to avoid installing packages when the `use-package'
+    ;; macro is being macro-expanded by elisp completion (see
+    ;; `lisp--local-variables'), but still do install packages when
+    ;; byte-compiling to avoid requiring `package' at runtime.
+    (if (bound-and-true-p byte-compile-current-file)
+        (eval ensure-form)              ; Eval when byte-compiling,
+      (push ensure-form body))          ; or else wait until runtime.
+    body))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :if, :when and :unless
+;;
 
-(defvar use-package-keywords
-  '(
-    :bind
-    :bind*
-    :commands
-    :config
-    :defer
-    :defines
-    :demand
-    :diminish
-    :disabled
-    :ensure
-    :idle
-    :idle-priority
-    :if
-    :init
-    :interpreter
-    :load-path
-    :mode
-    :pin
-    :pre-init
-    :pre-load
-    :requires
-    :bind-keymap
-    :bind-keymap*
-    )
-  "Keywords recognized by `use-package'.")
-
-(defun use-package-mplist-get (plist prop)
-  "Get the values associated to PROP in PLIST, a modified plist.
-
-A modified plist is one where keys are keywords and values are
-all non-keywords elements that follow it.
-
-As a special case : if the first occurrence of the keyword PROP
-is followed by another keyword or is the last element in the
-list, the function returns t.
-
-Currently this function infloops when the list is circular."
-  (let ((tail plist)
-        found
-        result)
-    (while (and
-            (consp tail)
-            (not
-             (eq prop (car tail))))
-      (pop tail))
-    (when (eq prop (pop tail))
-      (setq found t))
-    (while (and (consp tail)
-                (not (keywordp (car tail))))
-      (push (pop tail) result))
-    (or (nreverse result) found)))
-
-(defun use-package-plist-get (plist prop &optional eval-backquote no-progn)
-  "Compatibility layer between classical and modified plists.
-
-If `use-package-mplist-get' returns exactly one value, that is
-returned ; otherwise the list is returned wrapped in a `progn'
-unless NO-PROGN is non-nil.
-
-When EVAL-BACKQUOTE is non-nil, the value is first evaluated as
-if it were backquoted."
-  (let ((values (use-package-mplist-get plist prop)))
-    (when eval-backquote
-      (setq values (eval (list 'backquote values))))
-    (when values
-      (cond ((not (listp values))
-             values)
-            ((eq 1 (length values))
-             (car values))
-            (t (if no-progn
-                   values
-                 (cons 'progn values)))))))
-
-(defun use-package-mplist-keys (plist)
-  "Get the keys in PLIST, a modified plist.
-
-A modified plist is one where properties are keywords and values
-are all non-keywords elements that follow it."
-  (let ((result))
-    (mapc (lambda (elt)
-            (when (keywordp elt)
-              (push elt result)))
-          plist)
-    (nreverse result)))
-
-(defun use-package-validate-keywords (args)
-  "Error if any keyword given in ARGS is not recognized.
-Return the list of recognized keywords."
-  (mapc
-   (function
-    (lambda (keyword)
-      (unless (memq keyword use-package-keywords)
-        (error "Unrecognized keyword: %s" keyword))))
-   (use-package-mplist-keys args)))
+(defsubst use-package-normalize-value (label arg)
+  "Normalize a value."
+  (cond ((symbolp arg)
+         `(symbol-value ',arg))
+        ((functionp arg)
+         `(funcall #',arg))
+        (t arg)))
 
-(defmacro use-package (name &rest args)
-  "Use a package with configuration options.
+(defun use-package-normalize-test (name keyword args)
+  (use-package-only-one (symbol-name keyword) args
+    #'use-package-normalize-value))
 
-For full documentation. please see commentary.
+(defalias 'use-package-normalize/:if 'use-package-normalize-test)
+(defalias 'use-package-normalize/:when 'use-package-normalize-test)
+(defalias 'use-package-normalize/:unless 'use-package-normalize-test)
 
-  (use-package package-name
-     :keyword option)
-
-:init Code to run when `use-package' form evals.
-:bind Perform key bindings, and define autoload for bound
-      commands.
-:bind* Perform key bindings, and define autoload for bound
-      commands, overriding all minor mode bindings.
-:bind-keymap Bind key prefix to an auto-loaded keymap that
-      is defined in the package.  Like bind but for keymaps
-      instead of commands.
-:bind-keymap* like bind-keymap, but overrides all minor mode bindings
-:commands Define autoloads for given commands.
-:pre-load Code to run when `use-package' form evals and before
-       anything else. Unlike :init this form runs before the
-       package is required or autoloads added.
-:mode Form to be added to `auto-mode-alist'.
-:interpreter Form to be added to `interpreter-mode-alist'.
-:defer Defer loading of package -- automatic
-       if :commands, :bind, :bind*, :mode or :interpreter are used.
-:demand Prevent deferred loading in all cases.
-:config Runs if and when package loads.
-:if Conditional loading.
-:disabled Ignore everything.
-:defines Define vars to silence byte-compiler.
-:load-path Add to `load-path' before loading.
-:diminish Support for diminish package (if it's installed).
-:idle adds a form to run on an idle timer
-:idle-priority schedules the :idle form to run with the given
-       priority (lower priorities run first). Default priority
-       is 5; forms with the same priority are run in the order in
-       which they are evaluated.
-:ensure loads package using package.el if necessary.
-:pin pin package to archive."
-  (use-package-validate-keywords args) ; error if any bad keyword, ignore result
-  (let* ((commands (use-package-plist-get args :commands t t))
-         (pre-init-body (use-package-plist-get args :pre-init))
-         (pre-load-body (use-package-plist-get args :pre-load))
-         (init-body (use-package-plist-get args :init))
-         (config-body (use-package-plist-get args :config))
-         (diminish-var (use-package-plist-get args :diminish t))
-         (defines (use-package-plist-get args :defines t t))
-         (idle-body (use-package-plist-get args :idle))
-         (idle-priority (use-package-plist-get args :idle-priority))
-         (keybindings-alist (use-package-plist-get args :bind t t))
-         (overriding-keybindings-alist (use-package-plist-get args :bind* t t))
-         (keymap-alist (use-package-plist-get args :bind-keymap t t))
-         (overriding-keymap-alist (use-package-plist-get args :bind-keymap* t t))
-         (mode (use-package-plist-get args :mode t t))
-         (mode-alist
-          (if (stringp mode) (cons mode name) mode))
-         (interpreter (use-package-plist-get args :interpreter t t))
-         (interpreter-alist
-          (if (stringp interpreter) (cons interpreter name) interpreter))
-         (predicate (use-package-plist-get args :if))
-         (pkg-load-path (use-package-plist-get args :load-path t t))
-         (archive-name (use-package-plist-get args :pin))
-         (defines-eval (if (null defines)
-                           nil
-                         (if (listp defines)
-                             (mapcar (lambda (var) `(defvar ,var)) defines)
-                           `((defvar ,defines)))))
-         (requires (use-package-plist-get args :requires t))
-         (requires-test (if (null requires)
-                            t
-                          (if (listp requires)
-                              `(not (member nil (mapcar #'featurep
-                                                        (quote ,requires))))
-                            `(featurep (quote ,requires)))))
-         (name-string (if (stringp name) name (symbol-name name)))
-         (name-symbol (if (stringp name) (intern name) name)))
-
-    ;; force this immediately -- one off cost
-    (unless (use-package-plist-get args :disabled)
-
-      (when archive-name
-        (use-package-pin-package name archive-name))
-
-      (let* ((ensure (use-package-plist-get args :ensure))
-             (package-name
-              (or (and (eq ensure t)
-                       name)
-                  ensure)))
-
-        (when package-name
-          (require 'package)
-          (use-package-ensure-elpa package-name)))
-
-
-      (if diminish-var
-          (setq config-body
-                `(progn
-                   ,config-body
-                   (ignore-errors
-                     ,@(cond
-                        ((stringp diminish-var)
-                         `((diminish (quote ,(intern (concat name-string "-mode")))
-                                     ,diminish-var)))
-                        ((symbolp diminish-var)
-                         `((diminish (quote ,diminish-var))))
-                        ((and (consp diminish-var) (stringp (cdr diminish-var)))
-                         `((diminish (quote ,(car diminish-var)) ,(cdr diminish-var))))
-                        (t      ; list of symbols or (symbol . "string") pairs
-                         (mapcar (lambda (var)
-                                   (if (listp var)
-                                       `(diminish (quote ,(car var)) ,(cdr var))
-                                     `(diminish (quote ,var))))
-                                 diminish-var)))))))
-
-      (if (and commands (symbolp commands))
-          (setq commands (list commands)))
-
-
-      (when idle-body
-        (when (null idle-priority)
-          (setq idle-priority 5))
-        (setq init-body
-              `(progn
-                 (require 'use-package)
-                 (use-package-init-on-idle (lambda () ,idle-body) ,idle-priority)
-                 ,init-body)))
-
-      (let ((init-for-commands-or-keymaps
-             (lambda (func sym-or-list &optional keymap)
-               (let ((cons-list (if (and (consp sym-or-list)
-                                         (stringp (car sym-or-list)))
-                                    (list sym-or-list)
-                                  sym-or-list)))
-                 (if cons-list
-                     (setq init-body
-                           `(progn
-                              ,init-body
-                              ,@(mapcar (lambda (elem)
-                                          (when (not keymap)
-                                              (push (cdr elem) commands))
-                                          (funcall func elem))
-                                        cons-list))))))))
-
-        (funcall init-for-commands-or-keymaps
-                 (lambda (binding)
-                   `(bind-key ,(car binding)
-                              (lambda () (interactive)
-                                (use-package-autoload-keymap
-                                 (quote ,(cdr binding))
-                                 ,(if (stringp name) name `',name)
-                                 nil))))
-                 keymap-alist
-                 t)
-
-        (funcall init-for-commands-or-keymaps
-                 (lambda (binding)
-                   `(bind-key ,(car binding)
-                              (lambda () (interactive)
-                                (use-package-autoload-keymap
-                                 (quote ,(cdr binding))
-                                 ,(if (stringp name) name `',name)
-                                 t))))
-                 overriding-keymap-alist
-                 t)
-
-        (funcall init-for-commands-or-keymaps
-                 (lambda (binding)
-                   `(bind-key ,(car binding)
-                              (quote ,(cdr binding))))
-                 keybindings-alist)
-
-        (funcall init-for-commands-or-keymaps
-                 (lambda (binding)
-                   `(bind-key* ,(car binding)
-                               (quote ,(cdr binding))))
-                 overriding-keybindings-alist)
-
-        (funcall init-for-commands-or-keymaps
-                 (lambda (mode)
-                   `(add-to-list 'auto-mode-alist
-                                 (quote ,mode)))
-                 mode-alist)
-
-        (funcall init-for-commands-or-keymaps
-                 (lambda (interpreter)
-                   `(add-to-list 'interpreter-mode-alist
-                                 (quote ,interpreter)))
-                 interpreter-alist))
-
-      `(progn
-         ,pre-load-body
-         ,@(mapcar
-            (lambda (path)
-              `(add-to-list 'load-path
-                            ,(if (file-name-absolute-p path)
-                                 path
-                               (expand-file-name path user-emacs-directory))))
-            (cond ((stringp pkg-load-path)
-                   (list pkg-load-path))
-                  ((functionp pkg-load-path)
-                   (funcall pkg-load-path))
-                  (t
-                   pkg-load-path)))
-
-         (eval-when-compile
-           (when (bound-and-true-p byte-compile-current-file)
-             ,@defines-eval
-             (condition-case err
-                 ,(if (stringp name)
-                      `(load ,name t)
-                    `(require ',name nil t))
-               (error (message "Error requiring %s: %s" ',name err) nil))))
-
-         ,(if (and (or commands (use-package-plist-get args :defer)
-                       (use-package-plist-get args :bind-keymap)
-                       (use-package-plist-get args :bind-keymap*))
-                   (not (use-package-plist-get args :demand)))
-              (let (form)
-                (mapc (lambda (command)
-                   (push `(unless (fboundp (quote ,command))
-                            (autoload (function ,command)
-                              ,name-string nil t))
-                         form))
-                      commands)
-
-                `(when ,(or predicate t)
-                   ,pre-init-body
-                   ,@form
-                   ,init-body
-                   ,(unless (null config-body)
-                      `(eval-after-load ,(if (stringp name) name `',name)
-                         `(,(lambda ()
-                              (if ,requires-test
-                                  (use-package-with-elapsed-timer
-                                      ,(format "Configuring package %s" name-string)
-                                    ,config-body))))))
-                   t))
-            `(if (and ,(or predicate t)
-                      ,requires-test)
-                 (use-package-with-elapsed-timer
-                     ,(format "Loading package %s" name-string)
-                   (if (not ,(if (stringp name)
-                                 `(load ,name t)
-                               `(require ',name nil t)))
-                       (message "Could not load package %s" ,name-string)
-                     ,pre-init-body
-                     ,init-body
-                     ,config-body
-                     t))))))))
+(defun use-package-handler/:if (name keyword pred rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    `((when ,pred ,@body))))
+
+(defalias 'use-package-handler/:when 'use-package-handler/:if)
+
+(defun use-package-handler/:unless (name keyword pred rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    `((unless ,pred ,@body))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :requires
+;;
+
+(defun use-package-as-one (label args f)
+  "Call F on the first element of ARGS if it has one element, or all of ARGS."
+  (declare (indent 1))
+  (if (and (listp args) (listp (cdr args)))
+      (if (= (length args) 1)
+          (funcall f label (car args))
+        (funcall f label args))
+    (use-package-error
+     (concat label " wants a list"))))
+
+(put 'use-package-as-one 'lisp-indent-function 'defun)
+
+(defun use-package-normalize-symbols (label arg &optional recursed)
+  "Normalize a list of symbols."
+  (cond
+   ((symbolp arg)
+    (list arg))
+   ((and (not recursed) (listp arg) (listp (cdr arg)))
+    (mapcar #'(lambda (x) (car (use-package-normalize-symbols label x t))) arg))
+   (t
+    (use-package-error
+     (concat label " wants a symbol, or list of symbols")))))
+
+(defun use-package-normalize-symlist (name keyword args)
+  (use-package-as-one (symbol-name keyword) args
+    #'use-package-normalize-symbols))
+
+(defalias 'use-package-normalize/:requires 'use-package-normalize-symlist)
+
+(defun use-package-handler/:requires (name keyword requires rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (if (null requires)
+        body
+      `((when ,(if (listp requires)
+                   `(not (member nil (mapcar #'featurep ',requires)))
+                 `(featurep ',requires))
+          ,@body)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :load-path
+;;
+
+(defun use-package-normalize-paths (label arg &optional recursed)
+  "Normalize a list of filesystem paths."
+  (cond
+   ((and arg (or (symbolp arg) (functionp arg)))
+    (let ((value (use-package-normalize-value label arg)))
+      (use-package-normalize-paths label (eval value))))
+   ((stringp arg)
+    (let ((path (if (file-name-absolute-p arg)
+                    arg
+                  (expand-file-name arg user-emacs-directory))))
+      (list path)))
+   ((and (not recursed) (listp arg) (listp (cdr arg)))
+    (mapcar #'(lambda (x)
+                (car (use-package-normalize-paths label x t))) arg))
+   (t
+    (use-package-error
+     (concat label " wants a directory path, or list of paths")))))
+
+(defun use-package-normalize/:load-path (name keyword args)
+  (use-package-as-one (symbol-name keyword) args
+    #'use-package-normalize-paths))
+
+(defun use-package-handler/:load-path (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (use-package-concat
+     (mapcar #'(lambda (path)
+                 `(eval-and-compile (add-to-list 'load-path ,path))) arg)
+     body)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :no-require
+;;
+
+(defun use-package-normalize-predicate (name keyword args)
+  (if (null args)
+      t
+    (use-package-only-one (symbol-name keyword) args
+      #'use-package-normalize-value)))
+
+(defalias 'use-package-normalize/:no-require 'use-package-normalize-predicate)
+
+(defun use-package-handler/:no-require (name keyword arg rest state)
+  ;; This keyword has no functional meaning.
+  (use-package-process-keywords name rest state))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :preface
+;;
+
+(defun use-package-normalize-form (label args)
+  "Given a list of forms, return it wrapped in `progn'."
+  (unless (listp (car args))
+    (use-package-error (concat label " wants a sexp or list of sexps")))
+  (mapcar #'(lambda (form)
+              (if (and (consp form)
+                       (eq (car form) 'use-package))
+                  (macroexpand form)
+                form)) args))
+
+(defun use-package-normalize-forms (name keyword args)
+  (use-package-normalize-form (symbol-name keyword) args))
+
+(defalias 'use-package-normalize/:preface 'use-package-normalize-forms)
+
+(defun use-package-handler/:preface (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (use-package-concat
+     (unless (null arg)
+       `((eval-and-compile ,@arg)))
+     body)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :bind, :bind*
+;;
+
+(defsubst use-package-is-sympair (x &optional allow-vector)
+  "Return t if X has the type (STRING . SYMBOL)."
+  (and (consp x)
+       (or (stringp (car x))
+           (and allow-vector (vectorp (car x))))
+       (symbolp (cdr x))))
+
+(defsubst use-package-is-string-pair (x)
+  "Return t if X has the type (STRING . STRING)."
+  (and (consp x)
+       (stringp (car x))
+       (stringp (cdr x))))
+
+(defun use-package-normalize-pairs
+    (name label arg &optional recursed allow-vector allow-string-cdrs)
+  "Normalize a list of string/symbol pairs.
+If RECURSED is non-nil, recurse into sublists.
+If ALLOW-VECTOR is non-nil, then the key to bind may specify a
+vector of keys, as accepted by `define-key'.
+If ALLOW-STRING-CDRS is non-nil, then the command name to bind to
+may also be a string, as accepted by `define-key'."
+  (cond
+   ((or (stringp arg) (and allow-vector (vectorp arg)))
+    (list (cons arg (use-package-as-symbol name))))
+   ((use-package-is-sympair arg allow-vector)
+    (list arg))
+   ((and (not recursed) (listp arg) (listp (cdr arg)))
+    (mapcar #'(lambda (x)
+                (let ((ret (use-package-normalize-pairs
+                            name label x t allow-vector allow-string-cdrs)))
+                  (if (listp ret)
+                      (car ret)
+                    ret))) arg))
+   ((and allow-string-cdrs (use-package-is-string-pair arg))
+    (list arg))
+   (t arg)))
+
+(defun use-package-normalize-binder (name keyword args)
+  (use-package-as-one (symbol-name keyword) args
+    (lambda (label arg)
+      (use-package-normalize-pairs name label arg nil t t))))
+
+(defalias 'use-package-normalize/:bind 'use-package-normalize-binder)
+(defalias 'use-package-normalize/:bind* 'use-package-normalize-binder)
+
+(defun use-package-handler/:bind
+    (name keyword arg rest state &optional bind-macro)
+  (let ((commands (remq nil (mapcar #'(lambda (arg)
+                                        (if (listp arg)
+                                            (cdr arg)
+                                          nil)) arg))))
+    (use-package-concat
+     (use-package-process-keywords name
+       (use-package-sort-keywords
+        (use-package-plist-maybe-put rest :defer t))
+       (use-package-plist-append state :commands commands))
+     `((ignore
+        ,(macroexpand
+          `(,(if bind-macro bind-macro 'bind-keys)
+            :package ,name ,@arg)))))))
+
+(defun use-package-handler/:bind* (name keyword arg rest state)
+  (use-package-handler/:bind name keyword arg rest state 'bind-keys*))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :bind-keymap, :bind-keymap*
+;;
+
+(defalias 'use-package-normalize/:bind-keymap 'use-package-normalize-binder)
+(defalias 'use-package-normalize/:bind-keymap* 'use-package-normalize-binder)
 
 (defun use-package-autoload-keymap (keymap-symbol package override)
-  "Loads PACKAGE and then binds the key sequence used to invoke this function to
-KEYMAP-SYMBOL.  It then simulates pressing the same key sequence a again, so
-that the next key pressed is routed to the newly loaded keymap.
-
-This function supports use-package's :bind-keymap keyword.  It works
-by binding the given key sequence to an invocation of this function for a
-particular keymap.  The keymap is expected to be defined by the package.  In
-this way, loading the package is deferred until the prefix key sequence is
-pressed."
-  (if (if (stringp package) (load package t) (require package nil t))
-      (if (and (boundp keymap-symbol) (keymapp (symbol-value keymap-symbol)))
-          (let ((key (key-description (this-command-keys-vector)))
-                (keymap (symbol-value keymap-symbol)))
-            (progn
-              (if override
-                  `(eval `(bind-key* ,key ,keymap)) ; eval form is necessary to avoid compiler error
-                (bind-key key keymap))
-              (setq unread-command-events
-                    (listify-key-sequence (this-command-keys-vector)))))
-        (error
-         "use-package: package %s failed to define keymap %s"
-         package keymap-symbol))
-    (error "Could not load package %s" package)))
+  "Loads PACKAGE and then binds the key sequence used to invoke
+this function to KEYMAP-SYMBOL.  It then simulates pressing the
+same key sequence a again, so that the next key pressed is routed
+to the newly loaded keymap.
+
+This function supports use-package's :bind-keymap keyword.  It
+works by binding the given key sequence to an invocation of this
+function for a particular keymap.  The keymap is expected to be
+defined by the package.  In this way, loading the package is
+deferred until the prefix key sequence is pressed."
+  (if (not (require package nil t))
+      (use-package-error (format "Cannot load package.el: %s" package))
+    (if (and (boundp keymap-symbol)
+             (keymapp (symbol-value keymap-symbol)))
+        (let* ((kv (this-command-keys-vector))
+               (key (key-description kv))
+               (keymap (symbol-value keymap-symbol)))
+          (if override
+              (bind-key* key keymap)
+            (bind-key key keymap))
+          (setq unread-command-events
+                (listify-key-sequence kv)))
+      (use-package-error
+       (format "use-package: package.el %s failed to define keymap %s"
+               package keymap-symbol)))))
+
+(defun use-package-handler/:bind-keymap
+    (name keyword arg rest state &optional override)
+  (let ((form (mapcar
+               #'(lambda (binding)
+                   `(,(if override
+                          'bind-key*
+                        'bind-key)
+                     ,(car binding)
+                     #'(lambda ()
+                         (interactive)
+                         (use-package-autoload-keymap
+                          ',(cdr binding) ',(use-package-as-symbol name) ,override)))) arg)))
+    (use-package-concat
+     (use-package-process-keywords name
+       (use-package-sort-keywords
+        (use-package-plist-maybe-put rest :defer t))
+       state)
+     `((ignore ,@form)))))
+
+(defun use-package-handler/:bind-keymap* (name keyword arg rest state)
+  (use-package-handler/:bind-keymap name keyword arg rest state t))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :interpreter
+;;
 
-(put 'use-package 'lisp-indent-function 'defun)
+(defun use-package-normalize-mode (name keyword args)
+  (use-package-as-one (symbol-name keyword) args
+    (apply-partially #'use-package-normalize-pairs name)))
+
+(defalias 'use-package-normalize/:interpreter 'use-package-normalize-mode)
+
+(defun use-package-handler/:interpreter (name keyword arg rest state)
+  (let* (commands
+         (form (mapcar #'(lambda (interpreter)
+                           (push (cdr interpreter) commands)
+                           `(add-to-list 'interpreter-mode-alist ',interpreter)) arg)))
+    (use-package-concat
+     (use-package-process-keywords name
+       (use-package-sort-keywords
+        (use-package-plist-maybe-put rest :defer t))
+       (use-package-plist-append state :commands commands))
+     `((ignore ,@form)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :mode
+;;
 
-(defconst use-package-font-lock-keywords
-  '(("(\\(use-package\\(?:-with-elapsed-timer\\)?\\)\\_>[ \t']*\\(\\(?:\\sw\\|\\s_\\)+\\)?"
-     (1 font-lock-keyword-face)
-     (2 font-lock-constant-face nil t))))
+(defalias 'use-package-normalize/:mode 'use-package-normalize-mode)
+
+(defun use-package-handler/:mode (name keyword arg rest state)
+  (let* (commands
+         (form (mapcar #'(lambda (mode)
+                           (push (cdr mode) commands)
+                           `(add-to-list 'auto-mode-alist ',mode)) arg)))
+    (use-package-concat
+     (use-package-process-keywords name
+       (use-package-sort-keywords
+        (use-package-plist-maybe-put rest :defer t))
+       (use-package-plist-append state :commands commands))
+     `((ignore ,@form)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :commands
+;;
 
-(font-lock-add-keywords 'emacs-lisp-mode use-package-font-lock-keywords)
+(defalias 'use-package-normalize/:commands 'use-package-normalize-symlist)
+
+(defun use-package-handler/:commands (name keyword arg rest state)
+  ;; The actual processing for commands is done in :defer
+  (use-package-process-keywords name
+    (use-package-sort-keywords
+     (use-package-plist-maybe-put rest :defer t))
+    (use-package-plist-append state :commands arg)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :defines
+;;
+
+(defalias 'use-package-normalize/:defines 'use-package-normalize-symlist)
+
+(defun use-package-handler/:defines (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    body))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :functions
+;;
+
+(defalias 'use-package-normalize/:functions 'use-package-normalize-symlist)
+
+(defun use-package-handler/:functions (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (if (not (bound-and-true-p byte-compile-current-file))
+        body
+      (use-package-concat
+       (unless (null arg)
+         `((eval-when-compile
+             ,@(mapcar
+                #'(lambda (fn)
+                    `(declare-function ,fn ,(use-package-as-string name))) arg))))
+       body))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :defer
+;;
+
+(defalias 'use-package-normalize/:defer 'use-package-normalize-predicate)
+
+(defun use-package-handler/:defer (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest
+                (plist-put state :deferred t)))
+        (name-string (use-package-as-string name)))
+    (use-package-concat
+     ;; Load the package after a set amount of idle time, if the argument to
+     ;; `:defer' was a number.
+     (when (numberp arg)
+       `((run-with-idle-timer ,arg nil #'require ',(use-package-as-symbol name) nil t)))
+
+     ;; Since we deferring load, establish any necessary autoloads, and also
+     ;; keep the byte-compiler happy.
+     (apply
+      #'nconc
+      (mapcar #'(lambda (command)
+                  (when (not (stringp command))
+                    (append
+                     `((unless (fboundp ',command)
+                         (autoload #',command ,name-string nil t)))
+                     (when (bound-and-true-p byte-compile-current-file)
+                       `((eval-when-compile
+                           (declare-function ,command ,name-string)))))))
+              (delete-dups (plist-get state :commands))))
+
+     body)))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :after
+;;
+
+(defalias 'use-package-normalize/:after 'use-package-normalize-symlist)
+
+(defun use-package-require-after-load (features name)
+  "Return form for after any of FEATURES require NAME."
+  `(progn
+     ,@(mapcar
+        (lambda (feat)
+          `(eval-after-load
+               (quote ,feat)
+             (quote (require (quote ,name) nil t))))
+        features)))
+
+(defun use-package-handler/:after (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest
+                (plist-put state :deferred t)))
+        (name-string (use-package-as-string name)))
+    (use-package-concat
+     (when arg
+       (list (use-package-require-after-load arg name)))
+     body)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :demand
+;;
+
+(defalias 'use-package-normalize/:demand 'use-package-normalize-predicate)
+
+(defun use-package-handler/:demand (name keyword arg rest state)
+  (use-package-process-keywords name rest
+    (use-package-plist-delete state :deferred)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :init
+;;
+
+(defalias 'use-package-normalize/:init 'use-package-normalize-forms)
+
+(defun use-package-handler/:init (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (use-package-concat
+     ;; The user's initializations
+     (let ((init-body
+            (use-package-hook-injector (use-package-as-string name)
+                                       :init arg)))
+       (if use-package-check-before-init
+           `((if (locate-library ,(use-package-as-string name))
+                 ,(macroexp-progn init-body)))
+         init-body))
+     body)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :config
+;;
+
+(defalias 'use-package-normalize/:config 'use-package-normalize-forms)
+
+(defun use-package-handler/:config (name keyword arg rest state)
+  (let* ((body (use-package-process-keywords name rest state))
+         (name-symbol (use-package-as-symbol name))
+         (config-body
+          (if (equal arg '(t))
+              body
+            (use-package--with-elapsed-timer
+                (format "Configuring package %s" name-symbol)
+              (use-package-concat
+               (use-package-hook-injector (symbol-name name-symbol)
+                                          :config arg)
+               body
+               (list t))))))
+    (if (plist-get state :deferred)
+        (unless (or (null config-body) (equal config-body '(t)))
+          `((eval-after-load ,(if (symbolp name) `',name name)
+              ',(macroexp-progn config-body))))
+      (use-package--with-elapsed-timer
+          (format "Loading package %s" name)
+        (if use-package-expand-minimally
+            (use-package-concat
+             (list (use-package-load-name name))
+             config-body)
+          `((if (not ,(use-package-load-name name t))
+                (ignore
+                 (message (format "Cannot load %s" ',name)))
+              ,@config-body)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :diminish
+
+(defun use-package-normalize-diminish (name label arg &optional recursed)
+  "Normalize the arguments to diminish down to a list of one of two forms:
+     SYMBOL
+     (SYMBOL . STRING)"
+  (cond
+   ((symbolp arg)
+    (list arg))
+   ((stringp arg)
+    (list (cons (intern (concat (use-package-as-string name) "-mode")) arg)))
+   ((and (consp arg) (stringp (cdr arg)))
+    (list arg))
+   ((and (not recursed) (listp arg) (listp (cdr arg)))
+    (mapcar #'(lambda (x) (car (use-package-normalize-diminish
+                                name label x t))) arg))
+   (t
+    (use-package-error
+     (concat label " wants a string, symbol, "
+             "(symbol . string) or list of these")))))
+
+(defun use-package-normalize/:diminish (name keyword args)
+  (use-package-as-one (symbol-name keyword) args
+    (apply-partially #'use-package-normalize-diminish name)))
+
+(defun use-package-handler/:diminish (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (use-package-concat
+     (mapcar #'(lambda (var)
+                 `(if (fboundp 'diminish)
+                      ,(if (consp var)
+                           `(diminish ',(car var) ,(cdr var))
+                         `(diminish ',var))))
+             arg)
+     body)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :delight
+;;
+
+(defun use-package-normalize/:delight (name keyword args)
+  "Normalize arguments to delight."
+  (cond
+   ((and (= (length args) 1)
+         (symbolp (car args)))
+    (list (car args) nil name))
+   ((and (= (length args) 2)
+         (symbolp (car args)))
+    (list (car args) (cadr args) (use-package-as-symbol name)))
+   ((and (= (length args) 3)
+         (symbolp (car args)))
+    args)
+   (t
+    (use-package-error ":delight expects same args as delight function"))))
+
+(defun use-package-handler/:delight (name keyword args rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (use-package-concat
+     body
+     `((delight (quote ,(nth 0 args)) ,(nth 1 args) (quote ,(nth 2 args))) t))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; The main macro
+;;
+
+;;;###autoload
+(defmacro use-package (name &rest args)
+  "Declare an Emacs package by specifying a group of configuration options.
+
+For full documentation, please see the README file that came with
+this file.  Usage:
+
+  (use-package package-name
+     [:keyword [option]]...)
+
+:init          Code to run before PACKAGE-NAME has been loaded.
+:config        Code to run after PACKAGE-NAME has been loaded.  Note that if
+               loading is deferred for any reason, this code does not execute
+               until the lazy load has occurred.
+:preface       Code to be run before everything except `:disabled'; this can
+               be used to define functions for use in `:if', or that should be
+               seen by the byte-compiler.
+
+:mode          Form to be added to `auto-mode-alist'.
+:interpreter   Form to be added to `interpreter-mode-alist'.
+
+:commands      Define autoloads for commands that will be defined by the
+               package.  This is useful if the package is being lazily loaded,
+               and you wish to conditionally call functions in your `:init'
+               block that are defined in the package.
+
+:bind          Bind keys, and define autoloads for the bound commands.
+:bind*         Bind keys, and define autoloads for the bound commands,
+               *overriding all minor mode bindings*.
+:bind-keymap   Bind a key prefix to an auto-loaded keymap defined in the
+               package.  This is like `:bind', but for keymaps.
+:bind-keymap*  Like `:bind-keymap', but overrides all minor mode bindings
+
+:defer         Defer loading of a package -- this is implied when using
+               `:commands', `:bind', `:bind*', `:mode' or `:interpreter'.
+               This can be an integer, to force loading after N seconds of
+               idle time, if the package has not already been loaded.
+
+:after         Defer loading of a package until after any of the named
+               features are loaded.
+
+:demand        Prevent deferred loading in all cases.
+
+:if EXPR       Initialize and load only if EXPR evaluates to a non-nil value.
+:disabled      The package is ignored completely if this keyword is present.
+:defines       Declare certain variables to silence the byte-compiler.
+:functions     Declare certain functions to silence the byte-compiler.
+:load-path     Add to the `load-path' before attempting to load the package.
+:diminish      Support for diminish.el (if installed).
+:ensure        Loads the package using package.el if necessary.
+:pin           Pin the package to an archive."
+  (declare (indent 1))
+  (unless (member :disabled args)
+    (let* ((name-symbol (if (stringp name) (intern name) name))
+           (args0 (use-package-plist-maybe-put
+                   (use-package-normalize-plist name args)
+                   :config '(t)))
+           (args* (use-package-sort-keywords
+                   (if use-package-always-ensure
+                       (use-package-plist-maybe-put
+                        args0 :ensure use-package-always-ensure)
+                     args0)))
+           (args* (use-package-sort-keywords
+                   (if use-package-always-pin
+                       (use-package-plist-maybe-put
+                        args* :pin use-package-always-pin)
+                     args*))))
+
+      ;; When byte-compiling, pre-load the package so all its symbols are in
+      ;; scope.
+      (if (bound-and-true-p byte-compile-current-file)
+          (setq args*
+                (use-package-plist-cons
+                 args* :preface
+                 `(eval-when-compile
+                    ,@(mapcar #'(lambda (var) `(defvar ,var))
+                              (plist-get args* :defines))
+                    (with-demoted-errors
+                        ,(format "Cannot load %s: %%S" name)
+                      ,(if (eq use-package-verbose 'debug)
+                           `(message "Compiling package %s" ',name-symbol))
+                      ,(unless (plist-get args* :no-require)
+                         (use-package-load-name name)))))))
+
+      (let ((body
+             (macroexp-progn
+              (use-package-process-keywords name args*
+                (and use-package-always-defer (list :deferred t))))))
+        (if use-package-debug
+            (display-buffer
+             (save-current-buffer
+               (let ((buf (get-buffer-create "*use-package*")))
+                 (with-current-buffer buf
+                   (delete-region (point-min) (point-max))
+                   (emacs-lisp-mode)
+                   (insert (pp-to-string body)))
+                 buf))))
+        body))))
+
+
+(put 'use-package 'lisp-indent-function 'defun)
 
 (provide 'use-package)
+
 ;; Local Variables:
 ;; indent-tabs-mode: nil
 ;; End:
+
 ;;; use-package.el ends here
index 9038866..f078c1f 100644 (file)
@@ -43,7 +43,7 @@
                    (org-bbdb org-bibtex org-crypt org-docview org-gnus
                     org-id org-info org-habit org-inlinetask
                     org-irc org-protocol org-w3m org-mouse
-                    org-notmuch icalendar)))
+                    icalendar))) ; org-notmuch
 
 ;; And load org-mode
 (require 'org)