1 ;;; tpu-edt.el --- Emacs emulating TPU emulating EDT
3 ;; Copyright (C) 1993, 1994, 1995, 2000, 2001, 2002, 2003, 2004,
4 ;; 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
6 ;; Author: Rob Riepel <riepel@networking.stanford.edu>
7 ;; Maintainer: Rob Riepel <riepel@networking.stanford.edu>
9 ;; Keywords: emulations
11 ;; This file is part of GNU Emacs.
13 ;; GNU Emacs is free software; you can redistribute it and/or modify
14 ;; it under the terms of the GNU General Public License as published by
15 ;; the Free Software Foundation; either version 3, or (at your option)
18 ;; GNU Emacs is distributed in the hope that it will be useful,
19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 ;; GNU General Public License for more details.
23 ;; You should have received a copy of the GNU General Public License
24 ;; along with GNU Emacs; see the file COPYING. If not, write to the
25 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
26 ;; Boston, MA 02110-1301, USA.
28 ;; TPU-edt is based on tpu.el by Jeff Kowalski and Bob Covey.
32 ;; %% TPU-edt -- Emacs emulating TPU emulating EDT
37 ;; % Differences Between TPU-edt and DEC TPU/edt
39 ;; % Customizing TPU-edt using the Emacs Initialization File
40 ;; % Regular Expressions in TPU-edt
45 ;; TPU-edt emulates the popular DEC VMS editor EDT (actually, it emulates
46 ;; DEC TPU's EDT emulation, hence the name TPU-edt). TPU-edt features the
47 ;; following TPU/edt functionality:
55 ;; . Rectangular cut and paste
56 ;; . Multiple windows and buffers
57 ;; . TPU line-mode REPLACE command
58 ;; . Wild card search and substitution
59 ;; . Configurable through an initialization file
60 ;; . History recall of search strings, file names, and commands
62 ;; Please note that TPU-edt does NOT emulate TPU. It emulates TPU's EDT
63 ;; emulation. Very few TPU line-mode commands are supported.
65 ;; TPU-edt, like its VMS cousin, works on VT-series terminals with DEC
66 ;; style keyboards. VT terminal emulators, including xterm with the
67 ;; appropriate key translations, work just fine too.
69 ;; TPU-edt works with X-windows. This is accomplished through a TPU-edt X
70 ;; key map. The TPU-edt module tpu-mapper creates this map and stores it
71 ;; in a file. Tpu-mapper will be run automatically the first time you
72 ;; invoke the X-windows version of emacs, or you can run it by hand. See
73 ;; the commentary in tpu-mapper.el for details.
76 ;; %% Differences Between TPU-edt and DEC TPU/edt
78 ;; In some cases, Emacs doesn't support text highlighting, so selected
79 ;; regions are not shown in inverse video. Emacs uses the concept of "the
80 ;; mark". The mark is set at one end of a selected region; the cursor is
81 ;; at the other. In cases where the selected region cannot be shown in
82 ;; inverse video an at sign (@) appears in the mode line when mark is set.
83 ;; The native emacs command ^X^X (Control-X twice) exchanges the cursor
84 ;; with the mark; this provides a handy way to find the location of the
87 ;; In TPU the cursor can be either bound or free. Bound means the cursor
88 ;; cannot wander outside the text of the file being edited. Free means
89 ;; the arrow keys can move the cursor past the ends of lines. Free is the
90 ;; default mode in TPU; bound is the only mode in EDT. Bound is the only
91 ;; mode in the base version of TPU-edt; optional extensions add an
92 ;; approximation of free mode, see the commentary in tpu-extras.el for
95 ;; Like TPU, emacs uses multiple buffers. Some buffers are used to hold
96 ;; files you are editing; other "internal" buffers are used for emacs' own
97 ;; purposes (like showing you help). Here are some commands for dealing
100 ;; Gold-B moves to next buffer, including internal buffers
101 ;; Gold-N moves to next buffer containing a file
102 ;; Gold-M brings up a buffer menu (like TPU "show buffers")
104 ;; Emacs is very fond of throwing up new windows. Dealing with all these
105 ;; windows can be a little confusing at first, so here are a few commands
108 ;; Gold-Next_Scr moves to the next window on the screen
109 ;; Gold-Prev_Scr moves to the previous window on the screen
110 ;; Gold-TAB also moves to the next window on the screen
112 ;; Control-x 1 deletes all but the current window
113 ;; Control-x 0 deletes the current window
115 ;; Note that the buffers associated with deleted windows still exist!
117 ;; Like TPU, TPU-edt has a "command" function, invoked with Gold-KP7 or
118 ;; Do. Most of the commands available are emacs commands. Some TPU
119 ;; commands are available, they are: replace, exit, quit, include, and
120 ;; Get (unfortunately, "get" is an internal emacs function, so we are
121 ;; stuck with "Get" - to make life easier, Get is available as Gold-g).
123 ;; TPU-edt supports the recall of commands, file names, and search
124 ;; strings. The history of strings recalled differs slightly from
125 ;; TPU/edt, but it is still very convenient.
127 ;; Help is available! The traditional help keys (Help and PF2) display
128 ;; a small help file showing the default keypad layout, control key
129 ;; functions, and Gold key functions. Pressing any key inside of help
130 ;; splits the screen and prints a description of the function of the
131 ;; pressed key. Gold-PF2 invokes the native emacs help, with its
132 ;; zillions of options.
134 ;; Thanks to emacs, TPU-edt has some extensions that may make your life
135 ;; easier, or at least more interesting. For example, Gold-r toggles
136 ;; TPU-edt rectangular mode. In rectangular mode, Remove and Insert work
137 ;; on rectangles. Likewise, Gold-* toggles TPU-edt regular expression
138 ;; mode. In regular expression mode Find, Find Next, and the line-mode
139 ;; replace command work with regular expressions. [A regular expression
140 ;; is a pattern that denotes a set of strings; like VMS wildcards.]
142 ;; Emacs also gives TPU-edt the undo and occur functions. Undo does
143 ;; what it says; it undoes the last change. Multiple undos in a row
144 ;; undo multiple changes. For your convenience, undo is available on
145 ;; Gold-u. Occur shows all the lines containing a specific string in
146 ;; another window. Moving to that window, and typing ^C^C (Control-C
147 ;; twice) on a particular line moves you back to the original window
148 ;; at that line. Occur is on Gold-o.
150 ;; Finally, as you edit, remember that all the power of emacs is at
151 ;; your disposal. It really is a fantastic tool. You may even want to
152 ;; take some time and read the emacs tutorial; perhaps not to learn the
153 ;; native emacs key bindings, but to get a feel for all the things
154 ;; emacs can do for you. The emacs tutorial is available from the
155 ;; emacs help function: "Gold-PF2 t"
158 ;; %% Starting TPU-edt
160 ;; All you have to do to start TPU-edt, is turn it on. This can be
161 ;; done from the command line when running emacs.
163 ;; prompt> emacs -f tpu-edt
165 ;; If you've already started emacs, turn on TPU-edt using the tpu-edt
166 ;; command. First press `M-x' (that's usually `ESC' followed by `x')
167 ;; and type `tpu-edt' followed by a carriage return.
169 ;; If you like TPU-edt and want to use it all the time, you can start
170 ;; TPU-edt using the emacs initialization file, .emacs. Simply create
171 ;; a .emacs file in your home directory containing the line:
175 ;; That's all you need to do to start TPU-edt.
178 ;; %% Customizing TPU-edt using the Emacs Initialization File
180 ;; The following is a sample emacs initialization file. It shows how to
181 ;; invoke TPU-edt, and how to customize it.
183 ;; ; .emacs - a sample emacs initialization file
188 ;; ; Set scroll margins 10% (top) and 15% (bottom).
189 ;; (tpu-set-scroll-margins "10%" "15%")
191 ;; ; Load the vtxxx terminal control functions.
192 ;; (load "vt-control" t)
194 ;; ; TPU-edt treats words like EDT; here's how to add word separators.
195 ;; ; Note that backslash (\) and double quote (") are quoted with '\'.
196 ;; (tpu-add-word-separators "]\\[-_,.\"=+()'/*#:!&;$")
198 ;; ; Emacs is happy to save files without a final newline; other Unix
199 ;; ; programs hate that! Here we make sure that files end with newlines.
200 ;; (setq require-final-newline t)
202 ;; ; Emacs uses Control-s and Control-q. Problems can occur when using
203 ;; ; emacs on terminals that use these codes for flow control (Xon/Xoff
204 ;; ; flow control). These lines disable emacs' use of these characters.
205 ;; (global-unset-key "\C-s")
206 ;; (global-unset-key "\C-q")
208 ;; ; The emacs universal-argument function is very useful.
209 ;; ; This line maps universal-argument to Gold-PF1.
210 ;; (define-key GOLD-SS3-map "P" 'universal-argument) ; Gold-PF1
212 ;; ; Make KP7 move by paragraphs, instead of pages.
213 ;; (define-key SS3-map "w" 'tpu-paragraph) ; KP7
215 ;; ; Repeat the preceding mappings for X-windows.
218 ;; (global-set-key [kp_7] 'tpu-paragraph) ; KP7
219 ;; (define-key GOLD-map [kp_f1] 'universal-argument))) ; GOLD-PF1
221 ;; ; Display the TPU-edt version.
225 ;; %% Regular Expressions in TPU-edt
227 ;; Gold-* toggles TPU-edt regular expression mode. In regular expression
228 ;; mode, find, find next, replace, and substitute accept emacs regular
229 ;; expressions. A complete list of emacs regular expressions can be found
230 ;; using the emacs "info" command (it's somewhat like the VMS help
231 ;; command). Try the following sequence of commands:
233 ;; DO info <enter info mode>
234 ;; m emacs <select the "emacs" topic>
235 ;; m regexs <select the "regular expression" topic>
237 ;; Type "q" to quit out of info mode.
239 ;; There is a problem in regular expression mode when searching for empty
240 ;; strings, like beginning-of-line (^) and end-of-line ($). When searching
241 ;; for these strings, find-next may find the current string, instead of the
242 ;; next one. This can cause global replace and substitute commands to loop
243 ;; forever in the same location. For this reason, commands like
245 ;; replace "^" "> " <add "> " to beginning of line>
246 ;; replace "$" "00711" <add "00711" to end of line>
248 ;; may not work properly.
250 ;; Commands like those above are very useful for adding text to the
251 ;; beginning or end of lines. They might work on a line-by-line basis, but
252 ;; go into an infinite loop if the "all" response is specified. If the
253 ;; goal is to add a string to the beginning or end of a particular set of
254 ;; lines TPU-edt provides functions to do this.
256 ;; Gold-^ Add a string at BOL in region or buffer
257 ;; Gold-$ Add a string at EOL in region or buffer
259 ;; There is also a TPU-edt interface to the native emacs string replacement
260 ;; commands. Gold-/ invokes this command. It accepts regular expressions
261 ;; if TPU-edt is in regular expression mode. Given a repeat count, it will
262 ;; perform the replacement without prompting for confirmation.
264 ;; This command replaces empty strings correctly, however, it has its
265 ;; drawbacks. As a native emacs command, it has a different interface
266 ;; than the emulated TPU commands. Also, it works only in the forward
267 ;; direction, regardless of the current TPU-edt direction.
271 ;; We shouldn't use vt100 ESC sequences since it is uselessly fighting
272 ;; against function-key-map. Better use real key names.
276 (eval-when-compile (require 'cl
))
277 ;; we use picture-mode functions
281 "Emacs emulating TPU emulating EDT."
287 ;;; Version Information
289 (defconst tpu-version
"4.5" "TPU-edt version number.")
293 ;;; User Configurable Variables
295 (defcustom tpu-have-ispell t
296 "*If non-nil (default), TPU-edt uses ispell for spell checking."
300 (defcustom tpu-kill-buffers-silently nil
301 "*If non-nil, TPU-edt kills modified buffers without asking."
305 (defcustom tpu-percent-scroll
75
306 "*Percentage of the screen to scroll for next/previous screen commands."
310 (defcustom tpu-pan-columns
16
311 "*Number of columns the tpu-pan functions scroll left or right."
317 ;;; Emacs version identifiers - currently referenced by
319 ;;; o tpu-mark o tpu-set-mark
320 ;;; o mode line section o tpu-load-xkeys
322 (defconst tpu-lucid-emacs-p
323 (string-match "Lucid" emacs-version
)
324 "Non-nil if we are running Lucid Emacs.")
330 (let ((map (make-sparse-keymap)))
331 (define-key map
"A" 'tpu-previous-line
) ; up
332 (define-key map
"B" 'tpu-next-line
) ; down
333 (define-key map
"D" 'tpu-backward-char
) ; left
334 (define-key map
"C" 'tpu-forward-char
) ; right
336 (define-key map
"1~" 'tpu-search
) ; Find
337 (define-key map
"2~" 'tpu-paste
) ; Insert Here
338 (define-key map
"3~" 'tpu-cut
) ; Remove
339 (define-key map
"4~" 'tpu-select
) ; Select
340 (define-key map
"5~" 'tpu-scroll-window-down
) ; Prev Screen
341 (define-key map
"6~" 'tpu-scroll-window-up
) ; Next Screen
343 (define-key map
"11~" 'nil
) ; F1
344 (define-key map
"12~" 'nil
) ; F2
345 (define-key map
"13~" 'nil
) ; F3
346 (define-key map
"14~" 'nil
) ; F4
347 (define-key map
"15~" 'nil
) ; F5
348 (define-key map
"17~" 'nil
) ; F6
349 (define-key map
"18~" 'nil
) ; F7
350 (define-key map
"19~" 'nil
) ; F8
351 (define-key map
"20~" 'nil
) ; F9
352 (define-key map
"21~" 'tpu-exit
) ; F10
353 (define-key map
"23~" 'tpu-insert-escape
) ; F11 (ESC)
354 (define-key map
"24~" 'tpu-next-beginning-of-line
) ; F12 (BS)
355 (define-key map
"25~" 'tpu-delete-previous-word
) ; F13 (LF)
356 (define-key map
"26~" 'tpu-toggle-overwrite-mode
) ; F14
357 (define-key map
"28~" 'tpu-help
) ; HELP
358 (define-key map
"29~" 'execute-extended-command
) ; DO
359 (define-key map
"31~" 'tpu-goto-breadcrumb
) ; F17
360 (define-key map
"32~" 'nil
) ; F18
361 (define-key map
"33~" 'nil
) ; F19
362 (define-key map
"34~" 'nil
) ; F20
364 "Maps the CSI function keys on the VT100 keyboard.
365 CSI is DEC's name for the sequence <ESC>[.")
368 (let ((map (make-sparse-keymap)))
369 (define-key map
"A" 'tpu-move-to-beginning
) ; up-arrow
370 (define-key map
"B" 'tpu-move-to-end
) ; down-arrow
371 (define-key map
"C" 'end-of-line
) ; right-arrow
372 (define-key map
"D" 'beginning-of-line
) ; left-arrow
374 (define-key map
"1~" 'nil
) ; Find
375 (define-key map
"2~" 'nil
) ; Insert Here
376 (define-key map
"3~" 'tpu-store-text
) ; Remove
377 (define-key map
"4~" 'tpu-unselect
) ; Select
378 (define-key map
"5~" 'tpu-previous-window
) ; Prev Screen
379 (define-key map
"6~" 'tpu-next-window
) ; Next Screen
381 (define-key map
"11~" 'nil
) ; F1
382 (define-key map
"12~" 'nil
) ; F2
383 (define-key map
"13~" 'nil
) ; F3
384 (define-key map
"14~" 'nil
) ; F4
385 (define-key map
"16~" 'nil
) ; F5
386 (define-key map
"17~" 'nil
) ; F6
387 (define-key map
"18~" 'nil
) ; F7
388 (define-key map
"19~" 'nil
) ; F8
389 (define-key map
"20~" 'nil
) ; F9
390 (define-key map
"21~" 'nil
) ; F10
391 (define-key map
"23~" 'nil
) ; F11
392 (define-key map
"24~" 'nil
) ; F12
393 (define-key map
"25~" 'nil
) ; F13
394 (define-key map
"26~" 'nil
) ; F14
395 (define-key map
"28~" 'describe-bindings
) ; HELP
396 (define-key map
"29~" 'nil
) ; DO
397 (define-key map
"31~" 'tpu-drop-breadcrumb
) ; F17
398 (define-key map
"32~" 'nil
) ; F18
399 (define-key map
"33~" 'nil
) ; F19
400 (define-key map
"34~" 'nil
) ; F20
402 "Maps the function keys on the VT100 keyboard preceded by GOLD-CSI.")
405 (let ((map (make-sparse-keymap)))
406 (define-key map
"A" 'tpu-move-to-beginning
) ; up-arrow
407 (define-key map
"B" 'tpu-move-to-end
) ; down-arrow
408 (define-key map
"C" 'end-of-line
) ; right-arrow
409 (define-key map
"D" 'beginning-of-line
) ; left-arrow
411 (define-key map
"P" 'keyboard-quit
) ; PF1
412 (define-key map
"Q" 'help-for-help
) ; PF2
413 (define-key map
"R" 'tpu-search
) ; PF3
414 (define-key map
"S" 'tpu-undelete-lines
) ; PF4
415 (define-key map
"p" 'open-line
) ; KP0
416 (define-key map
"q" 'tpu-change-case
) ; KP1
417 (define-key map
"r" 'tpu-delete-to-eol
) ; KP2
418 (define-key map
"s" 'tpu-special-insert
) ; KP3
419 (define-key map
"t" 'tpu-move-to-end
) ; KP4
420 (define-key map
"u" 'tpu-move-to-beginning
) ; KP5
421 (define-key map
"v" 'tpu-paste
) ; KP6
422 (define-key map
"w" 'execute-extended-command
) ; KP7
423 (define-key map
"x" 'tpu-fill
) ; KP8
424 (define-key map
"y" 'tpu-replace
) ; KP9
425 (define-key map
"m" 'tpu-undelete-words
) ; KP-
426 (define-key map
"l" 'tpu-undelete-char
) ; KP,
427 (define-key map
"n" 'tpu-unselect
) ; KP.
428 (define-key map
"M" 'tpu-substitute
) ; KPenter
430 "Maps the function keys on the VT100 keyboard preceded by GOLD-SS3.")
433 (let ((map (make-keymap)))
434 (define-key map
"\e[" GOLD-CSI-map
) ; GOLD-CSI map
435 (define-key map
"\eO" GOLD-SS3-map
) ; GOLD-SS3 map
437 (define-key map
"\C-A" 'tpu-toggle-overwrite-mode
) ; ^A
438 (define-key map
"\C-B" 'nil
) ; ^B
439 (define-key map
"\C-C" 'nil
) ; ^C
440 (define-key map
"\C-D" 'nil
) ; ^D
441 (define-key map
"\C-E" 'nil
) ; ^E
442 (define-key map
"\C-F" 'set-visited-file-name
) ; ^F
443 (define-key map
"\C-g" 'keyboard-quit
) ; safety first
444 (define-key map
"\C-h" 'delete-other-windows
) ; BS
445 (define-key map
"\C-i" 'other-window
) ; TAB
446 (define-key map
"\C-J" 'nil
) ; ^J
447 (define-key map
"\C-K" 'tpu-define-macro-key
) ; ^K
448 (define-key map
"\C-l" 'downcase-region
) ; ^L
449 (define-key map
"\C-M" 'nil
) ; ^M
450 (define-key map
"\C-N" 'nil
) ; ^N
451 (define-key map
"\C-O" 'nil
) ; ^O
452 (define-key map
"\C-P" 'nil
) ; ^P
453 (define-key map
"\C-Q" 'nil
) ; ^Q
454 (define-key map
"\C-R" 'nil
) ; ^R
455 (define-key map
"\C-S" 'nil
) ; ^S
456 (define-key map
"\C-T" 'tpu-toggle-control-keys
) ; ^T
457 (define-key map
"\C-u" 'upcase-region
) ; ^U
458 (define-key map
"\C-V" 'nil
) ; ^V
459 (define-key map
"\C-w" 'tpu-write-current-buffers
) ; ^W
460 (define-key map
"\C-X" 'nil
) ; ^X
461 (define-key map
"\C-Y" 'nil
) ; ^Y
462 (define-key map
"\C-Z" 'nil
) ; ^Z
463 (define-key map
" " 'undo
) ; SPC
464 (define-key map
"!" 'nil
) ; !
465 (define-key map
"#" 'nil
) ; #
466 (define-key map
"$" 'tpu-add-at-eol
) ; $
467 (define-key map
"%" 'tpu-goto-percent
) ; %
468 (define-key map
"&" 'nil
) ; &
469 (define-key map
"(" 'nil
) ; (
470 (define-key map
")" 'nil
) ; )
471 (define-key map
"*" 'tpu-toggle-regexp
) ; *
472 (define-key map
"+" 'nil
) ; +
473 (define-key map
"," 'tpu-goto-breadcrumb
) ; ,
474 (define-key map
"-" 'negative-argument
) ; -
475 (define-key map
"." 'tpu-drop-breadcrumb
) ; .
476 (define-key map
"/" 'tpu-emacs-replace
) ; /
477 (define-key map
"0" 'digit-argument
) ; 0
478 (define-key map
"1" 'digit-argument
) ; 1
479 (define-key map
"2" 'digit-argument
) ; 2
480 (define-key map
"3" 'digit-argument
) ; 3
481 (define-key map
"4" 'digit-argument
) ; 4
482 (define-key map
"5" 'digit-argument
) ; 5
483 (define-key map
"6" 'digit-argument
) ; 6
484 (define-key map
"7" 'digit-argument
) ; 7
485 (define-key map
"8" 'digit-argument
) ; 8
486 (define-key map
"9" 'digit-argument
) ; 9
487 (define-key map
":" 'nil
) ; :
488 (define-key map
";" 'tpu-trim-line-ends
) ; ;
489 (define-key map
"<" 'nil
) ; <
490 (define-key map
"=" 'nil
) ; =
491 (define-key map
">" 'nil
) ; >
492 (define-key map
"?" 'tpu-spell-check
) ; ?
493 (define-key map
"A" 'tpu-toggle-newline-and-indent
) ; A
494 (define-key map
"B" 'tpu-next-buffer
) ; B
495 (define-key map
"C" 'repeat-complex-command
) ; C
496 (define-key map
"D" 'shell-command
) ; D
497 (define-key map
"E" 'tpu-exit
) ; E
498 (define-key map
"F" 'tpu-set-cursor-free
) ; F
499 (define-key map
"G" 'tpu-get
) ; G
500 (define-key map
"H" 'nil
) ; H
501 (define-key map
"I" 'tpu-include
) ; I
502 (define-key map
"K" 'tpu-kill-buffer
) ; K
503 (define-key map
"L" 'tpu-what-line
) ; L
504 (define-key map
"M" 'buffer-menu
) ; M
505 (define-key map
"N" 'tpu-next-file-buffer
) ; N
506 (define-key map
"O" 'occur
) ; O
507 (define-key map
"P" 'lpr-buffer
) ; P
508 (define-key map
"Q" 'tpu-quit
) ; Q
509 (define-key map
"R" 'tpu-toggle-rectangle
) ; R
510 (define-key map
"S" 'replace
) ; S
511 (define-key map
"T" 'tpu-line-to-top-of-window
) ; T
512 (define-key map
"U" 'undo
) ; U
513 (define-key map
"V" 'tpu-version
) ; V
514 (define-key map
"W" 'save-buffer
) ; W
515 (define-key map
"X" 'tpu-save-all-buffers-kill-emacs
) ; X
516 (define-key map
"Y" 'copy-region-as-kill
) ; Y
517 (define-key map
"Z" 'suspend-emacs
) ; Z
518 (define-key map
"[" 'blink-matching-open
) ; [
519 (define-key map
"\\" 'nil
) ; \
520 (define-key map
"]" 'blink-matching-open
) ; ]
521 (define-key map
"^" 'tpu-add-at-bol
) ; ^
522 (define-key map
"_" 'split-window-vertically
) ; -
523 (define-key map
"`" 'what-line
) ; `
524 (define-key map
"a" 'tpu-toggle-newline-and-indent
) ; a
525 (define-key map
"b" 'tpu-next-buffer
) ; b
526 (define-key map
"c" 'repeat-complex-command
) ; c
527 (define-key map
"d" 'shell-command
) ; d
528 (define-key map
"e" 'tpu-exit
) ; e
529 (define-key map
"f" 'tpu-set-cursor-free
) ; f
530 (define-key map
"g" 'tpu-get
) ; g
531 (define-key map
"h" 'nil
) ; h
532 (define-key map
"i" 'tpu-include
) ; i
533 (define-key map
"k" 'tpu-kill-buffer
) ; k
534 (define-key map
"l" 'goto-line
) ; l
535 (define-key map
"m" 'buffer-menu
) ; m
536 (define-key map
"n" 'tpu-next-file-buffer
) ; n
537 (define-key map
"o" 'occur
) ; o
538 (define-key map
"p" 'lpr-region
) ; p
539 (define-key map
"q" 'tpu-quit
) ; q
540 (define-key map
"r" 'tpu-toggle-rectangle
) ; r
541 (define-key map
"s" 'replace
) ; s
542 (define-key map
"t" 'tpu-line-to-top-of-window
) ; t
543 (define-key map
"u" 'undo
) ; u
544 (define-key map
"v" 'tpu-version
) ; v
545 (define-key map
"w" 'save-buffer
) ; w
546 (define-key map
"x" 'tpu-save-all-buffers-kill-emacs
) ; x
547 (define-key map
"y" 'copy-region-as-kill
) ; y
548 (define-key map
"z" 'suspend-emacs
) ; z
549 (define-key map
"{" 'nil
) ; {
550 (define-key map
"|" 'split-window-horizontally
) ; |
551 (define-key map
"}" 'nil
) ; }
552 (define-key map
"~" 'exchange-point-and-mark
) ; ~
553 (define-key map
"\177" 'delete-window
) ; <X]
555 "Maps the function keys on the VT100 keyboard preceded by PF1.
556 GOLD is the ASCII 7-bit escape sequence <ESC>OP.")
559 (let ((map (make-sparse-keymap)))
560 (define-key map
"P" GOLD-map
) ; GOLD map
562 (define-key map
"A" 'tpu-previous-line
) ; up
563 (define-key map
"B" 'tpu-next-line
) ; down
564 (define-key map
"C" 'tpu-forward-char
) ; right
565 (define-key map
"D" 'tpu-backward-char
) ; left
567 (define-key map
"Q" 'tpu-help
) ; PF2
568 (define-key map
"R" 'tpu-search-again
) ; PF3
569 (define-key map
"S" 'tpu-delete-current-line
) ; PF4
570 (define-key map
"p" 'tpu-line
) ; KP0
571 (define-key map
"q" 'tpu-word
) ; KP1
572 (define-key map
"r" 'tpu-end-of-line
) ; KP2
573 (define-key map
"s" 'tpu-char
) ; KP3
574 (define-key map
"t" 'tpu-advance-direction
) ; KP4
575 (define-key map
"u" 'tpu-backup-direction
) ; KP5
576 (define-key map
"v" 'tpu-cut
) ; KP6
577 (define-key map
"w" 'tpu-page
) ; KP7
578 (define-key map
"x" 'tpu-scroll-window
) ; KP8
579 (define-key map
"y" 'tpu-append-region
) ; KP9
580 (define-key map
"m" 'tpu-delete-current-word
) ; KP-
581 (define-key map
"l" 'tpu-delete-current-char
) ; KP,
582 (define-key map
"n" 'tpu-select
) ; KP.
583 (define-key map
"M" 'newline
) ; KPenter
585 "Maps the SS3 function keys on the VT100 keyboard.
586 SS3 is DEC's name for the sequence <ESC>O.")
588 (defvar tpu-global-map
589 (let ((map (make-sparse-keymap)))
590 (define-key map
"\e[" CSI-map
)
591 (define-key map
"\eO" SS3-map
)
593 "TPU-edt global keymap.")
595 (and (not (boundp 'minibuffer-local-ns-map
))
596 (defvar minibuffer-local-ns-map
(make-sparse-keymap)
597 "Hack to give Lucid Emacs the same maps as ordinary Emacs."))
603 (defvar tpu-last-replaced-text
""
604 "Last text deleted by a TPU-edt replace command.")
605 (defvar tpu-last-deleted-region
""
606 "Last text deleted by a TPU-edt remove command.")
607 (defvar tpu-last-deleted-lines
""
608 "Last text deleted by a TPU-edt line-delete command.")
609 (defvar tpu-last-deleted-words
""
610 "Last text deleted by a TPU-edt word-delete command.")
611 (defvar tpu-last-deleted-char
""
612 "Last character deleted by a TPU-edt character-delete command.")
614 (defvar tpu-searching-forward t
615 "If non-nil, TPU-edt is searching in the forward direction.")
616 (defvar tpu-search-last-string
""
617 "Last text searched for by the TPU-edt search commands.")
618 (defvar tpu-search-overlay
(make-overlay 1 1)
619 "Search highlight overlay.")
620 (overlay-put tpu-search-overlay
'face
'bold
)
622 (defvar tpu-replace-overlay
(make-overlay 1 1)
623 "Replace highlight overlay.")
624 (overlay-put tpu-replace-overlay
'face
'highlight
)
626 (defvar tpu-regexp-p nil
627 "If non-nil, TPU-edt uses regexp search and replace routines.")
628 (defvar tpu-rectangular-p nil
629 "If non-nil, TPU-edt removes and inserts rectangles.")
630 (defvar tpu-advance t
631 "True when TPU-edt is operating in the forward direction.")
632 (defvar tpu-reverse nil
633 "True when TPU-edt is operating in the backward direction.")
634 (defvar tpu-control-keys nil
635 "If non-nil, control keys are set to perform TPU functions.")
636 (defvar tpu-xkeys-file nil
637 "File containing TPU-edt X key map.")
639 (defvar tpu-rectangle-string nil
640 "Mode line string to identify rectangular mode.")
641 (defvar tpu-direction-string nil
642 "Mode line string to identify current direction.")
644 (defvar tpu-add-at-bol-hist nil
645 "History variable for tpu-edt-add-at-bol function.")
646 (defvar tpu-add-at-eol-hist nil
647 "History variable for tpu-edt-add-at-eol function.")
648 (defvar tpu-regexp-prompt-hist nil
649 "History variable for search and replace functions.")
653 ;;; Buffer Local Variables
655 (defvar tpu-newline-and-indent-p nil
656 "If non-nil, Return produces a newline and indents.")
657 (make-variable-buffer-local 'tpu-newline-and-indent-p
)
659 (defvar tpu-newline-and-indent-string nil
660 "Mode line string to identify AutoIndent mode.")
661 (make-variable-buffer-local 'tpu-newline-and-indent-string
)
663 (defvar tpu-saved-delete-func nil
664 "Saved value of the delete key.")
665 (make-variable-buffer-local 'tpu-saved-delete-func
)
667 (defvar tpu-buffer-local-map nil
668 "TPU-edt buffer local key map.")
669 (make-variable-buffer-local 'tpu-buffer-local-map
)
673 ;;; Mode Line - Modify the mode line to show the following
676 ;;; o Direction of motion.
677 ;;; o Active rectangle mode.
678 ;;; o Active auto indent mode.
680 (defvar tpu-original-mm-alist minor-mode-alist
)
682 (defvar tpu-mark-flag
"")
683 (make-variable-buffer-local 'tpu-mark-flag
)
685 (defun tpu-set-mode-line (for-tpu)
686 "Set ``minor-mode-alist'' for TPU-edt, or reset it to default Emacs."
687 (let ((entries '((tpu-newline-and-indent-p tpu-newline-and-indent-string
)
688 (tpu-rectangular-p tpu-rectangle-string
)
689 (tpu-direction-string tpu-direction-string
)
690 (tpu-mark-flag tpu-mark-flag
))))
691 (dolist (entry entries
)
693 (add-to-list 'minor-mode-alist entry
)
694 (setq minor-mode-alist
(remove entry minor-mode-alist
))))))
696 (defun tpu-update-mode-line nil
697 "Make sure mode-line in the current buffer reflects all changes."
698 (setq tpu-mark-flag
(if transient-mark-mode
"" (if (tpu-mark) " @" " ")))
699 (force-mode-line-update))
701 (cond (tpu-lucid-emacs-p
702 (add-hook 'zmacs-deactivate-region-hook
'tpu-update-mode-line
)
703 (add-hook 'zmacs-activate-region-hook
'tpu-update-mode-line
))
705 (add-hook 'activate-mark-hook
'tpu-update-mode-line
)
706 (add-hook 'deactivate-mark-hook
'tpu-update-mode-line
)))
714 ;;; Used in: Replace, Substitute, Store-Text, Cut/Remove,
715 ;;; Append, and Change-Case
717 (defvar tpu-match-beginning-mark
(make-marker))
718 (defvar tpu-match-end-mark
(make-marker))
720 (defun tpu-set-match nil
721 "Set markers at match beginning and end."
722 ;; Add one to beginning mark so it stays with the first character of
723 ;; the string even if characters are added just before the string.
724 (setq tpu-match-beginning-mark
(copy-marker (match-beginning 0) t
))
725 (setq tpu-match-end-mark
(copy-marker (match-end 0))))
727 (defun tpu-unset-match nil
728 "Unset match beginning and end markers."
729 (set-marker tpu-match-beginning-mark nil
)
730 (set-marker tpu-match-end-mark nil
))
732 (defun tpu-match-beginning nil
733 "Returns the location of the last match beginning."
734 (marker-position tpu-match-beginning-mark
))
736 (defun tpu-match-end nil
737 "Returns the location of the last match end."
738 (marker-position tpu-match-end-mark
))
740 (defun tpu-check-match nil
741 "Returns t if point is between tpu-match markers.
742 Otherwise sets the tpu-match markers to nil and returns nil."
743 ;; make sure 1- marker is in this buffer
744 ;; 2- point is at or after beginning marker
745 ;; 3- point is before ending marker, or in the case of
746 ;; zero length regions (like bol, or eol) that the
747 ;; beginning, end, and point are equal.
749 (equal (marker-buffer tpu-match-beginning-mark
) (current-buffer))
750 (>= (point) (marker-position tpu-match-beginning-mark
))
752 (< (point) (marker-position tpu-match-end-mark
))
753 (and (= (marker-position tpu-match-beginning-mark
)
754 (marker-position tpu-match-end-mark
))
755 (= (marker-position tpu-match-end-mark
) (point))))) t
)
757 (tpu-unset-match) nil
)))
759 (defun tpu-show-match-markers nil
760 "Show the values of the match markers."
762 (if (markerp tpu-match-beginning-mark
)
763 (message "(%s, %s) in %s -- current %s in %s"
764 (marker-position tpu-match-beginning-mark
)
765 (marker-position tpu-match-end-mark
)
766 (marker-buffer tpu-match-end-mark
)
767 (point) (current-buffer))))
773 (defun tpu-caar (thingy) (car (car thingy
)))
774 (defun tpu-cadr (thingy) (car (cdr thingy
)))
776 (defvar zmacs-regions
)
779 "TPU-edt version of the mark function.
780 Return the appropriate value of the mark for the current
782 (cond (tpu-lucid-emacs-p (mark (not zmacs-regions
)))
783 (t (and mark-active
(mark (not transient-mark-mode
))))))
785 (defun tpu-set-mark (pos)
786 "TPU-edt version of the `set-mark' function.
787 Sets the mark at POS and activates the region according to the
788 current version of Emacs."
790 ;; We use a separate `if' for the fboundp so the byte-compiler notices it
791 ;; and doesn't complain about the subsequent call.
792 (if (fboundp 'zmacs-activate-region
) (if pos
(zmacs-activate-region))))
794 (defun tpu-string-prompt (prompt history-symbol
)
795 "Read a string with PROMPT."
796 (read-from-minibuffer prompt nil nil nil history-symbol
))
798 (defvar tpu-last-answer nil
"Most recent response to tpu-y-or-n-p.")
800 (defun tpu-y-or-n-p (prompt &optional not-yes
)
801 "Prompt for a y or n answer with positive default.
802 Optional second argument NOT-YES changes default to negative.
803 Like Emacs `y-or-n-p', but also accepts space as y and DEL as n."
804 (message "%s[%s]" prompt
(if not-yes
"n" "y"))
808 (let ((ans (read-char)))
809 (cond ((or (= ans ?y
) (= ans ?Y
) (= ans ?\
))
810 (setq tpu-last-answer t
))
811 ((or (= ans ?n
) (= ans ?N
) (= ans ?\C-?
))
812 (setq tpu-last-answer nil
))
813 ((= ans ?
\r) (setq tpu-last-answer
(not not-yes
)))
816 (message "Please answer y or n. %s[%s]"
817 prompt
(if not-yes
"n" "y")))))))
820 (defun tpu-local-set-key (key func
)
821 "Replace a key in the TPU-edt local key map.
822 Create the key map if necessary."
823 (cond ((not (keymapp tpu-buffer-local-map
))
824 (setq tpu-buffer-local-map
(if (current-local-map)
825 (copy-keymap (current-local-map))
826 (make-sparse-keymap)))
827 (use-local-map tpu-buffer-local-map
)))
828 (local-set-key key func
))
830 (defun tpu-current-line ()
831 "Return the vertical position of point in the selected window.
832 Top line is 0. Counts each text line only once, even if it wraps."
834 (cdr (nth 6 (posn-at-point)))
835 (if (eq (window-start) (point)) 0
836 (1- (count-screen-lines (window-start) (point) 'count-final-newline
)))))
842 (defvar tpu-breadcrumb-plist nil
843 "The set of user-defined markers (breadcrumbs), as a plist.")
845 (defun tpu-drop-breadcrumb (num)
846 "Drops a breadcrumb that can be returned to later with goto-breadcrumb."
848 (put tpu-breadcrumb-plist num
(list (current-buffer) (point)))
849 (message "Mark %d set." num
))
851 (defun tpu-goto-breadcrumb (num)
852 "Returns to a breadcrumb set with drop-breadcrumb."
854 (cond ((get tpu-breadcrumb-plist num
)
855 (switch-to-buffer (car (get tpu-breadcrumb-plist num
)))
856 (goto-char (tpu-cadr (get tpu-breadcrumb-plist num
)))
857 (message "mark %d found." num
))
859 (message "mark %d not found." num
))))
865 (defun tpu-change-case (num)
866 "Change the case of the character under the cursor or region.
867 Accepts a prefix argument of the number of characters to invert."
870 (let ((beg (region-beginning)) (end (region-end)))
872 (funcall (if (= (downcase (char-after beg
)) (char-after beg
))
873 'upcase-region
'downcase-region
)
878 (let ((beg (tpu-match-beginning)) (end (tpu-match-end)))
880 (funcall (if (= (downcase (char-after beg
)) (char-after beg
))
881 'upcase-region
'downcase-region
)
887 (funcall (if (= (downcase (following-char)) (following-char))
888 'upcase-region
'downcase-region
)
889 (point) (1+ (point)))
890 (forward-char (if tpu-reverse -
1 1))
891 (setq num
(1- num
))))))
893 (defun tpu-fill (num)
894 "Fill paragraph or marked region.
895 With argument, fill and justify."
898 (fill-region (point) (tpu-mark) num
)
901 (fill-paragraph num
))))
903 (defun tpu-version nil
904 "Print the TPU-edt version number."
907 "TPU-edt version %s by Rob Riepel (riepel@networking.stanford.edu)"
910 (defun tpu-reset-screen-size (height width
)
911 "Sets the screen size."
912 (interactive "nnew screen height: \nnnew screen width: ")
913 (set-frame-height (selected-frame) height
)
914 (set-frame-width (selected-frame) width
))
916 (defun tpu-toggle-newline-and-indent nil
917 "Toggle between 'newline and indent' and 'simple newline'."
919 (cond (tpu-newline-and-indent-p
920 (setq tpu-newline-and-indent-string
"")
921 (setq tpu-newline-and-indent-p nil
)
922 (tpu-local-set-key "\C-m" 'newline
))
924 (setq tpu-newline-and-indent-string
" AutoIndent")
925 (setq tpu-newline-and-indent-p t
)
926 (tpu-local-set-key "\C-m" 'newline-and-indent
)))
927 (tpu-update-mode-line)
929 (message "Carriage return inserts a newline%s"
930 (if tpu-newline-and-indent-p
" and indents." "."))))
932 (defun tpu-spell-check nil
933 "Checks the spelling of the region, or of the entire buffer if no
936 (cond (tpu-have-ispell
937 (if (tpu-mark) (ispell-region (tpu-mark) (point)) (ispell-buffer)))
939 (if (tpu-mark) (spell-region (tpu-mark) (point)) (spell-buffer))))
940 (if (tpu-mark) (tpu-unselect t
)))
942 (defun tpu-toggle-overwrite-mode nil
943 "Switches in and out of overwrite mode"
945 (cond (overwrite-mode
946 (tpu-local-set-key "\177" tpu-saved-delete-func
)
949 (setq tpu-saved-delete-func
(local-key-binding "\177"))
950 (tpu-local-set-key "\177" 'picture-backward-clear-column
)
951 (overwrite-mode 1))))
953 (defun tpu-special-insert (num)
954 "Insert a character or control code according to
955 its ASCII decimal value."
957 (if overwrite-mode
(delete-char 1))
958 (insert (if num num
0)))
960 (defun tpu-quoted-insert (num)
961 "Read next input character and insert it.
962 This is useful for inserting control characters."
964 (let ((char (read-char)) )
965 (if overwrite-mode
(delete-char num
))
966 (insert-char char num
)))
970 ;;; TPU line-mode commands
972 (defun tpu-include (file)
973 "TPU-like include file"
974 (interactive "fInclude file: ")
975 (insert-file-contents file
)
978 (defun tpu-get (file)
980 (interactive "FFile to get: ")
981 (find-file file find-file-wildcards
))
983 (defun tpu-what-line nil
984 "Tells what line the point is on,
985 and the total number of lines in the buffer."
988 (message "You are at the End of Buffer. The last line is %d."
989 (count-lines 1 (point-max)))
990 (let* ((cur (count-lines 1 (1+ (point))))
991 (max (count-lines 1 (point-max)))
992 (pct (/ (* 100 (+ cur
(/ max
200))) max
)))
993 (message "You are on line %d out of %d (%d%%)." cur max pct
))))
996 "Exit the way TPU does, save current buffer and ask about others."
998 (if (not (eq (recursion-depth) 0))
999 (exit-recursive-edit)
1000 (progn (save-buffer) (save-buffers-kill-emacs))))
1003 "Quit the way TPU does, ask to make sure changes should be abandoned."
1005 (let ((list (buffer-list))
1007 (while (and list working
)
1008 (let ((buffer (car list
)))
1009 (if (and (buffer-file-name buffer
) (buffer-modified-p buffer
))
1011 "Modifications will not be saved, continue quitting? ")
1012 (kill-emacs t
) (setq working nil
)))
1013 (setq list
(cdr list
))))
1014 (if working
(kill-emacs t
))))
1018 ;;; Command and Function Aliases
1021 (define-minor-mode tpu-edt-mode
1022 "TPU/edt emulation."
1024 (if tpu-edt-mode
(tpu-edt-on) (tpu-edt-off)))
1026 (defalias 'TPU-EDT-MODE
'tpu-edt-mode
)
1029 (defalias 'tpu-edt
'tpu-edt-on
)
1030 (defalias 'TPU-EDT
'tpu-edt-on
)
1032 ;; Note: The following functions have no `tpu-' prefix. This is unavoidable.
1033 ;; The real TPU/edt editor has interactive commands with these names,
1034 ;; so tpu-edt.el users expect things like M-x exit RET and M-x help RET
1035 ;; to work. Therefore it really is necessary to define these functions,
1036 ;; even in cases where they redefine existing Emacs functions.
1038 (defalias 'exit
'tpu-exit
)
1039 (defalias 'EXIT
'tpu-exit
)
1041 (defalias 'Get
'tpu-get
)
1042 (defalias 'GET
'tpu-get
)
1044 (defalias 'include
'tpu-include
)
1045 (defalias 'INCLUDE
'tpu-include
)
1047 (defalias 'quit
'tpu-quit
)
1048 (defalias 'QUIT
'tpu-quit
)
1050 (defalias 'spell
'tpu-spell-check
)
1051 (defalias 'SPELL
'tpu-spell-check
)
1053 (defalias 'what\ line
'tpu-what-line
)
1054 (defalias 'WHAT\ LINE
'tpu-what-line
)
1056 (defalias 'replace
'tpu-lm-replace
)
1057 (defalias 'REPLACE
'tpu-lm-replace
)
1059 (defalias 'help
'tpu-help
)
1060 (defalias 'HELP
'tpu-help
)
1062 (defalias 'set\ cursor\ free
'tpu-set-cursor-free
)
1063 (defalias 'SET\ CURSOR\ FREE
'tpu-set-cursor-free
)
1065 (defalias 'set\ cursor\ bound
'tpu-set-cursor-bound
)
1066 (defalias 'SET\ CURSOR\ BOUND
'tpu-set-cursor-bound
)
1068 (defalias 'set\ scroll\ margins
'tpu-set-scroll-margins
)
1069 (defalias 'SET\ SCROLL\ MARGINS
'tpu-set-scroll-margins
)
1071 ;; Real TPU error messages end in periods.
1072 ;; Define this to avoid openly flouting Emacs coding standards.
1073 (defalias 'tpu-error
'error
)
1079 (defvar tpu-help-keypad-map
"\f
1080 _______________________ _______________________________
1081 | HELP | Do | | | | | |
1082 |KeyDefs| | | | | | |
1083 |_______|_______________| |_______|_______|_______|_______|
1084 _______________________ _______________________________
1085 | Find |Insert |Remove | | Gold | HELP |FndNxt | Del L |
1086 | | |Sto Tex| | key |E-Help | Find |Undel L|
1087 |_______|_______|_______| |_______|_______|_______|_______|
1088 |Select |Pre Scr|Nex Scr| | Page | Sect |Append | Del W |
1089 | Reset |Pre Win|Nex Win| | Do | Fill |Replace|Undel W|
1090 |_______|_______|_______| |_______|_______|_______|_______|
1091 |Move up| |Forward|Reverse|Remove | Del C |
1092 | Top | |Bottom | Top |Insert |Undel C|
1093 _______|_______|_______ |_______|_______|_______|_______|
1094 |Mov Lef|Mov Dow|Mov Rig| | Word | EOL | Char | |
1095 |StaOfLi|Bottom |EndOfLi| |ChngCas|Del EOL|SpecIns| Enter |
1096 |_______|_______|_______| |_______|_______|_______| |
1097 | Line |Select | Subs |
1098 | Open Line | Reset | |
1099 |_______________|_______|_______|
1102 (defvar tpu-help-text
"
1103 \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\f
1107 ^A toggle insert and overwrite
1111 ^G Cancel current operation
1112 ^H beginning of line
1113 ^J delete previous word
1116 ^L insert page break
1117 ^R remember (during learn), re-center
1119 ^U delete to beginning of line
1124 ^X^X exchange point and mark - useful for checking region boundaries
1126 \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\f
1127 Gold-<key> Functions
1129 B Next Buffer - display the next buffer (all buffers)
1130 C Recall - edit and possibly repeat previous commands
1131 E Exit - save current buffer and ask about others
1132 G Get - load a file into a new edit buffer
1134 I Include - include a file in this buffer
1135 K Kill Buffer - abandon edits and delete buffer
1136 M Buffer Menu - display a list of all buffers
1137 N Next File Buffer - display next buffer containing a file
1139 O Occur - show following lines containing REGEXP
1140 Q Quit - exit without saving anything
1141 R Toggle rectangular mode for remove and insert
1142 S Search and substitute - line mode REPLACE command
1144 ^T Toggle control key bindings between TPU and Emacs
1145 U Undo - undo the last edit
1146 W Write - save current buffer
1147 X Exit - save all modified buffers and exit
1149 \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\f
1151 More extensive documentation on TPU-edt can be found in the `Commentary'
1152 section of tpu-edt.el. This section can be accessed through the standard
1153 Emacs help facility using the `p' option. Once you exit TPU-edt Help, one
1154 of the following key sequences is sure to get you there.
1156 ^h p if you're not yet using TPU-edt
1157 Gold-PF2 p if you're using TPU-edt
1159 Alternatively, fire up Emacs help from the command prompt, with
1161 M-x help-for-help <CR> p <CR>
1163 Where `M-x' might be any of `Gold-KP7', 'Do', or 'ESC-x'.
1165 When you successfully invoke this part of the Emacs help facility, you
1166 will see a buffer named `*Finder*' listing a number of topics. Look for
1167 tpu-edt under `emulations'.
1169 \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\f
1171 *** No more help, use P to view previous screen")
1173 (defvar tpu-help-enter
(format "%s" "\eOM")) ; tpu-help enter key symbol
1174 (defvar tpu-help-return
(format "%s" "\r")) ; tpu-help enter key symbol
1175 (defvar tpu-help-N
"N") ; tpu-help "N" symbol
1176 (defvar tpu-help-n
"n") ; tpu-help "n" symbol
1177 (defvar tpu-help-P
"P") ; tpu-help "P" symbol
1178 (defvar tpu-help-p
"p") ; tpu-help "p" symbol
1181 "Display TPU-edt help."
1183 ;; Save current window configuration
1184 (save-window-excursion
1185 ;; Create and fill help buffer if necessary
1186 (if (not (get-buffer "*TPU-edt Help*"))
1187 (progn (generate-new-buffer "*TPU-edt Help*")
1188 (switch-to-buffer "*TPU-edt Help*")
1189 (insert tpu-help-keypad-map
)
1190 (insert tpu-help-text
)
1191 (setq buffer-read-only t
)))
1193 ;; Display the help buffer
1194 (switch-to-buffer "*TPU-edt Help*")
1195 (delete-other-windows)
1196 (tpu-move-to-beginning)
1198 (tpu-line-to-top-of-window)
1200 ;; Prompt for keys to describe, based on screen state (split/not split)
1201 (let ((key nil
) (fkey nil
) (split nil
))
1202 (while (not (equal tpu-help-return fkey
))
1206 "Press the key you want help on (RET=exit, ENTER=redisplay, N=next, P=prev): "))
1209 "Press the key you want help on (RET to exit, N next screen, P prev screen): ")))
1211 ;; Process the read key
1213 ;; ENTER - Display just the help window
1214 ;; N or n - Next help or describe-key screen
1215 ;; P or p - Previous help or describe-key screen
1216 ;; RETURN - Exit from TPU-help
1217 ;; default - describe the key
1219 (setq fkey
(format "%s" key
))
1220 (cond ((equal tpu-help-enter fkey
)
1222 (delete-other-windows))
1223 ((or (equal tpu-help-N fkey
) (equal tpu-help-n fkey
))
1226 (scroll-other-window 8)
1231 (tpu-line-to-top-of-window))))
1232 ((or (equal tpu-help-P fkey
) (equal tpu-help-p fkey
))
1235 (scroll-other-window -
8)
1241 (tpu-line-to-top-of-window))))
1242 ((not (equal tpu-help-return fkey
))
1245 ;; If the key is undefined, leave the
1246 ;; message in the mini-buffer for 3 seconds
1247 (if (not (key-binding key
)) (sit-for 3))))))))
1253 (defun tpu-insert-escape nil
1254 "Inserts an escape character, and so becomes the escape-key alias."
1258 (defun tpu-insert-formfeed nil
1259 "Inserts a formfeed character."
1267 (defvar tpu-saved-control-r nil
"Saved value of Control-r.")
1269 (defun tpu-end-define-macro-key (key)
1270 "Ends the current macro definition"
1271 (interactive "kPress the key you want to use to do what was just learned: ")
1273 (global-set-key key last-kbd-macro
)
1274 (global-set-key "\C-r" tpu-saved-control-r
))
1276 (defun tpu-define-macro-key nil
1277 "Bind a set of keystrokes to a single key, or key combination."
1279 (setq tpu-saved-control-r
(global-key-binding "\C-r"))
1280 (global-set-key "\C-r" 'tpu-end-define-macro-key
)
1281 (start-kbd-macro nil
))
1285 ;;; Buffers and Windows
1287 (defun tpu-kill-buffer nil
1288 "Kills the current buffer. If tpu-kill-buffers-silently is non-nil,
1289 kills modified buffers without asking."
1291 (if tpu-kill-buffers-silently
(set-buffer-modified-p nil
))
1292 (kill-buffer (current-buffer)))
1294 (defun tpu-save-all-buffers-kill-emacs nil
1295 "Save all buffers and exit Emacs."
1297 (let ((delete-old-versions t
))
1298 (save-buffers-kill-emacs t
)))
1300 (defun tpu-write-current-buffers nil
1301 "Save all modified buffers without exiting."
1303 (save-some-buffers t
))
1305 (defun tpu-next-buffer nil
1306 "Go to next buffer in ring."
1308 (switch-to-buffer (car (reverse (buffer-list)))))
1310 (defun tpu-next-file-buffer nil
1311 "Go to next buffer in ring that is visiting a file or directory."
1313 (let ((list (tpu-make-file-buffer-list (buffer-list))))
1314 (setq list
(delq (current-buffer) list
))
1315 (if (not list
) (tpu-error "No other buffers."))
1316 (switch-to-buffer (car (reverse list
)))))
1318 (defun tpu-make-file-buffer-list (buffer-list)
1319 "Returns names from BUFFER-LIST excluding those beginning with a space or star."
1320 (delq nil
(mapcar '(lambda (b)
1321 (if (or (= (aref (buffer-name b
) 0) ?
)
1322 (= (aref (buffer-name b
) 0) ?
*)) nil b
))
1325 (defun tpu-next-window nil
1326 "Move to the next window."
1328 (if (one-window-p) (message "There is only one window on screen.")
1331 (defun tpu-previous-window nil
1332 "Move to the previous window."
1334 (if (one-window-p) (message "There is only one window on screen.")
1335 (select-window (previous-window))))
1341 (defun tpu-toggle-regexp nil
1342 "Switches in and out of regular expression search and replace mode."
1344 (setq tpu-regexp-p
(not tpu-regexp-p
))
1346 (and (interactive-p)
1347 (message "Regular expression search and substitute %sabled."
1348 (if tpu-regexp-p
"en" "dis"))))
1350 (defun tpu-regexp-prompt (prompt)
1351 "Read a string, adding 'RE' to the prompt if tpu-regexp-p is set."
1352 (let ((re-prompt (concat (if tpu-regexp-p
"RE ") prompt
)))
1353 (read-from-minibuffer re-prompt nil nil nil
'tpu-regexp-prompt-hist
)))
1355 (defun tpu-search-highlight nil
1356 (if (tpu-check-match)
1357 (move-overlay tpu-search-overlay
1358 (tpu-match-beginning) (tpu-match-end) (current-buffer))
1359 (unless (equal (overlay-start tpu-search-overlay
)
1360 (overlay-end tpu-search-overlay
))
1361 (move-overlay tpu-search-overlay
1 1 (current-buffer)))))
1363 (defun tpu-search nil
1364 "Search for a string or regular expression.
1365 The search is performed in the current direction."
1368 (tpu-search-internal ""))
1370 (defun tpu-search-forward nil
1371 "Search for a string or regular expression.
1372 The search is begins in the forward direction."
1374 (setq tpu-searching-forward t
)
1376 (tpu-search-internal ""))
1378 (defun tpu-search-reverse nil
1379 "Search for a string or regular expression.
1380 The search is begins in the reverse direction."
1382 (setq tpu-searching-forward nil
)
1384 (tpu-search-internal ""))
1386 (defun tpu-search-again nil
1387 "Search for the same string or regular expression as last time.
1388 The search is performed in the current direction."
1390 (tpu-search-internal tpu-search-last-string
))
1392 ;; tpu-set-search defines the search functions used by the TPU-edt internal
1393 ;; search function. It should be called whenever the direction changes, or
1394 ;; the regular expression mode is turned on or off. It can also be called
1395 ;; to ensure that the next search will be in the current direction. It is
1398 ;; tpu-advance tpu-backup
1399 ;; tpu-toggle-regexp tpu-toggle-search-direction (t)
1400 ;; tpu-search tpu-lm-replace
1401 ;; tpu-search-forward (t) tpu-search-reverse (t)
1402 ;; tpu-search-forward-exit (t) tpu-search-backward-exit (t)
1404 (defun tpu-set-search (&optional arg
)
1405 "Set the search functions and set the search direction to the current
1406 direction. If an argument is specified, don't set the search direction."
1407 (if (not arg
) (setq tpu-searching-forward tpu-advance
))
1408 (cond (tpu-searching-forward
1410 (fset 'tpu-emacs-search
're-search-forward
)
1411 (fset 'tpu-emacs-rev-search
're-search-backward
))
1413 (fset 'tpu-emacs-search
'search-forward
)
1414 (fset 'tpu-emacs-rev-search
'search-backward
))))
1417 (fset 'tpu-emacs-search
're-search-backward
)
1418 (fset 'tpu-emacs-rev-search
're-search-forward
))
1420 (fset 'tpu-emacs-search
'search-backward
)
1421 (fset 'tpu-emacs-rev-search
'search-forward
))))))
1423 (defun tpu-search-internal (pat &optional quiet
)
1424 "Search for a string or regular expression."
1425 (setq tpu-search-last-string
1426 (if (not (string= "" pat
)) pat
(tpu-regexp-prompt "Search: ")))
1431 (let ((case-fold-search
1432 (and case-fold-search
(tpu-check-search-case tpu-search-last-string
))))
1434 (cond ((tpu-emacs-search tpu-search-last-string nil t
)
1435 (tpu-set-match) (goto-char (tpu-match-beginning)))
1438 (tpu-adjust-search t
)
1439 (let ((found nil
) (pos nil
))
1441 (let ((tpu-searching-forward (not tpu-searching-forward
)))
1443 (setq found
(tpu-emacs-rev-search tpu-search-last-string nil t
))
1444 (setq pos
(match-beginning 0))))
1448 (cond ((tpu-y-or-n-p
1449 (format "Found in %s direction. Go there? "
1450 (if tpu-searching-forward
"reverse" "forward")))
1451 (goto-char pos
) (tpu-set-match)
1452 (tpu-toggle-search-direction))))
1457 "%sSearch failed: \"%s\""
1458 (if tpu-regexp-p
"RE " "") tpu-search-last-string
)))))))))
1460 (defalias 'tpu-search-internal-core
(symbol-function 'tpu-search-internal
))
1462 (defun tpu-check-search-case (string)
1463 "Returns t if string contains upper case."
1464 ;; if using regexp, eliminate upper case forms (\B \W \S.)
1466 (let ((pat (copy-sequence string
)) (case-fold-search nil
) (pos 0))
1467 (while (setq pos
(string-match "\\\\\\\\" pat
)) (aset pat
(+ 1 pos
) ?.
))
1468 (while (setq pos
(string-match "\\\\B" pat
)) (aset pat
(+ 1 pos
) ?.
))
1469 (while (setq pos
(string-match "\\\\W" pat
)) (aset pat
(+ 1 pos
) ?.
))
1470 (while (setq pos
(string-match "\\\\S." pat
))
1471 (aset pat
(+ 1 pos
) ?.
) (aset pat
(+ 2 pos
) ?.
))
1472 (string-equal pat
(downcase pat
)))
1473 (string-equal string
(downcase string
))))
1475 (defun tpu-adjust-search (&optional arg
)
1476 "For forward searches, move forward a character before searching,
1477 and backward a character after a failed search. Arg means end of search."
1478 (if tpu-searching-forward
1479 (cond (arg (if (not (bobp)) (forward-char -
1)))
1480 (t (if (not (eobp)) (forward-char 1))))))
1482 (defun tpu-toggle-search-direction nil
1483 "Toggle the TPU-edt search direction.
1484 Used for reversing a search in progress."
1486 (setq tpu-searching-forward
(not tpu-searching-forward
))
1488 (and (interactive-p)
1489 (message "Searching %sward."
1490 (if tpu-searching-forward
"for" "back"))))
1492 (defun tpu-search-forward-exit nil
1493 "Set search direction forward and exit minibuffer."
1495 (setq tpu-searching-forward t
)
1499 (defun tpu-search-backward-exit nil
1500 "Set search direction backward and exit minibuffer."
1502 (setq tpu-searching-forward nil
)
1508 ;;; Select / Unselect
1510 (defun tpu-select (&optional quiet
)
1511 "Sets the mark to define one end of a region."
1514 (tpu-unselect quiet
))
1516 (tpu-set-mark (point))
1517 (tpu-update-mode-line)
1518 (if (not quiet
) (message "Move the text cursor to select text.")))))
1520 (defun tpu-unselect (&optional quiet
)
1521 "Removes the mark to unselect the current region."
1524 (setq mark-ring nil
)
1526 (tpu-update-mode-line)
1527 (if (not quiet
) (message "Selection canceled.")))
1533 (defun tpu-toggle-rectangle nil
1534 "Toggle rectangular mode for remove and insert."
1536 (setq tpu-rectangular-p
(not tpu-rectangular-p
))
1537 (setq tpu-rectangle-string
(if tpu-rectangular-p
" Rect" ""))
1538 (tpu-update-mode-line)
1539 (and (interactive-p)
1540 (message "Rectangular cut and paste %sabled."
1541 (if tpu-rectangular-p
"en" "dis"))))
1543 (defun tpu-arrange-rectangle nil
1544 "Adjust point and mark to mark upper left and lower right
1545 corners of a rectangle."
1546 (let ((mc (current-column))
1547 (pc (progn (exchange-point-and-mark) (current-column))))
1549 (cond ((> (point) (tpu-mark)) ; point on lower line
1550 (cond ((> pc mc
) ; point @ lower-right
1551 (exchange-point-and-mark)) ; point -> upper-left
1553 (t ; point @ lower-left
1554 (move-to-column mc t
) ; point -> lower-right
1555 (exchange-point-and-mark) ; point -> upper-right
1556 (move-to-column pc t
)))) ; point -> upper-left
1558 (t ; point on upper line
1559 (cond ((> pc mc
) ; point @ upper-right
1560 (move-to-column mc t
) ; point -> upper-left
1561 (exchange-point-and-mark) ; point -> lower-left
1562 (move-to-column pc t
) ; point -> lower-right
1563 (exchange-point-and-mark))))))) ; point -> upper-left
1565 (defun tpu-cut-text nil
1566 "Delete the selected region.
1567 The text is saved for the tpu-paste command."
1570 (cond (tpu-rectangular-p
1571 (tpu-arrange-rectangle)
1572 (picture-clear-rectangle (point) (tpu-mark) (not overwrite-mode
))
1575 (setq tpu-last-deleted-region
1576 (buffer-substring (tpu-mark) (point)))
1577 (delete-region (tpu-mark) (point))
1580 (let ((beg (tpu-match-beginning)) (end (tpu-match-end)))
1581 (setq tpu-last-deleted-region
(buffer-substring beg end
))
1582 (delete-region beg end
)
1585 (tpu-error "No selection active."))))
1587 (defun tpu-store-text nil
1588 "Copy the selected region to the cut buffer without deleting it.
1589 The text is saved for the tpu-paste command."
1592 (cond (tpu-rectangular-p
1594 (tpu-arrange-rectangle)
1595 (setq picture-killed-rectangle
1596 (extract-rectangle (point) (tpu-mark))))
1599 (setq tpu-last-deleted-region
1600 (buffer-substring (tpu-mark) (point)))
1603 (setq tpu-last-deleted-region
1604 (buffer-substring (tpu-match-beginning) (tpu-match-end)))
1607 (tpu-error "No selection active."))))
1609 (defun tpu-cut (arg)
1610 "Copy selected region to the cut buffer. In the absence of an
1611 argument, delete the selected region too."
1613 (if arg
(tpu-store-text) (tpu-cut-text)))
1615 (defun tpu-append-region (arg)
1616 "Append selected region to the tpu-cut buffer. In the absence of an
1617 argument, delete the selected region too."
1620 (let ((beg (region-beginning)) (end (region-end)))
1621 (setq tpu-last-deleted-region
1622 (concat tpu-last-deleted-region
1623 (buffer-substring beg end
)))
1624 (if (not arg
) (delete-region beg end
))
1627 (let ((beg (tpu-match-beginning)) (end (tpu-match-end)))
1628 (setq tpu-last-deleted-region
1629 (concat tpu-last-deleted-region
1630 (buffer-substring beg end
)))
1631 (if (not arg
) (delete-region beg end
))
1634 (tpu-error "No selection active."))))
1636 (defun tpu-delete-current-line (num)
1637 "Delete one or specified number of lines after point.
1638 This includes the newline character at the end of each line.
1639 They are saved for the TPU-edt undelete-lines command."
1641 (let ((beg (point)))
1643 (if (not (eq (preceding-char) ?
\n))
1645 (setq tpu-last-deleted-lines
1646 (buffer-substring beg
(point)))
1647 (delete-region beg
(point))))
1649 (defun tpu-delete-to-eol (num)
1650 "Delete text up to end of line.
1651 With argument, delete up to the Nth line-end past point.
1652 They are saved for the TPU-edt undelete-lines command."
1654 (let ((beg (point)))
1657 (setq tpu-last-deleted-lines
1658 (buffer-substring beg
(point)))
1659 (delete-region beg
(point))))
1661 (defun tpu-delete-to-bol (num)
1662 "Delete text back to beginning of line.
1663 With argument, delete up to the Nth line-end past point.
1664 They are saved for the TPU-edt undelete-lines command."
1666 (let ((beg (point)))
1667 (tpu-next-beginning-of-line num
)
1668 (setq tpu-last-deleted-lines
1669 (buffer-substring (point) beg
))
1670 (delete-region (point) beg
)))
1672 (defun tpu-delete-current-word (num)
1673 "Delete one or specified number of words after point.
1674 They are saved for the TPU-edt undelete-words command."
1676 (let ((beg (point)))
1677 (tpu-forward-to-word num
)
1678 (setq tpu-last-deleted-words
1679 (buffer-substring beg
(point)))
1680 (delete-region beg
(point))))
1682 (defun tpu-delete-previous-word (num)
1683 "Delete one or specified number of words before point.
1684 They are saved for the TPU-edt undelete-words command."
1686 (let ((beg (point)))
1687 (tpu-backward-to-word num
)
1688 (setq tpu-last-deleted-words
1689 (buffer-substring (point) beg
))
1690 (delete-region beg
(point))))
1692 (defun tpu-delete-current-char (num)
1693 "Delete one or specified number of characters after point. The last
1694 character deleted is saved for the TPU-edt undelete-char command."
1696 (while (and (> num
0) (not (eobp)))
1697 (setq tpu-last-deleted-char
(char-after (point)))
1698 (cond (overwrite-mode
1699 (picture-clear-column 1)
1703 (setq num
(1- num
))))
1707 ;;; Undelete / Paste
1709 (defun tpu-paste (num)
1710 "Insert the last region or rectangle of killed text.
1711 With argument reinserts the text that many times."
1714 (cond (tpu-rectangular-p
1715 (let ((beg (point)))
1717 (picture-yank-rectangle (not overwrite-mode
))
1721 (insert tpu-last-deleted-region
)))
1722 (setq num
(1- num
))))
1724 (defun tpu-undelete-lines (num)
1725 "Insert lines deleted by last TPU-edt line-deletion command.
1726 With argument reinserts lines that many times."
1728 (let ((beg (point)))
1730 (insert tpu-last-deleted-lines
)
1731 (setq num
(1- num
)))
1734 (defun tpu-undelete-words (num)
1735 "Insert words deleted by last TPU-edt word-deletion command.
1736 With argument reinserts words that many times."
1738 (let ((beg (point)))
1740 (insert tpu-last-deleted-words
)
1741 (setq num
(1- num
)))
1744 (defun tpu-undelete-char (num)
1745 "Insert character deleted by last TPU-edt character-deletion command.
1746 With argument reinserts the character that many times."
1749 (if overwrite-mode
(prog1 (forward-char -
1) (delete-char 1)))
1750 (insert tpu-last-deleted-char
)
1752 (setq num
(1- num
))))
1756 ;;; Replace and Substitute
1758 (defun tpu-replace nil
1759 "Replace the selected region with the contents of the cut buffer."
1762 (let ((beg (region-beginning)) (end (region-end)))
1763 (setq tpu-last-replaced-text
(buffer-substring beg end
))
1764 (delete-region beg end
)
1765 (insert tpu-last-deleted-region
)
1768 (let ((beg (tpu-match-beginning)) (end (tpu-match-end)))
1769 (setq tpu-last-replaced-text
(buffer-substring beg end
))
1770 (replace-match tpu-last-deleted-region
1771 (not case-replace
) (not tpu-regexp-p
))
1774 (tpu-error "No selection active."))))
1776 (defun tpu-substitute (num)
1777 "Replace the selected region with the contents of the cut buffer, and
1778 repeat most recent search. A numeric argument serves as a repeat count.
1779 A negative argument means replace all occurrences of the search string."
1781 (cond ((or (tpu-mark) (tpu-check-match))
1782 (while (and (not (= num
0)) (or (tpu-mark) (tpu-check-match)))
1783 (let ((beg (point)))
1785 (if tpu-searching-forward
(forward-char -
1) (goto-char beg
))
1786 (if (= num
1) (tpu-search-internal tpu-search-last-string
)
1787 (tpu-search-internal-core tpu-search-last-string
)))
1788 (setq num
(1- num
))))
1790 (tpu-error "No selection active."))))
1792 (defun tpu-lm-replace (from to
)
1793 "Interactively search for OLD-string and substitute NEW-string."
1794 (interactive (list (tpu-regexp-prompt "Old String: ")
1795 (tpu-regexp-prompt "New String: ")))
1797 (let ((doit t
) (strings 0))
1799 ;; Can't replace null strings
1800 (if (string= "" from
) (tpu-error "No string to replace."))
1802 ;; Find the first occurrence
1804 (tpu-search-internal from t
)
1806 ;; Loop on replace question - yes, no, all, last, or quit.
1808 (if (not (tpu-check-match)) (setq doit nil
)
1810 (move-overlay tpu-replace-overlay
1811 (tpu-match-beginning) (tpu-match-end) (current-buffer))
1812 (message "Replace? Type Yes, No, All, Last, or Quit: ")
1813 (let ((ans (read-char)))
1815 (cond ((or (= ans ?y
) (= ans ?Y
) (= ans ?
\r) (= ans ?\
))
1816 (let ((beg (point)))
1817 (replace-match to
(not case-replace
) (not tpu-regexp-p
))
1818 (setq strings
(1+ strings
))
1819 (if tpu-searching-forward
(forward-char -
1) (goto-char beg
)))
1820 (tpu-search-internal from t
))
1822 ((or (= ans ?n
) (= ans ?N
) (= ans ?\C-?
))
1823 (tpu-search-internal from t
))
1825 ((or (= ans ?a
) (= ans ?A
))
1827 (let ((beg (point)))
1828 (replace-match to
(not case-replace
) (not tpu-regexp-p
))
1829 (setq strings
(1+ strings
))
1830 (if tpu-searching-forward
(forward-char -
1) (goto-char beg
)))
1831 (tpu-search-internal-core from t
)
1832 (while (tpu-check-match)
1833 (let ((beg (point)))
1834 (replace-match to
(not case-replace
) (not tpu-regexp-p
))
1835 (setq strings
(1+ strings
))
1836 (if tpu-searching-forward
(forward-char -
1) (goto-char beg
)))
1837 (tpu-search-internal-core from t
)))
1840 ((or (= ans ?l
) (= ans ?L
))
1841 (let ((beg (point)))
1842 (replace-match to
(not case-replace
) (not tpu-regexp-p
))
1843 (setq strings
(1+ strings
))
1844 (if tpu-searching-forward
(forward-char -
1) (goto-char beg
)))
1847 ((or (= ans ?q
) (= ans ?Q
))
1849 (setq doit nil
)))))))
1851 (move-overlay tpu-replace-overlay
1 1 (current-buffer))
1852 (message "Replaced %s occurrence%s." strings
(if (not (= 1 strings
)) "s" ""))))
1854 (defun tpu-emacs-replace (&optional dont-ask
)
1855 "A TPU-edt interface to the Emacs replace functions. If TPU-edt is
1856 currently in regular expression mode, the Emacs regular expression
1857 replace functions are used. If an argument is supplied, replacements
1858 are performed without asking. Only works in forward direction."
1861 (setq current-prefix-arg nil
)
1863 (if tpu-regexp-p
'replace-regexp
'replace-string
)))
1866 (if tpu-regexp-p
'query-replace-regexp
'query-replace
)))))
1868 (defun tpu-add-at-bol (text)
1869 "Add text to the beginning of each line in a region,
1870 or each line in the entire buffer if no region is selected."
1872 (list (tpu-string-prompt "String to add: " 'tpu-add-at-bol-hist
)))
1873 (if (string= "" text
) (tpu-error "No string specified."))
1876 (if (> (point) (tpu-mark)) (exchange-point-and-mark))
1877 (while (and (< (point) (tpu-mark)) (re-search-forward "^" (tpu-mark) t
))
1878 (if (< (point) (tpu-mark)) (replace-match text
))))
1882 (goto-char (point-min))
1883 (while (and (re-search-forward "^" nil t
) (not (eobp)))
1884 (replace-match text
))))))
1886 (defun tpu-add-at-eol (text)
1887 "Add text to the end of each line in a region,
1888 or each line of the entire buffer if no region is selected."
1890 (list (tpu-string-prompt "String to add: " 'tpu-add-at-eol-hist
)))
1891 (if (string= "" text
) (tpu-error "No string specified."))
1894 (if (> (point) (tpu-mark)) (exchange-point-and-mark))
1895 (while (< (point) (tpu-mark))
1897 (if (<= (point) (tpu-mark)) (insert text
))
1902 (goto-char (point-min))
1904 (end-of-line) (insert text
) (forward-line))))))
1906 (defun tpu-trim-line-ends nil
1907 "Removes trailing whitespace from every line in the buffer."
1911 (goto-char (point-min))
1912 (while (re-search-forward "[ \t][ \t]*$" nil t
)
1913 (delete-region (match-beginning 0) (match-end 0))))))
1917 ;;; Movement by character
1919 (defun tpu-char (num)
1920 "Move to the next character in the current direction.
1921 A repeat count means move that many characters."
1923 (if tpu-advance
(tpu-forward-char num
) (tpu-backward-char num
)))
1925 (defun tpu-forward-char (num)
1926 "Move right ARG characters (left if ARG is negative)."
1930 (defun tpu-backward-char (num)
1931 "Move left ARG characters (right if ARG is negative)."
1933 (backward-char num
))
1937 ;;; Movement by word
1939 (defvar tpu-word-separator-list
'()
1940 "List of additional word separators.")
1941 (defvar tpu-skip-chars
"^ \t"
1942 "Characters to skip when moving by word.
1943 Additional word separators are added to this string.")
1945 (defun tpu-word (num)
1946 "Move to the beginning of the next word in the current direction.
1947 A repeat count means move that many words."
1949 (if tpu-advance
(tpu-forward-to-word num
) (tpu-backward-to-word num
)))
1951 (defun tpu-forward-to-word (num)
1952 "Move forward until encountering the beginning of a word.
1953 With argument, do this that many times."
1955 (while (and (> num
0) (not (eobp)))
1956 (let* ((beg (point))
1957 (end (prog2 (end-of-line) (point) (goto-char beg
))))
1960 ((memq (char-after (point)) tpu-word-separator-list
)
1962 (skip-chars-forward " \t" end
))
1964 (skip-chars-forward tpu-skip-chars end
)
1965 (skip-chars-forward " \t" end
))))
1966 (setq num
(1- num
))))
1968 (defun tpu-backward-to-word (num)
1969 "Move backward until encountering the beginning of a word.
1970 With argument, do this that many times."
1972 (while (and (> num
0) (not (bobp)))
1973 (let* ((beg (point))
1974 (end (prog2 (beginning-of-line) (point) (goto-char beg
))))
1977 ((memq (char-after (1- (point))) tpu-word-separator-list
)
1980 (skip-chars-backward " \t" end
)
1981 (skip-chars-backward tpu-skip-chars end
)
1982 (if (and (not (bolp)) (= ?
(char-syntax (char-after (point)))))
1983 (forward-char -
1)))))
1984 (setq num
(1- num
))))
1986 (defun tpu-add-word-separators (separators)
1987 "Add new word separators for TPU-edt word commands."
1988 (interactive "sSeparators: ")
1989 (let* ((n 0) (length (length separators
)))
1991 (let ((char (aref separators n
))
1992 (ss (substring separators n
(1+ n
))))
1993 (cond ((not (memq char tpu-word-separator-list
))
1994 (setq tpu-word-separator-list
1995 (append ss tpu-word-separator-list
))
1997 (setq tpu-skip-chars
(concat tpu-skip-chars
"\\-")))
1999 (setq tpu-skip-chars
(concat tpu-skip-chars
"\\\\")))
2001 (setq tpu-skip-chars
(concat tpu-skip-chars
"\\^")))
2003 (setq tpu-skip-chars
(concat tpu-skip-chars ss
))))))
2006 (defun tpu-reset-word-separators nil
2007 "Reset word separators to default value."
2009 (setq tpu-word-separator-list nil
)
2010 (setq tpu-skip-chars
"^ \t"))
2012 (defun tpu-set-word-separators (separators)
2013 "Set new word separators for TPU-edt word commands."
2014 (interactive "sSeparators: ")
2015 (tpu-reset-word-separators)
2016 (tpu-add-word-separators separators
))
2020 ;;; Movement by line
2022 (defun tpu-next-line (num)
2024 Prefix argument serves as a repeat count."
2027 (setq this-command
'next-line
))
2029 (defun tpu-previous-line (num)
2030 "Move to previous line.
2031 Prefix argument serves as a repeat count."
2034 (setq this-command
'previous-line
))
2036 (defun tpu-next-beginning-of-line (num)
2037 "Move to beginning of line; if at beginning, move to beginning of next line.
2038 Accepts a prefix argument for the number of lines to move."
2041 (forward-visible-line (- 1 num
)))
2043 (defun tpu-end-of-line (num)
2044 "Move to the next end of line in the current direction.
2045 A repeat count means move that many lines."
2047 (if tpu-advance
(tpu-next-end-of-line num
) (tpu-previous-end-of-line num
)))
2049 (defun tpu-next-end-of-line (num)
2050 "Move to end of line; if at end, move to end of next line.
2051 Accepts a prefix argument for the number of lines to move."
2056 (defun tpu-previous-end-of-line (num)
2058 Accepts a prefix argument for the number of lines to move."
2060 (end-of-line (- 1 num
)))
2062 (defun tpu-current-end-of-line nil
2063 "Move point to end of current line."
2065 (let ((beg (point)))
2067 (if (= beg
(point)) (message "You are already at the end of a line."))))
2069 (defun tpu-line (num)
2070 "Move to the beginning of the next line in the current direction.
2071 A repeat count means move that many lines."
2073 (if tpu-advance
(tpu-forward-line num
) (tpu-backward-line num
)))
2075 (defun tpu-forward-line (num)
2076 "Move to beginning of next line.
2077 Prefix argument serves as a repeat count."
2081 (defun tpu-backward-line (num)
2082 "Move to beginning of previous line.
2083 Prefix argument serves as repeat count."
2085 (or (bolp) (>= 0 num
) (setq num
(- num
1)))
2086 (forward-line (- num
)))
2090 ;;; Movement by paragraph
2092 (defun tpu-paragraph (num)
2093 "Move to the next paragraph in the current direction.
2094 A repeat count means move that many paragraphs."
2097 (tpu-next-paragraph num
) (tpu-previous-paragraph num
)))
2099 (defun tpu-next-paragraph (num)
2100 "Move to beginning of the next paragraph.
2101 Accepts a prefix argument for the number of paragraphs."
2104 (while (and (not (eobp)) (> num
0))
2105 (if (re-search-forward "^[ \t]*$" nil t
)
2106 (if (re-search-forward "[^ \t\n]" nil t
)
2107 (goto-char (match-beginning 0))
2108 (goto-char (point-max))))
2109 (setq num
(1- num
)))
2110 (beginning-of-line))
2113 (defun tpu-previous-paragraph (num)
2114 "Move to beginning of previous paragraph.
2115 Accepts a prefix argument for the number of paragraphs."
2118 (while (and (not (bobp)) (> num
0))
2119 (if (not (and (re-search-backward "^[ \t]*$" nil t
)
2120 (re-search-backward "[^ \t\n]" nil t
)
2121 (re-search-backward "^[ \t]*$" nil t
)
2122 (progn (re-search-forward "[^ \t\n]" nil t
)
2123 (goto-char (match-beginning 0)))))
2124 (goto-char (point-min)))
2125 (setq num
(1- num
)))
2126 (beginning-of-line))
2130 ;;; Movement by page
2132 (defun tpu-page (num)
2133 "Move to the next page in the current direction.
2134 A repeat count means move that many pages."
2136 (if tpu-advance
(forward-page num
) (backward-page num
))
2137 (if (eobp) (recenter -
1)))
2141 ;;; Scrolling and movement within the buffer
2143 (defun tpu-scroll-window (num)
2144 "Scroll the display to the next section in the current direction.
2145 A repeat count means scroll that many sections."
2147 (if tpu-advance
(tpu-scroll-window-up num
) (tpu-scroll-window-down num
)))
2149 (defun tpu-scroll-window-down (num)
2150 "Scroll the display down to the next section.
2151 A repeat count means scroll that many sections."
2153 (let* ((beg (tpu-current-line))
2154 (height (1- (window-height)))
2155 (lines (* num
(/ (* height tpu-percent-scroll
) 100))))
2156 (line-move (- lines
))
2157 (if (> lines beg
) (recenter 0))))
2159 (defun tpu-scroll-window-up (num)
2160 "Scroll the display up to the next section.
2161 A repeat count means scroll that many sections."
2163 (let* ((beg (tpu-current-line))
2164 (height (1- (window-height)))
2165 (lines (* num
(/ (* height tpu-percent-scroll
) 100))))
2167 (if (>= (+ lines beg
) height
) (recenter -
1))))
2169 (defun tpu-pan-right (num)
2170 "Pan right tpu-pan-columns (16 by default).
2171 Accepts a prefix argument for the number of tpu-pan-columns to scroll."
2173 (scroll-left (* tpu-pan-columns num
)))
2175 (defun tpu-pan-left (num)
2176 "Pan left tpu-pan-columns (16 by default).
2177 Accepts a prefix argument for the number of tpu-pan-columns to scroll."
2179 (scroll-right (* tpu-pan-columns num
)))
2181 (defun tpu-move-to-beginning nil
2182 "Move cursor to the beginning of buffer, but don't set the mark."
2184 (goto-char (point-min)))
2186 (defun tpu-move-to-end nil
2187 "Move cursor to the end of buffer, but don't set the mark."
2189 (goto-char (point-max))
2192 (defun tpu-goto-percent (perc)
2193 "Move point to ARG percentage of the buffer."
2194 (interactive "NGoto-percentage: ")
2195 (if (or (> perc
100) (< perc
0))
2196 (tpu-error "Percentage %d out of range 0 < percent < 100." perc
)
2197 (goto-char (/ (* (point-max) perc
) 100))))
2199 (defun tpu-beginning-of-window nil
2200 "Move cursor to top of window."
2202 (move-to-window-line 0))
2204 (defun tpu-end-of-window nil
2205 "Move cursor to bottom of window."
2207 (move-to-window-line -
1))
2209 (defun tpu-line-to-bottom-of-window nil
2210 "Move the current line to the bottom of the window."
2214 (defun tpu-line-to-top-of-window nil
2215 "Move the current line to the top of the window."
2223 (defun tpu-advance-direction nil
2224 "Set TPU Advance mode so keypad commands move forward."
2226 (setq tpu-direction-string
" Advance")
2227 (setq tpu-advance t
)
2228 (setq tpu-reverse nil
)
2230 (tpu-update-mode-line))
2232 (defun tpu-backup-direction nil
2233 "Set TPU Backup mode so keypad commands move backward."
2235 (setq tpu-direction-string
" Reverse")
2236 (setq tpu-advance nil
)
2237 (setq tpu-reverse t
)
2239 (tpu-update-mode-line))
2241 (defun tpu-toggle-direction nil
2242 "Change the current TPU direction."
2244 (if tpu-advance
(tpu-backup-direction) (tpu-advance-direction)))
2248 ;;; Minibuffer map additions to make KP_enter = RET
2250 ;; Standard Emacs settings under xterm in function-key-map map
2251 ;; "\eOM" to [kp-enter] and [kp-enter] to RET, but since the output of the map
2252 ;; is not fed back into the map, the key stays as kp-enter :-(.
2253 (define-key minibuffer-local-map
[kp-enter
] 'exit-minibuffer
)
2254 ;; These are not necessary because they are inherited.
2255 ;; (define-key minibuffer-local-ns-map [kp-enter] 'exit-minibuffer)
2256 ;; (define-key minibuffer-local-completion-map [kp-enter] 'exit-minibuffer)
2257 (define-key minibuffer-local-must-match-map
[kp-enter
] 'minibuffer-complete-and-exit
)
2261 ;;; Minibuffer map additions to set search direction
2263 (define-key minibuffer-local-map
"\eOt" 'tpu-search-forward-exit
) ;KP4
2264 (define-key minibuffer-local-map
"\eOu" 'tpu-search-backward-exit
) ;KP5
2268 ;;; Functions to set, reset, and toggle the control key bindings
2271 (defvar tpu-control-keys-map
2272 (let ((map (make-sparse-keymap)))
2273 (define-key map
"\C-\\" 'quoted-insert
) ; ^\
2274 (define-key map
"\C-a" 'tpu-toggle-overwrite-mode
) ; ^A
2275 (define-key map
"\C-b" 'repeat-complex-command
) ; ^B
2276 (define-key map
"\C-e" 'tpu-current-end-of-line
) ; ^E
2277 (define-key map
"\C-h" 'tpu-next-beginning-of-line
) ; ^H (BS)
2278 (define-key map
"\C-j" 'tpu-delete-previous-word
) ; ^J (LF)
2279 (define-key map
"\C-k" 'tpu-define-macro-key
) ; ^K
2280 (define-key map
"\C-l" 'tpu-insert-formfeed
) ; ^L (FF)
2281 (define-key map
"\C-r" 'recenter
) ; ^R
2282 (define-key map
"\C-u" 'tpu-delete-to-bol
) ; ^U
2283 (define-key map
"\C-v" 'tpu-quoted-insert
) ; ^V
2284 (define-key map
"\C-w" 'redraw-display
) ; ^W
2285 (define-key map
"\C-z" 'tpu-exit
) ; ^Z
2288 (defun tpu-set-control-keys ()
2289 "Set control keys to TPU style functions."
2290 (tpu-reset-control-keys 'tpu
))
2292 (defun tpu-reset-control-keys (tpu-style)
2293 "Set control keys to TPU or Emacs style functions."
2294 (let ((parent (keymap-parent tpu-global-map
)))
2296 (if (eq parent tpu-control-keys-map
)
2297 nil
;All done already.
2298 ;; Insert tpu-control-keys-map in the global map.
2299 (set-keymap-parent tpu-control-keys-map parent
)
2300 (set-keymap-parent tpu-global-map tpu-control-keys-map
))
2301 (if (not (eq parent tpu-control-keys-map
))
2302 nil
;All done already.
2303 ;; Remove tpu-control-keys-map from the global map.
2304 (set-keymap-parent tpu-global-map
(keymap-parent parent
))
2305 (set-keymap-parent tpu-control-keys-map nil
)))
2306 (setq tpu-control-keys tpu-style
)))
2308 (defun tpu-toggle-control-keys nil
2309 "Toggles control key bindings between TPU-edt and Emacs."
2311 (tpu-reset-control-keys (not tpu-control-keys
))
2312 (and (interactive-p)
2313 (message "Control keys function with %s bindings."
2314 (if tpu-control-keys
"TPU-edt" "Emacs"))))
2318 ;;; Emacs version 19 minibuffer history support
2320 (defun tpu-next-history-element (n)
2321 "Insert the next element of the minibuffer history into the minibuffer."
2323 (next-history-element n
)
2324 (goto-char (point-max)))
2326 (defun tpu-previous-history-element (n)
2327 "Insert the previous element of the minibuffer history into the minibuffer."
2329 (previous-history-element n
)
2330 (goto-char (point-max)))
2332 (defun tpu-arrow-history nil
2333 "Modify minibuffer maps to use arrows for history recall."
2335 (dolist (cur (where-is-internal 'tpu-previous-line
))
2336 (define-key read-expression-map cur
'tpu-previous-history-element
)
2337 (define-key minibuffer-local-map cur
'tpu-previous-history-element
)
2338 ;; These are inherited anyway. --Stef
2339 ;; (define-key minibuffer-local-ns-map cur 'tpu-previous-history-element)
2340 ;; (define-key minibuffer-local-completion-map cur 'tpu-previous-history-element)
2341 ;; (define-key minibuffer-local-must-match-map cur 'tpu-previous-history-element)
2344 (dolist (cur (where-is-internal 'tpu-next-line
))
2345 (define-key read-expression-map cur
'tpu-next-history-element
)
2346 (define-key minibuffer-local-map cur
'tpu-next-history-element
)
2347 ;; These are inherited anyway. --Stef
2348 ;; (define-key minibuffer-local-ns-map cur 'tpu-next-history-element)
2349 ;; (define-key minibuffer-local-completion-map cur 'tpu-next-history-element)
2350 ;; (define-key minibuffer-local-must-match-map cur 'tpu-next-history-element)
2355 ;;; Emacs version 19 X-windows key definition support
2357 (defun tpu-load-xkeys (file)
2358 "Load the TPU-edt X-windows key definitions FILE.
2359 If FILE is nil, try to load a default file. The default file names are
2360 `~/.tpu-lucid-keys' for Lucid emacs, and `~/.tpu-keys' for Emacs."
2361 (interactive "fX key definition file: ")
2363 (setq file
(expand-file-name file
)))
2365 (setq file
(expand-file-name tpu-xkeys-file
)))
2367 (setq file
(convert-standard-filename
2368 (expand-file-name "~/.tpu-lucid-keys"))))
2370 (setq file
(convert-standard-filename
2371 (expand-file-name "~/.tpu-keys")))
2372 (and (not (file-exists-p file
))
2374 (convert-standard-filename
2375 (expand-file-name "~/.tpu-gnu-keys")))
2377 (convert-standard-filename
2378 (expand-file-name "~/.tpu-gnu-keys")) file
))))
2379 (cond ((file-readable-p file
)
2382 (switch-to-buffer "*scratch*")
2386 Ack!! You're running TPU-edt under X-windows without loading an
2387 X key definition file. To create a TPU-edt X key definition
2388 file, run the tpu-mapper.el program. It came with TPU-edt. It
2389 even includes directions on how to use it! Perhaps it's lying
2390 around here someplace. ")
2391 (let ((file "tpu-mapper.el")
2394 (search-list (append (list (expand-file-name ".")) load-path
)))
2395 (while (and (not found
) search-list
)
2396 (setq path
(concat (car search-list
)
2397 (if (string-match "/$" (car search-list
)) "" "/")
2399 (if (and (file-exists-p path
) (not (file-directory-p path
)))
2401 (setq search-list
(cdr search-list
)))
2404 "Ah yes, there it is, in \n\n %s \n\n" path
))
2405 (if (tpu-y-or-n-p "Do you want to run it now? ")
2408 (insert "Nope, I can't seem to find it. :-(\n\n")
2411 (defun tpu-copy-keyfile (oldname newname
)
2412 "Copy the TPU-edt X key definitions file to the new default name."
2413 (interactive "fOld name: \nFNew name: ")
2414 (if (not (get-buffer "*TPU-Notice*")) (generate-new-buffer "*TPU-Notice*"))
2415 (set-buffer "*TPU-Notice*")
2420 The default name of the TPU-edt key definition file has changed
2421 from `~/.tpu-gnu-keys' to `~/.tpu-keys'. With your permission,
2422 your key definitions will be copied to the new file. If you'll
2423 never use older versions of Emacs, you can remove the old file.
2424 If the copy fails, you'll be asked if you want to create a new
2425 key definitions file. Do you want to copy your key definition
2428 (save-window-excursion
2429 (switch-to-buffer-other-window "*TPU-Notice*")
2430 (shrink-window-if-larger-than-buffer)
2431 (goto-char (point-min))
2433 (and (tpu-y-or-n-p "Copy key definitions to the new file now? ")
2434 (condition-case conditions
2435 (copy-file oldname newname
)
2436 (tpu-error (message "Sorry, couldn't copy - %s." (cdr conditions
)))))
2437 (kill-buffer "*TPU-Notice*")))
2439 (defvar tpu-edt-old-global-values nil
)
2442 ;;; Start and Stop TPU-edt
2445 (defun tpu-edt-on ()
2446 "Turn on TPU/edt emulation."
2448 ;; To clean things up (and avoid cycles in the global map).
2450 ;; First, activate tpu-global-map, while protecting the original keymap.
2451 (set-keymap-parent tpu-global-map global-map
)
2452 (setq global-map tpu-global-map
)
2453 (use-global-map global-map
)
2454 ;; Then do the normal TPU setup.
2455 (transient-mark-mode t
)
2456 (add-hook 'post-command-hook
'tpu-search-highlight
)
2457 (tpu-set-mode-line t
)
2458 (tpu-advance-direction)
2459 ;; set page delimiter, display line truncation, and scrolling like TPU
2460 (dolist (varval '((page-delimiter .
"\f")
2461 (truncate-lines . t
)
2463 (push (cons (car varval
) (default-value (car varval
)))
2464 tpu-edt-old-global-values
)
2465 (set-default (car varval
) (cdr varval
)))
2466 (tpu-set-control-keys)
2467 (and window-system
(tpu-load-xkeys nil
))
2469 ;; Then protect tpu-global-map from user modifications.
2470 (let ((map (make-sparse-keymap)))
2471 (set-keymap-parent map global-map
)
2472 (setq global-map map
)
2473 (use-global-map map
))
2474 (setq tpu-edt-mode t
))
2476 (defun tpu-edt-off ()
2477 "Turn off TPU/edt emulation. Note that the keypad is left on."
2479 (tpu-reset-control-keys nil
)
2480 (remove-hook 'post-command-hook
'tpu-search-highlight
)
2481 (tpu-set-mode-line nil
)
2482 (while tpu-edt-old-global-values
2483 (let ((varval (pop tpu-edt-old-global-values
)))
2484 (set-default (car varval
) (cdr varval
))))
2485 ;; Remove tpu-global-map from the global map.
2486 (let ((map global-map
))
2488 (let ((parent (keymap-parent map
)))
2489 (if (eq tpu-global-map parent
)
2490 (set-keymap-parent map
(keymap-parent parent
))
2491 (setq map parent
)))))
2492 (ignore-errors (ad-disable-regexp "\\`tpu-"))
2493 (setq tpu-edt-mode nil
))
2497 ;; arch-tag: f3dfe61c-2cbd-4f73-b9cc-eb215020b857
2498 ;;; tpu-edt.el ends here
