root/trunk/lisp/emulation/tpu-edt.el

;;; tpu-edt.el --- Emacs emulating TPU emulating EDT

;; Copyright (C) 1993, 1994, 1995, 2000, 2001, 2002, 2003, 2004,
;;   2005, 2006, 2007, 2008 Free Software Foundation, Inc.

;; Author: Rob Riepel <riepel@networking.stanford.edu>
;; Maintainer: Rob Riepel <riepel@networking.stanford.edu>
;; Version: 4.5
;; Keywords: emulations

;; 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, 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; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.

;; TPU-edt is based on tpu.el by Jeff Kowalski and Bob Covey.

;;; Commentary:

;; %% TPU-edt -- Emacs emulating TPU emulating EDT

;; %% Contents

;;  % Introduction
;;  % Differences Between TPU-edt and DEC TPU/edt
;;  % Starting TPU-edt
;;  % Customizing TPU-edt using the Emacs Initialization File
;;  % Regular Expressions in TPU-edt


;; %% Introduction

;;    TPU-edt emulates the popular DEC VMS editor EDT (actually, it emulates
;;    DEC TPU's EDT emulation, hence the name TPU-edt).  TPU-edt features the
;;    following TPU/edt functionality:

;;     .  EDT keypad
;;     .  On-line help
;;     .  Repeat counts
;;     .  Scroll margins
;;     .  Learn sequences
;;     .  Free cursor mode
;;     .  Rectangular cut and paste
;;     .  Multiple windows and buffers
;;     .  TPU line-mode REPLACE command
;;     .  Wild card search and substitution
;;     .  Configurable through an initialization file
;;     .  History recall of search strings, file names, and commands

;;    Please note that TPU-edt does NOT emulate TPU.  It emulates TPU's EDT
;;    emulation.  Very few TPU line-mode commands are supported.

;;    TPU-edt, like its VMS cousin, works on VT-series terminals with DEC
;;    style keyboards.  VT terminal emulators, including xterm with the
;;    appropriate key translations, work just fine too.

;;    TPU-edt works with X-windows.  This is accomplished through a TPU-edt X
;;    key map.  The TPU-edt module tpu-mapper creates this map and stores it
;;    in a file.  Tpu-mapper will be run automatically the first time you
;;    invoke the X-windows version of emacs, or you can run it by hand.  See
;;    the commentary in tpu-mapper.el for details.


;; %% Differences Between TPU-edt and DEC TPU/edt

;;    In some cases, Emacs doesn't support text highlighting, so selected
;;    regions are not shown in inverse video.  Emacs uses the concept of "the
;;    mark".  The mark is set at one end of a selected region; the cursor is
;;    at the other.  In cases where the selected region cannot be shown in
;;    inverse video an at sign (@) appears in the mode line when mark is set.
;;    The native emacs command ^X^X (Control-X twice) exchanges the cursor
;;    with the mark; this provides a handy way to find the location of the
;;    mark.

;;    In TPU the cursor can be either bound or free.  Bound means the cursor
;;    cannot wander outside the text of the file being edited.  Free means
;;    the arrow keys can move the cursor past the ends of lines.  Free is the
;;    default mode in TPU; bound is the only mode in EDT.  Bound is the only
;;    mode in the base version of TPU-edt; optional extensions add an
;;    approximation of free mode, see the commentary in tpu-extras.el for
;;    details.

;;    Like TPU, emacs uses multiple buffers.  Some buffers are used to hold
;;    files you are editing; other "internal" buffers are used for emacs' own
;;    purposes (like showing you help).  Here are some commands for dealing
;;    with buffers.

;;       Gold-B   moves to next buffer, including internal buffers
;;       Gold-N   moves to next buffer containing a file
;;       Gold-M   brings up a buffer menu (like TPU "show buffers")

;;    Emacs is very fond of throwing up new windows.  Dealing with all these
;;    windows can be a little confusing at first, so here are a few commands
;;    to that may help:

;;       Gold-Next_Scr  moves to the next window on the screen
;;       Gold-Prev_Scr  moves to the previous window on the screen
;;       Gold-TAB       also moves to the next window on the screen

;;       Control-x 1    deletes all but the current window
;;       Control-x 0    deletes the current window

;;    Note that the buffers associated with deleted windows still exist!

;;    Like TPU, TPU-edt has a "command" function, invoked with Gold-KP7 or
;;    Do.  Most of the commands available are emacs commands.  Some TPU
;;    commands are available, they are: replace, exit, quit, include, and
;;    Get (unfortunately, "get" is an internal emacs function, so we are
;;    stuck with "Get" - to make life easier, Get is available as Gold-g).

;;    TPU-edt supports the recall of commands, file names, and search
;;    strings.  The history of strings recalled differs slightly from
;;    TPU/edt, but it is still very convenient.

;;    Help is available!  The traditional help keys (Help and PF2) display
;;    a small help file showing the default keypad layout, control key
;;    functions, and Gold key functions.  Pressing any key inside of help
;;    splits the screen and prints a description of the function of the
;;    pressed key.  Gold-PF2 invokes the native emacs help, with its
;;    zillions of options.

;;    Thanks to emacs, TPU-edt has some extensions that may make your life
;;    easier, or at least more interesting.  For example, Gold-r toggles
;;    TPU-edt rectangular mode.  In rectangular mode, Remove and Insert work
;;    on rectangles.  Likewise, Gold-* toggles TPU-edt regular expression
;;    mode.  In regular expression mode Find, Find Next, and the line-mode
;;    replace command work with regular expressions.  [A regular expression
;;    is a pattern that denotes a set of strings; like VMS wildcards.]

;;    Emacs also gives TPU-edt the undo and occur functions.  Undo does
;;    what it says; it undoes the last change.  Multiple undos in a row
;;    undo multiple changes.  For your convenience, undo is available on
;;    Gold-u.  Occur shows all the lines containing a specific string in
;;    another window.  Moving to that window, and typing ^C^C (Control-C
;;    twice) on a particular line moves you back to the original window
;;    at that line.  Occur is on Gold-o.

;;    Finally, as you edit, remember that all the power of emacs is at
;;    your disposal.  It really is a fantastic tool.  You may even want to
;;    take some time and read the emacs tutorial; perhaps not to learn the
;;    native emacs key bindings, but to get a feel for all the things
;;    emacs can do for you.  The emacs tutorial is available from the
;;    emacs help function: "Gold-PF2 t"


;; %% Starting TPU-edt

;;    All you have to do to start TPU-edt, is turn it on.  This can be
;;    done from the command line when running emacs.

;;        prompt> emacs -f tpu-edt

;;    If you've already started emacs, turn on TPU-edt using the tpu-edt
;;    command.  First press `M-x' (that's usually `ESC' followed by `x')
;;    and type `tpu-edt' followed by a carriage return.

;;    If you like TPU-edt and want to use it all the time, you can start
;;    TPU-edt using the emacs initialization file, .emacs.  Simply create
;;    a .emacs file in your home directory containing the line:

;;        (tpu-edt)

;;    That's all you need to do to start TPU-edt.


;; %% Customizing TPU-edt using the Emacs Initialization File

;;    The following is a sample emacs initialization file.  It shows how to
;;    invoke TPU-edt, and how to customize it.

;;    ; .emacs - a sample emacs initialization file

;;    ; Turn on TPU-edt
;;    (tpu-edt)

;;    ; Set scroll margins 10% (top) and 15% (bottom).
;;    (tpu-set-scroll-margins "10%" "15%")

;;    ; Load the vtxxx terminal control functions.
;;    (load "vt-control" t)

;;    ; TPU-edt treats words like EDT; here's how to add word separators.
;;    ; Note that backslash (\) and double quote (") are quoted with '\'.
;;    (tpu-add-word-separators "]\\[-_,.\"=+()'/*#:!&;$")

;;    ; Emacs is happy to save files without a final newline; other Unix
;;    ; programs hate that!  Here we make sure that files end with newlines.
;;    (setq require-final-newline t)

;;    ; Emacs uses Control-s and Control-q.  Problems can occur when using
;;    ; emacs on terminals that use these codes for flow control (Xon/Xoff
;;    ; flow control).  These lines disable emacs' use of these characters.
;;    (global-unset-key "\C-s")
;;    (global-unset-key "\C-q")

;;    ; The emacs universal-argument function is very useful.
;;    ; This line maps universal-argument to Gold-PF1.
;;    (define-key GOLD-SS3-map "P" 'universal-argument)          ; Gold-PF1

;;    ; Make KP7 move by paragraphs, instead of pages.
;;    (define-key SS3-map "w" 'tpu-paragraph)                    ; KP7

;;    ; Repeat the preceding mappings for X-windows.
;;    (cond
;;     (window-system
;;      (global-set-key [kp_7] 'tpu-paragraph)                   ; KP7
;;      (define-key GOLD-map [kp_f1] 'universal-argument)))      ; GOLD-PF1

;;    ; Display the TPU-edt version.
;;    (tpu-version)


;; %% Regular Expressions in TPU-edt

;;    Gold-* toggles TPU-edt regular expression mode.  In regular expression
;;    mode, find, find next, replace, and substitute accept emacs regular
;;    expressions.  A complete list of emacs regular expressions can be found
;;    using the emacs "info" command (it's somewhat like the VMS help
;;    command).  Try the following sequence of commands:

;;        DO info             <enter info mode>
;;        m emacs             <select the "emacs" topic>
;;        m regexs            <select the "regular expression" topic>

;;    Type "q" to quit out of info mode.

;;    There is a problem in regular expression mode when searching for empty
;;    strings, like beginning-of-line (^) and end-of-line ($).  When searching
;;    for these strings, find-next may find the current string, instead of the
;;    next one.  This can cause global replace and substitute commands to loop
;;    forever in the same location.  For this reason, commands like

;;        replace "^" "> "       <add "> " to beginning of line>
;;        replace "$" "00711"    <add "00711" to end of line>

;;    may not work properly.

;;    Commands like those above are very useful for adding text to the
;;    beginning or end of lines.  They might work on a line-by-line basis, but
;;    go into an infinite loop if the "all" response is specified.  If the
;;    goal is to add a string to the beginning or end of a particular set of
;;    lines TPU-edt provides functions to do this.

;;        Gold-^  Add a string at BOL in region or buffer
;;        Gold-$  Add a string at EOL in region or buffer

;;    There is also a TPU-edt interface to the native emacs string replacement
;;    commands.  Gold-/ invokes this command.  It accepts regular expressions
;;    if TPU-edt is in regular expression mode.  Given a repeat count, it will
;;    perform the replacement without prompting for confirmation.

;;    This command replaces empty strings correctly, however, it has its
;;    drawbacks.  As a native emacs command, it has a different interface
;;    than the emulated TPU commands.  Also, it works only in the forward
;;    direction, regardless of the current TPU-edt direction.

;;; Todo/Bugs:

;; We shouldn't use vt100 ESC sequences since it is uselessly fighting
;; against function-key-map.  Better use real key names.

;;; Code:

(eval-when-compile (require 'cl))
;; we use picture-mode functions
(require 'picture)

(defgroup tpu nil
  "Emacs emulating TPU emulating EDT."
  :prefix "tpu-"
  :group 'emulations)


;;;
;;;  Version Information
;;;
(defconst tpu-version "4.5" "TPU-edt version number.")


;;;
;;;  User Configurable Variables
;;;
(defcustom tpu-have-ispell t
  "*If non-nil (default), TPU-edt uses ispell for spell checking."
  :type 'boolean
  :group 'tpu)

(defcustom tpu-kill-buffers-silently nil
  "*If non-nil, TPU-edt kills modified buffers without asking."
  :type 'boolean
  :group 'tpu)

(defcustom tpu-percent-scroll 75
  "*Percentage of the screen to scroll for next/previous screen commands."
  :type 'integer
  :group 'tpu)

(defcustom tpu-pan-columns 16
  "*Number of columns the tpu-pan functions scroll left or right."
  :type 'integer
  :group 'tpu)


;;;
;;;  Emacs version identifiers - currently referenced by
;;;
;;;     o tpu-mark              o tpu-set-mark
;;;     o mode line section     o tpu-load-xkeys
;;;
(defconst tpu-lucid-emacs-p
  (string-match "Lucid" emacs-version)
  "Non-nil if we are running Lucid Emacs.")

;;;
;;;  Global Keymaps
;;;
(defvar CSI-map
  (let ((map (make-sparse-keymap)))
    (define-key map "A" 'tpu-previous-line)               ; up
    (define-key map "B" 'tpu-next-line)                   ; down
    (define-key map "D" 'tpu-backward-char)               ; left
    (define-key map "C" 'tpu-forward-char)                ; right

    (define-key map "1~" 'tpu-search)                     ; Find
    (define-key map "2~" 'tpu-paste)                      ; Insert Here
    (define-key map "3~" 'tpu-cut)                        ; Remove
    (define-key map "4~" 'tpu-select)                     ; Select
    (define-key map "5~" 'tpu-scroll-window-down)         ; Prev Screen
    (define-key map "6~" 'tpu-scroll-window-up)           ; Next Screen

    (define-key map "11~" 'nil)                           ; F1
    (define-key map "12~" 'nil)                           ; F2
    (define-key map "13~" 'nil)                           ; F3
    (define-key map "14~" 'nil)                           ; F4
    (define-key map "15~" 'nil)                           ; F5
    (define-key map "17~" 'nil)                           ; F6
    (define-key map "18~" 'nil)                           ; F7
    (define-key map "19~" 'nil)                           ; F8
    (define-key map "20~" 'nil)                           ; F9
    (define-key map "21~" 'tpu-exit)                      ; F10
    (define-key map "23~" 'tpu-insert-escape)             ; F11 (ESC)
    (define-key map "24~" 'tpu-next-beginning-of-line)    ; F12 (BS)
    (define-key map "25~" 'tpu-delete-previous-word)      ; F13 (LF)
    (define-key map "26~" 'tpu-toggle-overwrite-mode)     ; F14
    (define-key map "28~" 'tpu-help)                      ; HELP
    (define-key map "29~" 'execute-extended-command)      ; DO
    (define-key map "31~" 'tpu-goto-breadcrumb)           ; F17
    (define-key map "32~" 'nil)                           ; F18
    (define-key map "33~" 'nil)                           ; F19
    (define-key map "34~" 'nil)                           ; F20
    map)
  "Maps the CSI function keys on the VT100 keyboard.
CSI is DEC's name for the sequence <ESC>[.")

(defvar GOLD-CSI-map
  (let ((map (make-sparse-keymap)))
    (define-key map "A" 'tpu-move-to-beginning)      ; up-arrow
    (define-key map "B" 'tpu-move-to-end)            ; down-arrow
    (define-key map "C" 'end-of-line)                ; right-arrow
    (define-key map "D" 'beginning-of-line)          ; left-arrow

    (define-key map "1~" 'nil)                       ; Find
    (define-key map "2~" 'nil)                       ; Insert Here
    (define-key map "3~" 'tpu-store-text)            ; Remove
    (define-key map "4~" 'tpu-unselect)              ; Select
    (define-key map "5~" 'tpu-previous-window)       ; Prev Screen
    (define-key map "6~" 'tpu-next-window)           ; Next Screen

    (define-key map "11~" 'nil)                      ; F1
    (define-key map "12~" 'nil)                      ; F2
    (define-key map "13~" 'nil)                      ; F3
    (define-key map "14~" 'nil)                      ; F4
    (define-key map "16~" 'nil)                      ; F5
    (define-key map "17~" 'nil)                      ; F6
    (define-key map "18~" 'nil)                      ; F7
    (define-key map "19~" 'nil)                      ; F8
    (define-key map "20~" 'nil)                      ; F9
    (define-key map "21~" 'nil)                      ; F10
    (define-key map "23~" 'nil)                      ; F11
    (define-key map "24~" 'nil)                      ; F12
    (define-key map "25~" 'nil)                      ; F13
    (define-key map "26~" 'nil)                      ; F14
    (define-key map "28~" 'describe-bindings)        ; HELP
    (define-key map "29~" 'nil)                      ; DO
    (define-key map "31~" 'tpu-drop-breadcrumb)      ; F17
    (define-key map "32~" 'nil)                      ; F18
    (define-key map "33~" 'nil)                      ; F19
    (define-key map "34~" 'nil)                      ; F20
    map)
  "Maps the function keys on the VT100 keyboard preceded by GOLD-CSI.")

(defvar GOLD-SS3-map
  (let ((map (make-sparse-keymap)))
    (define-key map "A" 'tpu-move-to-beginning)      ; up-arrow
    (define-key map "B" 'tpu-move-to-end)            ; down-arrow
    (define-key map "C" 'end-of-line)                ; right-arrow
    (define-key map "D" 'beginning-of-line)          ; left-arrow

    (define-key map "P" 'keyboard-quit)              ; PF1
    (define-key map "Q" 'help-for-help)              ; PF2
    (define-key map "R" 'tpu-search)                 ; PF3
    (define-key map "S" 'tpu-undelete-lines)         ; PF4
    (define-key map "p" 'open-line)                  ; KP0
    (define-key map "q" 'tpu-change-case)            ; KP1
    (define-key map "r" 'tpu-delete-to-eol)          ; KP2
    (define-key map "s" 'tpu-special-insert)         ; KP3
    (define-key map "t" 'tpu-move-to-end)            ; KP4
    (define-key map "u" 'tpu-move-to-beginning)      ; KP5
    (define-key map "v" 'tpu-paste)                  ; KP6
    (define-key map "w" 'execute-extended-command)   ; KP7
    (define-key map "x" 'tpu-fill)                   ; KP8
    (define-key map "y" 'tpu-replace)                ; KP9
    (define-key map "m" 'tpu-undelete-words)         ; KP-
    (define-key map "l" 'tpu-undelete-char)          ; KP,
    (define-key map "n" 'tpu-unselect)               ; KP.
    (define-key map "M" 'tpu-substitute)             ; KPenter
    map)
  "Maps the function keys on the VT100 keyboard preceded by GOLD-SS3.")

(defvar GOLD-map
  (let ((map (make-keymap)))
    (define-key map "\e[" GOLD-CSI-map)                  ; GOLD-CSI map
    (define-key map "\eO" GOLD-SS3-map)                  ; GOLD-SS3 map
    ;;
    (define-key map "\C-A" 'tpu-toggle-overwrite-mode)   ; ^A
    (define-key map "\C-B" 'nil)                         ; ^B
    (define-key map "\C-C" 'nil)                         ; ^C
    (define-key map "\C-D" 'nil)                         ; ^D
    (define-key map "\C-E" 'nil)                         ; ^E
    (define-key map "\C-F" 'set-visited-file-name)       ; ^F
    (define-key map "\C-g" 'keyboard-quit)               ; safety first
    (define-key map "\C-h" 'delete-other-windows)        ; BS
    (define-key map "\C-i" 'other-window)                ; TAB
    (define-key map "\C-J" 'nil)                         ; ^J
    (define-key map "\C-K" 'tpu-define-macro-key)        ; ^K
    (define-key map "\C-l" 'downcase-region)             ; ^L
    (define-key map "\C-M" 'nil)                         ; ^M
    (define-key map "\C-N" 'nil)                         ; ^N
    (define-key map "\C-O" 'nil)                         ; ^O
    (define-key map "\C-P" 'nil)                         ; ^P
    (define-key map "\C-Q" 'nil)                         ; ^Q
    (define-key map "\C-R" 'nil)                         ; ^R
    (define-key map "\C-S" 'nil)                         ; ^S
    (define-key map "\C-T" 'tpu-toggle-control-keys)     ; ^T
    (define-key map "\C-u" 'upcase-region)               ; ^U
    (define-key map "\C-V" 'nil)                         ; ^V
    (define-key map "\C-w" 'tpu-write-current-buffers)   ; ^W
    (define-key map "\C-X" 'nil)                         ; ^X
    (define-key map "\C-Y" 'nil)                         ; ^Y
    (define-key map "\C-Z" 'nil)                         ; ^Z
    (define-key map " " 'undo)                           ; SPC
    (define-key map "!" 'nil)                            ; !
    (define-key map "#" 'nil)                            ; #
    (define-key map "$" 'tpu-add-at-eol)                 ; $
    (define-key map "%" 'tpu-goto-percent)               ; %
    (define-key map "&" 'nil)                            ; &
    (define-key map "(" 'nil)                            ; (
    (define-key map ")" 'nil)                            ; )
    (define-key map "*" 'tpu-toggle-regexp)              ; *
    (define-key map "+" 'nil)                            ; +
    (define-key map "," 'tpu-goto-breadcrumb)            ; ,
    (define-key map "-" 'negative-argument)              ; -
    (define-key map "." 'tpu-drop-breadcrumb)            ; .
    (define-key map "/" 'tpu-emacs-replace)              ; /
    (define-key map "0" 'digit-argument)                 ; 0
    (define-key map "1" 'digit-argument)                 ; 1
    (define-key map "2" 'digit-argument)                 ; 2
    (define-key map "3" 'digit-argument)                 ; 3
    (define-key map "4" 'digit-argument)                 ; 4
    (define-key map "5" 'digit-argument)                 ; 5
    (define-key map "6" 'digit-argument)                 ; 6
    (define-key map "7" 'digit-argument)                 ; 7
    (define-key map "8" 'digit-argument)                 ; 8
    (define-key map "9" 'digit-argument)                 ; 9
    (define-key map ":" 'nil)                            ; :
    (define-key map ";" 'tpu-trim-line-ends)             ; ;
    (define-key map "<" 'nil)                            ; <
    (define-key map "=" 'nil)                            ; =
    (define-key map ">" 'nil)                            ; >
    (define-key map "?" 'tpu-spell-check)                ; ?
    (define-key map "A" 'tpu-toggle-newline-and-indent)  ; A
    (define-key map "B" 'tpu-next-buffer)                ; B
    (define-key map "C" 'repeat-complex-command)         ; C
    (define-key map "D" 'shell-command)                  ; D
    (define-key map "E" 'tpu-exit)                       ; E
    (define-key map "F" 'tpu-set-cursor-free)            ; F
    (define-key map "G" 'tpu-get)                        ; G
    (define-key map "H" 'nil)                            ; H
    (define-key map "I" 'tpu-include)                    ; I
    (define-key map "K" 'tpu-kill-buffer)                ; K
    (define-key map "L" 'tpu-what-line)                  ; L
    (define-key map "M" 'buffer-menu)                    ; M
    (define-key map "N" 'tpu-next-file-buffer)           ; N
    (define-key map "O" 'occur)                          ; O
    (define-key map "P" 'lpr-buffer)                     ; P
    (define-key map "Q" 'tpu-quit)                       ; Q
    (define-key map "R" 'tpu-toggle-rectangle)           ; R
    (define-key map "S" 'replace)                        ; S
    (define-key map "T" 'tpu-line-to-top-of-window)      ; T
    (define-key map "U" 'undo)                           ; U
    (define-key map "V" 'tpu-version)                    ; V
    (define-key map "W" 'save-buffer)                    ; W
    (define-key map "X" 'tpu-save-all-buffers-kill-emacs) ; X
    (define-key map "Y" 'copy-region-as-kill)             ; Y
    (define-key map "Z" 'suspend-emacs)                   ; Z
    (define-key map "[" 'blink-matching-open)             ; [
    (define-key map "\\" 'nil)                            ; \
    (define-key map "]" 'blink-matching-open)             ; ]
    (define-key map "^" 'tpu-add-at-bol)                  ; ^
    (define-key map "_" 'split-window-vertically)         ; -
    (define-key map "`" 'what-line)                       ; `
    (define-key map "a" 'tpu-toggle-newline-and-indent)   ; a
    (define-key map "b" 'tpu-next-buffer)                 ; b
    (define-key map "c" 'repeat-complex-command)          ; c
    (define-key map "d" 'shell-command)                   ; d
    (define-key map "e" 'tpu-exit)                        ; e
    (define-key map "f" 'tpu-set-cursor-free)             ; f
    (define-key map "g" 'tpu-get)                         ; g
    (define-key map "h" 'nil)                             ; h
    (define-key map "i" 'tpu-include)                     ; i
    (define-key map "k" 'tpu-kill-buffer)                 ; k
    (define-key map "l" 'goto-line)                       ; l
    (define-key map "m" 'buffer-menu)                     ; m
    (define-key map "n" 'tpu-next-file-buffer)            ; n
    (define-key map "o" 'occur)                           ; o
    (define-key map "p" 'lpr-region)                      ; p
    (define-key map "q" 'tpu-quit)                        ; q
    (define-key map "r" 'tpu-toggle-rectangle)            ; r
    (define-key map "s" 'replace)                         ; s
    (define-key map "t" 'tpu-line-to-top-of-window)       ; t
    (define-key map "u" 'undo)                            ; u
    (define-key map "v" 'tpu-version)                     ; v
    (define-key map "w" 'save-buffer)                     ; w
    (define-key map "x" 'tpu-save-all-buffers-kill-emacs) ; x
    (define-key map "y" 'copy-region-as-kill)             ; y
    (define-key map "z" 'suspend-emacs)                   ; z
    (define-key map "{" 'nil)                             ; {
    (define-key map "|" 'split-window-horizontally)       ; |
    (define-key map "}" 'nil)                             ; }
    (define-key map "~" 'exchange-point-and-mark)         ; ~
    (define-key map "\177" 'delete-window)                ; <X]
    map)
  "Maps the function keys on the VT100 keyboard preceded by PF1.
GOLD is the ASCII 7-bit escape sequence <ESC>OP.")

(defvar SS3-map
  (let ((map (make-sparse-keymap)))
    (define-key map "P" GOLD-map)                         ; GOLD map
    ;;
    (define-key map "A" 'tpu-previous-line)               ; up
    (define-key map "B" 'tpu-next-line)                   ; down
    (define-key map "C" 'tpu-forward-char)                ; right
    (define-key map "D" 'tpu-backward-char)               ; left

    (define-key map "Q" 'tpu-help)                        ; PF2
    (define-key map "R" 'tpu-search-again)                ; PF3
    (define-key map "S" 'tpu-delete-current-line)