;ELC   
;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:39:47 2003
;;; from file /home/pot/gnu/emacs-pretest.new/lisp/emulation/viper-init.el
;;; in Emacs version 21.3
;;; with bytecomp version 2.85.4.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.
(if (and (boundp 'emacs-version)
	 (< (aref emacs-version (1- (length emacs-version))) ?A)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.29")))
    (error "`viper-init.el' was compiled for Emacs 19.29 or later"))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\301\302!\210\303B\304B\305B\306B\307B\310B\311B\312B\313B\301\207" [current-load-list provide viper-init mark-even-if-inactive quail-mode iso-accents-mode viper-current-state viper-version viper-expert-level current-input-method default-input-method describe-current-input-method-function] 2)
(defalias 'viper-version #[nil "\301\302\"\207" [viper-version message "Viper version is %s"] 3 nil nil])
(byte-code "\302B\304\305	\"\303B\n?\302\207" [current-load-list emacs-version viper-xemacs-p viper-emacs-p string-match "XEmacs"] 3)
(defalias 'viper-device-type #[nil "\203 	\207\302\303 !\207" [viper-emacs-p window-system device-type selected-device] 2])
(put 'viper-device-type 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'viper-window-display-p #[nil "\203 	\202\f \302\303 !\205 \203 	\202 \302\303 !\304>?\207" [viper-emacs-p window-system device-type selected-device (tty stream pc)] 2])
#@74 Tells if Emacs is running under an MS-style OS: ms-dos, windows-nt, W95.
(custom-declare-variable 'viper-ms-style-os-p '(memq system-type '(ms-dos windows-nt windows-95)) '(#$ . 1584) :type 'boolean :tag "Is it Microsoft-made OS?" :group 'viper-misc)
#@38 Tells if Emacs is running under VMS.
(custom-declare-variable 'viper-vms-os-p '(memq system-type '(vax-vms axp-vms)) '(#$ . 1841) :type 'boolean :tag "Is it VMS?" :group 'viper-misc)
#@250 If t, Viper will think that it is running on a display that supports faces.
This is provided as a temporary relief for users of graphics-capable terminals
that Viper doesn't know about.
In all likelihood, you don't need to bother with this setting.
(custom-declare-variable 'viper-force-faces 'nil '(#$ . 2031) :type 'boolean :group 'viper-highlighting)
(defalias 'viper-has-face-support-p #[nil "\304 \206. \206. 	\203 	\203 \n\202 \305\306 !\307>\207\205. 	\203( \n\202, \305\306 !\310>\207" [viper-force-faces viper-emacs-p window-system viper-xemacs-p viper-window-display-p device-type selected-device (pc) (tty pc)] 2])
(defalias 'viper-deflocalvar '(macro . #[(var default-value &optional documentation) "\303\304	\305\306\n\"F\307\310DDE\207" [var default-value documentation progn defvar format "%s\n(buffer local)" make-variable-buffer-local quote] 7]))
(defalias 'viper-loop '(macro . #[(count &rest body) "\302\300DC\303\304\305	\306\"BBE\207" [count body let while (> count 0) append ((setq count (1- count)))] 7]))
(defalias 'viper-buffer-live-p '(macro . #[(buf) "\301\302D\303\302DDF\207" [buf and get-buffer buffer-name] 6]))
(defalias 'viper-kbd-buf-alist '(macro . #[(macro-elt) "\301\302E\207" [macro-elt nth 1] 3]))
(defalias 'viper-kbd-buf-pair '(macro . #[(macro-elt) "\301\302\303DE\207" [macro-elt assoc (buffer-name) viper-kbd-buf-alist] 4]))
(defalias 'viper-kbd-buf-definition '(macro . #[(macro-elt) "\301\302DD\207" [macro-elt cdr viper-kbd-buf-pair] 3]))
(defalias 'viper-kbd-mode-alist '(macro . #[(macro-elt) "\301\302E\207" [macro-elt nth 2] 3]))
(defalias 'viper-kbd-mode-pair '(macro . #[(macro-elt) "\301\302\303DE\207" [macro-elt assoc major-mode viper-kbd-mode-alist] 4]))
(defalias 'viper-kbd-mode-definition '(macro . #[(macro-elt) "\301\302DD\207" [macro-elt cdr viper-kbd-mode-pair] 3]))
(defalias 'viper-kbd-global-pair '(macro . #[(macro-elt) "\301\302E\207" [macro-elt nth 3] 3]))
(defalias 'viper-kbd-global-definition '(macro . #[(macro-elt) "\301\302DD\207" [macro-elt cdr viper-kbd-global-pair] 3]))
(defalias 'viper-seq-last-elt #[(seq) "\211GS\234\207" [seq] 2])
(put 'viper-seq-last-elt 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'viper-string-to-list #[(string) "\301\302!\303\"\207" [string append vconcat nil] 3])
(put 'viper-string-to-list 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'viper-charlist-to-string #[(list) "\301\302\303#\207" [list mapconcat char-to-string ""] 4])
(put 'viper-charlist-to-string 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'viper-char-at-pos #[(direction &optional offset) "\250\204 \302	\303=\203 `\\f\207`ZSf\207" [offset direction 0 forward] 2])
(byte-code "\301B\304\301!\204\f \305\302B\304\302!\204 \306\303B\304\303!\204$ \307\301\207" [current-load-list viper-minibuffer-overlay-priority viper-replace-overlay-priority viper-search-overlay-priority boundp 300 400 500] 2)
#@20 nil
(buffer local)
(defvar viper-vi-intercept-minor-mode nil (#$ . 4976))
(make-variable-buffer-local 'viper-vi-intercept-minor-mode)
#@52 Viper's minor mode for Vi bindings.
(buffer local)
(defvar viper-vi-basic-minor-mode nil (#$ . 5116))
(make-variable-buffer-local 'viper-vi-basic-minor-mode)
#@82 Auxiliary minor mode for user-defined local bindings in Vi state.
(buffer local)
(defvar viper-vi-local-user-minor-mode nil (#$ . 5280))
(make-variable-buffer-local 'viper-vi-local-user-minor-mode)
#@83 Auxiliary minor mode for user-defined global bindings in Vi state.
(buffer local)
(defvar viper-vi-global-user-minor-mode nil (#$ . 5484))
(make-variable-buffer-local 'viper-vi-global-user-minor-mode)
#@86 Minor mode used to make major-mode-specific modification to Vi state.
(buffer local)
(defvar viper-vi-state-modifier-minor-mode nil (#$ . 5691))
(make-variable-buffer-local 'viper-vi-state-modifier-minor-mode)
#@81 This minor mode is in effect when the user wants Viper to be Vi.
(buffer local)
(defvar viper-vi-diehard-minor-mode nil (#$ . 5907))
(make-variable-buffer-local 'viper-vi-diehard-minor-mode)
#@154 Minor mode for Ex command macros in Vi state.
The corresponding keymap stores key bindings of Vi macros defined with
the Ex command :map.
(buffer local)
(defvar viper-vi-kbd-minor-mode nil (#$ . 6105))
(make-variable-buffer-local 'viper-vi-kbd-minor-mode)
#@20 nil
(buffer local)
(defvar viper-insert-intercept-minor-mode nil (#$ . 6367))
(make-variable-buffer-local 'viper-insert-intercept-minor-mode)
#@64 Viper's minor mode for bindings in Insert mode.
(buffer local)
(defvar viper-insert-basic-minor-mode nil (#$ . 6515))
(make-variable-buffer-local 'viper-insert-basic-minor-mode)
#@188 Auxiliary minor mode for buffer-local user-defined bindings in Insert state.
This is a way to overshadow normal Insert mode bindings locally to certain
designated buffers.
(buffer local)
(defvar viper-insert-local-user-minor-mode nil (#$ . 6700))
(make-variable-buffer-local 'viper-insert-local-user-minor-mode)
#@87 Auxiliary minor mode for global user-defined bindings in Insert state.
(buffer local)
(defvar viper-insert-global-user-minor-mode nil (#$ . 7018))
(make-variable-buffer-local 'viper-insert-global-user-minor-mode)
#@90 Minor mode used to make major-mode-specific modification to Insert state.
(buffer local)
(defvar viper-insert-state-modifier-minor-mode nil (#$ . 7237))
(make-variable-buffer-local 'viper-insert-state-modifier-minor-mode)
#@103 Minor mode that simulates Vi very closely.
Not recommened, except for the novice user.
(buffer local)
(defvar viper-insert-diehard-minor-mode nil (#$ . 7466))
(make-variable-buffer-local 'viper-insert-diehard-minor-mode)
#@156 Minor mode for Ex command macros Insert state.
The corresponding keymap stores key bindings of Vi macros defined with
the Ex command :map!.
(buffer local)
(defvar viper-insert-kbd-minor-mode nil (#$ . 7694))
(make-variable-buffer-local 'viper-insert-kbd-minor-mode)
#@86 Minor mode in effect in replace state (cw, C, and the like commands).
(buffer local)
(defvar viper-replace-minor-mode nil (#$ . 7966))
(make-variable-buffer-local 'viper-replace-minor-mode)
#@20 nil
(buffer local)
(defvar viper-emacs-intercept-minor-mode nil (#$ . 8162))
(make-variable-buffer-local 'viper-emacs-intercept-minor-mode)
#@155 Minor mode for local user bindings effective in Emacs state.
Users can use it to override Emacs bindings when Viper is in its Emacs
state.
(buffer local)
(defvar viper-emacs-local-user-minor-mode nil (#$ . 8309))
(make-variable-buffer-local 'viper-emacs-local-user-minor-mode)
#@156 Minor mode for global user bindings in effect in Emacs state.
Users can use it to override Emacs bindings when Viper is in its Emacs
state.
(buffer local)
(defvar viper-emacs-global-user-minor-mode nil (#$ . 8593))
(make-variable-buffer-local 'viper-emacs-global-user-minor-mode)
#@224 Minor mode for Vi style macros in Emacs state.
The corresponding keymap stores key bindings of Vi macros defined with
`viper-record-kbd-macro' command.  There is no Ex-level command to do this
interactively.
(buffer local)
(defvar viper-emacs-kbd-minor-mode nil (#$ . 8880))
(make-variable-buffer-local 'viper-emacs-kbd-minor-mode)
#@186 Minor mode used to make major-mode-specific modification to Emacs state.
For instance, a Vi purist may want to bind `dd' in Dired mode to a function
that deletes a file.
(buffer local)
(defvar viper-emacs-state-modifier-minor-mode nil (#$ . 9219))
(make-variable-buffer-local 'viper-emacs-state-modifier-minor-mode)
#@84 Minor mode that forces Vi-style when the Minibuffer is in Vi state.
(buffer local)
(defvar viper-vi-minibuffer-minor-mode nil (#$ . 9541))
(make-variable-buffer-local 'viper-vi-minibuffer-minor-mode)
#@88 Minor mode that forces Vi-style when the Minibuffer is in Insert state.
(buffer local)
(defvar viper-insert-minibuffer-minor-mode nil (#$ . 9747))
(make-variable-buffer-local 'viper-insert-minibuffer-minor-mode)
#@2 
(defconst viper-SpuriousText "Spurious text after command" (#$ . 9964))
#@2 
(defconst viper-BadExCommand "Not an editor command" (#$ . 10042))
#@2 
(defconst viper-InvalidCommandArgument "Invalid command argument" (#$ . 10115))
#@2 
(defconst viper-NoPrevSearch "No previous search string" (#$ . 10201))
#@2 
(defconst viper-EmptyRegister "`%c': Nothing in this register" (#$ . 10278))
#@2 
(defconst viper-InvalidRegister "`%c': Invalid register" (#$ . 10361))
#@2 
(defconst viper-EmptyTextmarker "`%c': Text marker doesn't point anywhere" (#$ . 10438))
#@2 
(defconst viper-InvalidTextmarker "`%c': Invalid text marker" (#$ . 10533))
#@2 
(defconst viper-InvalidViCommand "Invalid command" (#$ . 10615))
#@2 
(defconst viper-BadAddress "Ill-formed address" (#$ . 10686))
#@2 
(defconst viper-FirstAddrExceedsSecond "First address exceeds second" (#$ . 10754))
#@2 
(defconst viper-NoFileSpecified "No file specified" (#$ . 10844))
(byte-code "\301B\302\301!\204\f \303\301\207" [current-load-list viper-first-time boundp t] 2)
#@341 User's expert level.
The minor mode viper-vi-diehard-minor-mode is in effect when
viper-expert-level is 1 or 2 or when viper-want-emacs-keys-in-vi is t.
The minor mode viper-insert-diehard-minor-mode is in effect when
viper-expert-level is 1 or 2 or if viper-want-emacs-keys-in-insert is t.
Use `M-x viper-set-expert-level' to change this.
(defvar viper-expert-level (byte-code "\301\300!\203 \207\302\207" [viper-expert-level boundp 0] 2) (#$ . 11017))
(byte-code "\301B\302\301\207" [current-load-list viper-max-expert-level 5] 2)
#@17 
(buffer local)
(defvar viper-automatic-iso-accents nil (#$ . 11561))
(make-variable-buffer-local 'viper-automatic-iso-accents)
(defalias 'viper-set-iso-accents-mode #[(arg) "\302\301!\205	 \211\207" [arg iso-accents-mode boundp] 2])
(byte-code "\302\303\304\305#\210\301B\306\301!\204 \307\302\207" [current-load-list viper-mule-hook-flag put viper-set-iso-accents-mode byte-optimizer byte-compile-inline-expand boundp t] 4)
#@17 
(buffer local)
(defvar viper-special-input-method nil (#$ . 11999))
(make-variable-buffer-local 'viper-special-input-method)
(defalias 'viper-activate-input-method-action #[nil "\205- \305\n\306=\203 \307\310!\210\n\311>\205- \312\313\204  \f\203+ \314\315\206' \f\"\202, \316\"\207" [viper-mule-hook-flag viper-special-input-method viper-current-state current-input-method default-input-method t vi-state viper-set-input-method nil (vi-state insert-state replace-state) message "Viper special input method%s: on" format " %S" ""] 5])
(defalias 'viper-inactivate-input-method-action #[nil "\205# \305\n\306>\205# \307\310\204 \f\203! \311\312\206 \f\"\202\" \313\"\207" [viper-mule-hook-flag viper-special-input-method viper-current-state current-input-method default-input-method nil (vi-state insert-state replace-state) message "Viper special input method%s: off" format " %S" ""] 5])
(defalias 'viper-inactivate-input-method #[nil "\203 \305\306!\203 \306 \207	\205, \307\304!\205, \310\311\312!\203\" \313 \210\310\310\314\315!\210\316 \207" [viper-emacs-p viper-xemacs-p quail-mode describe-current-input-method-function current-input-method fboundp inactivate-input-method boundp nil featurep quail quail-delete-overlays run-hooks input-method-inactivate-hook force-mode-line-update] 2])
(defalias 'viper-activate-input-method #[nil "\203 \303\304!\203 \304	!\207\n\205 \303\305!\205 \305\306!\207" [viper-emacs-p default-input-method viper-xemacs-p fboundp activate-input-method quail-mode 1] 2])
(defalias 'viper-set-input-method #[(arg) "\303\304	\203 \305	!\306V\203 \n\203 \307 \202 \310 )\207" [viper-mule-hook-flag arg default-input-method t nil prefix-numeric-value 0 viper-activate-input-method viper-inactivate-input-method] 2])
#@20 nil
(buffer local)
(defvar viper-undo-needs-adjustment nil (#$ . 13780))
(byte-code "\302\303!\210\304\303\305\306#\210\301B\307\302\207" [current-load-list viper-buffer-undo-list-mark make-variable-buffer-local viper-undo-needs-adjustment put permanent-local t viper] 4)
#@154 *Non-nil means not to move point while undoing commands.
This style is different from Emacs and Vi.  Try it to see if
it better fits your working style.
(custom-declare-variable 'viper-keep-point-on-undo 'nil '(#$ . -14062) :type 'boolean :tag "Preserve Position of Point After Undo" :group 'viper)
#@17 
(buffer local)
(defvar viper-intermediate-command nil (#$ . 14367))
(byte-code "\302\303!\210\301B\304\304\207" [current-load-list viper-this-command-keys make-variable-buffer-local viper-intermediate-command nil] 2)
#@17 
(buffer local)
(defvar viper-began-as-replace nil (#$ . 14594))
(make-variable-buffer-local 'viper-began-as-replace)
#@222 If non-nil, Viper will allow multi-line replace regions.
This is an extension to standard Vi.
If nil, commands that attempt to replace text spanning multiple lines first
delete the text being replaced, as in standard Vi.
(custom-declare-variable 'viper-allow-multiline-replace-regions 't '(#$ . 14719) :type 'boolean :group 'viper)
#@47 *Cursor color when Viper is in Replace state.
(custom-declare-variable 'viper-replace-overlay-cursor-color '"Red" '(#$ . -15057) :type 'string :group 'viper)
#@45 Cursor color when Viper is in insert state.
(custom-declare-variable 'viper-insert-state-cursor-color '"Green" '(#$ . 15221) :type 'string :group 'viper)
(byte-code "\301B\302\301!\204\f \303\303\207" [current-load-list viper-vi-state-cursor-color boundp nil] 2)
#@17 
(buffer local)
(defvar viper-replace-overlay nil (#$ . 15493))
(byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local viper-replace-overlay put permanent-local t] 4)
#@132 A string marking the end of replacement regions.
It is used only with TTYs or if `viper-use-replace-region-delimiters'
is non-nil.
(custom-declare-variable 'viper-replace-region-end-delimiter '"$" '(#$ . 15688) :type 'string :group 'viper)
#@138 A string marking the beginning of replacement regions.
It is used only with TTYs or if `viper-use-replace-region-delimiters'
is non-nil.
(custom-declare-variable 'viper-replace-region-start-delimiter '"" '(#$ . 15935) :type 'string :group 'viper)
#@223 *If non-nil, Viper will always use `viper-replace-region-end-delimiter' and
`viper-replace-region-start-delimiter' to delimit replacement regions, even on
color displays.  By default, the delimiters are used only on TTYs.
(custom-declare-variable 'viper-use-replace-region-delimiters '(or (not (viper-has-face-support-p)) (and viper-xemacs-p (eq (viper-device-type) 'tty))) '(#$ . -16189) :type 'boolean :group 'viper)
#@59 Function to use for prompting the user for a buffer name.
(custom-declare-variable 'viper-read-buffer-function ''read-buffer '(#$ . 16614) :type 'symbol :group 'viper)
(byte-code "\203 \303	!\204 \304	!\303\n!\204 \304\n!\303\207" [viper-xemacs-p viper-replace-region-end-delimiter viper-replace-region-start-delimiter glyphp make-glyph] 2)
#@20 nil
(buffer local)
(defvar viper-last-posn-in-replace-region nil (#$ . 16967))
(make-variable-buffer-local 'viper-last-posn-in-replace-region)
#@20 nil
(buffer local)
(defvar viper-last-posn-while-in-insert-state nil (#$ . 17116))
(byte-code "\300\301!\210\302\303\304\305#\210\302\301\304\305#\207" [make-variable-buffer-local viper-last-posn-while-in-insert-state put viper-last-posn-in-replace-region permanent-local t] 4)
#@17 
(buffer local)
(defvar viper-sitting-in-replace nil (#$ . 17400))
(byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local viper-sitting-in-replace put permanent-local t] 4)
#@17 
(buffer local)
(defvar viper-replace-chars-to-delete 0 (#$ . 17600))
(make-variable-buffer-local 'viper-replace-chars-to-delete)
#@17 
(buffer local)
(defvar viper-replace-region-chars-deleted 0 (#$ . 17736))
(make-variable-buffer-local 'viper-replace-region-chars-deleted)
#@123 The size of history of inserted text.
This is a list where Viper keeps the history of previously inserted pieces of
text.
(custom-declare-variable 'viper-insertion-ring-size '14 '(#$ . 17883) :type 'integer :group 'viper-misc)
(byte-code "\301B\304\301!\204\f \305\302B\304\302!\204 \305\303B\304\303!\204$ \306\305\207" [current-load-list viper-insertion-ring viper-temp-insertion-ring viper-last-inserted-string-from-insertion-ring boundp nil ""] 2)
#@57 The size of history of Vi commands repeatable with dot.
(custom-declare-variable 'viper-command-ring-size '14 '(#$ . 18351) :type 'integer :group 'viper-misc)
(byte-code "\301B\303\301!\204\f \304\302B\303\302!\204 \304\304\207" [current-load-list viper-command-ring viper-temp-command-ring boundp nil] 2)
#@250 *Key sequence separated by no more than this many milliseconds is viewed as a Vi-style macro, if such a macro is defined.
Setting this too high may slow down your typing.  Setting this value too low
will make it hard to use Vi-style timeout macros.
(custom-declare-variable 'viper-fast-keyseq-timeout '200 '(#$ . -18671) :type 'integer :group 'viper-misc)
#@324 *Key sequence beginning with ESC and separated by no more than this many milliseconds is considered to be generated by a keyboard function key.
Setting this too high may slow down switching from insert to vi state.  Setting
this value too low will make it impossible to use function keys in insert mode
on a dumb terminal.
(custom-declare-variable 'viper-ESC-keyseq-timeout '(if (viper-window-display-p) 0 viper-fast-keyseq-timeout) '(#$ . -19034) :type 'integer :group 'viper-misc)
#@620 Allow translation of all key sequences into commands.
Normally, Viper lets Emacs translate only those ESC key sequences that are
defined in the low-level key-translation-map or function-key-map, such as those
emitted by the arrow and function keys. Other sequences, e.g., \e/, are
treated as ESC command followed by a `/'. This is done for people who type fast
and tend to hit other characters right after they hit ESC. Other people like
Emacs to translate ESC sequences all the time. 
The default is to translate all sequences only when using a dumb terminal.
This permits you to use ESC as a meta key in insert mode.
(custom-declare-variable 'viper-translate-all-ESC-keysequences '(not (viper-window-display-p)) '(#$ . 19524) :type 'boolean :group 'viper-misc)
#@20 nil
(buffer local)
(defvar viper-current-state 'emacs-state (#$ . 20293))
(make-variable-buffer-local 'viper-current-state)
#@17 
(buffer local)
(defvar viper-cted nil (#$ . 20423))
(make-variable-buffer-local 'viper-cted)
#@20 nil
(buffer local)
(defvar viper-current-indent 0 (#$ . 20523))
(make-variable-buffer-local 'viper-current-indent)
#@20 nil
(buffer local)
(defvar viper-preserve-indent nil (#$ . 20644))
(make-variable-buffer-local 'viper-preserve-indent)
#@17 
(buffer local)
(defvar viper-auto-indent nil (#$ . 20769))
(make-variable-buffer-local 'viper-auto-indent)
#@60 *Enable autoindent, if t.
This is a buffer-local variable.
(custom-declare-variable 'viper-auto-indent 'nil '(#$ . -20883) :type 'boolean :group 'viper)
#@17 
(buffer local)
(defvar viper-electric-mode t (#$ . 21042))
(make-variable-buffer-local 'viper-electric-mode)
#@311 *If t, electrify Viper.
Currently, this only electrifies auto-indentation, making it appropriate to the
mode of the buffer.
This means that auto-indentation will depart from standard Vi and will indent
appropriate to the mode of the buffer.  This is especially useful for editing
programs and LaTeX documents.
(custom-declare-variable 'viper-electric-mode 't '(#$ . -21159) :type 'boolean :group 'viper)
#@126 *The value of the shiftwidth.
This determines the number of columns by which the Ctl-t moves the cursor in
the Insert state.
(custom-declare-variable 'viper-shift-width '8 '(#$ . -21570) :type 'integer :group 'viper)
#@238 *If t, don't move point when repeating previous command.
This is useful for doing repeated changes with the '.' key.
The user can change this to nil, if she likes when the cursor moves
to a new place after repeating previous Vi command.
(custom-declare-variable 'viper-keep-point-on-repeat 't '(#$ . -21794) :type 'boolean :group 'viper)
#@20 nil
(buffer local)
(defvar viper-insert-point nil (#$ . 22138))
(byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local viper-insert-point put permanent-local t] 4)
#@20 nil
(buffer local)
(defvar viper-pre-command-point nil (#$ . 22329))
(byte-code "\303\304!\210\305\304\306\307#\210\301B\310\301!\204 \311\302B\310\302!\204\" \312\311\207" [current-load-list viper-last-insertion viper-last-replace-region make-variable-buffer-local viper-pre-command-point put permanent-local t boundp nil ""] 4)
#@20 nil
(buffer local)
(defvar viper-com-point nil (#$ . 22672))
(byte-code "\306\307!\210\301B\310\301!\204 \311\302B\310\302!\204 \311\303B\310\303!\204( \311\312\313\311\314\315\316\317\320&\210\304B\310\304!\204? \311\305B\310\305!\204K \311\321B\310\321!\204X \311\322B\310\322!\204e \311\323B\310\323!\204r \324\311\207" [current-load-list viper-d-com viper-d-char viper-use-register viper-f-char viper-F-char make-variable-buffer-local viper-com-point boundp nil custom-declare-group viper-search "Variables that define the search and query-replace behavior of Viper." :prefix "viper-" :group viper viper-f-forward viper-f-offset viper-s-string ""] 8)
#@52 String inserted at the beginning of quoted region.
(custom-declare-variable 'viper-quote-string '"> " '(#$ . 23363) :type 'string :group 'viper)
(byte-code "\301B\302\301!\204\f \303\303\207" [current-load-list viper-s-forward boundp nil] 2)
#@36 *If not nil, search ignores cases.
(custom-declare-variable 'viper-case-fold-search 'nil '(#$ . -23614) :type 'boolean :group 'viper-search)
#@65 *If not nil, search is regexp search, otherwise vanilla search.
(custom-declare-variable 'viper-re-search 't '(#$ . -23761) :type 'boolean :tag "Regexp Search" :group 'viper-search)
#@233 *If search lands within this threshnold from the window top/bottom,
the window will be scrolled up or down appropriately, to reveal context.
If you want Viper search to behave as usual in Vi, set this variable to a
negative number.
(custom-declare-variable 'viper-search-scroll-threshold '2 '(#$ . -23950) :type 'boolean :group 'viper-search)
#@62 *If t then do regexp replace, if nil then do string replace.
(custom-declare-variable 'viper-re-query-replace 't '(#$ . -24299) :type 'boolean :tag "Regexp Query Replace" :group 'viper-search)
#@57 *If t, do regexp replace.  nil means do string replace.
(custom-declare-variable 'viper-re-replace 't '(#$ . -24498) :type 'boolean :tag "Regexp Replace" :group 'viper-search)
#@64 *If t, `%' ignores the parentheses that occur inside comments.
(custom-declare-variable 'viper-parse-sexp-ignore-comments 't '(#$ . -24680) :type 'boolean :group 'viper)
#@17 
(buffer local)
(defvar viper-ex-style-motion t (#$ . 24856))
(make-variable-buffer-local 'viper-ex-style-motion)
#@107 *If t, the commands l,h do not cross lines, etc (Ex-style).
If nil, these commands cross line boundaries.
(custom-declare-variable 'viper-ex-style-motion 't '(#$ . -24977) :type 'boolean :group 'viper)
#@17 
(buffer local)
(defvar viper-ex-style-editing t (#$ . 25185))
(make-variable-buffer-local 'viper-ex-style-editing)
#@402 *If t, Ex-style behavior while editing in Vi command and insert states.
`Backspace' and `Delete' don't cross line boundaries in insert.
`X' and `x' can't delete characters across line boundary in Vi, etc.
Note: this doesn't preclude `Backspace' and `Delete' from deleting characters
by moving past the insertion point.  This is a feature, not a bug.

If nil, the above commands can work across lines.
(custom-declare-variable 'viper-ex-style-editing 't '(#$ . -25308) :type 'boolean :group 'viper)
#@17 
(buffer local)
(defvar viper-ESC-moves-cursor-back viper-ex-style-editing (#$ . 25812))
(make-variable-buffer-local 'viper-ESC-moves-cursor-back)
#@125 *If t, ESC moves cursor back when changing from insert to vi state.
If nil, the cursor stays where it was when ESC was hit.
(custom-declare-variable 'viper-ESC-moves-cursor-back 'nil '(#$ . -25966) :type 'boolean :group 'viper)
#@17 
(buffer local)
(defvar viper-delete-backwards-in-replace nil (#$ . 26200))
(make-variable-buffer-local 'viper-delete-backwards-in-replace)
#@140 *If t, DEL key will delete characters while moving the cursor backwards.
If nil, the cursor will move backwards without deleting anything.
(custom-declare-variable 'viper-delete-backwards-in-replace 'nil '(#$ . -26347) :type 'boolean :group 'viper)
#@70 *Key used for buffer-searching.  Must be a character type, e.g., ?g.
(custom-declare-variable 'viper-buffer-search-char 'nil '(#$ . -26602) :type '(choice (const nil) character) :group 'viper-search)
#@29 *If t, search wraps around.
(custom-declare-variable 'viper-search-wrap-around-t 't '(#$ . -26808) :type 'boolean :tag "Search Wraps Around" :group 'viper-search)
#@17 
(buffer local)
(defvar viper-related-files-and-buffers-ring nil (#$ . 26977))
(make-variable-buffer-local 'viper-related-files-and-buffers-ring)
#@151 *List of file and buffer names that are considered to be related to the current buffer.
Related buffers can be cycled through via :R and :P commands.
(custom-declare-variable 'viper-related-files-and-buffers-ring 'nil '(#$ . -27130) :type 'boolean :group 'viper-misc)
(put 'viper-related-files-and-buffers-ring 'permanent-local t)
#@20 nil
(buffer local)
(defvar viper-local-search-start-marker nil (#$ . 27467))
(byte-code "\302\303!\210\301B\304\301!\204 \305 \302\207" [current-load-list viper-search-start-marker make-variable-buffer-local viper-local-search-start-marker boundp make-marker] 2)
#@20 nil
(buffer local)
(defvar viper-search-overlay nil (#$ . 27740))
(make-variable-buffer-local 'viper-search-overlay)
#@44 *Regexps for Headings.  Used by [[ and ]].
(defvar viper-heading-start "^\\s-*(\\s-*defun\\s-\\|^{\\s-*$\\|^[_a-zA-Z][^()]*[()].*{\\s-*$\\|^\\s-*class.*{\\|^\\s-*struct.*{\\|^\\s-*enum.*{\\|^\\\\[sb][a-z]*{.*}\\s-*$\\|^@node\\|@table\\|^@m?enu\\|^@itemize\\|^@if\\|^.+:-" (#$ . -27863))
#@49 *Regexps to end Headings/Sections.  Used by [].
(defvar viper-heading-end "^}\\|^\\\\end{\\|^@end \\|)\n\n[ 	\n]*\\|\\.\\s-*$" (#$ . -28156))
#@20 nil
(buffer local)
(defvar viper-last-jump nil (#$ . 28304))
(make-variable-buffer-local 'viper-last-jump)
#@20 nil
(buffer local)
(defvar viper-last-jump-ignore 0 (#$ . 28417))
(byte-code "\306\307!\210\301B\310\301!\204 \311C\302B\310\302!\204 \312\303B\310\303!\204) \312\305B\310\305!\2046 \fC\313B\310\313!\204C \312\314B\310\314!\204P \312\f\315B\310\315!\204] \312\312\207" [current-load-list viper-search-history viper-replace1-history viper-replace2-history viper-quote-string viper-quote-region-history make-variable-buffer-local viper-last-jump-ignore boundp "" nil viper-ex-history viper-shell-history viper-last-shell-com] 2)
(defalias 'viper-hide-face #[(face) "\302 \205 \205 \303\304	\"\207" [viper-emacs-p face viper-has-face-support-p add-to-list facemenu-unlisted-faces] 3])
(byte-code "\300\301\302\303\304\305\306\307&\210\310\311\312\313\306\301%\207" [custom-declare-group viper-highlighting nil "Hilighting of replace region, search pattern, minibuffer, etc." :prefix "viper-" :group viper custom-declare-face viper-search-face ((((class color)) (:foreground "Black" :background "khaki")) (t (:underline t :stipple "gray3"))) "*Face used to flash out the search pattern."] 8)
#@194 Face used to flash out the search pattern.
DO NOT CHANGE this variable.  Instead, use the customization widget
to customize the actual face object `viper-search-face'
this variable represents.
(defvar viper-search-face 'viper-search-face (#$ . 29541))
(byte-code "\300\301!\210\302\303\304\305\306\307%\207" [viper-hide-face viper-search-face custom-declare-face viper-replace-overlay-face ((((class color)) (:foreground "Black" :background "darkseagreen2")) (t (:underline t :stipple "gray3"))) "*Face for highlighting replace regions on a window display." :group viper-highlighting] 6)
#@219 Face for highlighting replace regions on a window display.
DO NOT CHANGE this variable.  Instead, use the customization widget
to customize the actual face object `viper-replace-overlay-face'
this variable represents.
(defvar viper-replace-overlay-face 'viper-replace-overlay-face (#$ . 30136))
(byte-code "\300\301!\210\302\303\304\305\306\307%\207" [viper-hide-face viper-replace-overlay-face custom-declare-face viper-minibuffer-emacs-face ((((class color)) (:foreground "Black" :background "darkseagreen2")) (t (:bold t))) "Face used in the Minibuffer when it is in Emacs state." :group viper-highlighting] 6)
#@216 Face used in the Minibuffer when it is in Emacs state.
DO NOT CHANGE this variable.  Instead, use the customization widget
to customize the actual face object `viper-minibuffer-emacs-face'
this variable represents.
(defvar viper-minibuffer-emacs-face 'viper-minibuffer-emacs-face (#$ . 30757))
(byte-code "\300\301!\210\302\303\304\305\306\307%\207" [viper-hide-face viper-minibuffer-emacs-face custom-declare-face viper-minibuffer-insert-face ((((class color)) (:foreground "Black" :background "pink")) (t (:italic t))) "Face used in the Minibuffer when it is in Insert state." :group viper-highlighting] 6)
#@218 Face used in the Minibuffer when it is in Insert state.
DO NOT CHANGE this variable.  Instead, use the customization widget
to customize the actual face object `viper-minibuffer-insert-face'
this variable represents.
(defvar viper-minibuffer-insert-face 'viper-minibuffer-insert-face (#$ . 31373))
(byte-code "\300\301!\210\302\303\304\305\306\307%\207" [viper-hide-face viper-minibuffer-insert-face custom-declare-face viper-minibuffer-vi-face ((((class color)) (:foreground "DarkGreen" :background "grey")) (t (:inverse-video t))) "Face used in the Minibuffer when it is in Vi state." :group viper-highlighting] 6)
#@210 Face used in the Minibuffer when it is in Vi state.
DO NOT CHANGE this variable.  Instead, use the customization widget
to customize the actual face object `viper-minibuffer-vi-face'
this variable represents.
(defvar viper-minibuffer-vi-face 'viper-minibuffer-vi-face (#$ . 31997))
(viper-hide-face 'viper-minibuffer-vi-face)
#@17 
(buffer local)
(defvar viper-minibuffer-current-face viper-minibuffer-emacs-face (#$ . 32329))
(make-variable-buffer-local 'viper-minibuffer-current-face)
#@52 Whether Viper startup message should be inhibited.
(defvar viper-inhibit-startup-message nil (#$ . 32491))
#@51 Spell function used by #s<move> command to spell.
(custom-declare-variable 'viper-spell-function ''ispell-region '(#$ . 32604) :type 'function :group 'viper-misc)
#@30 The tags file used by Viper.
(custom-declare-variable 'viper-tags-file-name '"TAGS" '(#$ . 32773) :type 'string :group 'viper-misc)
#@283 Notify the user when this many lines or characters have been deleted/yanked.
For line-deleting/yanking commands (like `dd', `yy'), the value denotes the
number of lines.  For character-based commands (such as `x', `dw', etc.), the
value refers to the number of characters affected.
(custom-declare-variable 'viper-change-notification-threshold '1 '(#$ . 32912) :type 'integer :group 'viper-misc)
#@77 If t, use vi-style editing in minibuffer.
Should be set in `~/.viper' file.
(custom-declare-variable 'viper-vi-style-in-minibuffer 't '(#$ . 33314) :type 'boolean :group 'viper)
#@20 nil
(buffer local)
(defvar viper-minibuffer-overlay nil (#$ . 33498))
(byte-code "\302\303!\210\304\303\305\306#\210\301B\307\301!\204 \310\310\207" [current-load-list viper-minibuffer-exit-hook make-variable-buffer-local viper-minibuffer-overlay put permanent-local t boundp nil] 4)
#@49 Mode line tag identifying the Vi mode of Viper.
(defconst viper-vi-state-id "<V> " (#$ . 33792))
#@52 Mode line tag identifying the Emacs mode of Viper.
(defconst viper-emacs-state-id "<E> " (#$ . 33895))
#@53 Mode line tag identifying the Insert mode of Viper.
(defconst viper-insert-state-id "<I> " (#$ . 34004))
#@54 Mode line tag identifying the Replace mode of Viper.
(defconst viper-replace-state-id "<R> " (#$ . 34115))
(custom-declare-group 'viper-hooks nil "Viper hooks." :prefix "viper-" :group 'viper)
#@60 *Hooks run just before the switch to Vi mode is completed.
(custom-declare-variable 'viper-vi-state-hook ''viper-restore-cursor-type '(#$ . -34314) :type 'hook :group 'viper-hooks)
#@64 *Hooks run just before the switch to Insert mode is completed.
(custom-declare-variable 'viper-insert-state-hook ''viper-set-insert-cursor-type '(#$ . -34501) :type 'hook :group 'viper-hooks)
#@65 *Hooks run just before the switch to Replace mode is completed.
(custom-declare-variable 'viper-replace-state-hook ''viper-restore-cursor-type '(#$ . -34699) :type 'hook :group 'viper-hooks)
#@63 *Hooks run just before the switch to Emacs mode is completed.
(custom-declare-variable 'viper-emacs-state-hook ''viper-restore-cursor-type '(#$ . -34896) :type 'hook :group 'viper-hooks)
#@37 Hooks run just after loading Viper.
(custom-declare-variable 'viper-load-hook 'nil '(#$ . 35089) :type 'hook :group 'viper-hooks)
(defalias 'viper-restore-cursor-type #[nil "\300\301\302\217\207" [nil (byte-code "\203 \304\211\207\n\211\207" [viper-xemacs-p bar-cursor default-cursor-type cursor-type nil] 2) ((error))] 3])
(defalias 'viper-set-insert-cursor-type #[nil "\203 \303\211\207\304\211\207" [viper-xemacs-p bar-cursor cursor-type 2 (bar . 2)] 2])