;;; hippie-autoloads.el --- automatically extracted autoloads
;;
;;; Code:


;;;### (autoloads (hippie-buffer/replace-regexp hippie-buffer/isearch-backward
;;;;;;  hippie-buffer/isearch-forward hippie-buffer/indent-right
;;;;;;  hippie-buffer/indent-left hippy-buffer/untabify-buffer hippie-buffer/delete-backward
;;;;;;  hippie-buffer/kill-region-or-char hippie-buffer/kill-buffers
;;;;;;  hippie-buffer/comment hippie-buffer/backward-move-to-tab-stop
;;;;;;  hippie-buffer/previous-line hippie-buffer/next-line) "hippie-buffer"
;;;;;;  "hippie-buffer.el" (18964 61478))
;;; Generated autoloads from hippie-buffer.el

(autoload 'hippie-buffer/next-line "hippie-buffer" "\
Navigate to the next line and skip over any preceding whitespace.

\(fn)" t nil)

(autoload 'hippie-buffer/previous-line "hippie-buffer" "\
Navigate to the previous line and skip over any preceding whitespace.

\(fn)" t nil)

(autoload 'hippie-buffer/backward-move-to-tab-stop "hippie-buffer" "\
Move point to previous (greatest less than point) tab-stop.
The variable `tab-stop-list' is a list of columns at which there are tab stops.
Use \\[edit-tab-stops] to edit tab stops interactively.
This is a move-backward version of \\[move-to-tab-stop].

\(fn)" t nil)

(autoload 'hippie-buffer/comment "hippie-buffer" "\
If the current region or line, if there is no region, is currently commented,
uncomments this region or line; otherwise, comments this region or line.

If a prefix argument of 1 is passed, copy the current region or line onto a new
line immediately below the current region or line, then comment the current
region or line if uncommented or uncomment the current region or line if
commented. (In other words, this preserves the current region or line before
commenting or uncommenting that region or line.)

If a prefix argument of greater than 1 is passed, this comments or uncomments
that many lines after and including the current line. This ignores whether or
not there is a current region.

\(fn &optional ARG)" t nil)

(autoload 'hippie-buffer/kill-buffers "hippie-buffer" "\
Save and kill all non-blacklisted buffers. Blacklisted buffers are any
buffers not matched by `hippie-buffer/kill-buffers-blacklist-regexp'; these are
buffers resembling the '*scratch*' buffer that should never be killed during an
Emacs session.

If ARG is non-nil, unconditionally save unsaved buffers prior to killing this
frame; otherwise, query the user with each such buffer as to whether its changes
should be saved or discarded.

\(fn &optional ARG)" t nil)

(autoload 'hippie-buffer/kill-region-or-char "hippie-buffer" "\
Kill (\"cut\") the current region or character after the current point.
Context-sensitively determine which to kill as follows: if there is a current
region, then kill that; otherwise, kill the character after the current point.

\(fn)" t nil)

(autoload 'hippie-buffer/delete-backward "hippie-buffer" "\
Adaptively deletes the character before the character at the
current point and, when that character is a non-newline whitespace character--
e.g., a space or tab--deletes each previous non-newline whitespace
character belonging to the current indendation level. (That is, this
\"unindents\" one indentation level when backspacing over whitespace.)

\(fn)" t nil)

(autoload 'hippy-buffer/untabify-buffer "hippie-buffer" "\
Untabify the current buffer. Convert all tab characters in this buffer to
multiple space characters, preserving columns just as with the `untabify'
function. This function should not be called in major modes for which tab
characters are syntactical symbols (e.g., `makefile-mode'). See
`hippy-buffer/untabify-buffers-before-save-flag' for discussion about this.

\(fn)" t nil)

(autoload 'hippie-buffer/indent-left "hippie-buffer" "\
Adaptively decreases the indentation level of the current region or, when
there is no current region, current line (by one indentation level).

Specifically, this deletes `tab-width' characters from the left margin.

\(fn)" t nil)

(autoload 'hippie-buffer/indent-right "hippie-buffer" "\
Adaptively increases the indentation level of the current region or, when
there is no current region, current line (by one indentation level).

Specifically, this inserts `tab-width' characters onto the left margin.

\(fn)" t nil)

(autoload 'hippie-buffer/isearch-forward "hippie-buffer" "\
Incrementally searches forward, using the symbol under the current point as
a default search term.

\(fn &optional PARTIALP)" t nil)

(autoload 'hippie-buffer/isearch-backward "hippie-buffer" "\
Incrementally searches backward, using the symbol under the current point as
a default search term.

\(fn &optional PARTIALP)" t nil)

(autoload 'hippie-buffer/replace-regexp "hippie-buffer" "\
Adaptively replaces strings matching REGEXP with TO-STRING over the current
region or, when there is no current region, current buffer. Please see
documentation for the `replace-regexp' function, from which this function
liberally borrows its implementation. (That function replaces strings after the
current point for the current buffer, when there is no current region. That is,
possibly, less useful than replacing strings for the entire buffer--regardless
of where the current point in that buffer is. This function corrects that.)

\(fn REGEXP TO-STRING &optional DELIMITED START END)" t nil)

;;;***

;;;### (autoloads (hippie-dired/prev-file-or-directory hippie-dired/next-file-or-directory
;;;;;;  hippie-dired/last-file-or-directory hippie-dired/first-file-or-directory)
;;;;;;  "hippie-dired" "hippie-dired.el" (18980 33732))
;;; Generated autoloads from hippie-dired.el

(autoload 'hippie-dired/first-file-or-directory "hippie-dired" "\
Move to the first Dired line listing a file or directory name.

\(fn)" t nil)

(autoload 'hippie-dired/last-file-or-directory "hippie-dired" "\
Move to the last Dired line listing a file or directory name.

\(fn)" t nil)

(autoload 'hippie-dired/next-file-or-directory "hippie-dired" "\
Move to the next Dired line listing a file or directory name.

\(fn)" t nil)

(autoload 'hippie-dired/prev-file-or-directory "hippie-dired" "\
Move to the previous Dired line listing a file or directory name.

\(fn)" t nil)

;;;***

(autoload 'hippie-ediff/toggle-display "hippie-ediff" "\
Toggle display of the ediff window configuration. If the ediff window
configuration is already displayed, this suspends it; otherwise, this
recenters (i.e., resumes) it.

Naturally, this supports ediff window configurations sharing one and only one
ediff session - but is certainly sufficient for the general case (of only one
ediff session).

\(fn)" t nil)

;;;### (autoloads (hippie-ediff/scroll-right hippie-ediff/scroll-left
;;;;;;  hippie-ediff/next-column hippie-ediff/previous-column hippie-ediff/scroll-down
;;;;;;  hippie-ediff/scroll-up hippie-ediff/next-page hippie-ediff/previous-page
;;;;;;  hippie-ediff/next-line hippie-ediff/previous-line hippie-ediff/toggle-display)
;;;;;;  "hippie-ediff" "hippie-ediff.el" (18998 10080))
;;; Generated autoloads from hippie-ediff.el

(autoload 'hippie-ediff/toggle-display "hippie-ediff" "\
Toggle display of the ediff window configuration. If the ediff window
configuration is already displayed, this suspends it; otherwise, this
recenters (i.e., resumes) it.

Naturally, this supports ediff window configurations sharing one and only one
ediff session - but is certainly sufficient for the general case (of only one
ediff session).

\(fn)" t nil)

(autoload 'hippie-ediff/previous-line "hippie-ediff" "\
Vertically scroll the current pair (or trio) of ediff buffers up one line.

\(fn)" t nil)

(autoload 'hippie-ediff/next-line "hippie-ediff" "\
Vertically scroll the current pair (or trio) of ediff buffers down one line.

\(fn)" t nil)

(autoload 'hippie-ediff/previous-page "hippie-ediff" "\
Vertically scroll the current pair (or trio) of ediff buffers up one page.

\(fn)" t nil)

(autoload 'hippie-ediff/next-page "hippie-ediff" "\
Vertically scroll the current pair (or trio) of ediff buffers down one page.

\(fn)" t nil)

(autoload 'hippie-ediff/scroll-up "hippie-ediff" "\
Vertically scroll the current pair (or trio) of ediff buffers up the passed
number of lines or, if no number of lines is passed, one half-page.

\(fn &optional ARG)" t nil)

(autoload 'hippie-ediff/scroll-down "hippie-ediff" "\
Vertically scroll the current pair (or trio) of ediff buffers down the passed
number of lines or, if no number of lines is passed, one half-page.

\(fn &optional ARG)" t nil)

(autoload 'hippie-ediff/previous-column "hippie-ediff" "\
Horizontally scroll the current pair (or trio) of ediff buffers left one
column.

\(fn)" t nil)

(autoload 'hippie-ediff/next-column "hippie-ediff" "\
Horizontally scroll the current pair (or trio) of ediff buffers right one
column.

\(fn)" t nil)

(autoload 'hippie-ediff/scroll-left "hippie-ediff" "\
Horizontally scroll the current pair (or trio) of ediff buffers left the
passed number of columns or, if no number of lines is passed, one half-page.

\(fn &optional ARG)" t nil)

(autoload 'hippie-ediff/scroll-right "hippie-ediff" "\
Horizontally scroll the current pair (or trio) of ediff buffers right the
passed number of columns or, if no number of lines is passed, one half-page.

\(fn &optional ARG)" t nil)

;;;***

;;;### (autoloads (hippie-file-cache/iswitchb-find-file hippie-file-cache/ido-find-file
;;;;;;  hippie-file-cache/add-path-ruby hippie-file-cache/add-path-python
;;;;;;  hippie-file-cache/add-path-perl hippie-file-cache/cache-load-path)
;;;;;;  "hippie-file-cache" "hippie-file-cache.el" (18964 61479))
;;; Generated autoloads from hippie-file-cache.el

(autoload 'hippie-file-cache/cache-load-path "hippie-file-cache" "\
Add Emacs Lisp files in all paths in the Emacs Lisp `load-path' to the
`file-cache', if `load-path' hasn't already been added (i.e., this is the
first time you've called this function this session).

\(fn)" t nil)

(autoload 'hippie-file-cache/add-path-perl "hippie-file-cache" "\
Adds all Perl-specific files in PATH to the `file-cache', if that path has not
already been added.

\(fn PATH)" t nil)

(autoload 'hippie-file-cache/add-path-python "hippie-file-cache" "\
Adds all Python-specific files in PATH to the `file-cache', if that path has not
already been added.

\(fn PATH)" t nil)

(autoload 'hippie-file-cache/add-path-ruby "hippie-file-cache" "\
Adds all Ruby-specific files in PATH to the `file-cache', if that path has not
already been added.

\(fn PATH)" t nil)

(autoload 'hippie-file-cache/ido-find-file "hippie-file-cache" "\
Using ido, interactively open file from file cache. First select a file,
matched using ido-switch-buffer against the contents in `file-cache-alist'. If
the file exist in more than one directory, select directory. Lastly the file is
opened.

\(fn FILE)" t nil)

(autoload 'hippie-file-cache/iswitchb-find-file "hippie-file-cache" "\
Using iswitchb, interactively open file from file cache'.
First select a file, matched using iswitchb against the contents
in `file-cache-alist'. If the file exist in more than one
directory, select directory. Lastly the file is opened.

\(fn)" t nil)

;;;***

;;;### (autoloads (hippie-frame/fullscreen hippie-frame/toggle-fullscreen
;;;;;;  hippie-frame/delete-selected-frame) "hippie-frame" "hippie-frame.el"
;;;;;;  (18996 60125))
;;; Generated autoloads from hippie-frame.el

(autoload 'hippie-frame/delete-selected-frame "hippie-frame" "\
Save buffers pertaining to the current frame and kill it. If this frame is a
client of the current server, delete this frame and remove this client from the
client list. Otherwise, this frame is not dependent on the current server but is
a stand-alone frame; in this case, if this frame is the final frame, delete this
frame and kill Emacs, or, if this frame is not the final frame, just delete this
frame. In other words, do the right thing so as to ensure the current frame's
deletion.

If ARG is non-nil, unconditionally save unsaved buffers prior to killing this
frame; otherwise, query the user with each such buffer as to whether its changes
should be saved or discarded.

This lets you delete Emacs client and server frames with the same function (and,
therefore, same key binding). Typically, you delete an Emacs client frame with
one function (`delete-frame' or `server-edit') and the Emacs server frame with
another function (`save-buffers-kill-emacs'); typically, the former function's
bound to <Ctrl-x #> and the latter to <Ctrl-x Ctrl-c>. As these are not the
same key bindings, you must cognitively, actively consider whether you are
currently in an Emacs client or server frame when deleting the current frame
\(so as to hit the 'proper' key binding to delete that frame).

This function eliminates that cognitive load by transparently unifying those
two functions. To delete the current frame, regardless of whether that frame
is an Emacs client or server frame, bind this function to a custom key.

This function serves as a generic replacement for the conventional
`save-buffers-kill-emacs' and `save-buffers-kill-terminal' functions, and
complements existing functionality for the `hippie-server' feature.

\(fn &optional ARG)" t nil)

(autoload 'hippie-frame/toggle-fullscreen "hippie-frame" "\
Toggle \"full screen\" display of the current frame. If the current frame is
not already full screened, enable that; otherwise, disable that.

\(fn &optional ARG)" nil nil)

(autoload 'hippie-frame/fullscreen "hippie-frame" "\
Toggle \"full screen\" display of the current frame. If ARG is nil, toggle
full screen (i.e., enable full screen if the current frame is not already full
screened or disable full screen if it is). If ARG is positive, enable full
screen. Or, if ARG is negative, disable full screen.

\"Full screen\" means stretch the frame dimensions so as to have that frame fill
the screen, horizontally and vertically, in a cross platform-portable fashion.
\(Fortunately, Emacs already implements by marshalling a call to this host's
window manager.)

\(fn &optional ARG)" t nil)

;;;***

;;;### (autoloads (hippie-help/apropos-feature) "hippie-help" "hippie-help.el"
;;;;;;  (18997 62638))
;;; Generated autoloads from hippie-help.el

(autoload 'hippie-help/apropos-feature "hippie-help" "\
Display documentation for feature FEATURE-NAME. Display the first line of
docstring for all symbols defined by this feature and having a docstring.

\(fn FEATURE-NAME)" t nil)

;;;***

;;;### (autoloads (hippie/copy-keymap-into hippie/make-sparse-child-keymap
;;;;;;  hippie/ad-activated-enabled-p hippie/ad-mapc hippie/ad-remove-regexp
;;;;;;  hippie/ad-disable-activate-regexp hippie/ad-enable-activate-regexp
;;;;;;  hippie/ad-disable-activate hippie/ad-enable-activate hippie/assq-pushnew
;;;;;;  hippie/assq-cdr hippie/assq-setcdr hippie/noop hippie/funcall-if-boundp
;;;;;;  hippie/funcall-if-fboundp) "hippie-lib" "hippie-lib.el" (18998
;;;;;;  9777))
;;; Generated autoloads from hippie-lib.el

(autoload 'hippie/funcall-if-fboundp "hippie-lib" "\
Call function with ARGUMENTS, if FUNCTION-NAME signifies a defined function.
If this is the case, call that function and return its return value; otherwise,
return nil.

\(fn FUNCTION-NAME &rest ARGUMENTS)" nil (quote macro))

(autoload 'hippie/funcall-if-boundp "hippie-lib" "\
Call FUNCTION with ARGUMENTS, if VARIABLE-NAME signifies a defined variable.
If this is the case, call that function and return its return value; otherwise,
return nil.

\(fn FUNCTION VARIABLE-NAME &rest ARGUMENTS)" nil (quote macro))

(autoload 'hippie/noop "hippie-lib" "\
Return the first argument in ARGUMENTS or, if ARGUMENTS is empty, t. This
function implements an efficient no-op, for use as a function alias or as
argument to another function.

\(fn &rest ARGUMENTS)" nil nil)

(autoload 'hippie/assq-setcdr "hippie-lib" "\
Set the cdr of the first element of ALIST whose car is KEY to VALUE. Return
VALUE as is. If there is no such element, push a new element on ALIST whose car
is KEY and set the cdr of that to VALUE.

This modifies ALIST in place.

\(fn KEY VALUE ALIST)" nil (quote macro))

(autoload 'hippie/assq-cdr "hippie-lib" "\
Return the cdr of the first element of ALIST whose car is KEY. If there is no
such element, push a new element on ALIST whose car is KEY and return the cdr of
that (which should be an empty list).

This modifies ALIST in place, if pushing a new element onto it. Also, the cdr
returned is settable via the `setf' Common Lisp macro, ala:

  (setf (hippie/assq-cdr 'key \"old-value\" alist) \"new-value\")

\(fn KEY ALIST)" nil (quote macro))

(autoload 'hippie/assq-pushnew "hippie-lib" "\
Return the first element of ALIST whose car is KEY. If there is no such
element, push a new element on ALIST whose car is KEY and return that. And no:
the bathroom humour in this macro's name isn't lost on us.

If pushing a new element on to ALIST, this modifies that list in place and, if 
PUSHNEW-FUNCTION is non-nil, also calls that function with an argument list
resembling:

  (pushnew-function key alist new-list)

NEW-LIST, here, is the newly created list whose car is KEY.

\(fn KEY ALIST &optional PUSHNEW-FUNCTION)" nil (quote macro))

(autoload 'hippie/ad-enable-activate "hippie-lib" "\
Enable and activate advice named ADVICE-NAME in ADVICE-CLASS for FUNCTION.
ADVICE-CLASS should be explicitly specified for efficiency, but, if not,
defaults to `any', which matches all three advice classes: `before', `after',
and `around'.

This macro takes argument in a slightly different order from the
`ad-enable-advice' function, for sanity's sake.

\(fn FUNCTION ADVICE-NAME &optional ADVICE-CLASS)" nil (quote macro))

(autoload 'hippie/ad-disable-activate "hippie-lib" "\
Disable and activate advice named ADVICE-NAME in ADVICE-CLASS for FUNCTION.
ADVICE-CLASS should be explicitly specified for efficiency, but, if not,
defaults to `any', which matches all three advice classes: `before', `after',
and `around'.

This macro takes argument in a slightly different order from the
`ad-disable-advice' function, for sanity's sake.

\(fn FUNCTION ADVICE-NAME &optional ADVICE-CLASS)" nil (quote macro))

(autoload 'hippie/ad-enable-activate-regexp "hippie-lib" "\
Enable advice whose name matches REGEXP for all advised functions. Activate
the advice for such functions, so as to ensure that advised functions
definitions are updated to reflect that enabled advice.

This matches all advice classes: 'before, 'after, and 'about'.

\(fn REGEXP)" nil (quote macro))

(autoload 'hippie/ad-disable-activate-regexp "hippie-lib" "\
Disable advice whose name matches REGEXP for all advised functions. Activate
the advice for such functions, so as to ensure that advised functions
definitions are updated to reflect that disabled advice.

This matches all advice classes: 'before, 'after, and 'about'.

\(fn REGEXP)" nil (quote macro))

(autoload 'hippie/ad-remove-regexp "hippie-lib" "\
Remove REGEXP-matched advice from all advised functions. Advice whose advice
name matches REGEXP will be removed via `ad-remove'. This matches all
advice classes: 'before, 'after, and 'about.

\(fn REGEXP)" nil (quote macro))

(autoload 'hippie/ad-mapc "hippie-lib" "\
Apply FUNCTION to each advice matching REGEXP on all advised functions. This
function should accept an argument list resembling:

  lambda (advised-function advices advice advice-class advice-name)

If at least one advice is modified for any advised function, that function's
definition is updated and, if ACTIVATE-FLAG is non-nil, also activated.

\(fn FUNCTION REGEXP &optional ACTIVATE-FLAG)" nil nil)

(autoload 'hippie/ad-activated-enabled-p "hippie-lib" "\
Return non-nil if ADVICE-NAME in ADVICE-CLASS is activated and enabled. (For
this specific FUNCTION.) Return nil if advice for FUNCTION is deactivated or if
there is no advice with ADVICE-NAME in ADVICE-CLASS for FUNCTION.

ADVICE-CLASS defaults to `any' when nil, but should be specified for
efficiency.

\(fn FUNCTION ADVICE-NAME &optional ADVICE-CLASS)" nil nil)

(autoload 'hippie/make-sparse-child-keymap "hippie-lib" "\
Return a new sparse keymap having PARENT as its parent keymap. Keymap lookup
will search for key bindings not already defined for this keymap in this PARENT
keymap, instead.

\(fn PARENT)" nil (quote macro))

(autoload 'hippie/copy-keymap-into "hippie-lib" "\
Copy all key bindings in SOURCE-KEYMAP into existing TARGET-KEYMAP. Return
TARGET-KEYMAP. Also recursively copy all key bindings in all parent keymaps of
SOURCE-KEYMAP into TARGET-KEYMAP if SOURCE-KEYMAP has such a parent keymap.

The related `copy-keymap' primitive always returns a new copy of SOURCE-KEYMAP.
This macro, on the other hand, returns the TARGET-KEYMAP passed to it without
creating a new copy.

\(fn SOURCE-KEYMAP TARGET-KEYMAP)" nil (quote macro))

;;;***

;;;### (autoloads (hippie-lisp/info-lookup-symbol hippie-lisp/describe-symbol
;;;;;;  hippie-lisp/reload-buffer) "hippie-lisp" "hippie-lisp.el"
;;;;;;  (18964 61479))
;;; Generated autoloads from hippie-lisp.el

(autoload 'hippie-lisp/reload-buffer "hippie-lisp" "\
Re-load the current Emacs Lisp-specific buffer. Specifically, re-evaluate this
buffer and, when this is a file-associated buffer, re-byte compile this file.

If `eval-expression-debug-on-error' is non-nil, which is the default, this
command arranges for all errors to enter the debugger.

\(fn)" t nil)

(autoload 'hippie-lisp/describe-symbol "hippie-lisp" "\
Show the docstring help for the Emacs Lisp symbol at the current point. This
iteratively searches, in order:

* For a function name at the current point.
* For a variable name at the current point.
* For whether the current point is enclosed in a named function.

We search for function names prior to variable names so as to properly account
for a likely situation in which: firstly, the Emacs Lisp symbol at the current
point is a function's name and, secondly, there also exists a variable name
bound to the function name. In this case, the function rather than variable
should be described.

\(fn)" t nil)

(autoload 'hippie-lisp/info-lookup-symbol "hippie-lisp" "\
Show the Info node for the Emacs Lisp symbol at the current point. This
iteratively searches for that Emacs Lisp symbol using the same algorithm as in
`hippie-lisp/describe-symbol'.

The first call to this function is considerably slower than subsequent calls,
since the `info-lookup' feature must first grep through the entirety of the
Emacs Info manual for all Emacs Lisp symbols, and cache the results.

\(fn)" t nil)

;;;***

;;;### (autoloads (hippie-mode) "hippie-mode" "hippie-mode.el" (18997
;;;;;;  45976))
;;; Generated autoloads from hippie-mode.el

(defvar hippie-mode nil "\
Non-nil if Hippie mode is enabled.
See the command `hippie-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 `hippie-mode'.")

(custom-autoload 'hippie-mode "hippie-mode" nil)

(autoload 'hippie-mode "hippie-mode" "\
Toggle, enable, or disable Hippie mode. This behaves as follows:

* When called with no argument (interactively) or a nil argument
  (non-interactively), toggle Hippie mode.
* When called with a non-nil prefix argument (interactively) or t or a positive
  integer argument (non-interactively) enable Hippie mode.
* When called with a nil prefix argument (interactively) or 0 or a negative
  integer argument (non-interactively) disable Hippie mode.

Hippie mode is a global (i.e., not buffer-local) minor mode encapsulating the
Hippie system, from top to bottom. Enabling this minor mode also enables all
Hippie subfeatures; similarly, disabling this minor mode also disables all
Hippie subfeatures.

Hippie subfeatures can, themselves, be selectively enabled or disabled prior to
calling this function. By default, the following Hippie subfeatures are enabled:

* `hippie-feature-manager'.
* `hippie-theme'.
* `hippie-eclipse'.
* `hippie-project'.
* `hippie-modes'.
* `hippie-mode-map'.

Note that Eclipse emulation via `hippie-eclipse' is enabled by default but that
Vi(M) emulation via `hippie-vi' is not enabled by default. You may correct this
by setting appropriate variables prior to calling this function, like so:

  (setq hippie-eclipse nil
        hippie-vi t)
  (hippie-mode t)

\\{hippie-mode-map}

\(fn &optional ARG)" t nil)

;;;***

;;;### (autoloads (hippie-tags/tables-rebuild hippie-tags/tables-add-path)
;;;;;;  "hippie-tags" "hippie-tags.el" (18980 33732))
;;; Generated autoloads from hippie-tags.el

(autoload 'hippie-tags/tables-add-path "hippie-tags" "\
Add PATH to `tags-table-list', if that path has not already been added.

`hippie-tags' recursively scans all source code-resembling files (as matched by
`hippie-tags/filename-suffixes') under that path, when rebuilding tags via
`hippie-tags/tables-rebuild'. As `hippie-tags' calls that function,
automatically, whenever you call a function for which the desired tag is not
found, this has the devilish effect of ensuring that that path is recursively,
automatically indexed for all tags as needed to find that tag.

Calling this function with the root of a source-code tree ensures that
`hippie-tags' auto-indexes all tags for all files in that tree, as needed.

\(fn PATH)" nil nil)

(autoload 'hippie-tags/tables-rebuild "hippie-tags" "\
Rebuild all TAGS tables as listed by the `tags-table-list'.

When the current buffer is associated with a filename, this function
automatically adds that filename's path to the `tags-table-list' (if not already
added). Thus, this recursively, automatically indexes all tags under the current
path.

When the optional argument INTERACTIVE-P is non-nil, this function interactively
prompts the user for which TAGS table to rebuild, when `tags-table-list' and
`tags-file-name' are empty and the current buffer has no associate filename.

\(fn &optional INTERACTIVE-P)" t nil)

;;;***

;;;### (autoloads nil nil ("hippie-autoloads-contrib.el" "hippie-eclipse.el"
;;;;;;  "hippie-feature-manager.el" "hippie-feature-undoable.el"
;;;;;;  "hippie-feature-undoless.el" "hippie-feature.el" "hippie-mode-map.el"
;;;;;;  "hippie-modes-major.el" "hippie-modes.el" "hippie-project.el"
;;;;;;  "hippie-server.el" "hippie-theme.el" "hippie-vi.el") (18998
;;;;;;  11719 944037))

;;;***

(provide 'hippie-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; hippie-autoloads.el ends here