OS/2 Professional/OS2PRO194.ISO/os2/prgramer/unix/emacs/lisp/em-keys.elc

Text File | 1993-06-14 | 10.3 KB | 280 lines

(provide (quote em-keys))

(defvar ext-map nil "\
Keymap used for extended scan codes.")

(setq ext-map (make-keymap))

(defvar em-map nil "\
Keymap used for em's key definitions which are prefixed by F9.")

(setq em-map (make-sparse-keymap))

(define-key ext-map " " (quote em-dup-line))

(define-key ext-map "!" (quote find-file))

(define-key ext-map "\"" (quote goto-line))

(define-key ext-map "." (quote em-copy-region))

(define-key ext-map "&" (quote em-copy-line-as-kill))

(define-key ext-map "2" (quote em-match-paren))

(define-key ext-map "" (quote open-rectangle))

(define-key ext-map "" (quote em-kill-word))

(define-key ext-map "" (quote undo))

(define-key ext-map "<" (quote em-switch-to-nth-buffer))

(define-key ext-map "=" (quote em-search-forward))

(define-key ext-map ">" (quote em-search-backward))

(define-key ext-map "?" (quote em-fill-paragraph))

(define-key ext-map "@" (quote other-window))

(define-key ext-map "A" (quote undefined))

(define-key ext-map "B" (quote undefined))

(define-key ext-map "C" em-map)

(define-key ext-map "D" (quote undefined))

(define-key ext-map "E" (quote undefined))

(define-key ext-map "F" (quote undefined))

(define-key ext-map "G" (quote beginning-of-line))

(define-key ext-map "H" (quote previous-line))

(define-key ext-map "I" (quote scroll-down))

(define-key ext-map "J" (quote undefined))

(define-key ext-map "K" (quote backward-char))

(define-key ext-map "L" (quote goto-line))

(define-key ext-map "M" (quote forward-char))

(define-key ext-map "N" (quote undefined))

(define-key ext-map "O" (quote end-of-line))

(define-key ext-map "P" (quote next-line))

(define-key ext-map "Q" (quote scroll-up))

(define-key ext-map "R" (quote overwrite-mode))

(define-key ext-map "S" (quote delete-char))

(define-key ext-map "T" (quote describe-key))

(define-key ext-map "U" (quote em-buffer-list))

(define-key ext-map "V" (quote next-error))

(define-key ext-map "W" (quote undefined))

(define-key ext-map "X" (quote undefined))

(define-key ext-map "Y" (quote undefined))

(define-key ext-map "Z" (quote undefined))

(define-key ext-map "_" (quote em-find-file-at-point))

(define-key ext-map "s" (quote em-backward-to-word))

(define-key ext-map "t" (quote em-forward-to-word))

(define-key ext-map "u" (quote kill-line))

(define-key ext-map "v" (quote em-end-of-buffer))

(define-key ext-map "w" (quote em-kill-left-line))

(define-key ext-map "Ç" (quote undefined))

(define-key ext-map "ä" (quote em-beginning-of-buffer))

(define-key ext-map "à" (quote call-last-kbd-macro))

(define-key ext-map "å" (quote set-mark-command))

(define-key ext-map "ç" (quote expand-abbrev))

(define-key ext-map "ì" (quote em-scroll-line-down))

(define-key ext-map "Ä" (quote undefined))

(define-key ext-map "Å" (quote undefined))

(define-key ext-map "É" (quote undefined))

(define-key ext-map "æ" (quote em-scroll-line-up))

(define-key ext-map "Æ" (quote undefined))

(define-key ext-map "Ö" (quote undefined))

(define-key ext-map "¢" (quote scroll-right))

(define-key ext-map "¥" (quote scroll-left))

(define-key ext-map "í" (quote scroll-other-window))

(define-key ext-map "Ñ" (quote undefined))

(define-key em-map "c" (quote compile))

(define-key em-map "i" (quote em-reinitialize))

(define-key em-map "j" (quote just-one-space))

(define-key em-map "v" (quote em-buffer-file-name))

(global-set-key " " (quote set-mark-command))

(global-set-key "" ext-map)

(define-key ctl-x-map "" (make-sparse-keymap))

(define-key ctl-x-4-map "" (make-sparse-keymap))

(define-key esc-map "" (make-sparse-keymap))

(define-key mode-specific-map "" (make-sparse-keymap))

(define-key help-map "" (make-sparse-keymap))

(define-key em-map "" (make-sparse-keymap))

(defun em-forward-to-word (arg) "\
Move forward until encountering the beginning of a word.
With argument, do this that many times." (interactive "p") (byte-code "└ê├─└┴
$å
dbç" [nil t arg re-search-forward "\\W\\b"] 5))

(defun em-backward-to-word (arg) "\
Move backward until encountering the beginning of a word.
With argument, do this that many times." (interactive "p") (byte-code "└ê├ ê─┼└┴
$â╞╟!béebç" [nil t arg backward-char re-search-backward "\\W\\b" match-end 0] 6))

(defun em-kill-left-line nil "\
Kill from the beginning of the line to point." (interactive "*") (byte-code "└ê┴┬!ç" [nil kill-line 0] 2))

(defun em-end-of-buffer nil "\
Move to end of the buffer without setting mark." (interactive) (byte-code "└êdbç" [nil] 1))

(defun em-beginning-of-buffer nil "\
Move to the beginning of the buffer without setting mark." (interactive) (byte-code "└êebç" [nil] 1))

(defun em-reinitialize nil "\
Load \"~/.emacs, em-keys.el and em-misc.el\".
This is used to load new versions of these files while debugging." (interactive) (byte-code "┴ê┬├!ê┬─!ê┬┼└\"ç" [t nil load "~/.emacs" "em-keys" "em-misc"] 5))

(defun em-scroll-line-up (arg) "\
Scroll up by one line.
With argument, do this that many times." (interactive "p") (byte-code "┴ê┬!ç" [arg nil scroll-up] 2))

(defun em-scroll-line-down (arg) "\
Scroll down by one line.
With argument, do this that many times." (interactive "p") (byte-code "┴ê┬!ç" [arg nil scroll-down] 2))

(defun em-buffer-file-name nil "\
Display the name of the file visited in current buffer." (interactive) (byte-code "┬ê├─å    ┼\"ç" [buffer-file-name t nil message "%s" "Not visiting a file"] 3))

(defun em-copy-line-as-kill (arg) "\
Copy line as kill.
With argument, copy that many lines." (interactive "p") (byte-code "├ê`─ ê`┼
!ê╞    `\")êb)ç" [s b arg nil beginning-of-line forward-line copy-region-as-kill] 5))

(defun em-dup-line (arg) "\
Duplicate current line.
Set mark to the beginning of the new line.
With argument, do this that many times." (interactive "*p") (byte-code "─ê┼ëê`╞ ê`╟ êh╚=?à╚cê╔
`\"ê╩Và0╦ êSëêéê    b))ç" [last-command s b arg nil identity beginning-of-line forward-line 10 copy-region-as-kill 0 yank] 7))

(defun em-kill-word (arg) "\
Delete characters until encountering the beginning of a word.
With argument, do this that many times." (interactive "*p") (byte-code "┬ê`├    !ê─`\")ç" [b arg nil em-forward-to-word kill-region] 4))

(defvar em-search-string nil "\
Search string for em-search-forward and em-search-backward.")

(defvar em-search-re nil "\
Non-nil means use regular expression for em-search-forward and -backward.")

(defun em-search-forward (&optional arg) "\
Search forward for a string.
If prefixed by \\[universal-argument], ask for search string.
If prefixed by \\[universal-argument] \\[universal-argument], use regular expression." (interactive "P") (byte-code "┴ê┬├─#ç" [arg nil em-search-fb search-forward re-search-forward] 4))

(defun em-search-backward (&optional arg) "\
Search backward for a string.
If prefixed by \\[universal-argument], ask for search string.
If prefixed by \\[universal-argument] \\[universal-argument], use
regular expression." (interactive "P") (byte-code "┴ê┬├─#ç" [arg nil em-search-fb search-backward re-search-backward] 4))

(defun em-search-fb (arg fun re-fun) "\
Search forward or backward for a string.
If the first argument is nil, ask for the string.
The second argument is search-forward or search-backward.
The third argument is re-search-forward or re-search-backward." (byte-code "å    ?à*<à┼@!à@╞Yëê╟
â%╚é&╔    \"ëê╩
â4é5    \"ç" [arg em-search-string em-search-re re-fun fun numberp 16 read-from-minibuffer "Re-Search forward: " "Search forward: " funcall] 5))

(defun em-switch-to-nth-buffer (arg) "\
Switch to the ARG'th buffer.
If a numeric prefix argument is not given, the next buffer is
selected. When using this function successively, the top ARG+1 buffers
are rotated." (interactive "p") (byte-code "╚ê╔ G╩╚╚╞╩Yà
    Wà
àR
8ëê╦!ëê╠═!╬\"àI╧!âC╚ëéISëê
Tëêéê
àZ╨╤!ê╥!.ç" [bufs len idx buffer name more t arg nil buffer-list 0 buffer-name /= string-to-char 32 zerop error "Invalid buffer number" switch-to-buffer] 8))

(defun em-match-paren (arg) "\
Go to the matching parenthesis if on parenthesis.
This function uses the syntax table." (interactive "p") (byte-code "└ê┴┬!â├─!ê┼─!é┴╞!à╟─!ê╚─!ç" [nil looking-at "\\s(" forward-list 1 backward-char "\\s)" forward-char backward-list] 7))

(defun em-buffer-list nil "\
Display a list of names of existing buffers.
Inserts it in buffer *Buffer List* and selects that.
Note that buffers with names starting with spaces are omitted." (interactive) (byte-code "└ê┴ ê┬├─!!ê┴ ç" [nil list-buffers select-window get-buffer-window "*Buffer List*"] 5))

(defun em-copy-region nil "\
Copy region to point." (interactive) (byte-code "└ê┴`┬ \"ê├ ç" [nil copy-region-as-kill mark yank] 4))

(defun em-fill-paragraph (arg) "\
Fill paragraph at or before point using em's notion of a paragraph.
Prefix arg means justify as well.
Paragraphs are separated by blank lines. The indentation of the first line
is used for indenting the entire paragraph. If there are two consecutive
blanks in the first line of the paragraphs, everything to the left of these
blanks is left as-is and the paragraph is indented to the first non-blank
character after the first two consecutive blanks of the first line." (interactive "P") (byte-code "┼êè┼┼┼┼┼╟╚!à╔╩!êé
ê╦╚e╠#ê╟╚!à)═ ê`ëê╬╚d╠#ênå;╧╨!ê╤ ëê    bê╟╥!â┐╬╙!êiëê╘ ê`ëê╔╨!ê`ëê═!ê╒!âo┼és╓╫\"ëê╒╔╨!!àâ`╪
!Wà¼┘╠!êiVâ£┌█`i[#`\"é¿iWà¿▄╫iZ\"êévê▌    ╪
!#ê┌    \\\"é╟▌`╪
!#-)ç" [fill-prefix start end join column nil arg looking-at "^$" forward-line -1 re-search-backward 0 forward-char re-search-forward newline 1 point-marker "^ *[^
]*  " "^ *[^
]*   *" split-line zerop make-string 32 marker-position backward-to-indentation delete-region + insert-char fill-region-as-paragraph] 30))

(defun em-extract-file-name (at-point) "\
Return the file name around or before point.
If AT-POINT is not nil, the file names starts at point, that is, characters
before point are ignored." (byte-code "──è
â`ëé\\┼╞!à╟╚e╔#êoâ%eëé\\╟╩e╔#ê┼╦!à3o?âN`Sbê┼╠!âF`ëéK═`\\ëé\\oâX`ëé\\`Tëêbê┼╬!àk╧╔!ëêà~    à~    Và~╨    \")*ç" [start end at-point t nil looking-at "[][- ()<>\\\"|;=*?]" re-search-backward "[^][- :()<>\\\"|;=*?]" 0 "[][- :()<>\\\"|;=*?]" ":" "[A-Za-z]:" 2 "\\([A-Za-z]:\\|\\)[^][- :()<>\\\"|;=*?]*" match-end buffer-substring] 10))

(defun em-find-file-at-point (arg) "\
Find file whose name is around or before point.
With prefix argument find file whose name starts at point." (interactive "P") (byte-code "┴ê┬├!!ç" [arg nil find-file em-extract-file-name] 3))