2010-10-10 Dan Nicolaescu <dann@ics.uci.edu>
+ * shell.el (shell-mode-map):
+ * progmodes/modula2.el (m2-mode-map):
+ * progmodes/inf-lisp.el (inferior-lisp-mode-map):
+ * play/mpuz.el (mpuz-mode-map):
+ * play/landmark.el (lm-mode-map):
+ * play/decipher.el (decipher-mode-map):
+ * play/5x5.el (5x5-mode-map):
+ * net/telnet.el (telnet-mode-map):
+ * net/quickurl.el (quickurl-list-mode-map):
+ * net/mairix.el (mairix-searches-mode-map):
+ * net/eudc-hotlist.el (eudc-hotlist-mode-map):
+ * net/dig.el (dig-mode-map):
+ * mail/mspools.el (mspools-mode-map):
+ * hexl.el (hexl-mode-map):
+ * emulation/ws-mode.el (wordstar-C-k-map, wordstar-mode-map)
+ (wordstar-C-o-map, wordstar-C-q-map):
+ * emacs-lisp/edebug.el (edebug-eval-mode-map):
+ * emacs-lisp/chart.el (chart-map):
+ * edmacro.el (edmacro-mode-map):
+ * erc/erc-list.el (erc-list-menu-mode-map):
+ * array.el (array-mode-map): Declare and define in one step.
+
* vc/log-view.el (log-view-mode-map): Bind revert-buffer.
2010-10-10 Daiki Ueno <ueno@unixuser.org>
;;; Array mode.
-(defvar array-mode-map nil
+(defvar array-mode-map
+ (let ((map (make-keymap)))
+ (define-key map "\M-ad" 'array-display-local-variables)
+ (define-key map "\M-am" 'array-make-template)
+ (define-key map "\M-ae" 'array-expand-rows)
+ (define-key map "\M-ar" 'array-reconfigure-rows)
+ (define-key map "\M-a=" 'array-what-position)
+ (define-key map "\M-ag" 'array-goto-cell)
+ (define-key map "\M-af" 'array-fill-rectangle)
+ (define-key map "\C-n" 'array-next-row)
+ (define-key map "\C-p" 'array-previous-row)
+ (define-key map "\C-f" 'array-forward-column)
+ (define-key map "\C-b" 'array-backward-column)
+ (define-key map "\M-n" 'array-copy-down)
+ (define-key map "\M-p" 'array-copy-up)
+ (define-key map "\M-f" 'array-copy-forward)
+ (define-key map "\M-b" 'array-copy-backward)
+ (define-key map "\M-\C-n" 'array-copy-row-down)
+ (define-key map "\M-\C-p" 'array-copy-row-up)
+ (define-key map "\M-\C-f" 'array-copy-column-forward)
+ (define-key map "\M-\C-b" 'array-copy-column-backward)
+ map)
"Keymap used in array mode.")
-(if array-mode-map
- ()
- (setq array-mode-map (make-keymap))
- ;; Bind keys.
- (define-key array-mode-map "\M-ad" 'array-display-local-variables)
- (define-key array-mode-map "\M-am" 'array-make-template)
- (define-key array-mode-map "\M-ae" 'array-expand-rows)
- (define-key array-mode-map "\M-ar" 'array-reconfigure-rows)
- (define-key array-mode-map "\M-a=" 'array-what-position)
- (define-key array-mode-map "\M-ag" 'array-goto-cell)
- (define-key array-mode-map "\M-af" 'array-fill-rectangle)
- (define-key array-mode-map "\C-n" 'array-next-row)
- (define-key array-mode-map "\C-p" 'array-previous-row)
- (define-key array-mode-map "\C-f" 'array-forward-column)
- (define-key array-mode-map "\C-b" 'array-backward-column)
- (define-key array-mode-map "\M-n" 'array-copy-down)
- (define-key array-mode-map "\M-p" 'array-copy-up)
- (define-key array-mode-map "\M-f" 'array-copy-forward)
- (define-key array-mode-map "\M-b" 'array-copy-backward)
- (define-key array-mode-map "\M-\C-n" 'array-copy-row-down)
- (define-key array-mode-map "\M-\C-p" 'array-copy-row-up)
- (define-key array-mode-map "\M-\C-f" 'array-copy-column-forward)
- (define-key array-mode-map "\M-\C-b" 'array-copy-column-backward))
(put 'array-mode 'mode-class 'special)
"*Non-nil if `edit-kbd-macro' should leave 8-bit characters intact.
Default nil means to write characters above \\177 in octal notation.")
-(defvar edmacro-mode-map nil)
-(unless edmacro-mode-map
- (setq edmacro-mode-map (make-sparse-keymap))
- (define-key edmacro-mode-map "\C-c\C-c" 'edmacro-finish-edit)
- (define-key edmacro-mode-map "\C-c\C-q" 'edmacro-insert-key))
+(defvar edmacro-mode-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map "\C-c\C-c" 'edmacro-finish-edit)
+ (define-key map "\C-c\C-q" 'edmacro-insert-key)
+ map))
(defvar edmacro-store-hook)
(defvar edmacro-finish-hook)
(require 'eieio)
;;; Code:
-(defvar chart-map nil "Keymap used in chart mode.")
-(if chart-map
- ()
- (setq chart-map (make-sparse-keymap))
- )
+(defvar chart-map (make-sparse-keymap) "Keymap used in chart mode.")
(defvar chart-local-object nil
"Local variable containing the locally displayed chart object.")
-(defvar edebug-eval-mode-map nil
- "Keymap for Edebug Eval mode. Superset of Lisp Interaction mode.")
-
-(unless edebug-eval-mode-map
- (setq edebug-eval-mode-map (make-sparse-keymap))
- (set-keymap-parent edebug-eval-mode-map lisp-interaction-mode-map)
-
- (define-key edebug-eval-mode-map "\C-c\C-w" 'edebug-where)
- (define-key edebug-eval-mode-map "\C-c\C-d" 'edebug-delete-eval-item)
- (define-key edebug-eval-mode-map "\C-c\C-u" 'edebug-update-eval-list)
- (define-key edebug-eval-mode-map "\C-x\C-e" 'edebug-eval-last-sexp)
- (define-key edebug-eval-mode-map "\C-j" 'edebug-eval-print-last-sexp))
+(defvar edebug-eval-mode-map
+ (let ((map (make-sparse-keymap)))
+ (set-keymap-parent map lisp-interaction-mode-map)
+ (define-key map "\C-c\C-w" 'edebug-where)
+ (define-key map "\C-c\C-d" 'edebug-delete-eval-item)
+ (define-key map "\C-c\C-u" 'edebug-update-eval-list)
+ (define-key map "\C-x\C-e" 'edebug-eval-last-sexp)
+ (define-key map "\C-j" 'edebug-eval-print-last-sexp)
+ map)
+"Keymap for Edebug Eval mode. Superset of Lisp Interaction mode.")
(put 'edebug-eval-mode 'mode-class 'special)
;; This emulates WordStar, with a major mode.
;;; Code:
-
-(defvar wordstar-mode-map nil "")
+(defvar wordstar-C-k-map
+ (let ((map (make-keymap)))
+ (define-key map " " ())
+ (define-key map "0" 'ws-set-marker-0)
+ (define-key map "1" 'ws-set-marker-1)
+ (define-key map "2" 'ws-set-marker-2)
+ (define-key map "3" 'ws-set-marker-3)
+ (define-key map "4" 'ws-set-marker-4)
+ (define-key map "5" 'ws-set-marker-5)
+ (define-key map "6" 'ws-set-marker-6)
+ (define-key map "7" 'ws-set-marker-7)
+ (define-key map "8" 'ws-set-marker-8)
+ (define-key map "9" 'ws-set-marker-9)
+ (define-key map "b" 'ws-begin-block)
+ (define-key map "\C-b" 'ws-begin-block)
+ (define-key map "c" 'ws-copy-block)
+ (define-key map "\C-c" 'ws-copy-block)
+ (define-key map "d" 'save-buffers-kill-emacs)
+ (define-key map "\C-d" 'save-buffers-kill-emacs)
+ (define-key map "f" 'find-file)
+ (define-key map "\C-f" 'find-file)
+ (define-key map "h" 'ws-show-markers)
+ (define-key map "\C-h" 'ws-show-markers)
+ (define-key map "i" 'ws-indent-block)
+ (define-key map "\C-i" 'ws-indent-block)
+ (define-key map "k" 'ws-end-block)
+ (define-key map "\C-k" 'ws-end-block)
+ (define-key map "p" 'ws-print-block)
+ (define-key map "\C-p" 'ws-print-block)
+ (define-key map "q" 'kill-emacs)
+ (define-key map "\C-q" 'kill-emacs)
+ (define-key map "r" 'insert-file)
+ (define-key map "\C-r" 'insert-file)
+ (define-key map "s" 'save-some-buffers)
+ (define-key map "\C-s" 'save-some-buffers)
+ (define-key map "t" 'ws-mark-word)
+ (define-key map "\C-t" 'ws-mark-word)
+ (define-key map "u" 'ws-exdent-block)
+ (define-key map "\C-u" 'keyboard-quit)
+ (define-key map "v" 'ws-move-block)
+ (define-key map "\C-v" 'ws-move-block)
+ (define-key map "w" 'ws-write-block)
+ (define-key map "\C-w" 'ws-write-block)
+ (define-key map "x" 'save-buffers-kill-emacs)
+ (define-key map "\C-x" 'save-buffers-kill-emacs)
+ (define-key map "y" 'ws-delete-block)
+ (define-key map "\C-y" 'ws-delete-block)
+ map)
+ "")
+
+(defvar wordstar-C-o-map
+ (let ((map (make-keymap)))
+ (define-key map " " ())
+ (define-key map "c" 'wordstar-center-line)
+ (define-key map "\C-c" 'wordstar-center-line)
+ (define-key map "b" 'switch-to-buffer)
+ (define-key map "\C-b" 'switch-to-buffer)
+ (define-key map "j" 'justify-current-line)
+ (define-key map "\C-j" 'justify-current-line)
+ (define-key map "k" 'kill-buffer)
+ (define-key map "\C-k" 'kill-buffer)
+ (define-key map "l" 'list-buffers)
+ (define-key map "\C-l" 'list-buffers)
+ (define-key map "m" 'auto-fill-mode)
+ (define-key map "\C-m" 'auto-fill-mode)
+ (define-key map "r" 'set-fill-column)
+ (define-key map "\C-r" 'set-fill-column)
+ (define-key map "\C-u" 'keyboard-quit)
+ (define-key map "wd" 'delete-other-windows)
+ (define-key map "wh" 'split-window-horizontally)
+ (define-key map "wo" 'other-window)
+ (define-key map "wv" 'split-window-vertically)
+ map)
+ "")
+
+(defvar wordstar-C-q-map
+ (let ((map (make-keymap)))
+ (define-key map " " ())
+ (define-key map "0" 'ws-find-marker-0)
+ (define-key map "1" 'ws-find-marker-1)
+ (define-key map "2" 'ws-find-marker-2)
+ (define-key map "3" 'ws-find-marker-3)
+ (define-key map "4" 'ws-find-marker-4)
+ (define-key map "5" 'ws-find-marker-5)
+ (define-key map "6" 'ws-find-marker-6)
+ (define-key map "7" 'ws-find-marker-7)
+ (define-key map "8" 'ws-find-marker-8)
+ (define-key map "9" 'ws-find-marker-9)
+ (define-key map "a" 'ws-query-replace)
+ (define-key map "\C-a" 'ws-query-replace)
+ (define-key map "b" 'ws-goto-block-begin)
+ (define-key map "\C-b" 'ws-goto-block-begin)
+ (define-key map "c" 'end-of-buffer)
+ (define-key map "\C-c" 'end-of-buffer)
+ (define-key map "d" 'end-of-line)
+ (define-key map "\C-d" 'end-of-line)
+ (define-key map "f" 'ws-search)
+ (define-key map "\C-f" 'ws-search)
+ (define-key map "k" 'ws-goto-block-end)
+ (define-key map "\C-k" 'ws-goto-block-end)
+ (define-key map "l" 'ws-undo)
+ (define-key map "\C-l" 'ws-undo)
+ (define-key map "p" 'ws-last-cursorp)
+ (define-key map "\C-p" 'ws-last-cursorp)
+ (define-key map "r" 'beginning-of-buffer)
+ (define-key map "\C-r" 'beginning-of-buffer)
+ (define-key map "s" 'beginning-of-line)
+ (define-key map "\C-s" 'beginning-of-line)
+ (define-key map "\C-u" 'keyboard-quit)
+ (define-key map "w" 'ws-last-error)
+ (define-key map "\C-w" 'ws-last-error)
+ (define-key map "y" 'ws-kill-eol)
+ (define-key map "\C-y" 'ws-kill-eol)
+ (define-key map "\177" 'ws-kill-bol)
+ map)
+ "")
+
+(defvar wordstar-mode-map
+ (let ((map (make-keymap)))
+ (define-key map "\C-a" 'backward-word)
+ (define-key map "\C-b" 'fill-paragraph)
+ (define-key map "\C-c" 'scroll-up)
+ (define-key map "\C-d" 'forward-char)
+ (define-key map "\C-e" 'previous-line)
+ (define-key map "\C-f" 'forward-word)
+ (define-key map "\C-g" 'delete-char)
+ (define-key map "\C-h" 'backward-char)
+ (define-key map "\C-i" 'indent-for-tab-command)
+ (define-key map "\C-j" 'help-for-help)
+ (define-key map "\C-k" wordstar-C-k-map)
+ (define-key map "\C-l" 'ws-repeat-search)
+ (define-key map "\C-n" 'open-line)
+ (define-key map "\C-o" wordstar-C-o-map)
+ (define-key map "\C-p" 'quoted-insert)
+ (define-key map "\C-q" wordstar-C-q-map)
+ (define-key map "\C-r" 'scroll-down)
+ (define-key map "\C-s" 'backward-char)
+ (define-key map "\C-t" 'kill-word)
+ (define-key map "\C-u" 'keyboard-quit)
+ (define-key map "\C-v" 'overwrite-mode)
+ (define-key map "\C-w" 'scroll-down-line)
+ (define-key map "\C-x" 'next-line)
+ (define-key map "\C-y" 'kill-complete-line)
+ (define-key map "\C-z" 'scroll-up-line)
+ map)
+ "")
+
+;; wordstar-C-j-map not yet implemented
(defvar wordstar-C-j-map nil "")
-(defvar wordstar-C-k-map nil "")
-(defvar wordstar-C-o-map nil "")
-(defvar wordstar-C-q-map nil "")
-
-(if wordstar-mode-map
- ()
- (setq wordstar-mode-map (make-keymap))
- ;; (setq wordstar-C-j-map (make-keymap)) ; later, perhaps
- (setq wordstar-C-k-map (make-keymap))
- (setq wordstar-C-o-map (make-keymap))
- (setq wordstar-C-q-map (make-keymap))
-
- (define-key wordstar-mode-map "\C-a" 'backward-word)
- (define-key wordstar-mode-map "\C-b" 'fill-paragraph)
- (define-key wordstar-mode-map "\C-c" 'scroll-up)
- (define-key wordstar-mode-map "\C-d" 'forward-char)
- (define-key wordstar-mode-map "\C-e" 'previous-line)
- (define-key wordstar-mode-map "\C-f" 'forward-word)
- (define-key wordstar-mode-map "\C-g" 'delete-char)
- (define-key wordstar-mode-map "\C-h" 'backward-char)
- (define-key wordstar-mode-map "\C-i" 'indent-for-tab-command)
- (define-key wordstar-mode-map "\C-j" 'help-for-help)
- (define-key wordstar-mode-map "\C-k" wordstar-C-k-map)
- (define-key wordstar-mode-map "\C-l" 'ws-repeat-search)
- (define-key wordstar-mode-map "\C-n" 'open-line)
- (define-key wordstar-mode-map "\C-o" wordstar-C-o-map)
- (define-key wordstar-mode-map "\C-p" 'quoted-insert)
- (define-key wordstar-mode-map "\C-q" wordstar-C-q-map)
- (define-key wordstar-mode-map "\C-r" 'scroll-down)
- (define-key wordstar-mode-map "\C-s" 'backward-char)
- (define-key wordstar-mode-map "\C-t" 'kill-word)
- (define-key wordstar-mode-map "\C-u" 'keyboard-quit)
- (define-key wordstar-mode-map "\C-v" 'overwrite-mode)
- (define-key wordstar-mode-map "\C-w" 'scroll-down-line)
- (define-key wordstar-mode-map "\C-x" 'next-line)
- (define-key wordstar-mode-map "\C-y" 'kill-complete-line)
- (define-key wordstar-mode-map "\C-z" 'scroll-up-line)
-
- ;; wordstar-C-k-map
-
- (define-key wordstar-C-k-map " " ())
- (define-key wordstar-C-k-map "0" 'ws-set-marker-0)
- (define-key wordstar-C-k-map "1" 'ws-set-marker-1)
- (define-key wordstar-C-k-map "2" 'ws-set-marker-2)
- (define-key wordstar-C-k-map "3" 'ws-set-marker-3)
- (define-key wordstar-C-k-map "4" 'ws-set-marker-4)
- (define-key wordstar-C-k-map "5" 'ws-set-marker-5)
- (define-key wordstar-C-k-map "6" 'ws-set-marker-6)
- (define-key wordstar-C-k-map "7" 'ws-set-marker-7)
- (define-key wordstar-C-k-map "8" 'ws-set-marker-8)
- (define-key wordstar-C-k-map "9" 'ws-set-marker-9)
- (define-key wordstar-C-k-map "b" 'ws-begin-block)
- (define-key wordstar-C-k-map "\C-b" 'ws-begin-block)
- (define-key wordstar-C-k-map "c" 'ws-copy-block)
- (define-key wordstar-C-k-map "\C-c" 'ws-copy-block)
- (define-key wordstar-C-k-map "d" 'save-buffers-kill-emacs)
- (define-key wordstar-C-k-map "\C-d" 'save-buffers-kill-emacs)
- (define-key wordstar-C-k-map "f" 'find-file)
- (define-key wordstar-C-k-map "\C-f" 'find-file)
- (define-key wordstar-C-k-map "h" 'ws-show-markers)
- (define-key wordstar-C-k-map "\C-h" 'ws-show-markers)
- (define-key wordstar-C-k-map "i" 'ws-indent-block)
- (define-key wordstar-C-k-map "\C-i" 'ws-indent-block)
- (define-key wordstar-C-k-map "k" 'ws-end-block)
- (define-key wordstar-C-k-map "\C-k" 'ws-end-block)
- (define-key wordstar-C-k-map "p" 'ws-print-block)
- (define-key wordstar-C-k-map "\C-p" 'ws-print-block)
- (define-key wordstar-C-k-map "q" 'kill-emacs)
- (define-key wordstar-C-k-map "\C-q" 'kill-emacs)
- (define-key wordstar-C-k-map "r" 'insert-file)
- (define-key wordstar-C-k-map "\C-r" 'insert-file)
- (define-key wordstar-C-k-map "s" 'save-some-buffers)
- (define-key wordstar-C-k-map "\C-s" 'save-some-buffers)
- (define-key wordstar-C-k-map "t" 'ws-mark-word)
- (define-key wordstar-C-k-map "\C-t" 'ws-mark-word)
- (define-key wordstar-C-k-map "u" 'ws-exdent-block)
- (define-key wordstar-C-k-map "\C-u" 'keyboard-quit)
- (define-key wordstar-C-k-map "v" 'ws-move-block)
- (define-key wordstar-C-k-map "\C-v" 'ws-move-block)
- (define-key wordstar-C-k-map "w" 'ws-write-block)
- (define-key wordstar-C-k-map "\C-w" 'ws-write-block)
- (define-key wordstar-C-k-map "x" 'save-buffers-kill-emacs)
- (define-key wordstar-C-k-map "\C-x" 'save-buffers-kill-emacs)
- (define-key wordstar-C-k-map "y" 'ws-delete-block)
- (define-key wordstar-C-k-map "\C-y" 'ws-delete-block)
-
- ;; wordstar-C-j-map not yet implemented
-
- ;; wordstar-C-o-map
-
- (define-key wordstar-C-o-map " " ())
- (define-key wordstar-C-o-map "c" 'wordstar-center-line)
- (define-key wordstar-C-o-map "\C-c" 'wordstar-center-line)
- (define-key wordstar-C-o-map "b" 'switch-to-buffer)
- (define-key wordstar-C-o-map "\C-b" 'switch-to-buffer)
- (define-key wordstar-C-o-map "j" 'justify-current-line)
- (define-key wordstar-C-o-map "\C-j" 'justify-current-line)
- (define-key wordstar-C-o-map "k" 'kill-buffer)
- (define-key wordstar-C-o-map "\C-k" 'kill-buffer)
- (define-key wordstar-C-o-map "l" 'list-buffers)
- (define-key wordstar-C-o-map "\C-l" 'list-buffers)
- (define-key wordstar-C-o-map "m" 'auto-fill-mode)
- (define-key wordstar-C-o-map "\C-m" 'auto-fill-mode)
- (define-key wordstar-C-o-map "r" 'set-fill-column)
- (define-key wordstar-C-o-map "\C-r" 'set-fill-column)
- (define-key wordstar-C-o-map "\C-u" 'keyboard-quit)
- (define-key wordstar-C-o-map "wd" 'delete-other-windows)
- (define-key wordstar-C-o-map "wh" 'split-window-horizontally)
- (define-key wordstar-C-o-map "wo" 'other-window)
- (define-key wordstar-C-o-map "wv" 'split-window-vertically)
-
- ;; wordstar-C-q-map
- (define-key wordstar-C-q-map " " ())
- (define-key wordstar-C-q-map "0" 'ws-find-marker-0)
- (define-key wordstar-C-q-map "1" 'ws-find-marker-1)
- (define-key wordstar-C-q-map "2" 'ws-find-marker-2)
- (define-key wordstar-C-q-map "3" 'ws-find-marker-3)
- (define-key wordstar-C-q-map "4" 'ws-find-marker-4)
- (define-key wordstar-C-q-map "5" 'ws-find-marker-5)
- (define-key wordstar-C-q-map "6" 'ws-find-marker-6)
- (define-key wordstar-C-q-map "7" 'ws-find-marker-7)
- (define-key wordstar-C-q-map "8" 'ws-find-marker-8)
- (define-key wordstar-C-q-map "9" 'ws-find-marker-9)
- (define-key wordstar-C-q-map "a" 'ws-query-replace)
- (define-key wordstar-C-q-map "\C-a" 'ws-query-replace)
- (define-key wordstar-C-q-map "b" 'ws-goto-block-begin)
- (define-key wordstar-C-q-map "\C-b" 'ws-goto-block-begin)
- (define-key wordstar-C-q-map "c" 'end-of-buffer)
- (define-key wordstar-C-q-map "\C-c" 'end-of-buffer)
- (define-key wordstar-C-q-map "d" 'end-of-line)
- (define-key wordstar-C-q-map "\C-d" 'end-of-line)
- (define-key wordstar-C-q-map "f" 'ws-search)
- (define-key wordstar-C-q-map "\C-f" 'ws-search)
- (define-key wordstar-C-q-map "k" 'ws-goto-block-end)
- (define-key wordstar-C-q-map "\C-k" 'ws-goto-block-end)
- (define-key wordstar-C-q-map "l" 'ws-undo)
- (define-key wordstar-C-q-map "\C-l" 'ws-undo)
- (define-key wordstar-C-q-map "p" 'ws-last-cursorp)
- (define-key wordstar-C-q-map "\C-p" 'ws-last-cursorp)
- (define-key wordstar-C-q-map "r" 'beginning-of-buffer)
- (define-key wordstar-C-q-map "\C-r" 'beginning-of-buffer)
- (define-key wordstar-C-q-map "s" 'beginning-of-line)
- (define-key wordstar-C-q-map "\C-s" 'beginning-of-line)
- (define-key wordstar-C-q-map "\C-u" 'keyboard-quit)
- (define-key wordstar-C-q-map "w" 'ws-last-error)
- (define-key wordstar-C-q-map "\C-w" 'ws-last-error)
- (define-key wordstar-C-q-map "y" 'ws-kill-eol)
- (define-key wordstar-C-q-map "\C-y" 'ws-kill-eol)
- (define-key wordstar-C-q-map "\177" 'ws-kill-bol))
+
(put 'wordstar-mode 'mode-class 'special)
(sort-fields col (point-min) (point-max))
(sort-numeric-fields col (point-min) (point-max))))))
-(defvar erc-list-menu-mode-map nil
+(defvar erc-list-menu-mode-map
+ (let ((map (make-keymap)))
+ (suppress-keymap map)
+ (define-key map "k" 'erc-list-kill)
+ (define-key map "j" 'erc-list-join)
+ (define-key map "g" 'erc-list-revert)
+ (define-key map "n" 'next-line)
+ (define-key map "p" 'previous-line)
+ (define-key map "q" 'quit-window)
+ map)
"Local keymap for `erc-list-mode' buffers.")
-(unless erc-list-menu-mode-map
- (setq erc-list-menu-mode-map (make-keymap))
- (suppress-keymap erc-list-menu-mode-map)
- (define-key erc-list-menu-mode-map "k" 'erc-list-kill)
- (define-key erc-list-menu-mode-map "j" 'erc-list-join)
- (define-key erc-list-menu-mode-map "g" 'erc-list-revert)
- (define-key erc-list-menu-mode-map "n" 'next-line)
- (define-key erc-list-menu-mode-map "p" 'previous-line)
- (define-key erc-list-menu-mode-map "q" 'quit-window))
-
(defvar erc-list-menu-sort-button-map nil
"Local keymap for ERC list menu mode sorting buttons.")
(defvar hexl-max-address 0
"Maximum offset into hexl buffer.")
-(defvar hexl-mode-map nil)
+(defvar hexl-mode-map
+ (let ((map (make-keymap)))
+ ;; Make all self-inserting keys go through hexl-self-insert-command,
+ ;; because we need to convert them to unibyte characters before
+ ;; inserting them into the buffer.
+ (define-key map [remap self-insert-command] 'hexl-self-insert-command)
+
+ (define-key map "\C-m" 'hexl-self-insert-command)
+ (define-key map [left] 'hexl-backward-char)
+ (define-key map [right] 'hexl-forward-char)
+ (define-key map [up] 'hexl-previous-line)
+ (define-key map [down] 'hexl-next-line)
+ (define-key map [M-left] 'hexl-backward-short)
+ (define-key map [?\e left] 'hexl-backward-short)
+ (define-key map [M-right] 'hexl-forward-short)
+ (define-key map [?\e right] 'hexl-forward-short)
+ (define-key map [next] 'hexl-scroll-up)
+ (define-key map [prior] 'hexl-scroll-down)
+ (define-key map [home] 'hexl-beginning-of-line)
+ (define-key map [end] 'hexl-end-of-line)
+ (define-key map [C-home] 'hexl-beginning-of-buffer)
+ (define-key map [C-end] 'hexl-end-of-buffer)
+ (define-key map [deletechar] 'undefined)
+ (define-key map [deleteline] 'undefined)
+ (define-key map [insertline] 'undefined)
+ (define-key map [S-delete] 'undefined)
+ (define-key map "\177" 'undefined)
+
+ (define-key map "\C-a" 'hexl-beginning-of-line)
+ (define-key map "\C-b" 'hexl-backward-char)
+ (define-key map "\C-d" 'undefined)
+ (define-key map "\C-e" 'hexl-end-of-line)
+ (define-key map "\C-f" 'hexl-forward-char)
+
+ (if (not (memq (key-binding (char-to-string help-char))
+ '(help-command ehelp-command)))
+ (define-key map (char-to-string help-char) 'undefined))
+
+ (define-key map "\C-k" 'undefined)
+ (define-key map "\C-n" 'hexl-next-line)
+ (define-key map "\C-o" 'undefined)
+ (define-key map "\C-p" 'hexl-previous-line)
+ (define-key map "\C-q" 'hexl-quoted-insert)
+ (define-key map "\C-t" 'undefined)
+ (define-key map "\C-v" 'hexl-scroll-up)
+ (define-key map "\C-w" 'undefined)
+ (define-key map "\C-y" 'undefined)
+
+ (fset 'hexl-ESC-prefix (copy-keymap 'ESC-prefix))
+ (define-key map "\e" 'hexl-ESC-prefix)
+ (define-key map "\e\C-a" 'hexl-beginning-of-512b-page)
+ (define-key map "\e\C-b" 'hexl-backward-short)
+ (define-key map "\e\C-d" 'hexl-insert-decimal-char)
+ (define-key map "\e\C-e" 'hexl-end-of-512b-page)
+ (define-key map "\e\C-f" 'hexl-forward-short)
+ (define-key map "\e\C-i" 'undefined)
+ (define-key map "\e\C-j" 'undefined)
+ (define-key map "\e\C-k" 'undefined)
+ (define-key map "\e\C-o" 'hexl-insert-octal-char)
+ (define-key map "\e\C-q" 'undefined)
+ (define-key map "\e\C-t" 'undefined)
+ (define-key map "\e\C-x" 'hexl-insert-hex-char)
+ (define-key map "\eb" 'hexl-backward-word)
+ (define-key map "\ec" 'undefined)
+ (define-key map "\ed" 'undefined)
+ (define-key map "\ef" 'hexl-forward-word)
+ (define-key map "\eg" 'hexl-goto-hex-address)
+ (define-key map "\ei" 'undefined)
+ (define-key map "\ej" 'hexl-goto-address)
+ (define-key map "\ek" 'undefined)
+ (define-key map "\el" 'undefined)
+ (define-key map "\eq" 'undefined)
+ (define-key map "\es" 'undefined)
+ (define-key map "\et" 'undefined)
+ (define-key map "\eu" 'undefined)
+ (define-key map "\ev" 'hexl-scroll-down)
+ (define-key map "\ey" 'undefined)
+ (define-key map "\ez" 'undefined)
+ (define-key map "\e<" 'hexl-beginning-of-buffer)
+ (define-key map "\e>" 'hexl-end-of-buffer)
+
+ (fset 'hexl-C-c-prefix (copy-keymap mode-specific-map))
+ (define-key map "\C-c" 'hexl-C-c-prefix)
+ (define-key map "\C-c\C-c" 'hexl-mode-exit)
+
+ (fset 'hexl-C-x-prefix (copy-keymap 'Control-X-prefix))
+ (define-key map "\C-x" 'hexl-C-x-prefix)
+ (define-key map "\C-x[" 'hexl-beginning-of-1k-page)
+ (define-key map "\C-x]" 'hexl-end-of-1k-page)
+ (define-key map "\C-x\C-p" 'undefined)
+ (define-key map "\C-x\C-s" 'hexl-save-buffer)
+ (define-key map "\C-x\C-t" 'undefined)
+ map))
;; Variable declarations for suppressing warnings from the byte-compiler.
(defvar ruler-mode)
;; startup stuff.
-(if hexl-mode-map
- nil
- (setq hexl-mode-map (make-keymap))
- ;; Make all self-inserting keys go through hexl-self-insert-command,
- ;; because we need to convert them to unibyte characters before
- ;; inserting them into the buffer.
- (define-key hexl-mode-map [remap self-insert-command] 'hexl-self-insert-command)
-
- (define-key hexl-mode-map "\C-m" 'hexl-self-insert-command)
- (define-key hexl-mode-map [left] 'hexl-backward-char)
- (define-key hexl-mode-map [right] 'hexl-forward-char)
- (define-key hexl-mode-map [up] 'hexl-previous-line)
- (define-key hexl-mode-map [down] 'hexl-next-line)
- (define-key hexl-mode-map [M-left] 'hexl-backward-short)
- (define-key hexl-mode-map [?\e left] 'hexl-backward-short)
- (define-key hexl-mode-map [M-right] 'hexl-forward-short)
- (define-key hexl-mode-map [?\e right] 'hexl-forward-short)
- (define-key hexl-mode-map [next] 'hexl-scroll-up)
- (define-key hexl-mode-map [prior] 'hexl-scroll-down)
- (define-key hexl-mode-map [home] 'hexl-beginning-of-line)
- (define-key hexl-mode-map [end] 'hexl-end-of-line)
- (define-key hexl-mode-map [C-home] 'hexl-beginning-of-buffer)
- (define-key hexl-mode-map [C-end] 'hexl-end-of-buffer)
- (define-key hexl-mode-map [deletechar] 'undefined)
- (define-key hexl-mode-map [deleteline] 'undefined)
- (define-key hexl-mode-map [insertline] 'undefined)
- (define-key hexl-mode-map [S-delete] 'undefined)
- (define-key hexl-mode-map "\177" 'undefined)
-
- (define-key hexl-mode-map "\C-a" 'hexl-beginning-of-line)
- (define-key hexl-mode-map "\C-b" 'hexl-backward-char)
- (define-key hexl-mode-map "\C-d" 'undefined)
- (define-key hexl-mode-map "\C-e" 'hexl-end-of-line)
- (define-key hexl-mode-map "\C-f" 'hexl-forward-char)
-
- (if (not (memq (key-binding (char-to-string help-char))
- '(help-command ehelp-command)))
- (define-key hexl-mode-map (char-to-string help-char) 'undefined))
-
- (define-key hexl-mode-map "\C-k" 'undefined)
- (define-key hexl-mode-map "\C-n" 'hexl-next-line)
- (define-key hexl-mode-map "\C-o" 'undefined)
- (define-key hexl-mode-map "\C-p" 'hexl-previous-line)
- (define-key hexl-mode-map "\C-q" 'hexl-quoted-insert)
- (define-key hexl-mode-map "\C-t" 'undefined)
- (define-key hexl-mode-map "\C-v" 'hexl-scroll-up)
- (define-key hexl-mode-map "\C-w" 'undefined)
- (define-key hexl-mode-map "\C-y" 'undefined)
-
- (fset 'hexl-ESC-prefix (copy-keymap 'ESC-prefix))
- (define-key hexl-mode-map "\e" 'hexl-ESC-prefix)
- (define-key hexl-mode-map "\e\C-a" 'hexl-beginning-of-512b-page)
- (define-key hexl-mode-map "\e\C-b" 'hexl-backward-short)
- (define-key hexl-mode-map "\e\C-d" 'hexl-insert-decimal-char)
- (define-key hexl-mode-map "\e\C-e" 'hexl-end-of-512b-page)
- (define-key hexl-mode-map "\e\C-f" 'hexl-forward-short)
- (define-key hexl-mode-map "\e\C-i" 'undefined)
- (define-key hexl-mode-map "\e\C-j" 'undefined)
- (define-key hexl-mode-map "\e\C-k" 'undefined)
- (define-key hexl-mode-map "\e\C-o" 'hexl-insert-octal-char)
- (define-key hexl-mode-map "\e\C-q" 'undefined)
- (define-key hexl-mode-map "\e\C-t" 'undefined)
- (define-key hexl-mode-map "\e\C-x" 'hexl-insert-hex-char)
- (define-key hexl-mode-map "\eb" 'hexl-backward-word)
- (define-key hexl-mode-map "\ec" 'undefined)
- (define-key hexl-mode-map "\ed" 'undefined)
- (define-key hexl-mode-map "\ef" 'hexl-forward-word)
- (define-key hexl-mode-map "\eg" 'hexl-goto-hex-address)
- (define-key hexl-mode-map "\ei" 'undefined)
- (define-key hexl-mode-map "\ej" 'hexl-goto-address)
- (define-key hexl-mode-map "\ek" 'undefined)
- (define-key hexl-mode-map "\el" 'undefined)
- (define-key hexl-mode-map "\eq" 'undefined)
- (define-key hexl-mode-map "\es" 'undefined)
- (define-key hexl-mode-map "\et" 'undefined)
- (define-key hexl-mode-map "\eu" 'undefined)
- (define-key hexl-mode-map "\ev" 'hexl-scroll-down)
- (define-key hexl-mode-map "\ey" 'undefined)
- (define-key hexl-mode-map "\ez" 'undefined)
- (define-key hexl-mode-map "\e<" 'hexl-beginning-of-buffer)
- (define-key hexl-mode-map "\e>" 'hexl-end-of-buffer)
-
- (fset 'hexl-C-c-prefix (copy-keymap mode-specific-map))
- (define-key hexl-mode-map "\C-c" 'hexl-C-c-prefix)
- (define-key hexl-mode-map "\C-c\C-c" 'hexl-mode-exit)
-
- (fset 'hexl-C-x-prefix (copy-keymap 'Control-X-prefix))
- (define-key hexl-mode-map "\C-x" 'hexl-C-x-prefix)
- (define-key hexl-mode-map "\C-x[" 'hexl-beginning-of-1k-page)
- (define-key hexl-mode-map "\C-x]" 'hexl-end-of-1k-page)
- (define-key hexl-mode-map "\C-x\C-p" 'undefined)
- (define-key hexl-mode-map "\C-x\C-s" 'hexl-save-buffer)
- (define-key hexl-mode-map "\C-x\C-t" 'undefined))
-
(easy-menu-define hexl-menu hexl-mode-map "Hexl Mode menu"
`("Hexl"
:help "Hexl-specific Features"
(defvar mspools-buffer "*spools*"
"Name of buffer for displaying spool info.")
-(defvar mspools-mode-map nil
+(defvar mspools-mode-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map "\C-c\C-c" 'mspools-visit-spool)
+ (define-key map "\C-m" 'mspools-visit-spool)
+ (define-key map " " 'mspools-visit-spool)
+ (define-key map "?" 'mspools-help)
+ (define-key map "q" 'mspools-quit)
+ (define-key map "n" 'next-line)
+ (define-key map "p" 'previous-line)
+ (define-key map "g" 'revert-buffer))
"Keymap for the *spools* buffer.")
;;; Code
))))
(car (nth line-num mspools-files))))
-;;; Keymap
-
-(if mspools-mode-map
- ()
- (setq mspools-mode-map (make-sparse-keymap))
-
- (define-key mspools-mode-map "\C-c\C-c" 'mspools-visit-spool)
- (define-key mspools-mode-map "\C-m" 'mspools-visit-spool)
- (define-key mspools-mode-map " " 'mspools-visit-spool)
- (define-key mspools-mode-map "?" 'mspools-help)
- (define-key mspools-mode-map "q" 'mspools-quit)
- (define-key mspools-mode-map "n" 'next-line)
- (define-key mspools-mode-map "p" 'previous-line)
- (define-key mspools-mode-map "g" 'revert-buffer))
-
;;; Spools mode functions
(defun mspools-revert-buffer (ignore noconfirm)
(put 'dig-mode 'mode-class 'special)
-(defvar dig-mode-map nil)
-(unless dig-mode-map
- (setq dig-mode-map (make-sparse-keymap))
- (suppress-keymap dig-mode-map)
-
- (define-key dig-mode-map "q" 'dig-exit))
+(defvar dig-mode-map
+ (let ((map (make-sparse-keymap)))
+ (suppress-keymap map)
+ (define-key map "q" 'dig-exit)
+ map))
(define-derived-mode dig-mode nil "Dig"
"Major mode for displaying dig output."
(require 'eudc)
(defvar eudc-hotlist-menu nil)
-(defvar eudc-hotlist-mode-map nil)
(defvar eudc-hotlist-list-beginning nil)
+(defvar eudc-hotlist-mode-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map "a" 'eudc-hotlist-add-server)
+ (define-key map "d" 'eudc-hotlist-delete-server)
+ (define-key map "s" 'eudc-hotlist-select-server)
+ (define-key map "t" 'eudc-hotlist-transpose-servers)
+ (define-key map "q" 'eudc-hotlist-quit-edit)
+ (define-key map "x" 'kill-this-buffer)
+ map))
+
(defun eudc-hotlist-mode ()
"Major mode used to edit the hotlist of servers.
(forward-line 1)
(transpose-lines 1))))))
-(setq eudc-hotlist-mode-map
- (let ((map (make-sparse-keymap)))
- (define-key map "a" 'eudc-hotlist-add-server)
- (define-key map "d" 'eudc-hotlist-delete-server)
- (define-key map "s" 'eudc-hotlist-select-server)
- (define-key map "t" 'eudc-hotlist-transpose-servers)
- (define-key map "q" 'eudc-hotlist-quit-edit)
- (define-key map "x" 'kill-this-buffer)
- map))
-
(defconst eudc-hotlist-menu
'("EUDC Hotlist Edit"
["---" nil nil]
;;;; Major mode for editing/deleting/saving searches
-(defvar mairix-searches-mode-map nil "'mairix-searches-mode' keymap.")
-
-;; Keymap
-(if (not mairix-searches-mode-map)
- (let ((map (make-keymap)))
- (define-key map [(return)] 'mairix-select-search)
- (define-key map [(down)] 'mairix-next-search)
- (define-key map [(up)] 'mairix-previous-search)
- (define-key map [(right)] 'mairix-next-search)
- (define-key map [(left)] 'mairix-previous-search)
- (define-key map "\C-p" 'mairix-previous-search)
- (define-key map "\C-n" 'mairix-next-search)
- (define-key map [(q)] 'mairix-select-quit)
- (define-key map [(e)] 'mairix-select-edit)
- (define-key map [(d)] 'mairix-select-delete)
- (define-key map [(s)] 'mairix-select-save)
- (setq mairix-searches-mode-map map)))
+(defvar mairix-searches-mode-map
+ (let ((map (make-keymap)))
+ (define-key map [(return)] 'mairix-select-search)
+ (define-key map [(down)] 'mairix-next-search)
+ (define-key map [(up)] 'mairix-previous-search)
+ (define-key map [(right)] 'mairix-next-search)
+ (define-key map [(left)] 'mairix-previous-search)
+ (define-key map "\C-p" 'mairix-previous-search)
+ (define-key map "\C-n" 'mairix-next-search)
+ (define-key map [(q)] 'mairix-select-quit)
+ (define-key map [(e)] 'mairix-select-edit)
+ (define-key map [(d)] 'mairix-select-delete)
+ (define-key map [(s)] 'mairix-select-save)
+ (setq mairix-searches-mode-map map))
+ "'mairix-searches-mode' keymap.")
(defvar mairix-searches-mode-font-lock-keywords)
(defvar quickurl-urls nil
"URL alist for use with `quickurl' and `quickurl-ask'.")
-(defvar quickurl-list-mode-map nil
+(defvar quickurl-list-mode-map
+ (let ((map (make-sparse-keymap)))
+ (suppress-keymap map t)
+ (define-key map "a" #'quickurl-list-add-url)
+ (define-key map [(control m)] #'quickurl-list-insert-url)
+ (define-key map "u" #'quickurl-list-insert-naked-url)
+ (define-key map " " #'quickurl-list-insert-with-lookup)
+ (define-key map "l" #'quickurl-list-insert-lookup)
+ (define-key map "d" #'quickurl-list-insert-with-desc)
+ (define-key map [(control g)] #'quickurl-list-quit)
+ (define-key map "q" #'quickurl-list-quit)
+ (define-key map [mouse-2] #'quickurl-list-mouse-select)
+ (define-key map "?" #'describe-mode)
+ map)
"Local keymap for a `quickurl-list-mode' buffer.")
(defvar quickurl-list-buffer-name "*quickurl-list*"
;; quickurl-list mode.
-(unless quickurl-list-mode-map
- (let ((map (make-sparse-keymap)))
- (suppress-keymap map t)
- (define-key map "a" #'quickurl-list-add-url)
- (define-key map [(control m)] #'quickurl-list-insert-url)
- (define-key map "u" #'quickurl-list-insert-naked-url)
- (define-key map " " #'quickurl-list-insert-with-lookup)
- (define-key map "l" #'quickurl-list-insert-lookup)
- (define-key map "d" #'quickurl-list-insert-with-desc)
- (define-key map [(control g)] #'quickurl-list-quit)
- (define-key map "q" #'quickurl-list-quit)
- (define-key map [mouse-2] #'quickurl-list-mouse-select)
- (define-key map "?" #'describe-mode)
- (setq quickurl-list-mode-map map)))
-
(put 'quickurl-list-mode 'mode-class 'special)
;;;###autoload
LOGIN-NAME, which is optional, says what to log in as on that machine.")
(defvar telnet-new-line "\r")
-(defvar telnet-mode-map nil)
+(defvar telnet-mode-map
+ (let ((map (nconc (make-sparse-keymap) comint-mode-map)))
+ (define-key telnet-mode-map "\C-m" 'telnet-send-input)
+ ;; (define-key telnet-mode-map "\C-j" 'telnet-send-input)
+ (define-key map "\C-c\C-q" 'send-process-next-char)
+ (define-key map "\C-c\C-c" 'telnet-interrupt-subjob)
+ (define-key map "\C-c\C-z" 'telnet-c-z)
+ map))
+
(defvar telnet-prompt-pattern "^[^#$%>\n]*[#$%>] *")
(defvar telnet-replace-c-g nil)
(make-variable-buffer-local
(prog1 (read-char)
(setq quit-flag nil))))))
-; initialization on first load.
-(if telnet-mode-map
- nil
- (setq telnet-mode-map (nconc (make-sparse-keymap) comint-mode-map))
- (define-key telnet-mode-map "\C-m" 'telnet-send-input)
-; (define-key telnet-mode-map "\C-j" 'telnet-send-input)
- (define-key telnet-mode-map "\C-c\C-q" 'send-process-next-char)
- (define-key telnet-mode-map "\C-c\C-c" 'telnet-interrupt-subjob)
- (define-key telnet-mode-map "\C-c\C-z" 'telnet-c-z))
-
;;maybe should have a flag for when have found type
(defun telnet-check-software-type-initialize (string)
"Tries to put correct initializations in. Needs work."
(defvar 5x5-buffer-name "*5x5*"
"Name of the 5x5 play buffer.")
-(defvar 5x5-mode-map nil
- "Local keymap for the 5x5 game.")
-
-;; Keymap.
-
-(unless 5x5-mode-map
+(defvar 5x5-mode-map
(let ((map (make-sparse-keymap)))
(suppress-keymap map t)
(define-key map "?" #'describe-mode)
(define-key map [(control c) (control x)] #'5x5-crack-xor-mutate)
(define-key map "n" #'5x5-new-game)
(define-key map "q" #'5x5-quit-game)
- (setq 5x5-mode-map map)))
+ map)
+ "Local keymap for the 5x5 game.")
;; Menu definition.
'bold)))
in your `.emacs' file.")
-(defvar decipher-mode-map nil
+(defvar decipher-mode-map
+ (let ((map (make-keymap)))
+ (suppress-keymap map)
+ (define-key map "A" 'decipher-show-alphabet)
+ (define-key map "C" 'decipher-complete-alphabet)
+ (define-key map "D" 'decipher-digram-list)
+ (define-key map "F" 'decipher-frequency-count)
+ (define-key map "M" 'decipher-make-checkpoint)
+ (define-key map "N" 'decipher-adjacency-list)
+ (define-key map "R" 'decipher-restore-checkpoint)
+ (define-key map "U" 'decipher-undo)
+ (define-key map " " 'decipher-keypress)
+ (define-key map [remap undo] 'decipher-undo)
+ (define-key map [remap advertised-undo] 'decipher-undo)
+ (let ((key ?a))
+ (while (<= key ?z)
+ (define-key map (vector key) 'decipher-keypress)
+ (incf key)))
+ map)
"Keymap for Decipher mode.")
-(if (not decipher-mode-map)
- (progn
- (setq decipher-mode-map (make-keymap))
- (suppress-keymap decipher-mode-map)
- (define-key decipher-mode-map "A" 'decipher-show-alphabet)
- (define-key decipher-mode-map "C" 'decipher-complete-alphabet)
- (define-key decipher-mode-map "D" 'decipher-digram-list)
- (define-key decipher-mode-map "F" 'decipher-frequency-count)
- (define-key decipher-mode-map "M" 'decipher-make-checkpoint)
- (define-key decipher-mode-map "N" 'decipher-adjacency-list)
- (define-key decipher-mode-map "R" 'decipher-restore-checkpoint)
- (define-key decipher-mode-map "U" 'decipher-undo)
- (define-key decipher-mode-map " " 'decipher-keypress)
- (define-key decipher-mode-map [remap undo] 'decipher-undo)
- (define-key decipher-mode-map [remap advertised-undo] 'decipher-undo)
- (let ((key ?a))
- (while (<= key ?z)
- (define-key decipher-mode-map (vector key) 'decipher-keypress)
- (incf key)))))
-
-(defvar decipher-stats-mode-map nil
- "Keymap for Decipher-Stats mode.")
-(if (not decipher-stats-mode-map)
- (progn
- (setq decipher-stats-mode-map (make-keymap))
- (suppress-keymap decipher-stats-mode-map)
- (define-key decipher-stats-mode-map "D" 'decipher-digram-list)
- (define-key decipher-stats-mode-map "F" 'decipher-frequency-count)
- (define-key decipher-stats-mode-map "N" 'decipher-adjacency-list)
- ))
+
+
+(defvar decipher-stats-mode-map
+ (let ((map (make-keymap)))
+ (suppress-keymap map)
+ (define-key map "D" 'decipher-digram-list)
+ (define-key map "F" 'decipher-frequency-count)
+ (define-key map "N" 'decipher-adjacency-list)
+ map)
+"Keymap for Decipher-Stats mode.")
+
(defvar decipher-mode-syntax-table nil
"Decipher mode syntax table")
:type 'hook
:group 'lm)
-(defvar lm-mode-map nil
+(defvar lm-mode-map
+ (let ((map (make-sparse-keymap)))
+ ;; Key bindings for cursor motion.
+ (define-key map "y" 'lm-move-nw) ; y
+ (define-key map "u" 'lm-move-ne) ; u
+ (define-key map "b" 'lm-move-sw) ; b
+ (define-key map "n" 'lm-move-se) ; n
+ (define-key map "h" 'backward-char) ; h
+ (define-key map "l" 'forward-char) ; l
+ (define-key map "j" 'lm-move-down) ; j
+ (define-key map "k" 'lm-move-up) ; k
+
+ (define-key map [kp-7] 'lm-move-nw)
+ (define-key map [kp-9] 'lm-move-ne)
+ (define-key map [kp-1] 'lm-move-sw)
+ (define-key map [kp-3] 'lm-move-se)
+ (define-key map [kp-4] 'backward-char)
+ (define-key map [kp-6] 'forward-char)
+ (define-key map [kp-2] 'lm-move-down)
+ (define-key map [kp-8] 'lm-move-up)
+
+ (define-key map "\C-n" 'lm-move-down) ; C-n
+ (define-key map "\C-p" 'lm-move-up) ; C-p
+
+ ;; Key bindings for entering Human moves.
+ (define-key map "X" 'lm-human-plays) ; X
+ (define-key map "x" 'lm-human-plays) ; x
+
+ (define-key map " " 'lm-start-robot) ; SPC
+ (define-key map [down-mouse-1] 'lm-start-robot)
+ (define-key map [drag-mouse-1] 'lm-click)
+ (define-key map [mouse-1] 'lm-click)
+ (define-key map [down-mouse-2] 'lm-click)
+ (define-key map [mouse-2] 'lm-mouse-play)
+ (define-key map [drag-mouse-2] 'lm-mouse-play)
+
+ (define-key map [remap previous-line] 'lm-move-up)
+ (define-key map [remap next-line] 'lm-move-down)
+ (define-key map [remap beginning-of-line] 'lm-beginning-of-line)
+ (define-key map [remap end-of-line] 'lm-end-of-line)
+ (define-key map [remap undo] 'lm-human-takes-back)
+ (define-key map [remap advertised-undo] 'lm-human-takes-back)
+ map)
"Local keymap to use in Lm mode.")
-(if lm-mode-map nil
- (setq lm-mode-map (make-sparse-keymap))
-
- ;; Key bindings for cursor motion.
- (define-key lm-mode-map "y" 'lm-move-nw) ; y
- (define-key lm-mode-map "u" 'lm-move-ne) ; u
- (define-key lm-mode-map "b" 'lm-move-sw) ; b
- (define-key lm-mode-map "n" 'lm-move-se) ; n
- (define-key lm-mode-map "h" 'backward-char) ; h
- (define-key lm-mode-map "l" 'forward-char) ; l
- (define-key lm-mode-map "j" 'lm-move-down) ; j
- (define-key lm-mode-map "k" 'lm-move-up) ; k
-
- (define-key lm-mode-map [kp-7] 'lm-move-nw)
- (define-key lm-mode-map [kp-9] 'lm-move-ne)
- (define-key lm-mode-map [kp-1] 'lm-move-sw)
- (define-key lm-mode-map [kp-3] 'lm-move-se)
- (define-key lm-mode-map [kp-4] 'backward-char)
- (define-key lm-mode-map [kp-6] 'forward-char)
- (define-key lm-mode-map [kp-2] 'lm-move-down)
- (define-key lm-mode-map [kp-8] 'lm-move-up)
-
- (define-key lm-mode-map "\C-n" 'lm-move-down) ; C-n
- (define-key lm-mode-map "\C-p" 'lm-move-up) ; C-p
-
- ;; Key bindings for entering Human moves.
- (define-key lm-mode-map "X" 'lm-human-plays) ; X
- (define-key lm-mode-map "x" 'lm-human-plays) ; x
-
- (define-key lm-mode-map " " 'lm-start-robot) ; SPC
- (define-key lm-mode-map [down-mouse-1] 'lm-start-robot)
- (define-key lm-mode-map [drag-mouse-1] 'lm-click)
- (define-key lm-mode-map [mouse-1] 'lm-click)
- (define-key lm-mode-map [down-mouse-2] 'lm-click)
- (define-key lm-mode-map [mouse-2] 'lm-mouse-play)
- (define-key lm-mode-map [drag-mouse-2] 'lm-mouse-play)
-
- (define-key lm-mode-map [remap previous-line] 'lm-move-up)
- (define-key lm-mode-map [remap next-line] 'lm-move-down)
- (define-key lm-mode-map [remap beginning-of-line] 'lm-beginning-of-line)
- (define-key lm-mode-map [remap end-of-line] 'lm-end-of-line)
- (define-key lm-mode-map [remap undo] 'lm-human-takes-back)
- (define-key lm-mode-map [remap advertised-undo] 'lm-human-takes-back))
+
(defvar lm-emacs-won ()
"*For making font-lock use the winner's face for the line.")
:type 'hook
:group 'mpuz)
-(defvar mpuz-mode-map nil
+(defvar mpuz-mode-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map "a" 'mpuz-try-letter)
+ (define-key map "b" 'mpuz-try-letter)
+ (define-key map "c" 'mpuz-try-letter)
+ (define-key map "d" 'mpuz-try-letter)
+ (define-key map "e" 'mpuz-try-letter)
+ (define-key map "f" 'mpuz-try-letter)
+ (define-key map "g" 'mpuz-try-letter)
+ (define-key map "h" 'mpuz-try-letter)
+ (define-key map "i" 'mpuz-try-letter)
+ (define-key map "j" 'mpuz-try-letter)
+ (define-key map "A" 'mpuz-try-letter)
+ (define-key map "B" 'mpuz-try-letter)
+ (define-key map "C" 'mpuz-try-letter)
+ (define-key map "D" 'mpuz-try-letter)
+ (define-key map "E" 'mpuz-try-letter)
+ (define-key map "F" 'mpuz-try-letter)
+ (define-key map "G" 'mpuz-try-letter)
+ (define-key map "H" 'mpuz-try-letter)
+ (define-key map "I" 'mpuz-try-letter)
+ (define-key map "J" 'mpuz-try-letter)
+ (define-key map "\C-g" 'mpuz-offer-abort)
+ (define-key map "?" 'describe-mode)
+ map)
"Local keymap to use in Mult Puzzle.")
-(if mpuz-mode-map nil
- (setq mpuz-mode-map (make-sparse-keymap))
- (define-key mpuz-mode-map "a" 'mpuz-try-letter)
- (define-key mpuz-mode-map "b" 'mpuz-try-letter)
- (define-key mpuz-mode-map "c" 'mpuz-try-letter)
- (define-key mpuz-mode-map "d" 'mpuz-try-letter)
- (define-key mpuz-mode-map "e" 'mpuz-try-letter)
- (define-key mpuz-mode-map "f" 'mpuz-try-letter)
- (define-key mpuz-mode-map "g" 'mpuz-try-letter)
- (define-key mpuz-mode-map "h" 'mpuz-try-letter)
- (define-key mpuz-mode-map "i" 'mpuz-try-letter)
- (define-key mpuz-mode-map "j" 'mpuz-try-letter)
- (define-key mpuz-mode-map "A" 'mpuz-try-letter)
- (define-key mpuz-mode-map "B" 'mpuz-try-letter)
- (define-key mpuz-mode-map "C" 'mpuz-try-letter)
- (define-key mpuz-mode-map "D" 'mpuz-try-letter)
- (define-key mpuz-mode-map "E" 'mpuz-try-letter)
- (define-key mpuz-mode-map "F" 'mpuz-try-letter)
- (define-key mpuz-mode-map "G" 'mpuz-try-letter)
- (define-key mpuz-mode-map "H" 'mpuz-try-letter)
- (define-key mpuz-mode-map "I" 'mpuz-try-letter)
- (define-key mpuz-mode-map "J" 'mpuz-try-letter)
- (define-key mpuz-mode-map "\C-g" 'mpuz-offer-abort)
- (define-key mpuz-mode-map "?" 'describe-mode))
+
(defun mpuz-mode ()
"Multiplication puzzle mode.
:type 'regexp
:group 'inferior-lisp)
-(defvar inferior-lisp-mode-map nil)
-(unless inferior-lisp-mode-map
- (setq inferior-lisp-mode-map (copy-keymap comint-mode-map))
- (set-keymap-parent inferior-lisp-mode-map lisp-mode-shared-map)
- (define-key inferior-lisp-mode-map "\C-x\C-e" 'lisp-eval-last-sexp)
- (define-key inferior-lisp-mode-map "\C-c\C-l" 'lisp-load-file)
- (define-key inferior-lisp-mode-map "\C-c\C-k" 'lisp-compile-file)
- (define-key inferior-lisp-mode-map "\C-c\C-a" 'lisp-show-arglist)
- (define-key inferior-lisp-mode-map "\C-c\C-d" 'lisp-describe-sym)
- (define-key inferior-lisp-mode-map "\C-c\C-f"
- 'lisp-show-function-documentation)
- (define-key inferior-lisp-mode-map "\C-c\C-v"
- 'lisp-show-variable-documentation))
+(defvar inferior-lisp-mode-map
+ (let ((map (copy-keymap comint-mode-map)))
+ (set-keymap-parent map lisp-mode-shared-map)
+ (define-key map "\C-x\C-e" 'lisp-eval-last-sexp)
+ (define-key map "\C-c\C-l" 'lisp-load-file)
+ (define-key map "\C-c\C-k" 'lisp-compile-file)
+ (define-key map "\C-c\C-a" 'lisp-show-arglist)
+ (define-key map "\C-c\C-d" 'lisp-describe-sym)
+ (define-key map "\C-c\C-f" 'lisp-show-function-documentation)
+ (define-key map "\C-c\C-v" 'lisp-show-variable-documentation)
+ map))
;;; These commands augment Lisp mode, so you can process Lisp code in
;;; the source files.
(setq m2-mode-syntax-table table)))
;;; Added by TEP
-(defvar m2-mode-map nil
- "Keymap used in Modula-2 mode.")
-
-(if m2-mode-map ()
+(defvar m2-mode-map
(let ((map (make-sparse-keymap)))
(define-key map "\^i" 'm2-tab)
(define-key map "\C-cb" 'm2-begin)
(define-key map "\C-c\C-t" 'm2-toggle)
(define-key map "\C-c\C-l" 'm2-link)
(define-key map "\C-c\C-c" 'm2-compile)
- (setq m2-mode-map map)))
+ map)
+ "Keymap used in Modula-2 mode.")
(defcustom m2-indent 5
"*This variable gives the indentation in Modula-2-Mode."
(defvar shell-dirstack-query nil
"Command used by `shell-resync-dirs' to query the shell.")
-(defvar shell-mode-map nil)
-(cond ((not shell-mode-map)
- (setq shell-mode-map (nconc (make-sparse-keymap) comint-mode-map))
- (define-key shell-mode-map "\C-c\C-f" 'shell-forward-command)
- (define-key shell-mode-map "\C-c\C-b" 'shell-backward-command)
- (define-key shell-mode-map "\t" 'comint-dynamic-complete)
- (define-key shell-mode-map (kbd "M-RET") 'shell-resync-dirs)
- (define-key shell-mode-map "\M-?"
- 'comint-dynamic-list-filename-completions)
- (define-key shell-mode-map [menu-bar completion]
- (cons "Complete"
- (copy-keymap (lookup-key comint-mode-map [menu-bar completion]))))
- (define-key-after (lookup-key shell-mode-map [menu-bar completion])
- [complete-env-variable] '("Complete Env. Variable Name" .
- shell-dynamic-complete-environment-variable)
- 'complete-file)
- (define-key-after (lookup-key shell-mode-map [menu-bar completion])
- [expand-directory] '("Expand Directory Reference" .
- shell-replace-by-expanded-directory)
- 'complete-expand)))
+(defvar shell-mode-map
+ (let ((map (nconc (make-sparse-keymap) comint-mode-map)))
+ (define-key map "\C-c\C-f" 'shell-forward-command)
+ (define-key map "\C-c\C-b" 'shell-backward-command)
+ (define-key map "\t" 'comint-dynamic-complete)
+ (define-key map (kbd "M-RET") 'shell-resync-dirs)
+ (define-key map "\M-?" 'comint-dynamic-list-filename-completions)
+ (define-key map [menu-bar completion]
+ (cons "Complete"
+ (copy-keymap (lookup-key comint-mode-map [menu-bar completion]))))
+ (define-key-after (lookup-key map [menu-bar completion])
+ [complete-env-variable] '("Complete Env. Variable Name" .
+ shell-dynamic-complete-environment-variable)
+ 'complete-file)
+ (define-key-after (lookup-key map [menu-bar completion])
+ [expand-directory] '("Expand Directory Reference" .
+ shell-replace-by-expanded-directory)
+ 'complete-expand)
+ map))
(defcustom shell-mode-hook '()
"Hook for customizing Shell mode."