1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
| | ;;; viper-init.el --- some common definitions for Viper
;; Copyright (C) 1997-2020 Free Software Foundation, Inc.
;; Author: Michael Kifer <kifer@cs.stonybrook.edu>
;; Package: viper
;; This file is part of GNU Emacs.
;; GNU Emacs 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 3 of the License, or
;; (at your option) any later version.
;; GNU Emacs 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. If not, see <https://www.gnu.org/licenses/>.
;;; Commentary:
;;; Code:
;; compiler pacifier
(defvar mark-even-if-inactive)
(defvar quail-mode)
(defvar iso-accents-mode)
(defvar viper-current-state)
(defvar viper-version)
(defvar viper-expert-level)
(defvar current-input-method)
(defvar default-input-method)
(defvar describe-current-input-method-function)
(defvar bar-cursor)
(defvar cursor-type)
;; end pacifier
;; Viper version
(defun viper-version ()
(interactive)
(message "Viper version is %s" viper-version))
;; Tell whether we are running as a window application or on a TTY
(define-obsolete-function-alias 'viper-device-type 'window-system "27.1")
(defun viper-color-display-p ()
(condition-case nil
(display-color-p)
(error nil)))
;; in XEmacs: device-type is tty on tty and stream in batch.
(defun viper-window-display-p ()
(and window-system (not (memq window-system '(tty stream pc)))))
(defcustom viper-ms-style-os-p (memq system-type '(ms-dos windows-nt))
"Non-nil if Emacs is running under an MS-style OS: MS-DOS, or MS-Windows."
:type 'boolean
:tag "Is it Microsoft-made OS?"
:group 'viper-misc)
(defcustom viper-suppress-input-method-change-message nil
"If t, the message notifying about changes in the input method is not displayed.
Normally, a message is displayed each time on enters the vi, insert or replace
state."
:type 'boolean
:group 'viper-misc)
(defcustom viper-force-faces nil
"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."
:type 'boolean
:group 'viper-highlighting)
(defun viper-has-face-support-p ()
(cond ((viper-window-display-p))
(viper-force-faces)
((viper-color-display-p))
(t (memq window-system '(pc)))))
\f
;;; Macros
(defmacro viper-deflocalvar (var default-value &optional documentation)
"Define VAR as a buffer-local variable.
DEFAULT-VALUE is the default value, and DOCUMENTATION is the
docstring. The variable becomes buffer-local whenever set."
(declare (indent defun))
`(progn
(defvar ,var ,default-value
,(format "%s\n(buffer local)" documentation))
(make-variable-buffer-local ',var)))
;; (viper-loop COUNT BODY) Execute BODY COUNT times.
(defmacro viper-loop (count &rest body)
(declare (indent defun))
`(let ((count ,count))
(while (> count 0)
,@body
(setq count (1- count)))))
(defmacro viper-buffer-live-p (buf)
`(and ,buf (get-buffer ,buf) (buffer-name (get-buffer ,buf))))
;; return buffer-specific macro definition, given a full macro definition
(defmacro viper-kbd-buf-alist (macro-elt)
`(nth 1 ,macro-elt))
;; get a pair: (curr-buffer . macro-definition)
(defmacro viper-kbd-buf-pair (macro-elt)
`(assoc (buffer-name) (viper-kbd-buf-alist ,macro-elt)))
;; get macro definition for current buffer
(defmacro viper-kbd-buf-definition (macro-elt)
`(cdr (viper-kbd-buf-pair ,macro-elt)))
;; return mode-specific macro definitions, given a full macro definition
(defmacro viper-kbd-mode-alist (macro-elt)
`(nth 2 ,macro-elt))
;; get a pair: (major-mode . macro-definition)
(defmacro viper-kbd-mode-pair (macro-elt)
`(assoc major-mode (viper-kbd-mode-alist ,macro-elt)))
;; get macro definition for the current major mode
(defmacro viper-kbd-mode-definition (macro-elt)
`(cdr (viper-kbd-mode-pair ,macro-elt)))
;; return global macro definition, given a full macro definition
(defmacro viper-kbd-global-pair (macro-elt)
`(nth 3 ,macro-elt))
;; get global macro definition from an elt of macro-alist
(defmacro viper-kbd-global-definition (macro-elt)
`(cdr (viper-kbd-global-pair ,macro-elt)))
;; last elt of a sequence
(defsubst viper-seq-last-elt (seq)
(elt seq (1- (length seq))))
(defsubst viper-string-to-list (string)
(append (vconcat string) nil))
(defsubst viper-charlist-to-string (list)
(mapconcat 'char-to-string list ""))
;; like char-after/before, but saves typing
(defun viper-char-at-pos (direction &optional offset)
(or (integerp offset) (setq offset 0))
(if (eq direction 'forward)
(char-after (+ (point) offset))
(char-before (- (point) offset))))
\f
(defvar viper-minibuffer-overlay-priority 300)
(defvar viper-replace-overlay-priority 400)
(defvar viper-search-overlay-priority 500)
\f
;;; Viper minor modes
;; Mode for vital things like \e, C-z.
(viper-deflocalvar viper-vi-intercept-minor-mode nil)
(viper-deflocalvar viper-vi-basic-minor-mode nil
"Viper's minor mode for Vi bindings.")
(viper-deflocalvar viper-vi-local-user-minor-mode nil
"Auxiliary minor mode for user-defined local bindings in Vi state.")
(viper-deflocalvar viper-vi-global-user-minor-mode nil
"Auxiliary minor mode for user-defined global bindings in Vi state.")
(viper-deflocalvar viper-vi-state-modifier-minor-mode nil
"Minor mode used to make major-mode-specific modification to Vi state.")
(viper-deflocalvar viper-vi-diehard-minor-mode nil
"This minor mode is in effect when the user wants Viper to be Vi.")
(viper-deflocalvar viper-vi-kbd-minor-mode nil
"Minor mode for Ex command macros in Vi state.
The corresponding keymap stores key bindings of Vi macros defined with
the Ex command :map.")
;; Mode for vital things like \e, C-z.
(viper-deflocalvar viper-insert-intercept-minor-mode nil)
(viper-deflocalvar viper-insert-basic-minor-mode nil
"Viper's minor mode for bindings in Insert mode.")
(viper-deflocalvar viper-insert-local-user-minor-mode nil
"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.")
(viper-deflocalvar viper-insert-global-user-minor-mode nil
"Auxiliary minor mode for global user-defined bindings in Insert state.")
(viper-deflocalvar viper-insert-state-modifier-minor-mode nil
"Minor mode used to make major-mode-specific modification to Insert state.")
(viper-deflocalvar viper-insert-diehard-minor-mode nil
"Minor mode that simulates Vi very closely.
Not recommended, except for the novice user.")
(viper-deflocalvar viper-insert-kbd-minor-mode nil
"Minor mode for Ex command macros Insert state.
The corresponding keymap stores key bindings of Vi macros defined with
the Ex command :map!.")
(viper-deflocalvar viper-replace-minor-mode nil
"Minor mode in effect in replace state (cw, C, and the like commands).")
;; Mode for vital things like \C-z and \C-x) This is set to t, when viper-mode
;; is invoked. So, any new buffer will have C-z defined as switch to Vi,
;; unless we switched states in this buffer
(viper-deflocalvar viper-emacs-intercept-minor-mode nil)
(viper-deflocalvar viper-emacs-local-user-minor-mode nil
"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.")
(viper-deflocalvar viper-emacs-global-user-minor-mode nil
"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.")
(viper-deflocalvar viper-emacs-kbd-minor-mode nil
"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.")
(viper-deflocalvar viper-emacs-state-modifier-minor-mode nil
"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.")
(viper-deflocalvar viper-vi-minibuffer-minor-mode nil
"Minor mode that forces Vi-style when the Minibuffer is in Vi state.")
(viper-deflocalvar viper-insert-minibuffer-minor-mode nil
"Minor mode that forces Vi-style when the Minibuffer is in Insert state.")
\f
;; Some common error messages
(defconst viper-SpuriousText "Spurious text after command" "")
(defconst viper-BadExCommand "Not an editor command" "")
(defconst viper-InvalidCommandArgument "Invalid command argument" "")
(defconst viper-NoPrevSearch "No previous search string" "")
(defconst viper-EmptyRegister "`%c': Nothing in this register" "")
(defconst viper-InvalidRegister "`%c': Invalid register" "")
(defconst viper-EmptyTextmarker "`%c': Text marker doesn't point anywhere" "")
(defconst viper-InvalidTextmarker "`%c': Invalid text marker" "")
(defconst viper-InvalidViCommand "Invalid command" "")
(defconst viper-BadAddress "Ill-formed address" "")
(defconst viper-FirstAddrExceedsSecond "First address exceeds second" "")
(defconst viper-NoFileSpecified "No file specified" "")
(defconst viper-ViperBell "Viper bell" "")
;; Is t until viper-mode executes for the very first time.
;; Prevents recursive descend into startup messages.
(defvar viper-first-time t)
(defvar viper-expert-level (if (boundp 'viper-expert-level) viper-expert-level 0)
"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 `\\[viper-set-expert-level]' to change this.")
;; Max expert level supported by Viper. This is NOT a user option.
;; It is here to make it hard for the user from resetting it.
(defconst viper-max-expert-level 5)
;;; ISO characters and MULE
;; If non-nil, ISO accents will be turned on in insert/replace emacs states and
;; turned off in vi-state. For some users, this behavior may be too
;; primitive. In this case, use insert/emacs/vi state hooks.
(viper-deflocalvar viper-automatic-iso-accents nil "")
;; Set iso-accents-mode to ARG. Check if it is bound first
(defsubst viper-set-iso-accents-mode (arg)
(if (boundp 'iso-accents-mode)
(setq iso-accents-mode arg)))
;; Internal flag used to control when viper mule hooks are run.
;; Don't change this!
(defvar viper-mule-hook-flag t)
;; If non-nil, the default intl. input method is turned on.
(viper-deflocalvar viper-special-input-method nil "")
;; viper hook to run on input-method activation
(defun viper-activate-input-method-action ()
(if (null viper-mule-hook-flag)
()
(setq viper-special-input-method t)
;; turn off special input methods in vi-state
(if (eq viper-current-state 'vi-state)
(viper-set-input-method nil))
(if (and (memq viper-current-state '(vi-state insert-state replace-state))
(not viper-suppress-input-method-change-message))
(message "Viper special input method%s: on"
(if (or current-input-method default-input-method)
(format " %S"
(or current-input-method default-input-method))
"")))
))
;; viper hook to run on input-method deactivation
(defun viper-deactivate-input-method-action ()
(if (null viper-mule-hook-flag)
()
(setq viper-special-input-method nil)
(if (and (memq viper-current-state '(vi-state insert-state replace-state))
(not viper-suppress-input-method-change-message))
(message "Viper special input method%s: off"
(if (or current-input-method default-input-method)
(format " %S"
(or current-input-method default-input-method))
"")))))
(define-obsolete-function-alias 'viper-deactivate-input-method
#'deactivate-input-method "27.1")
(defun viper-activate-input-method ()
(declare (obsolete activate-input-method "27.1"))
(activate-input-method default-input-method))
;; Set quail-mode to ARG
(defun viper-set-input-method (arg)
(setq viper-mule-hook-flag t) ; just a precaution
(let (viper-mule-hook-flag) ; temporarily deactivate viper mule hooks
(cond ((and arg (> (prefix-numeric-value arg) 0) default-input-method)
;; activate input method
(activate-input-method default-input-method))
(t ; deactivate input method
(deactivate-input-method)))))
;; VI-style Undo
(defcustom viper-keep-point-on-undo nil
"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."
:type 'boolean
:tag "Preserve Position of Point After Undo"
:group 'viper)
;; Replace mode and changing text
;; Hack used to pass global states around for short period of time
(viper-deflocalvar viper-intermediate-command nil "")
;; This is used to pass the right Vi command key sequence to
;; viper-set-destructive-command whenever (this-command-keys) doesn't give the
;; right result. For instance, in commands like c/bla<RET>,
;; (this-command-keys) will return ^M, which invoked exit-minibuffer, while we
;; need "c/"
(defconst viper-this-command-keys nil)
;; Indicates that the current destructive command has started in replace mode.
(viper-deflocalvar viper-began-as-replace nil "")
(defcustom viper-allow-multiline-replace-regions t
"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."
:type 'boolean
:group 'viper)
(defcustom viper-replace-overlay-cursor-color "Red"
"Cursor color when Viper is in Replace state."
:type 'string
:group 'viper)
(defcustom viper-insert-state-cursor-color "Green"
"Cursor color when Viper is in insert state."
:type 'string
:group 'viper)
;; viper-emacs-state-cursor-color doesn't work well. Causes cursor colors to be
;; confused in some cases. So, this var is nulled for now.
;; (defcustom viper-emacs-state-cursor-color "Magenta"
(defcustom viper-emacs-state-cursor-color nil
"Cursor color when Viper is in Emacs state."
:type '(choice (const nil) string)
:group 'viper)
;; internal var, used to remember the default cursor color of emacs frames
(defvar viper-vi-state-cursor-color nil)
(viper-deflocalvar viper-replace-overlay nil "")
(put 'viper-replace-overlay 'permanent-local t)
(defcustom viper-replace-region-end-delimiter "$"
"A string marking the end of replacement regions.
It is used only with TTYs or if `viper-use-replace-region-delimiters'
is non-nil."
:type 'string
:group 'viper)
(defcustom viper-replace-region-start-delimiter ""
"A string marking the beginning of replacement regions.
It is used only with TTYs or if `viper-use-replace-region-delimiters'
is non-nil."
:type 'string
:group 'viper)
(defcustom viper-use-replace-region-delimiters
(not (viper-has-face-support-p))
"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."
:type 'boolean
:group 'viper)
(defcustom viper-read-buffer-function #'read-buffer
"Function to use for prompting the user for a buffer name."
:type 'symbol
:group 'viper)
;; These are local marker that must be initialized to nil and moved with
;; `viper-move-marker-locally'
;;
;; Remember the last position inside the replace region.
(viper-deflocalvar viper-last-posn-in-replace-region nil)
;; Remember the last position while inserting
(viper-deflocalvar viper-last-posn-while-in-insert-state nil)
(put 'viper-last-posn-in-replace-region 'permanent-local t)
(put 'viper-last-posn-while-in-insert-state 'permanent-local t)
(viper-deflocalvar viper-sitting-in-replace nil "")
(put 'viper-sitting-in-replace 'permanent-local t)
;; Remember the number of characters that have to be deleted in replace
;; mode to compensate for the inserted characters.
(viper-deflocalvar viper-replace-chars-to-delete 0 "")
;; This variable is used internally by the before/after changed functions to
;; determine how many chars were deleted by the change. This can't be
;; determined inside after-change-functions because those get the length of the
;; deleted region, not the number of chars deleted (which are two different
;; things under MULE).
(viper-deflocalvar viper-replace-region-chars-deleted 0 "")
;; Insertion ring and command ring
(defcustom viper-insertion-ring-size 14
"The size of history of inserted text.
This is a list where Viper keeps the history of previously inserted pieces of
text."
:type 'integer
:group 'viper-misc)
;; The insertion ring.
(defvar viper-insertion-ring nil)
;; This is temp insertion ring. Used to do rotation for display purposes.
;; When rotation just started, it is initialized to viper-insertion-ring.
(defvar viper-temp-insertion-ring nil)
(defvar viper-last-inserted-string-from-insertion-ring "")
(defcustom viper-command-ring-size 14
"The size of history of Vi commands repeatable with dot."
:type 'integer
:group 'viper-misc)
;; The command ring.
(defvar viper-command-ring nil)
;; This is temp command ring. Used to do rotation for display purposes.
;; When rotation just started, it is initialized to viper-command-ring.
(defvar viper-temp-command-ring nil)
;; Fast keyseq and ESC keyseq timeouts
(defcustom viper-fast-keyseq-timeout 200
"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."
:type 'integer
:group 'viper-misc)
;; This function determines if ESC key sequences are to be translated into
;; commands.
(defun viper-translate-all-ESC-keysequences ()
(not (viper-window-display-p)))
;; Modes and related variables
;; Current mode. One of: `emacs-state', `vi-state', `insert-state'
(viper-deflocalvar viper-current-state 'emacs-state)
;; Autoindent in insert
;; Variable that keeps track of whether C-t has been pressed.
(viper-deflocalvar viper-cted nil "")
;; Preserve the indent value, used by C-d in insert mode.
(viper-deflocalvar viper-current-indent 0)
;; Whether to preserve the indent, used by C-d in insert mode.
(viper-deflocalvar viper-preserve-indent nil)
(viper-deflocalvar viper-auto-indent nil "")
(defcustom viper-auto-indent nil
"Enable autoindent, if t.
This is a buffer-local variable."
:type 'boolean
:group 'viper)
(viper-deflocalvar viper-electric-mode t "")
(defcustom viper-electric-mode t
"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."
:type 'boolean
:group 'viper)
(defcustom viper-shift-width 8
"The value of the shiftwidth.
This determines the number of columns by which the Ctl-t moves the cursor in
the Insert state."
:type 'integer
:group 'viper)
;; Variables for repeating destructive commands
(defcustom viper-keep-point-on-repeat t
"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."
:type 'boolean
:group 'viper)
;; Remember insert point as a marker. This is a local marker that must be
;; initialized to nil and moved with `viper-move-marker-locally'.
(viper-deflocalvar viper-insert-point nil)
(put 'viper-insert-point 'permanent-local t)
;; This remembers the point before dabbrev-expand was called.
;; If viper-insert-point turns out to be bigger than that, it is reset
;; back to viper-pre-command-point.
;; The reason this is needed is because dabbrev-expand (and possibly
;; others) may jump to before the insertion point, delete something and
;; then reinsert a bigger piece. For instance: bla^blo
;; If dabbrev-expand is called after `blo' and ^ indicates viper-insert-point,
;; then point jumps to the beginning of `blo'. If expansion is found, `blablo'
;; is deleted, and we have |^, where | denotes point. Next, dabbrev-expand
;; will insert the expansion, and we get: blablo^
;; Whatever we insert next goes before the ^, i.e., before the
;; viper-insert-point marker. So, Viper will think that nothing was
;; inserted. Remembering the orig position of the marker circumvents the
;; problem.
;; We don't know of any command, except dabbrev-expand, that has the same
;; problem. However, the same trick can be used if such a command is
;; discovered later.
;;
(viper-deflocalvar viper-pre-command-point nil)
(put 'viper-pre-command-point 'permanent-local t) ; this is probably an overkill
;; This is used for saving inserted text.
(defvar viper-last-insertion nil)
;; Remembers the last replaced region.
(defvar viper-last-replace-region "")
;; Remember com point as a marker.
;; This is a local marker. Should be moved with `viper-move-marker-locally'
(viper-deflocalvar viper-com-point nil)
;; If non-nil, the value is a list (M-COM VAL COM REG inserted-text cmd-keys)
;; It is used to re-execute last destructive command.
;; M-COM is a Lisp symbol representing the function to be executed.
;; VAL is the prefix argument that was used with that command.
;; COM is an internal descriptor, such as ?r, ?c, ?C, which contains
;; additional information on how the function in M-COM is to be handled.
;; REG is the register used by command
;; INSERTED-TEXT is text inserted by that command (in case of o, c, C, i, r
;; commands).
;; COMMAND-KEYS are the keys that were typed to invoke the command.
(defvar viper-d-com nil)
;; The character remembered by the Vi `r' command.
(defvar viper-d-char nil)
;; Name of register to store deleted or yanked strings
(defvar viper-use-register nil)
;;; Variables for Moves and Searches
(defgroup viper-search nil
"Variables that define the search and query-replace behavior of Viper."
:prefix "viper-"
:group 'viper)
;; For use by `;' command.
(defvar viper-f-char nil)
;; For use by `.' command.
(defvar viper-F-char nil)
;; For use by `;' command.
(defvar viper-f-forward nil)
;; For use by `;' command.
(defvar viper-f-offset nil)
;; Last search string
(defvar viper-s-string "")
(defcustom viper-quote-string "> "
"String inserted at the beginning of quoted region."
:type 'string
:group 'viper)
;; If t, search is forward.
(defvar viper-s-forward nil)
(defcustom viper-case-fold-search nil
"If not nil, search ignores cases."
:type 'boolean
:group 'viper-search)
(defcustom viper-re-search t
"If not nil, search is regexp search, otherwise vanilla search."
:type 'boolean
:tag "Regexp Search"
:group 'viper-search)
(defcustom viper-search-scroll-threshold 2
"If search lands within this threshold 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."
:type 'integer
:group 'viper-search)
(defcustom viper-re-query-replace t
"If t then do regexp replace, if nil then do string replace."
:type 'boolean
:tag "Regexp Query Replace"
:group 'viper-search)
(defcustom viper-re-replace t
"If t, do regexp replace. nil means do string replace."
:type 'boolean
:tag "Regexp Replace"
:group 'viper-search)
(defcustom viper-parse-sexp-ignore-comments t
"If t, `%' ignores the parentheses that occur inside comments."
:type 'boolean
:group 'viper)
(viper-deflocalvar viper-ex-style-motion t "")
(defcustom viper-ex-style-motion t
"If t, the commands l,h do not cross lines, etc (Ex-style).
If nil, these commands cross line boundaries."
:type 'boolean
:group 'viper)
(viper-deflocalvar viper-ex-style-editing t "")
(defcustom viper-ex-style-editing t
"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."
:type 'boolean
:group 'viper)
(viper-deflocalvar viper-ESC-moves-cursor-back viper-ex-style-editing "")
(defcustom viper-ESC-moves-cursor-back nil
"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."
:type 'boolean
:group 'viper)
(viper-deflocalvar viper-delete-backwards-in-replace nil "")
(defcustom viper-delete-backwards-in-replace nil
"If t, DEL key will delete characters while moving the cursor backwards.
If nil, the cursor will move backwards without deleting anything."
:type 'boolean
:group 'viper)
(defcustom viper-buffer-search-char nil
"Key used for buffer-searching. Must be a character type, e.g., ?g."
:type '(choice (const nil) character)
:group 'viper-search)
(defcustom viper-search-wrap-around t
"If t, search wraps around."
:type 'boolean
:tag "Search Wraps Around"
:group 'viper-search)
(viper-deflocalvar viper-related-files-and-buffers-ring nil "")
(defcustom viper-related-files-and-buffers-ring nil
"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."
:type 'boolean
:group 'viper-misc)
(put 'viper-related-files-and-buffers-ring 'permanent-local t)
;; Used to find out if we are done with searching the current buffer.
(viper-deflocalvar viper-local-search-start-marker nil)
;; As above, but global
(defvar viper-search-start-marker (make-marker))
;; the search overlay
(viper-deflocalvar viper-search-overlay nil)
(defvar viper-heading-start
(concat "^\\s-*(\\s-*defun\\s-\\|" ; lisp
"^{\\s-*$\\|^[_a-zA-Z][^()]*[()].*{\\s-*$\\|" ; C/C++
"^\\s-*class.*{\\|^\\s-*struct.*{\\|^\\s-*enum.*{\\|"
"^\\\\[sb][a-z]*{.*}\\s-*$\\|" ; latex
"^@node\\|@table\\|^@m?enu\\|^@itemize\\|^@if\\|" ; texinfo
"^.+:-") ; prolog
"Regexps for Headings. Used by [[ and ]].")
(defvar viper-heading-end
(concat "^}\\|" ; C/C++
"^\\\\end{\\|" ; latex
"^@end \\|" ; texinfo
")\n\n[ \t\n]*\\|" ; lisp
"\\.\\s-*$") ; prolog
"Regexps to end Headings/Sections. Used by [].")
;; These two vars control the interaction of jumps performed by ' and `.
;; In this new version, '' doesn't erase the marks set by ``, so one can
;; use both kinds of jumps interchangeably and without losing positions
;; inside the lines.
;; Remembers position of the last jump done using ``'.
(viper-deflocalvar viper-last-jump nil)
;; Remembers position of the last jump done using `''.
(viper-deflocalvar viper-last-jump-ignore 0)
;; History variables
;; History of search strings.
(defvar viper-search-history (list ""))
;; History of query-replace strings used as a source.
(defvar viper-replace1-history nil)
;; History of query-replace strings used as replacement.
(defvar viper-replace2-history nil)
;; History of region quoting strings.
(defvar viper-quote-region-history (list viper-quote-string))
;; History of Ex-style commands.
(defvar viper-ex-history nil)
;; History of shell commands.
(defvar viper-shell-history nil)
;; Last shell command. There are two of these, one for Ex (in viper-ex)
;; and one for Vi.
;; Last shell command executed with ! command.
(defvar viper-last-shell-com nil)
\f
;;; Face-saving tricks
(defgroup viper-highlighting nil
"Highlighting of replace region, search pattern, minibuffer, etc."
:prefix "viper-"
:group 'viper)
(defface viper-search
'((((class color)) (:foreground "Black" :background "khaki"))
(t (:underline t :stipple "gray3")))
"Face used to flash out the search pattern."
:group 'viper-highlighting)
;; An internal variable. Viper takes the face from here.
(defvar viper-search-face 'viper-search
"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'
this variable represents.")
(defface viper-replace-overlay
'((((class color)) (:foreground "Black" :background "darkseagreen2"))
(t (:underline t :stipple "gray3")))
"Face for highlighting replace regions on a window display."
:group 'viper-highlighting)
;; An internal variable. Viper takes the face from here.
(defvar viper-replace-overlay-face 'viper-replace-overlay
"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'
this variable represents.")
(defface viper-minibuffer-emacs
'((((class color)) (:foreground "Black" :background "darkseagreen2"))
(t (:weight bold)))
"Face used in the Minibuffer when it is in Emacs state."
:group 'viper-highlighting)
;; An internal variable. Viper takes the face from here.
(defvar viper-minibuffer-emacs-face 'viper-minibuffer-emacs
"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'
this variable represents.")
(defface viper-minibuffer-insert
'((((class color)) (:foreground "Black" :background "pink"))
(t (:slant italic)))
"Face used in the Minibuffer when it is in Insert state."
:group 'viper-highlighting)
;; An internal variable. Viper takes the face from here.
(defvar viper-minibuffer-insert-face 'viper-minibuffer-insert
"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'
this variable represents.")
(defface viper-minibuffer-vi
'((((class color)) (:foreground "DarkGreen" :background "grey"))
(t (:inverse-video t)))
"Face used in the Minibuffer when it is in Vi state."
:group 'viper-highlighting)
;; An internal variable. Viper takes the face from here.
(defvar viper-minibuffer-vi-face 'viper-minibuffer-vi
"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'
this variable represents.")
;; the current face to be used in the minibuffer
(viper-deflocalvar
viper-minibuffer-current-face viper-minibuffer-emacs-face "")
\f
;;; Miscellaneous
(defvar viper-inhibit-startup-message nil
"Whether Viper startup message should be inhibited.")
(defcustom viper-spell-function 'ispell-region
"Spell function used by #s<move> command to spell."
:type 'function
:group 'viper-misc)
(defcustom viper-tags-file-name "TAGS"
"The tags file used by Viper."
:type 'string
:group 'viper-misc)
(defcustom viper-change-notification-threshold 1
"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."
:type 'integer
:group 'viper-misc)
;; Minibuffer
(defcustom viper-vi-style-in-minibuffer t
"If t, use vi-style editing in minibuffer.
Should be set in `viper-custom-file-name'."
:type 'boolean
:group 'viper)
;; overlay used in the minibuffer to indicate which state it is in
(viper-deflocalvar viper-minibuffer-overlay nil)
(put 'viper-minibuffer-overlay 'permanent-local t)
;; Hook, specific to Viper, which is run just *before* exiting the minibuffer.
;; This is needed because beginning with Emacs 19.26, the standard
;; `minibuffer-exit-hook' is run *after* exiting the minibuffer
(defvar viper-minibuffer-exit-hook nil)
;; Mode line
(defconst viper-vi-state-id "<V> "
"Mode line tag identifying the Vi mode of Viper.")
(defconst viper-emacs-state-id "<E> "
"Mode line tag identifying the Emacs mode of Viper.")
(defconst viper-insert-state-id "<I> "
"Mode line tag identifying the Insert mode of Viper.")
(defconst viper-replace-state-id "<R> "
"Mode line tag identifying the Replace mode of Viper.")
(defgroup viper-hooks nil
"Viper hooks."
:prefix "viper-"
:group 'viper)
(defcustom viper-vi-state-hook 'viper-restore-cursor-type
"Hooks run just before the switch to Vi mode is completed."
:type 'hook
:group 'viper-hooks)
(defcustom viper-insert-state-hook 'viper-set-insert-cursor-type
"Hooks run just before the switch to Insert mode is completed."
:type 'hook
:group 'viper-hooks)
(defcustom viper-replace-state-hook 'viper-restore-cursor-type
"Hooks run just before the switch to Replace mode is completed."
:type 'hook
:group 'viper-hooks)
(defcustom viper-emacs-state-hook 'viper-restore-cursor-type
"Hooks run just before the switch to Emacs mode is completed."
:type 'hook
:group 'viper-hooks)
(defcustom viper-load-hook nil
"Hooks run just after loading Viper."
:type 'hook
:group 'viper-hooks)
(make-obsolete-variable 'viper-load-hook
"use `with-eval-after-load' instead." "28.1")
(defun viper-restore-cursor-type ()
(condition-case nil
(setq cursor-type (default-value 'cursor-type))
(error nil)))
(defun viper-set-insert-cursor-type ()
(setq cursor-type '(bar . 2)))
(defun viper-ESC-keyseq-timeout ()
"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."
(if (viper-window-display-p)
0 viper-fast-keyseq-timeout))
(provide 'viper-init)
;; Local Variables:
;; eval: (put 'viper-deflocalvar 'lisp-indent-hook 'defun)
;; End:
;;; viper-init.el ends here
|