;;; simple.el --- basic editing commands for Emacs
;; Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-;; 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+;; 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
;; Free Software Foundation, Inc.
;; Maintainer: FSF
(car list)))
(defun last-buffer (&optional buffer visible-ok frame)
- "Return the last non-hidden displayable buffer in the buffer list.
-If BUFFER is non-nil, last-buffer will ignore that buffer.
+ "Return the last buffer in FRAME's buffer list.
+If BUFFER is the last buffer, return the preceding buffer instead.
Buffers not visible in windows are preferred to visible buffers,
unless optional argument VISIBLE-OK is non-nil.
-If the optional third argument FRAME is non-nil, use that frame's
-buffer list instead of the selected frame's buffer list.
-If no other buffer exists, the buffer `*scratch*' is returned."
+Optional third argument FRAME nil or omitted means use the
+selected frame's buffer list.
+If no such buffer exists, return the buffer `*scratch*', creating
+it if necessary."
(setq frame (or frame (selected-frame)))
(or (get-next-valid-buffer (nreverse (buffer-list frame))
buffer visible-ok frame)
- (progn
- (set-buffer-major-mode (get-buffer-create "*scratch*"))
- (get-buffer "*scratch*"))))
+ (get-buffer "*scratch*")
+ (let ((scratch (get-buffer-create "*scratch*")))
+ (set-buffer-major-mode scratch)
+ scratch)))
+
(defun next-buffer ()
"Switch to the next buffer in cyclic order."
(interactive)
(beforepos (point)))
(if flag (backward-char 1))
;; Call self-insert so that auto-fill, abbrev expansion etc. happens.
- ;; Set last-command-char to tell self-insert what to insert.
- (let ((last-command-char ?\n)
+ ;; Set last-command-event to tell self-insert what to insert.
+ (let ((last-command-event ?\n)
;; Don't auto-fill if we have a numeric argument.
;; Also not if flag is true (it would fill wrong line);
;; there is no need to since we're at BOL.
(defun quoted-insert (arg)
"Read next input character and insert it.
This is useful for inserting control characters.
+With argument, insert ARG copies of the character.
If the first character you type after this command is an octal digit,
you should type a sequence of octal digits which specify a character code.
;; Counting lines, one way or another.
-(defun goto-line (arg &optional buffer)
- "Goto line ARG, counting from line 1 at beginning of buffer.
-Normally, move point in the current buffer, and leave mark at previous
-position. With just \\[universal-argument] as argument, move point
-in the most recently displayed other buffer, and switch to it.
-When called from Lisp code, the optional argument BUFFER specifies
-a buffer to switch to.
+(defun goto-line (line &optional buffer)
+ "Goto LINE, counting from line 1 at beginning of buffer.
+Normally, move point in the current buffer, and leave mark at the
+previous position. With just \\[universal-argument] as argument,
+move point in the most recently selected other buffer, and switch
+to it. When called from Lisp code, the optional argument BUFFER
+specifies a buffer to switch to.
-If there's a number in the buffer at point, it is the default for ARG."
+If there's a number in the buffer at point, it is the default for
+LINE."
(interactive
(if (and current-prefix-arg (not (consp current-prefix-arg)))
(list (prefix-numeric-value current-prefix-arg))
(widen)
(goto-char 1)
(if (eq selective-display t)
- (re-search-forward "[\n\C-m]" nil 'end (1- arg))
- (forward-line (1- arg)))))
+ (re-search-forward "[\n\C-m]" nil 'end (1- line))
+ (forward-line (1- line)))))
(defun count-lines-region (start end)
"Print number of lines and characters in the region."
(defvar minibuffer-completing-symbol nil
"Non-nil means completing a Lisp symbol in the minibuffer.")
+(defvar minibuffer-default nil
+ "The current default value or list of default values in the minibuffer.
+The functions `read-from-minibuffer' and `completing-read' bind
+this variable locally.")
+
(defcustom eval-expression-print-level 4
"Value for `print-level' while printing value in `eval-expression'.
A value of nil means no limit."
A complex command is one which used the minibuffer.
The command is placed in the minibuffer as a Lisp form for editing.
The result is executed, repeating the command as changed.
-If the command has been changed or is not the most recent previous command
-it is added to the front of the command history.
-You can use the minibuffer history commands \\<minibuffer-local-map>\\[next-history-element] and \\[previous-history-element]
+If the command has been changed or is not the most recent previous
+command it is added to the front of the command history.
+You can use the minibuffer history commands \
+\\<minibuffer-local-map>\\[next-history-element] and \\[previous-history-element]
to get different commands to edit and resubmit."
(interactive "p")
(let ((elt (nth (1- arg) command-history))
(defvar minibuffer-temporary-goal-position nil)
(defvar minibuffer-default-add-function 'minibuffer-default-add-completions
- "Function run by `goto-history-element' before consuming `minibuffer-default'.
-This is useful to dynamically add more elements to the list `minibuffer-default'
+ "Function run by `goto-history-element' before consuming default values.
+This is useful to dynamically add more elements to the list of default values
when `goto-history-element' reaches the end of this list.
Before calling this function `goto-history-element' sets the variable
`minibuffer-default-add-done' to t, so it will call this function only
(defun minibuffer-history-isearch-pop-state (cmd hist-pos)
"Restore the minibuffer history search state.
-Go to the history element by the absolute history position `hist-pos'."
+Go to the history element by the absolute history position HIST-POS."
(goto-history-element hist-pos))
\f
(defun undo (&optional arg)
"Undo some previous changes.
Repeat this command to undo more changes.
-A numeric argument serves as a repeat count.
+A numeric ARG serves as a repeat count.
In Transient Mark mode when the mark is active, only undo changes within
the current region. Similarly, when not in Transient Mark mode, just \\[universal-argument]
(defun undo-only (&optional arg)
"Undo some previous changes.
Repeat this command to undo more changes.
-A numeric argument serves as a repeat count.
+A numeric ARG serves as a repeat count.
Contrary to `undo', this will not redo a previous undo."
(interactive "*p")
(let ((undo-no-redo t)) (undo arg)))
(declare-function mailcap-file-default-commands "mailcap" (files))
(defun minibuffer-default-add-shell-commands ()
- "Return a list of all commands associted with the current file.
+ "Return a list of all commands associated with the current file.
This function is used to add all related commands retrieved by `mailcap'
to the end of the list of defaults just after the default value."
(interactive)
Output*' even though that buffer is not automatically displayed.
To specify a coding system for converting non-ASCII characters
-in the shell command output, use \\[universal-coding-system-argument]
+in the shell command output, use \\[universal-coding-system-argument] \
before this command.
Noninteractive callers can specify coding systems by binding
the output can be displayed in the echo area or in its buffer.
If the output is short enough to display in the echo area
\(determined by the variable `max-mini-window-height' if
-`resize-mini-windows' is non-nil), it is shown there. Otherwise,
-the buffer containing the output is displayed.
+`resize-mini-windows' is non-nil), it is shown there.
+Otherwise,the buffer containing the output is displayed.
If there is output and an error, and you did not specify \"insert it
in the current buffer\", a message about the error goes at the end
"Part of the numeric argument for the next command.
\\[universal-argument] following digits or minus sign ends the argument."
(interactive "P")
- (let* ((char (if (integerp last-command-char)
- last-command-char
- (get last-command-char 'ascii-character)))
+ (let* ((char (if (integerp last-command-event)
+ last-command-event
+ (get last-command-event 'ascii-character)))
(digit (- (logand char ?\177) ?0)))
(cond ((integerp arg)
(setq prefix-arg (+ (* arg 10)
(defun rotate-yank-pointer (arg)
"Rotate the yanking point in the kill ring.
-With argument, rotate that many kills forward (or backward, if negative)."
+With ARG, rotate that many kills forward (or backward, if negative)."
(interactive "p")
(current-kill arg))
\f
killp))
(defun zap-to-char (arg char)
- "Kill up to and including ARG'th occurrence of CHAR.
+ "Kill up to and including ARGth occurrence of CHAR.
Case is ignored if `case-fold-search' is non-nil in the current buffer.
Goes backward if ARG is negative; error if CHAR not found."
(interactive "p\ncZap to char: ")
(defun kill-line (&optional arg)
"Kill the rest of the current line; if no nonblanks there, kill thru newline.
-With prefix argument, kill that many lines from point.
+With prefix argument ARG, kill that many lines from point.
Negative arguments kill lines backward.
With zero argument, kills the text before point on the current line.
(defun kill-whole-line (&optional arg)
"Kill current line.
-With prefix arg, kill that many lines starting from the current line.
-If arg is negative, kill backward. Also kill the preceding newline.
+With prefix ARG, kill that many lines starting from the current line.
+If ARG is negative, kill backward. Also kill the preceding newline.
\(This is meant to make \\[repeat] work well with negative arguments.\)
-If arg is zero, kill current line but exclude the trailing newline."
+If ARG is zero, kill current line but exclude the trailing newline."
(interactive "p")
+ (or arg (setq arg 1))
(if (and (> arg 0) (eobp) (save-excursion (forward-visible-line 0) (eobp)))
(signal 'end-of-buffer nil))
(if (and (< arg 0) (bobp) (save-excursion (end-of-visible-line) (bobp)))
(set-marker (mark-marker) nil)))
(defcustom use-empty-active-region nil
- "If non-nil, an active region takes control even if empty.
-This applies to certain commands which, in Transient Mark mode,
-apply to the active region if there is one. If the setting is t,
-these commands apply to an empty active region if there is one.
-If the setting is nil, these commands treat an empty active
-region as if it were not active."
+ "Whether \"region-aware\" commands should act on empty regions.
+If nil, region-aware commands treat empty regions as inactive.
+If non-nil, region-aware commands treat the region as active as
+long as the mark is active, even if the region is empty.
+
+Region-aware commands are those that act on the region if it is
+active and Transient Mark mode is enabled, and on the text near
+point otherwise."
:type 'boolean
:version "23.1"
:group 'editing-basics)
(defun use-region-p ()
- "Return t if certain commands should apply to the region.
-Certain commands normally apply to text near point,
-but in Transient Mark mode when the mark is active they apply
-to the region instead. Such commands should use this subroutine to
-test whether to do that.
-
-This function also obeys `use-empty-active-region'."
+ "Return t if the region is active and it is appropriate to act on it.
+This is used by commands that act specially on the region under
+Transient Mark mode. It returns t if and only if Transient Mark
+mode is enabled, the mark is active, and the region is non-empty.
+If `use-empty-active-region' is non-nil, it returns t even if the
+region is empty.
+
+For some commands, it may be appropriate to disregard the value
+of `use-empty-active-region'; in that case, use `region-active-p'."
(and (region-active-p)
(or use-empty-active-region (> (region-end) (region-beginning)))))
(defun region-active-p ()
"Return t if Transient Mark mode is enabled and the mark is active.
-To test whether a command should operate on the region instead of
-the usual behavior, use `use-region-p' instead. That returns nil
-for empty regions when `use-empty-active-region' is nil."
+
+Most commands that act on the region if it is active and
+Transient Mark mode is enabled, and on the text near point
+otherwise, should use `use-region-p' instead. That function
+checks the value of `use-empty-active-region' as well."
(and transient-mark-mode mark-active))
(defvar mark-ring nil
:group 'editing-basics)
(defun pop-to-mark-command ()
- "Jump to mark, and pop a new position for mark off the ring
-\(does not affect global mark ring\)."
+ "Jump to mark, and pop a new position for mark off the ring.
+\(Does not affect global mark ring\)."
(interactive)
(if (null (mark t))
(error "No mark set in this buffer")
(defun push-mark-command (arg &optional nomsg)
"Set mark at where point is.
-If no prefix arg and mark is already set there, just activate it.
+If no prefix ARG and mark is already set there, just activate it.
Display `Mark set' unless the optional second arg NOMSG is non-nil."
(interactive "P")
(let ((mark (marker-position (mark-marker))))
:type 'boolean
:group 'editing-basics)
+(defcustom set-mark-default-inactive nil
+ "If non-nil, setting the mark does not activate it.
+This causes \\[set-mark-command] and \\[exchange-point-and-mark] to
+behave the same whether or not `transient-mark-mode' is enabled.")
+
(defun set-mark-command (arg)
"Set the mark where point is, or jump to the mark.
Setting the mark also alters the region, which is the text
(activate-mark)
(message "Mark activated")))
(t
- (push-mark-command nil))))
+ (push-mark-command nil)
+ (if set-mark-default-inactive (deactivate-mark)))))
(defun push-mark (&optional location nomsg activate)
"Set mark at LOCATION (point, by default) and push old mark on mark ring.
This command works even when the mark is not active,
and it reactivates the mark.
-If Transient Mark mode is on, a prefix arg deactivates the mark
+If Transient Mark mode is on, a prefix ARG deactivates the mark
if it is active, and otherwise avoids reactivating it. If
-Transient Mark mode is off, a prefix arg enables Transient Mark
+Transient Mark mode is off, a prefix ARG enables Transient Mark
mode temporarily."
(interactive "P")
(let ((omark (mark t))
(deactivate-mark)
(set-mark (point))
(goto-char omark)
+ (if set-mark-default-inactive (deactivate-mark))
(cond (temp-highlight
(setq transient-mark-mode (cons 'only transient-mark-mode)))
((or (and arg (region-active-p)) ; (xor arg (not (region-active-p)))
(or (memq last-command '(next-line previous-line))
;; In case we're called from some other command.
(eq last-command this-command)))
- (let ((x (car (nth 2 (posn-at-point)))))
- (when x
- (setq temporary-goal-column (/ (float x) (frame-char-width))))))
+ (let ((posn (posn-at-point))
+ x)
+ (cond ((eq (nth 1 posn) 'right-fringe) ; overflow-newline-into-fringe
+ (setq temporary-goal-column (- (window-width) 1)))
+ ((setq x (car (nth 2 posn)))
+ (setq temporary-goal-column (/ (float x) (frame-char-width)))))))
(or (= (vertical-motion
(cons (or goal-column (truncate temporary-goal-column)) arg))
arg)
(defun move-end-of-line (arg)
"Move point to end of current line as displayed.
-\(If there's an image in the line, this disregards newlines
-which are part of the text that the image rests on.)
-
With argument ARG not nil or 1, move forward ARG - 1 lines first.
If point reaches the beginning or end of buffer, it stops there.
-To ignore intangibility, bind `inhibit-point-motion-hooks' to t."
+
+To ignore the effects of the `intangible' text or overlay
+property, bind `inhibit-point-motion-hooks' to t.
+If there is an image in the current line, this function
+disregards newlines that are part of the text on which the image
+rests."
(interactive "^p")
(or arg (setq arg 1))
(let (done)
"Set the current horizontal position as a goal for \\[next-line] and \\[previous-line].
Those commands will move to this position in the line moved to
rather than trying to keep the same horizontal position.
-With a non-nil argument, clears out the goal column
+With a non-nil argument ARG, clears out the goal column
so that \\[next-line] and \\[previous-line] resume vertical motion.
The goal column is stored in the variable `goal-column'."
(interactive "P")
If there are only whitespace characters there, kill through the
newline as well.
-With prefix argument, kill that many lines from point.
+With prefix argument ARG, kill that many lines from point.
Negative arguments kill lines backward.
With zero argument, kill the text before point on the current line.
(define-key map [remap kill-line] 'kill-visual-line)
(define-key map [remap move-beginning-of-line] 'beginning-of-visual-line)
(define-key map [remap move-end-of-line] 'end-of-visual-line)
- (define-key map "\M-[" 'previous-logical-line)
- (define-key map "\M-]" 'next-logical-line)
+ ;; These keybindings interfere with xterm function keys. Are
+ ;; there any other suitable bindings?
+ ;; (define-key map "\M-[" 'previous-logical-line)
+ ;; (define-key map "\M-]" 'next-logical-line)
map))
(defcustom visual-line-fringe-indicators '(nil nil)
\f
(defun backward-word (&optional arg)
"Move backward until encountering the beginning of a word.
-With argument, do this that many times."
+With argument ARG, do this that many times."
(interactive "^p")
(forward-word (- (or arg 1))))
(defun kill-word (arg)
"Kill characters forward until encountering the end of a word.
-With argument, do this that many times."
+With argument ARG, do this that many times."
(interactive "p")
(kill-region (point) (progn (forward-word arg) (point))))
(defun backward-kill-word (arg)
"Kill characters backward until encountering the beginning of a word.
-With argument, do this that many times."
+With argument ARG, do this that many times."
(interactive "p")
(kill-word (- arg)))
(message "Truncate long lines %s"
(if truncate-lines "enabled" "disabled")))
+(defun toggle-word-wrap (&optional arg)
+ "Toggle whether to use word-wrapping for continuation lines.
+With prefix argument ARG, wrap continuation lines at word boundaries
+if ARG is positive, otherwise wrap them at the right screen edge.
+This command toggles the value of `word-wrap'. It has no effect
+if long lines are truncated."
+ (interactive "P")
+ (setq word-wrap
+ (if (null arg)
+ (not word-wrap)
+ (> (prefix-numeric-value arg) 0)))
+ (force-mode-line-update)
+ (message "Word wrapping %s"
+ (if word-wrap "enabled" "disabled")))
+
(defvar overwrite-mode-textual " Ovwrt"
"The string displayed in the mode line when in overwrite mode.")
(defvar overwrite-mode-binary " Bin Ovwrt"
;; a matching-char info, in which case the two CDRs
;; should match.
(eq matching-paren (cdr (syntax-after (1- oldpos))))))
- (message "Mismatched parentheses"))
+ (if (minibufferp)
+ (minibuffer-message " [Mismatched parentheses]")
+ (message "Mismatched parentheses")))
((not blinkpos)
(or blink-matching-paren-distance
;; Don't complain when `$' with no blinkpos, because it
;; could just be the first one typed in the buffer.
atdollar
- (message "Unmatched parenthesis")))
+ (if (minibufferp)
+ (minibuffer-message " [Unmatched parenthesis]")
+ (message "Unmatched parenthesis"))))
((pos-visible-in-window-p blinkpos)
;; Matching open within window, temporarily move to blinkpos but only
;; if `blink-matching-paren-on-screen' is non-nil.
(set (make-local-variable 'completion-base-size) base-size))
(set (make-local-variable 'completion-reference-buffer) mainbuf)
(unless completion-base-size
- ;; This may be needed for old completion packages which don't use
- ;; completion-all-completions-with-base-size yet.
+ ;; This shouldn't be needed any more, but further analysis is needed
+ ;; to make sure it's the case.
(setq completion-base-size
(cond
(minibuffer-completing-file-name
(cond ((or (memq window-system '(x w32 ns pc))
(memq system-type '(ms-dos windows-nt)))
(let* ((bindings
- `(([C-delete] [C-backspace])
- ([M-delete] [M-backspace])
+ `(([M-delete] [M-backspace])
([C-M-delete] [C-M-backspace])
(,esc-map
[C-delete] [C-backspace])))
(boundp symbol)
(or (eq symbol t)
(and (stringp (setq symbol (eval symbol)))
- (string-match (nth 2 list) symbol)))
- (display-warning :warning (nth 3 list))))
+ (string-match-p (nth 2 list) symbol)))
+ (display-warning package (nth 3 list) :warning)))
(error nil)))
(mapc (lambda (elem)
HCoop / bpt / emacs.git / blobdiff