Commit 1586b965 authored by Richard M. Stallman's avatar Richard M. Stallman
Browse files

*** empty log message ***

parent df01170b
;;; comint.el --- general command interpreter in a window stuff
;;; Copyright Olin Shivers (1988).
;; Author: Olin Shivers <shivers@cs.cmu.edu>
;; Keyword: processes
;; Maintainer: Olin Shivers <shivers@cs.cmu.edu>
;; Version: 2.03
;; Keyword: estensions, processes
;; Copyright (C) 1988, 1990, 1992 Free Software Foundation, Inc.
;; Written by Olin Shivers.
;;; This file is part of GNU Emacs.
;; 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 2, or (at your option)
;;; any later version.
;; 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 2, 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.
;; 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, 675 Mass Ave, Cambridge, MA 02139, USA.
;; 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, 675 Mass Ave, Cambridge, MA 02139, USA.
;;; Commentary:
......@@ -71,7 +71,8 @@
;;;
;;; m-p comint-previous-input Cycle backwards in input history
;;; m-n comint-next-input Cycle forwards
;;; m-s comint-previous-similar-input Previous similar input
;;; m-r comint-previous-similar-input Previous similar input
;;; m-s comint-next-similar-input Next similar input
;;; c-m-r comint-previous-input-matching Search backwards in input history
;;; return comint-send-input
;;; c-a comint-bol Beginning of line; skip prompt.
......@@ -262,7 +263,8 @@ Entry to this mode runs the hooks on comint-mode-hook"
(setq comint-mode-map (make-sparse-keymap))
(define-key comint-mode-map "\ep" 'comint-previous-input)
(define-key comint-mode-map "\en" 'comint-next-input)
(define-key comint-mode-map "\es" 'comint-previous-similar-input)
(define-key comint-mode-map "\er" 'comint-previous-similar-input)
(define-key comint-mode-map "\es" 'comint-next-similar-input)
(define-key comint-mode-map "\C-m" 'comint-send-input)
(define-key comint-mode-map "\C-d" 'comint-delchar-or-maybe-eof)
(define-key comint-mode-map "\C-a" 'comint-bol)
......@@ -393,107 +395,6 @@ Option comparison function ELT= defaults to equal."
done))
;;; Ring Code
;;;============================================================================
;;; This code defines a ring data structure. A ring is a
;;; (hd-index tl-index . vector)
;;; list. You can insert to, remove from, and rotate a ring. When the ring
;;; fills up, insertions cause the oldest elts to be quietly dropped.
;;;
;;; HEAD = index of the newest item on the ring.
;;; TAIL = index of the oldest item on the ring.
;;;
;;; These functions are used by the input history mechanism, but they can
;;; be used for other purposes as well.
(defun ring-p (x)
"T if X is a ring; NIL otherwise."
(and (consp x) (integerp (car x))
(consp (cdr x)) (integerp (car (cdr x)))
(vectorp (cdr (cdr x)))))
(defun make-ring (size)
"Make a ring that can contain SIZE elts"
(cons 1 (cons 0 (make-vector (+ size 1) nil))))
(defun ring-plus1 (index veclen)
"INDEX+1, with wraparound"
(let ((new-index (+ index 1)))
(if (= new-index veclen) 0 new-index)))
(defun ring-minus1 (index veclen)
"INDEX-1, with wraparound"
(- (if (= 0 index) veclen index) 1))
(defun ring-length (ring)
"Number of elts in the ring."
(let ((hd (car ring)) (tl (car (cdr ring))) (siz (length (cdr (cdr ring)))))
(let ((len (if (<= hd tl) (+ 1 (- tl hd)) (+ 1 tl (- siz hd)))))
(if (= len siz) 0 len))))
(defun ring-empty-p (ring)
(= 0 (ring-length ring)))
(defun ring-insert (ring item)
"Insert a new item onto the ring. If the ring is full, dump the oldest
item to make room."
(let* ((vec (cdr (cdr ring))) (len (length vec))
(new-hd (ring-minus1 (car ring) len)))
(setcar ring new-hd)
(aset vec new-hd item)
(if (ring-empty-p ring) ;overflow -- dump one off the tail.
(setcar (cdr ring) (ring-minus1 (car (cdr ring)) len)))))
(defun ring-remove (ring)
"Remove the oldest item retained on the ring."
(if (ring-empty-p ring) (error "Ring empty")
(let ((tl (car (cdr ring))) (vec (cdr (cdr ring))))
(setcar (cdr ring) (ring-minus1 tl (length vec)))
(aref vec tl))))
;;; This isn't actually used in this package. I just threw it in in case
;;; someone else wanted it. If you want rotating-ring behavior on your history
;;; retrieval (analagous to kill ring behavior), this function is what you
;;; need. I should write the yank-input and yank-pop-input-or-kill to go with
;;; this, and not bind it to a key by default, so it would be available to
;;; people who want to bind it to a key. But who would want it? Blech.
(defun ring-rotate (ring n)
(if (not (= n 0))
(if (ring-empty-p ring) ;Is this the right error check?
(error "ring empty")
(let ((hd (car ring)) (tl (car (cdr ring))) (vec (cdr (cdr ring))))
(let ((len (length vec)))
(while (> n 0)
(setq tl (ring-plus1 tl len))
(aset ring tl (aref ring hd))
(setq hd (ring-plus1 hd len))
(setq n (- n 1)))
(while (< n 0)
(setq hd (ring-minus1 hd len))
(aset vec hd (aref vec tl))
(setq tl (ring-minus1 tl len))
(setq n (- n 1))))
(setcar ring hd)
(setcar (cdr ring) tl)))))
(defun comint-mod (n m)
"Returns N mod M. M is positive. Answer is guaranteed to be non-negative,
and less than m."
(let ((n (% n m)))
(if (>= n 0) n
(+ n
(if (>= m 0) m (- m)))))) ; (abs m)
(defun ring-ref (ring index)
(let ((numelts (ring-length ring)))
(if (= numelts 0) (error "indexed empty ring")
(let* ((hd (car ring)) (tl (car (cdr ring))) (vec (cdr (cdr ring)))
(index (comint-mod index numelts))
(vec-index (comint-mod (+ index hd)
(length vec))))
(aref vec vec-index)))))
;;; Input history retrieval commands
;;; M-p -- previous input M-n -- next input
;;; M-C-r -- previous input matching
......@@ -510,22 +411,28 @@ and less than m."
(message "Not after process mark")
(ding))
(t
(cond ((eq last-command 'comint-previous-input)
(delete-region (mark) (point)))
((eq last-command 'comint-previous-similar-input)
(delete-region
(process-mark (get-buffer-process (current-buffer)))
(point)))
(t
(setq comint-input-ring-index
(if (> arg 0) -1
(if (< arg 0) 1 0)))
(push-mark (point))))
(setq comint-input-ring-index (comint-mod (+ comint-input-ring-index arg) len))
(delete-region (point)
(process-mark (get-buffer-process (current-buffer))))
;; Initialize the index on the first use of this command
;; so that the first M-p gets index 0, and the first M-n gets
;; index -1.
(if (null comint-input-ring-index)
(setq comint-input-ring-index
(if (> arg 0) -1
(if (< arg 0) 1 0))))
(setq comint-input-ring-index
(comint-mod (+ comint-input-ring-index arg) len))
(message "%d" (1+ comint-input-ring-index))
(insert (ring-ref comint-input-ring comint-input-ring-index))
(setq this-command 'comint-previous-input)))))
(insert (ring-ref comint-input-ring comint-input-ring-index))))))
(defun comint-mod (n m)
"Returns N mod M. M is positive.
Answer is guaranteed to be non-negative, and less than m."
(let ((n (% n m)))
(if (>= n 0) n
(+ n
(if (>= m 0) m (- m)))))) ; (abs m)
(defun comint-next-input (arg)
"Cycle forwards through input history."
(interactive "*p")
......@@ -544,7 +451,7 @@ Buffer local variable.")
(list (if (string= s "") comint-last-input-match s))))
; (interactive "sCommand substring: ")
(setq comint-last-input-match str) ; update default
(if (not (eq last-command 'comint-previous-input))
(if (null comint-input-ring-index)
(setq comint-input-ring-index -1))
(let ((str (regexp-quote str))
(len (ring-length comint-input-ring))
......@@ -553,10 +460,7 @@ Buffer local variable.")
(setq n (+ n 1)))
(cond ((< n len)
(comint-previous-input (- n comint-input-ring-index)))
(t (if (eq last-command 'comint-previous-input)
(setq this-command 'comint-previous-input))
(message "Not found.")
(ding)))))
(t (error "Not found")))))
;;; These next three commands are alternatives to the input history commands
......@@ -621,15 +525,20 @@ Buffer local variable.")
(defvar comint-last-similar-string ""
"The string last used in a similar string search.")
(defun comint-previous-similar-input (arg)
"Reenters the last input that matches the string typed so far. If repeated
successively older inputs are reentered. If arg is 1, it will go back
in the history, if -1 it will go forward."
"Fetch the previous (older) input that matches the string typed so far.
Successive repetitions find successively older matching inputs.
A prefix argument serves as a repeat count; a negative argument
fetches following (more recent) inputs."
(interactive "p")
(if (not (comint-after-pmark-p))
(error "Not after process mark"))
(if (not (eq last-command 'comint-previous-similar-input))
(setq comint-input-ring-index -1
comint-last-similar-string
(if (null comint-input-ring-index)
(setq comint-input-ring-index
(if (> arg 0) -1
(if (< arg 0) 1 0))))
(if (not (or (eq last-command 'comint-previous-similar-input)
(eq last-command 'comint-next-similar-input)))
(setq comint-last-similar-string
(buffer-substring
(process-mark (get-buffer-process (current-buffer)))
(point))))
......@@ -644,13 +553,21 @@ in the history, if -1 it will go forward."
(setq n (+ n arg)))
(cond ((< n len)
(setq comint-input-ring-index n)
(if (eq last-command 'comint-previous-similar-input)
(if (or (eq last-command 'comint-previous-similar-input)
(eq last-command 'comint-next-similar-input))
(delete-region (mark) (point)) ; repeat
(push-mark (point))) ; 1st time
(insert (substring entry size)))
(t (message "Not found.") (ding) (sit-for 1)))
(t (error "Not found")))
(message "%d" (1+ comint-input-ring-index))))
(defun comint-next-similar-input (arg)
"Fetch the next (newer) input that matches the string typed so far.
Successive repetitions find successively newer matching inputs.
A prefix argument serves as a repeat count; a negative argument
fetches previous (older) inputs."
(interactive "p")
(comint-previous-similar-input (- arg)))
(defun comint-send-input ()
"Send input to process. After the process output mark, sends all text
......@@ -681,7 +598,7 @@ If the comint is Lucid Common Lisp,
comint-input-filter returns NIL if the input matches input-filter-regexp,
which matches (1) all whitespace (2) :a, :c, etc.
Similarly for Soar, Scheme, etc.."
Similarly for Soar, Scheme, etc."
(interactive)
;; Note that the input string does not include its terminal newline.
(let ((proc (get-buffer-process (current-buffer))))
......@@ -700,6 +617,7 @@ Similarly for Soar, Scheme, etc.."
(ring-insert comint-input-ring input))
(funcall comint-input-sentinel input)
(funcall comint-input-sender proc input)
(setq comint-input-ring-index nil)
(set-marker comint-last-input-start pmark)
(set-marker comint-last-input-end (point))
(set-marker (process-mark proc) (point))))))
......@@ -1087,8 +1005,6 @@ Useful if you accidentally suspend the top-level process."
;;; Filename completion in a buffer
;;; ===========================================================================
;;; Useful completion functions, courtesy of the Ergo group.
;;; M-<Tab> will complete the filename at the cursor as much as possible
;;; M-? will display a list of completions in the help buffer.
;;; Three commands:
;;; comint-dynamic-complete Complete filename at point.
......@@ -1098,15 +1014,11 @@ Useful if you accidentally suspend the top-level process."
;;; These are not installed in the comint-mode keymap. But they are
;;; available for people who want them. Shell-mode installs them:
;;; (define-key cmushell-mode-map "\M-\t" 'comint-dynamic-complete)
;;; (define-key cmushell-mode-map "\t" 'comint-dynamic-complete)
;;; (define-key cmushell-mode-map "\M-?" 'comint-dynamic-list-completions)))
;;;
;;; Commands like this are fine things to put in load hooks if you
;;; want them present in specific modes. Example:
;;; (setq cmushell-load-hook
;;; '((lambda () (define-key lisp-mode-map "\M-\t"
;;; 'comint-replace-by-expanded-filename))))
;;;
;;; want them present in specific modes.
(defun comint-match-partial-pathname ()
......@@ -1136,10 +1048,10 @@ comint-dynamic-complete."
(completion (file-name-completion pathnondir
(or pathdir default-directory))))
(cond ((null completion)
(message "No completions of %s." pathname)
(message "No completions of %s" pathname)
(ding))
((eql completion t)
(message "Unique completion."))
(message "Unique completion"))
(t ; this means a string was returned.
(delete-region (match-beginning 0) (match-end 0))
(insert (expand-file-name (concat pathdir completion)))))))
......@@ -1157,10 +1069,10 @@ it just adds completion characters to the end of the filename."
(completion (file-name-completion pathnondir
(or pathdir default-directory))))
(cond ((null completion)
(message "No completions of %s." pathname)
(message "No completions of %s" pathname)
(ding))
((eql completion t)
(message "Unique completion."))
(message "Unique completion"))
(t ; this means a string was returned.
(goto-char (match-end 0))
(insert (substring completion (length pathnondir)))))))
......@@ -1175,23 +1087,18 @@ it just adds completion characters to the end of the filename."
(file-name-all-completions pathnondir
(or pathdir default-directory))))
(cond ((null completions)
(message "No completions of %s." pathname)
(message "No completions of %s" pathname)
(ding))
(t
(let ((conf (current-window-configuration)))
(with-output-to-temp-buffer "*Help*"
(display-completion-list completions))
(sit-for 0)
(message "Hit space to flush.")
(message "Hit space to flush")
(let ((ch (read-char)))
(if (= ch ?\ )
(set-window-configuration conf)
(setq unread-command-char ch))))))))
; Ergo bindings
; (global-set-key "\M-\t" 'comint-replace-by-expanded-filename)
; (global-set-key "\M-?" 'comint-dynamic-list-completions)
; (define-key shell-mode-map "\M-\t" 'comint-dynamic-complete)
;;; Converting process modes to use comint mode
;;; ===========================================================================
......
......@@ -1083,7 +1083,9 @@ Optional second argument EXITING means ask about certain non-file buffers
'("buffer" "buffers" "save")
(list (list ?\C-r (lambda (buf)
(view-buffer buf)
(setq view-exit-action 'exit-recursive-edit)
(setq view-exit-action
'(lambda (ignore)
(exit-recursive-edit)))
(recursive-edit)
;; Return nil to ask about BUF again.
nil)
......
......@@ -118,7 +118,7 @@ the current %s and exit."
(progn
;; Prompt the user about this object.
(let ((cursor-in-echo-area t))
(message "%s(y, n, ! ., q, %sor %s)"
(message "%s(y, n, !, ., q, %sor %s) "
prompt user-keys
(key-description (char-to-string help-char)))
(setq char (read-char)))
......
;;; c-mode.el --- C code editing commands for Emacs
;; Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
;; Copyright (C) 1985, 1986, 1987, 1992 Free Software Foundation, Inc.
;; Maintainer: FSF
;; Keywords: c
......@@ -1122,5 +1122,57 @@ definition and conveniently use this command."
(if (looking-at "\\\\")
(delete-region (1+ (point))
(progn (skip-chars-backward " \t") (point)))))
(defun c-up-conditional (count)
"Move back to the containing preprocessor conditional, leaving mark behind.
A prefix argument acts as a repeat count. With a negative argument,
move forward to the end of the containing preprocessor conditional.
When going backwards, `#elif' is treated like `#else' followed by `#if'.
When going forwards, `#elif' is ignored."
(interactive "p")
(let* ((forward (< count 0))
(increment (if forward -1 1))
(search-function (if forward 're-search-forward 're-search-backward))
(opoint (point))
(new))
(save-excursion
(while (/= count 0)
(if forward (end-of-line))
(let ((depth 0) found)
(save-excursion
;; Find the "next" significant line in the proper direction.
(while (and (not found)
;; Rather than searching for a # sign that comes
;; at the beginning of a line aside from whitespace,
;; search first for a string starting with # sign.
;; Then verify what precedes it.
;; This is faster on account of the fastmap feature of
;; the regexp matcher.
(funcall search-function
"#[ \t]*\\(if\\|elif\\|endif\\)"
nil t)
(progn
(beginning-of-line)
(looking-at "^[ \t]*#[ \t]*\\(if\\|elif\\|endif\\)")))
;; Update depth according to what we found.
(beginning-of-line)
(cond ((looking-at "[ \t]*#[ \t]*endif")
(setq depth (+ depth increment)))
((looking-at "[ \t]*#[ \t]*elif")
(if (and forward (= depth 0))
(setq found (point))))
(t (setq depth (- depth increment))))
;; If this line exits a level of conditional, exit inner loop.
(if (< depth 0)
(setq found (point)))
;; When searching forward, start from end of line
;; so that we don't find the same line again.
(if forward (end-of-line))))
(or found
(error "No containing preprocessor conditional"))
(goto-char (setq new found)))
(setq count (- count increment))))
(push-mark)
(goto-char new)))
;;; c-mode.el ends here
......@@ -287,7 +287,7 @@ If you viewed a file that was not present in Emacs, its buffer is killed."
(eq (key-binding "\C-c") 'view-exit))
"Type C-h for help, ? for commands, C-c to quit"
(substitute-command-keys
"Type \\[Helper-help] for help, \\[Helper-describe-bindings] for commands, \\[exit-recursive-edit] to quit."))))
"Type \\[Helper-help] for help, \\[Helper-describe-bindings] for commands, \\[view-exit] to quit."))))
(defun View-undefined ()
(interactive)
......@@ -330,7 +330,7 @@ No arg means whole window full, or number of lines set by \\[View-scroll-lines-f
Arg is number of lines to scroll."
(interactive "P")
(if (pos-visible-in-window-p (point-max))
(exit-recursive-edit))
(view-exit))
(setq lines
(if lines (prefix-numeric-value lines)
(view-scroll-size)))
......@@ -344,7 +344,7 @@ Arg is number of lines to scroll."
(goto-char (point-max))
(recenter -1)
(message (substitute-command-keys
"End. Type \\[exit-recursive-edit] to quit viewing."))))
"End. Type \\[view-exit] to quit viewing."))))
(move-to-window-line -1)
(beginning-of-line))
......@@ -435,12 +435,6 @@ invocations return to earlier marks."
(sit-for 4))))
;;;###autoload
(define-key ctl-x-map "v" 'view-file)
;;;###autoload
(define-key ctl-x-4-map "v" 'view-file-other-window)
(provide 'view)
;;; view.el ends here
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment