* Emacs manual update: basic.texi
@ 2006-05-25 19:41 Ted Zlatanov
2006-05-31 20:12 ` Emacs manual update: mini.texi Ted Zlatanov
0 siblings, 1 reply; 2+ messages in thread
From: Ted Zlatanov @ 2006-05-25 19:41 UTC (permalink / raw)
[-- Attachment #1: Type: text/plain, Size: 146 bytes --]
Attached is my context diff of basic.texi. I hope it's useful. I
will continue revising the remaining parts of the manual as time
allows.
Ted
[-- Attachment #2: basic.diff --]
[-- Type: text/plain, Size: 50886 bytes --]
Index: basic.texi
===================================================================
RCS file: /sources/emacs/emacs/man/basic.texi,v
retrieving revision 1.63
diff -c -r1.63 basic.texi
*** basic.texi 7 Feb 2006 23:33:09 -0000 1.63
--- basic.texi 25 May 2006 19:37:38 -0000
***************
*** 7,34 ****
@kindex C-h t
@findex help-with-tutorial
! We now give the basics of how to enter text, make corrections, and
! save the text in a file. If this material is new to you, you might
! learn it more easily by running the Emacs learn-by-doing tutorial. To
! use the tutorial, run Emacs and type @kbd{Control-h t}
(@code{help-with-tutorial}).
! To clear the screen and redisplay, type @kbd{C-l} (@code{recenter}).
@menu
* Inserting Text:: Inserting text by simply typing it.
! * Moving Point:: How to move the cursor to the place where you want to
change something.
* Erasing:: Deleting and killing text.
* Basic Undo:: Undoing recent changes in the text.
* Files: Basic Files. Visiting, creating, and saving files.
* Help: Basic Help. Asking what a character does.
! * Blank Lines:: Commands to make or delete blank lines.
! * Continuation Lines:: Lines too wide for the screen.
! * Position Info:: What page, line, row, or column is point on?
! * Arguments:: Numeric arguments for repeating a command.
! * Repeating:: A short-cut for repeating the previous command.
@end menu
@node Inserting Text
--- 7,34 ----
@kindex C-h t
@findex help-with-tutorial
! Here you will learn to enter text, make corrections to it, and save
! the result in a file. If this material or the terms are new to you,
! you should run the Emacs learn-by-doing tutorial by typing
! @kbd{Control-h t} inside Emacs.
(@code{help-with-tutorial}).
! To clear and redisplay the screen, type @kbd{C-l} (@code{recenter}).
@menu
* Inserting Text:: Inserting text by simply typing it.
! * Moving Point:: Moving the cursor gets you where you want to
change something.
* Erasing:: Deleting and killing text.
* Basic Undo:: Undoing recent changes in the text.
* Files: Basic Files. Visiting, creating, and saving files.
* Help: Basic Help. Asking what a character does.
! * Blank Lines:: Making and deleting blank lines.
! * Continuation Lines:: Indicating lines too wide for the screen.
! * Position Info:: What page, line, row, and column is point on?
! * Arguments:: Repeating a command N times.
! * Repeating:: Repeating the previous command quickly.
@end menu
@node Inserting Text
***************
*** 36,101 ****
@cindex insertion
@cindex graphic characters
! To insert printing characters into the text you are editing, just type
! them. This inserts the characters you type into the buffer at the
! cursor (that is, at @dfn{point}; @pxref{Point}). The cursor moves
! forward, and any text after the cursor moves forward too. If the text
! in the buffer is @samp{FOOBAR}, with the cursor before the @samp{B},
! then if you type @kbd{XX}, you get @samp{FOOXXBAR}, with the cursor
! still before the @samp{B}.
!
! To @dfn{delete} text you have just inserted, use the large key
! labeled @key{DEL}, @key{BACKSPACE} or @key{DELETE} which is a short
! distance above the @key{RET} or @key{ENTER} key. This is the key you
! normally use, outside Emacs, for erasing the last character that you
! typed. Regardless of the label on that key, Emacs thinks of it as
! @key{DEL}, and that's what we call it in this manual.
The @key{DEL} key deletes the character @emph{before} the cursor.
As a consequence, the cursor and all the characters after it move
! backwards. If you type a printing character and then type @key{DEL},
! they cancel out.
! On most computers, Emacs recognizes automatically which key ought to
! be @key{DEL}, and sets it up that way. But in some cases, especially
! with text-only terminals, you will need to tell Emacs which key to use
! for that purpose. If the large key not far above the @key{RET} or
! @key{ENTER} key doesn't delete backwards, you need to do this.
! @xref{DEL Does Not Delete}, for an explanation of how.
!
! Most PC keyboards have both a @key{BACKSPACE} key not far above
! @key{RET} or @key{ENTER}, and a @key{DELETE} key elsewhere. On these
! keyboards, Emacs supports when possible the usual convention that the
! @key{BACKSPACE} key deletes backwards (it is @key{DEL}), while the
! @key{DELETE} key deletes ``forwards,'' deleting the character after
! point, the one underneath the cursor, like @kbd{C-d} (see below).
@kindex RET
@cindex newline
! To end a line and start typing a new one, type @key{RET}. This
! inserts a newline character in the buffer. If point is in the middle of
! a line, the effect is to split the line. Typing @key{DEL} when the cursor is
! at the beginning of a line deletes the preceding newline, thus joining
! the line with the preceding line.
!
! Emacs can split lines automatically when they become too long, if you
! turn on a special minor mode called @dfn{Auto Fill} mode.
! @xref{Filling}, for how to use Auto Fill mode and other modes for
! @dfn{filling} text.
!
! If you prefer to have text characters replace (overwrite) existing
! text rather than shove it to the right, you can enable Overwrite mode,
! a minor mode. @xref{Minor Modes}.
@cindex quoting
@kindex C-q
@findex quoted-insert
! Direct insertion works for printing characters and @key{SPC}, but other
! characters act as editing commands and do not insert themselves. If you
! need to insert a control character or a character whose code is above 200
! octal, you must @dfn{quote} it by typing the character @kbd{Control-q}
! (@code{quoted-insert}) first. (This character's name is normally written
! @kbd{C-q} for short.) There are two ways to use @kbd{C-q}:@refill
@itemize @bullet
@item
--- 36,102 ----
@cindex insertion
@cindex graphic characters
! Type printing characters (letters or numbers, for example) to insert
! them in text. The characters you type come into the buffer at the
! cursor. In Emacs, the cursor location is known as the @dfn{point}
! (this is not exactly true, but is helpful if you are not used to
! Emacs); @pxref{Point}. The cursor moves forward and pushes any
! following text forward as well. For example, if the text shown is
! @samp{FOOBAR}, with the cursor before the @samp{B}, then when you type
! @kbd{XX}, you'll see @samp{FOOXXBAR}, and the cursor (and point) still
! before the @samp{B}.
!
! To @dfn{delete} text, use the key labeled @key{DEL},
! @key{BACKSPACE} or @key{DELETE} which is usually just above the
! @key{RET} or @key{ENTER} key. Regardless of the label on that key,
! Emacs thinks of it as @key{DEL}, and that's what this manual will use.
! @key{DEL} is the key you normally use outside Emacs as well to erase
! the last character you typed.
The @key{DEL} key deletes the character @emph{before} the cursor.
As a consequence, the cursor and all the characters after it move
! backwards. If you type a letter and then type @key{DEL}, it's gone.
! On most computers, Emacs sets up @key{DEL} automatically.
! Sometimes, especially on text-only terminals, Emacs may guess wrong.
! If the large key above the @key{RET} or @key{ENTER} key doesn't delete
! backwards, @xref{DEL Does Not Delete}.
!
! Most PC keyboards have a @key{BACKSPACE} key above @key{RET} or
! @key{ENTER} and a @key{DELETE} key elsewhere. Emacs tries to set keys
! up so that the @key{BACKSPACE} key deletes backwards (it is the
! @key{DEL} key in this manual). In those cases, the @key{DELETE} key
! deletes ``forwards,'' which means the character underneath the cursor
! (after point), similar to the effect of @kbd{C-d} (see below).
@kindex RET
@cindex newline
! To end a line and start typing a new one, type @key{RET} (this key
! may be labeled @key{RETURN} or @key{ENTER}, but Emacs always calls it
! @key{RET}). This inserts a newline character in the buffer, which
! usually makes a new visual line. If point (the cursor) is in the
! middle of a line, the line is split. @key{DEL} when at the beginning
! of a line deletes the preceding newline character, visually joining
! the line with the one before it.
!
! Emacs splits long lines automatically if you turn on a special minor
! mode called @dfn{Auto Fill} mode. @xref{Filling}, to learn about Auto
! Fill mode and other modes for @dfn{filling} text.
!
! Typing can replace (overwrite) existing text rather than push it to
! the right, if Overwrite mode, a minor mode, is enabled. @xref{Minor
! Modes}.
@cindex quoting
@kindex C-q
@findex quoted-insert
! Printing characters and @key{SPC} are inserted as you type, but some
! other characters act as editing commands and do not insert themselves,
! or have a code above 200 octal. If you need to insert such a
! character, you must @dfn{quote} it by typing the character
! @kbd{Control-q} (@code{quoted-insert}) first. (This character's name
! is normally written @kbd{C-q} for short.) There are two ways to use
! @kbd{C-q}:@refill
@itemize @bullet
@item
***************
*** 131,146 ****
10, some letters starting with @kbd{a} serve as part of a character
code, just like digits.
! A numeric argument to @kbd{C-q} specifies how many copies of the
! quoted character should be inserted (@pxref{Arguments}).
@findex newline
@findex self-insert
Customization information: @key{DEL} in most modes runs the command
! @code{delete-backward-char}; @key{RET} runs the command @code{newline}, and
! self-inserting printing characters run the command @code{self-insert},
! which inserts whatever character was typed to invoke it. Some major modes
! rebind @key{DEL} to other commands.
@node Moving Point
@section Changing the Location of Point
--- 132,147 ----
10, some letters starting with @kbd{a} serve as part of a character
code, just like digits.
! A numeric argument tells @kbd{C-q} how many copies of the quoted
! character to insert (@pxref{Arguments}).
@findex newline
@findex self-insert
Customization information: @key{DEL} in most modes runs the command
! @code{delete-backward-char}; @key{RET} runs the command
! @code{newline}, and self-inserting printing characters run the command
! @code{self-insert}, which inserts the original character that invoked
! it. Some major modes rebind @key{DEL} to other commands.
@node Moving Point
@section Changing the Location of Point
***************
*** 199,219 ****
@item M-b
Move backward one word (@code{backward-word}).
@item C-n
! Move down one line, vertically (@code{next-line}). This command
attempts to keep the horizontal position unchanged, so if you start in
! the middle of one line, you end in the middle of the next. The
down-arrow key does the same thing.
@item C-p
Move up one line, vertically (@code{previous-line}). The up-arrow key
! has the same effect.
@item M-r
! Move point to left margin, vertically centered in the window
! (@code{move-to-window-line}). Text does not move on the screen.
!
! A numeric argument says which screen line to place point on. It counts
! screen lines down from the top of the window (zero for the top line). A
! negative argument counts lines from the bottom (@minus{}1 for the bottom
! line).
@item M-<
Move to the top of the buffer (@code{beginning-of-buffer}). With
numeric argument @var{n}, move to @var{n}/10 of the way from the top.
--- 200,219 ----
@item M-b
Move backward one word (@code{backward-word}).
@item C-n
! Move down one line vertically (@code{next-line}). This command
attempts to keep the horizontal position unchanged, so if you start in
! the middle of one line, you stay in the middle of the next. The
down-arrow key does the same thing.
@item C-p
Move up one line, vertically (@code{previous-line}). The up-arrow key
! has the same effect. This command attempts to preserve position line
! @code{next-line}.
@item M-r
! Move point all the way left, vertically centered in the window
! (@code{move-to-window-line}). Text does not move on the screen. A
! numeric argument says which screen line to place point on, counting
! down from the top of the window (zero is the top line). A negative
! argument counts lines from the bottom (@minus{}1 is the bottom line).
@item M-<
Move to the top of the buffer (@code{beginning-of-buffer}). With
numeric argument @var{n}, move to @var{n}/10 of the way from the top.
***************
*** 228,234 ****
point, but it is commonly used to do so. If your keyboard has a
@key{PAGEDOWN} or @key{PRIOR} key, it does the same thing.
! Scrolling commands are further described in @ref{Scrolling}.
@item M-v
@itemx @key{PAGEUP}
@itemx @key{NEXT}
--- 228,234 ----
point, but it is commonly used to do so. If your keyboard has a
@key{PAGEDOWN} or @key{PRIOR} key, it does the same thing.
! Scrolling commands are described further in @ref{Scrolling}.
@item M-v
@itemx @key{PAGEUP}
@itemx @key{NEXT}
***************
*** 244,262 ****
@itemx M-x goto-line
Read a number @var{n} and move point to the beginning of line number
@var{n}. Line 1 is the beginning of the buffer. If point is on or
! just after a number, then that is the default for @var{n}, if you just
! press @key{RET} with an empty minibuffer.
@item C-x C-n
@findex set-goal-column
@kindex C-x C-n
! Use the current column of point as the @dfn{semipermanent goal column} for
! @kbd{C-n} and @kbd{C-p} (@code{set-goal-column}). Henceforth, those
! commands always move to this column in each line moved into, or as
! close as possible given the contents of the line. This goal column remains
! in effect until canceled.
@item C-u C-x C-n
! Cancel the goal column. Henceforth, @kbd{C-n} and @kbd{C-p} once
! again try to stick to a fixed horizontal position, as usual.
@end table
@vindex track-eol
--- 244,262 ----
@itemx M-x goto-line
Read a number @var{n} and move point to the beginning of line number
@var{n}. Line 1 is the beginning of the buffer. If point is on or
! just after a number and you press @key{RET} without typing, that
! number will be used for @var{n}.
@item C-x C-n
@findex set-goal-column
@kindex C-x C-n
! Use the current column of point as the @dfn{semipermanent goal column}
! for @kbd{C-n} and @kbd{C-p} (@code{set-goal-column}). Henceforth,
! those commands always try to move to this column or as close as
! possible to it after moving vertically. The goal column remains in
! effect until canceled.
@item C-u C-x C-n
! Cancel the goal column. Henceforth, @kbd{C-n} and @kbd{C-p} will try
! to preserve the horizontal position when moving vertically, as usual.
@end table
@vindex track-eol
***************
*** 267,276 ****
@vindex next-line-add-newlines
@kbd{C-n} normally stops at the end of the buffer when you use it on
! the last line of the buffer. But if you set the variable
! @code{next-line-add-newlines} to a non-@code{nil} value, @kbd{C-n} on
! the last line of a buffer creates an additional line at the end and
! moves down onto it.
@node Erasing
@section Erasing Text
--- 267,275 ----
@vindex next-line-add-newlines
@kbd{C-n} normally stops at the end of the buffer when you use it on
! the last line of the buffer. If you set the variable
! @code{next-line-add-newlines} to a non-@code{nil} value, @kbd{C-n} at
! the end of the buffer creates an additional line and moves down to it.
@node Erasing
@section Erasing Text
***************
*** 299,314 ****
@cindex deleting characters and lines
@cindex erasing characters and lines
You already know about the @key{DEL} key which deletes the character
! before point (that is, before the cursor). Another key, @kbd{Control-d}
! (@kbd{C-d} for short), deletes the character after point (that is, the
! character that the cursor is on). This shifts the rest of the text on
! the line to the left. If you type @kbd{C-d} at the end of a line, it
! joins together that line and the next line.
!
! To erase a larger amount of text, use the @kbd{C-k} key, which kills a
! line at a time. If you type @kbd{C-k} at the beginning or middle of a
! line, it kills all the text up to the end of the line. If you type
! @kbd{C-k} at the end of a line, it joins that line and the next line.
@xref{Killing}, for more flexible ways of killing text.
--- 298,314 ----
@cindex deleting characters and lines
@cindex erasing characters and lines
You already know about the @key{DEL} key which deletes the character
! before point (that is, before the cursor). Another key,
! @kbd{Control-d} (@kbd{C-d} for short), deletes the character after
! point (that is, the character that the cursor is on). This shifts the
! rest of the text on the line left. If you type @kbd{C-d} at the end
! of a line, it joins it together with the next one.
!
! To erase larger amounts of text, use the @kbd{C-k} key, which erases
! (kills) a line at a time. If you type @kbd{C-k} at the beginning or
! middle of a line, it kills all the text up to the end of the line. If
! you type @kbd{C-k} at the end of a line, it joins it with the next
! one.
@xref{Killing}, for more flexible ways of killing text.
***************
*** 316,325 ****
@section Undoing Changes
Emacs records a list of changes made in the buffer text, so you can
! you can undo all the recent changes, as far as the records go.
! Usually each editing command makes a separate entry in the undo
! records, but sometimes an entry covers just part of a command, and
! very simple commands may be grouped.
@table @kbd
@item C-x u
--- 316,325 ----
@section Undoing Changes
Emacs records a list of changes made in the buffer text, so you can
! undo recent changes, as far as the records go. Usually each editing
! command makes a separate entry in the undo records, but sometimes an
! entry covers just part of a command, and very simple commands may be
! grouped.
@table @kbd
@item C-x u
***************
*** 330,410 ****
The same.
@end table
! The command @kbd{C-x u} (or @kbd{C-_} or @kbd{C-/}) is how you undo.
! The first time you give this command, it undoes the last change.
! Point moves back to where it was before the command that made the
! change.
!
! Consecutive repetitions of @kbd{C-x u} (or its aliases) undo earlier
! and earlier changes, back to the limit of the undo information
! available. If all recorded changes have already been undone, the undo
! command displays an error message and does nothing.
The undo command applies only to changes in the buffer; you can't
! use it to undo mere cursor motion. However, some cursor motion
! commands set the mark, so if you use these commands from time to time,
! you can move back to the neighborhoods you have moved through by
! popping the mark ring (@pxref{Mark Ring}).
@node Basic Files
@section Files
! The commands described above are sufficient for creating and altering
! text in an Emacs buffer; the more advanced Emacs commands just make
! things easier. However, to keep any text permanently you must put it in a
! @dfn{file}. Files are named units of text which are stored by the
! operating system for you to retrieve later by name. To look at or use
! the contents of a file in any way, including editing the file with
! Emacs, you must specify the file name.
! Consider a file named @file{test.emacs}. (We can assume it is in
! your home directory.) In Emacs, to begin editing this file, type
@example
C-x C-f test.emacs @key{RET}
@end example
@noindent
! Here the file name is given as an @dfn{argument} to the command @kbd{C-x
! C-f} (@code{find-file}). That command uses the @dfn{minibuffer} to
! read the argument, and you type @key{RET} to terminate the argument
! (@pxref{Minibuffer}).@refill
!
! Emacs obeys the command by @dfn{visiting} the file: creating a buffer,
! copying the contents of the file into the buffer, and then displaying
! the buffer for you to edit. If you alter the text, you can @dfn{save}
! the new text in the file by typing @kbd{C-x C-s} (@code{save-buffer}).
! This makes the changes permanent by copying the altered buffer contents
! back into the file @file{test.emacs}. Until you save, the changes
! exist only inside Emacs, and the file @file{test.emacs} is unaltered.
!
! To create a file, just visit the file with @kbd{C-x C-f} as if it
! already existed. This creates an empty buffer in which you can insert
! the text you want to put in the file. The file is actually created when
! you save this buffer with @kbd{C-x C-s}.
! Of course, there is a lot more to learn about using files. @xref{Files}.
@node Basic Help
@section Help
@cindex getting help with keys
! If you forget what a key does, you can find out with the Help
! character, which is @kbd{C-h} (or @key{F1}, which is an alias for
! @kbd{C-h}). Type @kbd{C-h k} followed by the key you want to know
! about; for example, @kbd{C-h k C-n} tells you all about what @kbd{C-n}
! does. @kbd{C-h} is a prefix key; @kbd{C-h k} is just one of its
! subcommands (the command @code{describe-key}). The other subcommands of
! @kbd{C-h} provide different kinds of help. Type @kbd{C-h} twice to get
! a description of all the help facilities. @xref{Help}.@refill
@node Blank Lines
@section Blank Lines
@cindex inserting blank lines
@cindex deleting blank lines
! Here are special commands and techniques for putting in and taking out
! blank lines.
@table @kbd
@item C-o
--- 330,405 ----
The same.
@end table
! The command @kbd{C-x u} (or @kbd{C-_} or @kbd{C-/}) lets you undo.
! The first time it's used, it undoes the last change. Point moves to
! where it was before that change.
!
! Repeating @kbd{C-x u} (or its aliases) undoes earlier and earlier
! changes, back as far as possible. If all the recorded changes have
! already been undone, the undo command displays an error message and
! does nothing.
The undo command applies only to changes in the buffer; you can't
! use it to undo just the cursor motion. Some cursor motion commands
! set the mark, however, so you can move back to where they were used
! using the mark ring (@pxref{Mark Ring}).
@node Basic Files
@section Files
! To keep any text permanently you must put it in a @dfn{file}. To
! Emacs, files are units of text which are stored and retrieved by name.
! Thus, to examine or use a file in any way with Emacs you must specify
! the file name first.
! Say we have a file named @file{test.emacs} in your home directory.
! To begin editing this file, type
@example
C-x C-f test.emacs @key{RET}
@end example
@noindent
! Here the file name is required as an @dfn{argument} by the command
! @kbd{C-x C-f} (@code{find-file}). That command uses the
! @dfn{minibuffer} to read the argument. Type @key{RET} to terminate
! the argument (@pxref{Minibuffer}).@refill
!
! Emacs then @dfn{visits} the file: it creates a buffer, copies the
! contents of the file into that buffer, and then displays the buffer
! for editing. If you alter the text, you can @dfn{save} it back in the
! file with @kbd{C-x C-s} (@code{save-buffer}). Emacs then copies the
! altered buffer contents back into the file @file{test.emacs}---a
! permanent change. Until you save, the changed text exists only inside
! Emacs, and the file @file{test.emacs} has the original text.
!
! To create a file, visit it with @kbd{C-x C-f} as if it already
! existed. Emacs will create an empty buffer. The file with the text
! from that buffer is not created until you first save this buffer with
! @kbd{C-x C-s}.
! Emacs can do much more with files. @xref{Files}.
@node Basic Help
@section Help
@cindex getting help with keys
! If you forget what a key does, you can check with the Help
! character, which is @kbd{C-h} (or @key{F1}, aliased to @kbd{C-h}).
! Type @kbd{C-h k} followed by the key of interest. For example,
! @kbd{C-h k C-n} tells you what @kbd{C-n} does. @kbd{C-h} is a prefix
! key; @kbd{C-h k} is just one of its subcommands (the command
! @code{describe-key}). The other subcommands of @kbd{C-h} provide
! different kinds of help. Type @kbd{C-h} twice to get a description of
! all the help facilities. @xref{Help}.@refill
@node Blank Lines
@section Blank Lines
@cindex inserting blank lines
@cindex deleting blank lines
! These commands and techniques help with the insertion and deletion
! of blank lines. A blank line contains no text.
@table @kbd
@item C-o
***************
*** 419,445 ****
@cindex blank lines
@findex open-line
@findex delete-blank-lines
! When you want to insert a new line of text before an existing line, you
! can do it by typing the new line of text, followed by @key{RET}.
! However, it may be easier to see what you are doing if you first make a
! blank line and then insert the desired text into it. This is easy to do
! using the key @kbd{C-o} (@code{open-line}), which inserts a newline
! after point but leaves point in front of the newline. After @kbd{C-o},
! type the text for the new line. @kbd{C-o F O O} has the same effect as
! @w{@kbd{F O O @key{RET}}}, except for the final location of point.
!
! You can make several blank lines by typing @kbd{C-o} several times, or
! by giving it a numeric argument to tell it how many blank lines to make.
! @xref{Arguments}, for how. If you have a fill prefix, the @kbd{C-o}
! command inserts the fill prefix on the new line, when you use it at the
beginning of a line. @xref{Fill Prefix}.
! The easy way to get rid of extra blank lines is with the command
! @kbd{C-x C-o} (@code{delete-blank-lines}). @kbd{C-x C-o} in a run of
! several blank lines deletes all but one of them. @kbd{C-x C-o} on a
! solitary blank line deletes that blank line. When point is on a
! nonblank line, @kbd{C-x C-o} deletes any blank lines following that
! nonblank line.
@node Continuation Lines
@section Continuation Lines
--- 414,439 ----
@cindex blank lines
@findex open-line
@findex delete-blank-lines
! To insert a new line of text before an existing line, type the new
! line of text, followed by @key{RET}. It may be easier to first make a
! blank line and then insert text into it, so you can see the new text
! alone. This is easy to do using @kbd{C-o} (@code{open-line}), which
! inserts a newline after point but leaves point in front of the
! newline. After @kbd{C-o}, type the text for the new line. @kbd{C-o F
! O O} has the same effect as @w{@kbd{F O O @key{RET}}}, except for the
! final location of point.
!
! Make multiple blank lines by typing @kbd{C-o} several times, or with
! a numeric argument specifying the number of blank lines desired.
! @xref{Arguments}, for more. If you have a fill prefix, the @kbd{C-o}
! command inserts the fill prefix on the new line, if you used it at the
beginning of a line. @xref{Fill Prefix}.
! Get rid of extra blank lines easily with @kbd{C-x C-o}
! (@code{delete-blank-lines}). @kbd{C-x C-o} in a run of several blank
! lines deletes all but one. @kbd{C-x C-o} on a lone blank line deletes
! it. When point is on a nonblank line, @kbd{C-x C-o} deletes any
! subsequent blank lines.
@node Continuation Lines
@section Continuation Lines
***************
*** 448,502 ****
@cindex wrapping
@cindex line wrapping
@cindex fringes, and continuation lines
! If you add too many characters to one line without breaking it with
! @key{RET}, the line grows to occupy two (or more) lines on the screen.
! On graphical displays, Emacs indicates line wrapping with small bent
! arrows in the fringes to the left and right of the window. On
! text-only terminals, Emacs displays a @samp{\} character at the right
! margin of a screen line if it is not the last in its text line. This
! @samp{\} character says that the following screen line is not really a
! distinct line in the text, just a @dfn{continuation} of a line too
! long to fit the screen. Continuation is also called @dfn{line
! wrapping}.
! When line wrapping occurs before a character that is wider than one
column, some columns at the end of the previous screen line may be
! ``empty.'' In this case, Emacs displays additional @samp{\}
! characters in the ``empty'' columns, just before the @samp{\}
! character that indicates continuation.
!
! Continued lines can be rather difficult to read, since each line is
! typically broken in the middle of a word. You can have Emacs insert a
! newline automatically when a line gets too long, by using Auto Fill
! mode. Another approach, intermediate between continued lines and Auto
! Fill mode, is Long Lines mode, which ensures that wrapping only occurs
! in the spaces between words. @xref{Filling}.
@cindex truncation
@cindex line truncation, and fringes
! Emacs can also display long lines by @dfn{truncation}. This means
! that all the characters that do not fit in the width of the screen or
! window do not appear at all. @samp{$} in the last column or a small
! straight arrow in the fringe to the right of the window indicates a
! truncated line.
! @xref{Display Custom}, for more information about line truncation,
! and other variables that affect how text is displayed.
@node Position Info
@section Cursor Position Information
! Here are commands to get information about the size and position of
! parts of the buffer, and to count lines.
@table @kbd
@item M-x what-page
! Display the page number of point, and the line number within the page.
@item M-x what-line
! Display the line number of point in the buffer.
@item M-x line-number-mode
@itemx M-x column-number-mode
! Toggle automatic display of current line number or column number.
@xref{Optional Mode Line}.
@item M-=
Display the number of lines in the current region (@code{count-lines-region}).
--- 442,493 ----
@cindex wrapping
@cindex line wrapping
@cindex fringes, and continuation lines
! When a text line has too much text to fit in one visual line, it
! needs to occupy two or more visual (``screen'') lines. On graphical
! displays, Emacs indicates that with small bent arrows in the left and
! right fringes of the window. On text-only terminals, Emacs displays a
! @samp{\} character at the right margin of a screen line if it is not
! the last in its text line. This @samp{\} character says that the
! following screen line is not a new text line, but a @dfn{continuation}
! of a text line too long to fit the screen. Continuation is also called
! @dfn{line wrapping}.
! If a text line is wrapped before a character that is wider than one
column, some columns at the end of the previous screen line may be
! ``empty.'' When that happens, Emacs displays additional @samp{\}
! characters in the ``empty'' columns before the @samp{\} character that
! indicates continuation.
!
! Continued lines can be difficult to read, since lines can break in
! the middle of a word. Turn on Auto Fill mode if you want Emacs to
! insert a newline automatically when a line gets too long. Also
! consider Long Lines mode, a compromise between continued lines and
! Auto Fill mode, which wraps only between words. @xref{Filling}.
@cindex truncation
@cindex line truncation, and fringes
! Emacs can @dfn{truncate} long lines---all the characters that do not
! fit inside the screen do not appear at all. @samp{$} in the last
! column or a small straight arrow in the window's right fringe
! indicate a truncated line.
! @xref{Display Custom}, for more about line truncation
! and other variables that affect text display.
@node Position Info
@section Cursor Position Information
! These commands show the size and position of parts of the buffer and
! count lines.
@table @kbd
@item M-x what-page
! Display the page number of point, and the line number within that page.
@item M-x what-line
! Display the line number of point in the whole buffer.
@item M-x line-number-mode
@itemx M-x column-number-mode
! Toggle automatic display of the current line number or column number.
@xref{Optional Mode Line}.
@item M-=
Display the number of lines in the current region (@code{count-lines-region}).
***************
*** 518,580 ****
@cindex location of point
@cindex cursor location
@cindex point location
! @kbd{M-x what-line} computes the current line number and displays it
! in the echo area. You can also see the current line number in the
! mode line; see @ref{Mode Line}. If you narrow the buffer, then the
! line number in the mode line is relative to the accessible portion
! (@pxref{Narrowing}). By contrast, @code{what-line} shows both the
! line number relative to the narrowed region and the line number
! relative to the whole buffer.
!
! @kbd{M-x what-page} counts pages from the beginning of the file, and
! counts lines within the page, showing both numbers in the echo area.
! @xref{Pages}.
@kindex M-=
@findex count-lines-region
! While on this subject, we might as well mention @kbd{M-=} (@code{count-lines-region}),
! which displays the number of lines in the region (@pxref{Mark}).
! @xref{Pages}, for the command @kbd{C-x l} which counts the lines in the
! current page.
@kindex C-x =
@findex what-cursor-position
! The command @kbd{C-x =} (@code{what-cursor-position}) shows what
! column the cursor is in, and other miscellaneous information about
! point and the character after it. It displays a line in the echo area
! that looks like this:
@smallexample
Char: c (99, #o143, #x63) point=28062 of 36168 (78%) column=53
@end smallexample
! The four values after @samp{Char:} describe the character that follows
! point, first by showing it and then by giving its character code in
! decimal, octal and hex. For a non-@acronym{ASCII} multibyte character, these are
! followed by @samp{file} and the character's representation, in hex, in
! the buffer's coding system, if that coding system encodes the character
! safely and with a single byte (@pxref{Coding Systems}). If the
! character's encoding is longer than one byte, Emacs shows @samp{file ...}.
!
! However, if the character displayed is in the range 0200 through
! 0377 octal, it may actually stand for an invalid UTF-8 byte read from
! a file. In Emacs, that byte is represented as a sequence of 8-bit
! characters, but all of them together display as the original invalid
! byte, in octal code. In this case, @kbd{C-x =} shows @samp{part of
! display ...} instead of @samp{file}.
!
! @samp{point=} is followed by the position of point expressed as a character
! count. The front of the buffer counts as position 1, one character later
! as 2, and so on. The next, larger, number is the total number of characters
! in the buffer. Afterward in parentheses comes the position expressed as a
! percentage of the total size.
@samp{column=} is followed by the horizontal position of point, in
columns from the left edge of the window.
If the buffer has been narrowed, making some of the text at the
beginning and the end temporarily inaccessible, @kbd{C-x =} displays
! additional text describing the currently accessible range. For example, it
might display this:
@smallexample
--- 509,569 ----
@cindex location of point
@cindex cursor location
@cindex point location
! @kbd{M-x what-line} displays the current line number. You can also
! always see the current line number in the mode line; see @ref{Mode
! Line}, but note that if you narrow the buffer, the line number in the
! mode line is relative to the accessible portion (@pxref{Narrowing}).
! By contrast, @code{what-line} shows both the line number relative to
! the narrowed region and the line number relative to the whole buffer.
!
! @kbd{M-x what-page} counts pages from the beginning of the file and
! lines within the current page, then shows both numbers in the echo
! area. @xref{Pages}.
@kindex M-=
@findex count-lines-region
! Use @kbd{M-=} (@code{count-lines-region}) to see the number of lines
! and characters in the region (@pxref{Mark}). @xref{Pages} for the
! command @kbd{C-x l} which counts the lines in the current page.
@kindex C-x =
@findex what-cursor-position
! @kbd{C-x =} (@code{what-cursor-position}) shows the cursor's column
! and other information about point and the character after it. It
! displays a line in the echo area that looks like this:
@smallexample
Char: c (99, #o143, #x63) point=28062 of 36168 (78%) column=53
@end smallexample
! The four values after @samp{Char:} describe the character that
! follows point, first by showing it and then its character code in
! decimal, octal and hex. For a non-@acronym{ASCII} multibyte
! character, these are followed by @samp{file} and the character's
! representation, in hex, in the buffer's coding system, if that coding
! system encodes the character safely and with a single byte
! (@pxref{Coding Systems}). If the character's encoding is longer than
! one byte, Emacs shows @samp{file ...}.
!
! If the character displayed is in the range 0200 through 0377 octal,
! it may actually represent an invalid UTF-8 byte read from a file. In
! Emacs, that byte is represented as a sequence of 8-bit characters, but
! all of them together display as the original invalid byte, in octal
! code. In this case, @kbd{C-x =} shows @samp{part of display ...}
! instead of @samp{file}.
!
! @samp{point=} is followed by the position of point as a character
! count. The first character of the buffer is at position 1, the next
! 2, and so on. The next, larger, number shown is the total number of
! characters in the buffer. Afterward in parentheses comes the position
! as a percentage of the total buffer size.
@samp{column=} is followed by the horizontal position of point, in
columns from the left edge of the window.
If the buffer has been narrowed, making some of the text at the
beginning and the end temporarily inaccessible, @kbd{C-x =} displays
! additional text about the currently accessible range. For example, it
might display this:
@smallexample
***************
*** 604,610 ****
@item
The character set name, and the codes that identify the character
within that character set; @acronym{ASCII} characters are identified
! as belonging to the @code{ascii} character set.
@item
The character's syntax and categories.
--- 593,599 ----
@item
The character set name, and the codes that identify the character
within that character set; @acronym{ASCII} characters are identified
! as members of the @code{ascii} character set.
@item
The character's syntax and categories.
***************
*** 614,621 ****
if you were to save the file.
@item
! What to type to input the character in the current input method
! (if it supports the character).
@item
If you are running Emacs on a graphical display, the font name and
--- 603,610 ----
if you were to save the file.
@item
! What keys input the character with the current input method (if the
! method supports the character).
@item
If you are running Emacs on a graphical display, the font name and
***************
*** 656,677 ****
@cindex prefix arguments
@cindex arguments to commands
! In mathematics and computer usage, the word @dfn{argument} means
! ``data provided to a function or operation.'' You can give any Emacs
! command a @dfn{numeric argument} (also called a @dfn{prefix argument}).
! Some commands interpret the argument as a repetition count. For
! example, @kbd{C-f} with an argument of ten moves forward ten characters
! instead of one. With these commands, no argument is equivalent to an
! argument of one. Negative arguments tell most such commands to move or
! act in the opposite direction.
@kindex M-1
@kindex M-@t{-}
@findex digit-argument
@findex negative-argument
If your terminal keyboard has a @key{META} key (labeled @key{ALT} on
! PC keyboards), the easiest way to specify a numeric argument is to
! type digits and/or a minus sign while holding down the @key{META} key.
For example,
@example
--- 645,667 ----
@cindex prefix arguments
@cindex arguments to commands
! In mathematics and computer usage, @dfn{argument} means ``data
! provided to a function or operation.'' Any Emacs command can take a
! @dfn{numeric argument} (also called a @dfn{prefix argument}).
! Sometimes the argument is ignored. To some commands, the argument is
! a repetition count. For example, @kbd{C-f} with an argument of ten
! moves forward ten characters instead of one. When such commands have
! no argument, they use 1. Negative arguments tell most such commands
! to move or act in the opposite direction.
@kindex M-1
@kindex M-@t{-}
@findex digit-argument
@findex negative-argument
If your terminal keyboard has a @key{META} key (labeled @key{ALT} on
! PC keyboards), hold it down and type digits and/or a minus sign to
! specify a numeric argument.
!
For example,
@example
***************
*** 679,745 ****
@end example
@noindent
! would move down five lines. The characters @kbd{Meta-1}, @kbd{Meta-2},
! and so on, as well as @kbd{Meta--}, do this because they are keys bound
! to commands (@code{digit-argument} and @code{negative-argument}) that
! are defined to contribute to an argument for the next command.
! @kbd{Meta--} without digits normally means @minus{}1. Digits and
! @kbd{-} modified with Control, or Control and Meta, also specify numeric
! arguments.
@kindex C-u
@findex universal-argument
! Another way of specifying an argument is to use the @kbd{C-u}
! (@code{universal-argument}) command followed by the digits of the
! argument. With @kbd{C-u}, you can type the argument digits without
! holding down modifier keys; @kbd{C-u} works on all terminals. To type a
! negative argument, type a minus sign after @kbd{C-u}. Just a minus sign
! without digits normally means @minus{}1.
!
! @kbd{C-u} without digits or minus sign has the special meaning of
! ``four times'': it multiplies the argument for the next command by
! four. @kbd{C-u C-u} multiplies it by sixteen. Thus, @kbd{C-u C-u
! C-f} moves forward sixteen characters. This is a good way to move
! forward ``fast,'' since it moves about 1/5 of a line in the usual size
! screen. Other useful combinations are @kbd{C-u C-n}, @kbd{C-u C-u
! C-n} (move down a good fraction of a screen), @kbd{C-u C-u C-o} (make
! ``a lot'' of blank lines), and @kbd{C-u C-k} (kill four lines).@refill
!
! Some commands care only about whether there is an argument, and not about
! its value. For example, the command @kbd{M-q} (@code{fill-paragraph}) with
! no argument fills text; with an argument, it justifies the text as well.
! (@xref{Filling}, for more information on @kbd{M-q}.) Plain @kbd{C-u} is a
! handy way of providing an argument for such commands.
!
! Some commands use the value of the argument as a repeat count, but do
! something peculiar when there is no argument. For example, the command
! @kbd{C-k} (@code{kill-line}) with argument @var{n} kills @var{n} lines,
! including their terminating newlines. But @kbd{C-k} with no argument is
! special: it kills the text up to the next newline, or, if point is right at
! the end of the line, it kills the newline itself. Thus, two @kbd{C-k}
! commands with no arguments can kill a nonblank line, just like @kbd{C-k}
! with an argument of one. (@xref{Killing}, for more information on
! @kbd{C-k}.)@refill
A few commands treat a plain @kbd{C-u} differently from an ordinary
argument. A few others may treat an argument of just a minus sign
differently from an argument of @minus{}1. These unusual cases are
! described when they come up; they are always for reasons of
! convenience of use of the individual command, and they are documented
! in the command's documentation string.
! You can use a numeric argument to insert multiple copies of a
! character. This is straightforward unless the character is a digit; for
example, @kbd{C-u 6 4 a} inserts 64 copies of the character @samp{a}.
But this does not work for inserting digits; @kbd{C-u 6 4 1} specifies
! an argument of 641, rather than inserting anything. To separate the
! digit to insert from the argument, type another @kbd{C-u}; for example,
! @kbd{C-u 6 4 C-u 1} does insert 64 copies of the character @samp{1}.
!
! We use the term ``prefix argument'' as well as ``numeric argument'' to
! emphasize that you type the argument before the command, and to
! distinguish these arguments from minibuffer arguments that come after
! the command.
@node Repeating
@section Repeating a Command
--- 669,734 ----
@end example
@noindent
! moves down five lines. The characters @kbd{Meta-1}, @kbd{Meta-2}, and
! so on, as well as @kbd{Meta--}, do this because they are keys bound to
! commands (@code{digit-argument} and @code{negative-argument}) that
! make an argument for the next command. @kbd{Meta--} without digits
! normally means @minus{}1. Digits and @kbd{-} modified with Control,
! or Control and Meta, also specify numeric arguments.
@kindex C-u
@findex universal-argument
! The @kbd{C-u} (@code{universal-argument}) command followed by the
! digits of the argument is another way to specify it. With @kbd{C-u},
! you can type the argument digits without modifier keys. Thus,
! @kbd{C-u} works on all terminals. For a negative argument, type a
! minus sign after @kbd{C-u}. Just a minus sign normally means
! @minus{}1.
!
! @kbd{C-u} alone has the special meaning of ``four times'': it
! multiplies the argument for the next command by four. @kbd{C-u C-u}
! multiplies it by sixteen. Thus, @kbd{C-u C-u C-f} moves forward
! sixteen characters. This is a good way to move forward ``fast,''
! since it moves about 1/5 of a line in the usual size screen. Other
! useful combinations are @kbd{C-u C-n}, @kbd{C-u C-u C-n} (move down a
! good fraction of a screen), @kbd{C-u C-u C-o} (make a lot of blank
! lines), and @kbd{C-u C-k} (kill four lines, explained below).@refill
!
! Some commands only care if there is an argument, not what it is.
! For example, the command @kbd{M-q} (@code{fill-paragraph}) fills text;
! with an argument, it justifies the text as well. (@xref{Filling}, for
! more information on @kbd{M-q}.) Plain @kbd{C-u} is a handy way of
! providing an argument for such commands.
!
! Some commands use the value of the argument as a repeat count, but
! do something peculiar when there is no argument. For example, the
! command @kbd{C-k} (@code{kill-line}) with argument @var{n} kills
! @var{n} lines, including their terminating newlines. @kbd{C-k} with
! no argument is different: it kills the text up to the next newline,
! or, if point is at the end of the line, it kills the newline itself.
! Thus, two @kbd{C-k} commands with no arguments can kill a nonblank
! line, just like @kbd{C-k} with an argument of one. (@xref{Killing},
! for more information on @kbd{C-k}.)@refill
A few commands treat a plain @kbd{C-u} differently from an ordinary
argument. A few others may treat an argument of just a minus sign
differently from an argument of @minus{}1. These unusual cases are
! described when they come up; they are always to make the individual
! command easier to use, and they are always documented appropriately in
! the command's documentation string.
! Use a numeric argument with a regular typed character to insert
! multiple copies. This is tricky if the character is a digit; for
example, @kbd{C-u 6 4 a} inserts 64 copies of the character @samp{a}.
But this does not work for inserting digits; @kbd{C-u 6 4 1} specifies
! an argument of 641. To separate the digit from the argument, type
! another @kbd{C-u}. For example, @kbd{C-u 6 4 C-u 1} will insert 64
! copies of the character @samp{1}.
!
! The terms ``prefix argument'' as well as ``numeric argument'' are
! used to emphasize that you type these argument before the command, and
! to distinguish them from the minibuffer arguments that come after the
! command.
@node Repeating
@section Repeating a Command
***************
*** 748,756 ****
Many simple commands, such as those invoked with a single key or
with @kbd{M-x @var{command-name} @key{RET}}, can be repeated by
invoking them with a numeric argument that serves as a repeat count
! (@pxref{Arguments}). However, if the command you want to repeat
! prompts for some input, or uses a numeric argument in another way,
! repetition using a numeric argument might be problematical.
@kindex C-x z
@findex repeat
--- 737,745 ----
Many simple commands, such as those invoked with a single key or
with @kbd{M-x @var{command-name} @key{RET}}, can be repeated by
invoking them with a numeric argument that serves as a repeat count
! (@pxref{Arguments}). If the command you want to repeat prompts for
! some input or uses a numeric argument in another way, things are not
! so simple.
@kindex C-x z
@findex repeat
***************
*** 759,773 ****
command, whatever that was. Repeating a command uses the same arguments
that were used before; it does not read new arguments each time.
! To repeat the command more than once, type additional @kbd{z}'s: each
! @kbd{z} repeats the command one more time. Repetition ends when you
type a character other than @kbd{z}, or press a mouse button.
! For example, suppose you type @kbd{C-u 2 0 C-d} to delete 20
! characters. You can repeat that command (including its argument) three
! additional times, to delete a total of 80 characters, by typing @kbd{C-x
! z z z}. The first @kbd{C-x z} repeats the command once, and each
! subsequent @kbd{z} repeats it once again.
@ignore
arch-tag: cda8952a-c439-41c1-aecf-4bc0d6482956
--- 748,760 ----
command, whatever that was. Repeating a command uses the same arguments
that were used before; it does not read new arguments each time.
! To repeat the command more than once, type additional @kbd{z}'s:
! each @kbd{z} repeats the command once more. Repetition ends when you
type a character other than @kbd{z}, or press a mouse button.
! For example, type @kbd{C-u 2 0 C-d} to delete 20 characters. Repeat
! that command (including its @kbd{2 0} argument) three more times,
! deleting a total of 80 characters, with @kbd{C-x z z z}.
@ignore
arch-tag: cda8952a-c439-41c1-aecf-4bc0d6482956
[-- Attachment #3: Type: text/plain, Size: 142 bytes --]
_______________________________________________
Emacs-devel mailing list
Emacs-devel@gnu.org
http://lists.gnu.org/mailman/listinfo/emacs-devel
^ permalink raw reply [flat|nested] 2+ messages in thread* Emacs manual update: mini.texi
2006-05-25 19:41 Emacs manual update: basic.texi Ted Zlatanov
@ 2006-05-31 20:12 ` Ted Zlatanov
0 siblings, 0 replies; 2+ messages in thread
From: Ted Zlatanov @ 2006-05-31 20:12 UTC (permalink / raw)
[-- Attachment #1: Type: text/plain, Size: 63 bytes --]
Attached is my context diff of mini.texi for the manual.
Ted
[-- Attachment #2: mini.diff --]
[-- Type: text/plain, Size: 51211 bytes --]
Index: mini.texi
===================================================================
RCS file: /sources/emacs/emacs/man/mini.texi,v
retrieving revision 1.39
diff -c -r1.39 mini.texi
*** mini.texi 6 May 2006 21:41:27 -0000 1.39
--- mini.texi 31 May 2006 19:41:28 -0000
***************
*** 6,60 ****
@chapter The Minibuffer
@cindex minibuffer
! The @dfn{minibuffer} is the facility used by Emacs commands to read
! arguments more complicated than a single number. Minibuffer arguments
! can be file names, buffer names, Lisp function names, Emacs command
! names, Lisp expressions, and many other things, depending on the command
! reading the argument. You can use the usual Emacs editing commands in
! the minibuffer to edit the argument text.
@cindex prompt
When the minibuffer is in use, it appears in the echo area, and the
! terminal's cursor moves there. The beginning of the minibuffer line
! displays a @dfn{prompt} in a special color, to say what kind of input
! you should supply and how it will be used. Often this prompt is
! derived from the name of the command that the argument is for. The
! prompt normally ends with a colon.
@cindex default argument
Sometimes a @dfn{default argument} appears in parentheses before the
! colon; it too is part of the prompt. The default will be used as the
! argument value if you enter an empty argument (that is, just type
! @key{RET}). For example, commands that read buffer names always show a
! default, which is the name of the buffer that will be used if you type
! just @key{RET}.
!
! The simplest way to enter a minibuffer argument is to type the text
! you want, terminated by @key{RET} which exits the minibuffer. You can
! cancel the command that wants the argument, and get out of the
! minibuffer, by typing @kbd{C-g}.
!
! Since the minibuffer uses the screen space of the echo area, it can
! conflict with other ways Emacs customarily uses the echo area. Here is how
! Emacs handles such conflicts:
@itemize @bullet
@item
! If a command gets an error while you are in the minibuffer, this does
! not cancel the minibuffer. However, the echo area is needed for the
! error message and therefore the minibuffer itself is hidden for a
! while. It comes back after a few seconds, or as soon as you type
! anything.
! @item
! If in the minibuffer you use a command whose purpose is to display a
! message in the echo area, such as @kbd{C-x =}, the message hides the
! minibuffer for a while. The minibuffer contents come back after a few
seconds, or as soon as you type anything.
@item
! Echoing of keystrokes does not take place while the minibuffer is in
! use.
@end itemize
@menu
--- 6,56 ----
@chapter The Minibuffer
@cindex minibuffer
! The @dfn{minibuffer} is where Emacs commands read complex (not a
! single number) arguments. Is it called the ``minibuffer'' because of
! its small visual size, its transient nature, and because you can edit
! text as in a normal buffer. Minibuffer arguments can name files,
! buffers, Lisp functions, Emacs commands, Lisp expressions, and many
! other things, depending on what the Emacs command requested.
@cindex prompt
When the minibuffer is in use, it appears in the echo area, and the
! cursor moves there. The minibuffer line begins with a @dfn{prompt} in
! a distinct color. The prompt specifies what input is expected and how
! it will be used. Often the prompt uses the name of the command that
! requested the argument. The prompt usually ends with a colon.
@cindex default argument
Sometimes a @dfn{default argument} appears in parentheses before the
! colon; it too is part of the prompt and will be used if you type just
! @key{RET}. For example, prompts for buffer names always show a
! default buffer name, which will be used if you type just @key{RET}.
!
! The simplest way to give a minibuffer argument is to type text, then
! type @key{RET} to exit the minibuffer. You can cancel the command
! that requested the argument and leave the minibuffer with @kbd{C-g}.
!
! Since the minibuffer appears in the echo area, it can conflict with
! other uses of the echo area. Here are some scenarios that can happen
! while you use the minibuffer.
@itemize @bullet
@item
! An error occurs while the minibuffer is open.
! The error message needs to be displayed in the echo area, so the
! minibuffer is hidden temporarily. It will come back after a few
seconds, or as soon as you type anything.
@item
! A command such as @kbd{C-x =} needs to display a message in the echo
! area.
!
! The message hides the minibuffer temporarily. The minibuffer contents
! will come back after a few seconds, or as soon as you type anything.
!
! @item
! Keystrokes are not echoed while the minibuffer is in use.
@end itemize
@menu
***************
*** 68,101 ****
@node Minibuffer File
@section Minibuffers for File Names
! Sometimes the minibuffer starts out with text in it. For example, when
! you are supposed to give a file name, the minibuffer starts out containing
! the @dfn{default directory}, which ends with a slash. This is to inform
! you which directory the file will be found in if you do not specify a
! directory.
@c Separate paragraph to clean up ugly page break--rms
@need 1500
! For example, the minibuffer might start out with these contents:
@example
Find File: /u2/emacs/src/
@end example
@noindent
! where @samp{Find File:@: } is the prompt. Typing @kbd{buffer.c} as
! input specifies the file @file{/u2/emacs/src/buffer.c}. To find files
! in nearby directories, use @kbd{..}; thus, if you type
! @kbd{../lisp/simple.el}, you will get the file named
! @file{/u2/emacs/lisp/simple.el}. Alternatively, you can kill with
! @kbd{M-@key{DEL}} the directory names you don't want (@pxref{Words}).
!
! If you don't want any of the default, you can kill it with @kbd{C-a
! C-k}. But you don't need to kill the default; you can simply ignore it.
! Insert an absolute file name, one starting with a slash or a tilde,
! after the default directory. For example, to specify the file
! @file{/etc/termcap}, just insert that name, giving these minibuffer
! contents:
@example
Find File: /u2/emacs/src//etc/termcap
--- 64,94 ----
@node Minibuffer File
@section Minibuffers for File Names
! Sometimes the minibuffer's contents have some initial text. For
! example, the minibuffer prompt for a file name is initially the
! @dfn{default directory}, ending with a slash. If you do not specify a
! directory, this default will be used to find or save files.
@c Separate paragraph to clean up ugly page break--rms
@need 1500
! For example, if the minibuffer starts with these contents:
@example
Find File: /u2/emacs/src/
@end example
@noindent
! Here, @samp{Find File:@: } is the prompt. To specify the file
! @file{/u2/emacs/src/buffer.c}, type @kbd{buffer.c}. To specify one
! directory level above, use @kbd{..}; thus, if you type
! @kbd{../lisp/simple.el}, you will get @file{/u2/emacs/lisp/simple.el}.
! You can kill the directory names you don't want with @kbd{M-@key{DEL}}
! (@pxref{Words}).
!
! You can kill it the entire default with @kbd{C-a C-k}, but there's
! no need. You can simply ignore it and give an absolute file name
! starting with a slash or a tilde after the default directory. For
! example, to specify @file{/etc/termcap}, just type that name:
@example
Find File: /u2/emacs/src//etc/termcap
***************
*** 106,219 ****
@cindex double slash in file name
@cindex slashes repeated in file name
@findex file-name-shadow-mode
! GNU Emacs gives a special meaning to a double slash (which is not
! normally a useful thing to write): it means, ``ignore everything
! before the second slash in the pair.'' Thus, @samp{/u2/emacs/src/} is
! ignored in the example above, and you get the file
! @file{/etc/termcap}. The ignored part of the file name is dimmed if
! the terminal allows it; to disable this, turn off
! @code{file-name-shadow-mode} minor mode.
!
! If you set @code{insert-default-directory} to @code{nil}, the
! default directory is never inserted in the minibuffer---so the
! minibuffer starts out empty. But the name you type, if relative, is
! still interpreted with respect to the same default directory.
@node Minibuffer Edit
@section Editing in the Minibuffer
! The minibuffer is an Emacs buffer (albeit a peculiar one), and the usual
! Emacs commands are available for editing the text of an argument you are
! entering.
!
! Since @key{RET} in the minibuffer is defined to exit the minibuffer,
! you can't use it to insert a newline in the minibuffer. To do that,
! type @kbd{C-o} or @kbd{C-q C-j}. (The newline character is really the
! @acronym{ASCII} character control-J.)
!
! The minibuffer has its own window, which normally has space on the
! Emacs frame at all times, but it only acts like an Emacs window when
! the minibuffer is really in use. At those times, its window is much
! like any other Emacs window; you can switch from the minibuffer window
! to another window with @kbd{C-x o}, and edit text in other windows,
! before returning to the minibuffer to submit the argument. You can
! kill text in another window, return to the minibuffer window, and then
! yank the text to use it in the argument. @xref{Windows}.
@cindex height of minibuffer
@cindex size of minibuffer
@cindex growing minibuffer
@cindex resizing minibuffer
! There are some restrictions on the use of the minibuffer window,
! however. You cannot switch buffers in it---the minibuffer and its
! window are permanently attached. Also, you cannot split or kill the
! minibuffer window. But you can make it taller in the normal fashion
! with @kbd{C-x ^}.
@vindex resize-mini-windows
! The minibuffer window expands vertically as necessary to hold the
! text that you put in the minibuffer. If @code{resize-mini-windows} is
! @code{t} (the default), the window is always resized to fit the size
! of the text it displays. If its value is the symbol @code{grow-only},
! the window grows when the size of displayed text increases, but
! shrinks (back to the normal size) only when the minibuffer becomes
inactive. If its value is @code{nil}, you have to adjust the height
yourself.
@vindex max-mini-window-height
! The variable @code{max-mini-window-height} controls the maximum
! height for resizing the minibuffer window: a floating-point number
! specifies a fraction of the frame's height; an integer specifies the
! maximum number of lines; @code{nil} means do not resize the minibuffer
! window automatically. The default value is 0.25.
!
! If, while in the minibuffer, you issue a command that displays help
! text of any sort in another window, you can use the @kbd{C-M-v}
! command while in the minibuffer to scroll the help text.
! (@kbd{M-@key{PAGEUP}} and @kbd{M-@key{PAGEDOWN}} also operate on that
! help text.) This lasts until you exit the minibuffer. This feature
! is especially useful when you display a buffer listing possible
completions. @xref{Other Window}.
@vindex enable-recursive-minibuffers
! Emacs normally disallows most commands that use the minibuffer while
! the minibuffer is active. This rule is to prevent recursive minibuffers
! from confusing novice users. If you want to be able to use such
! commands in the minibuffer, set the variable
@code{enable-recursive-minibuffers} to a non-@code{nil} value.
@node Completion
@section Completion
@cindex completion
! For certain kinds of arguments, you can use @dfn{completion} to enter
! the argument value. Completion means that you type part of the
! argument, then Emacs visibly fills in the rest, or as much as
! can be determined from the part you have typed.
!
! When completion is available, certain keys---@key{TAB}, @key{RET}, and
! @key{SPC}---are rebound to complete the text in the minibuffer before point
! into a longer string that it stands for, by matching it against a set of
! @dfn{completion alternatives} provided by the command reading the
! argument. @kbd{?} is defined to display a list of possible completions
! of what you have inserted.
!
! For example, when @kbd{M-x} uses the minibuffer to read the name of
! a command, it provides a list of all available Emacs command names to
! complete against. The completion keys match the minibuffer text
! against all the command names, find any additional name characters
! implied by the ones already present in the minibuffer, and add those
! characters to the ones you have given. This is what makes it possible
! to type @kbd{M-x ins @key{SPC} b @key{RET}} instead of @kbd{M-x
! insert-buffer @key{RET}} (for example). (@key{SPC} does not do
! completion in reading file names, because it is common to use spaces
! in file names on some systems.)
!
! Case is normally significant in completion, because it is significant
! in most of the names that you can complete (buffer names, file names and
! command names). Thus, @samp{fo} does not complete to @samp{Foo}.
! Completion does ignore case distinctions for certain arguments in which
! case does not matter.
Completion acts only on the text before point. If there is text in
the minibuffer after point---i.e., if you move point backward after
--- 99,199 ----
@cindex double slash in file name
@cindex slashes repeated in file name
@findex file-name-shadow-mode
! GNU Emacs interprets a double slash (which is not normally a useful
! thing to write) as ``ignore everything up to the second slash in the
! pair.'' In the example above, @samp{/u2/emacs/src/} is ignored and
! you get @file{/etc/termcap}. The ignored portion of the file name is
! dimmed if the terminal allows it; to disable this highlighting, turn
! off the @code{file-name-shadow-mode} minor mode.
!
! If @code{insert-default-directory} is @code{nil}, the minibuffer
! starts out empty. If you type a relative name, though, it will be
! interpreted with the same default directory.
@node Minibuffer Edit
@section Editing in the Minibuffer
! The minibuffer is a special Emacs buffer and the usual Emacs
! commands are available for editing the text you are entering.
!
! Since @key{RET} in the minibuffer exits it, you can't use @key{RET}
! to insert a newline in the minibuffer. Use @kbd{C-o} or @kbd{C-q
! C-j}. (In Emacs, this inserts a literal @acronym{ASCII} newline
! Control-J.)
!
! The minibuffer has its own window, normally in the Emacs frame at
! all times, but it only acts like an Emacs window when the minibuffer
! is really in use. Its window is then like any other Emacs window; you
! can navigate between the minibuffer window and others with @kbd{C-x
! o}, edit text in other windows, then return to the minibuffer. You
! can kill text in another window and then yank the text into the
! minibuffer. @xref{Windows}.
@cindex height of minibuffer
@cindex size of minibuffer
@cindex growing minibuffer
@cindex resizing minibuffer
! There are some restrictions on the minibuffer window. Only the
! minibuffer can be shown there, and it can not be split or killed.
! @kbd{C-x ^}, however, will make it taller.
@vindex resize-mini-windows
! The minibuffer window will expand vertically to hold the text in the
! minibuffer. If @code{resize-mini-windows} is @code{t} (the default),
! the window is always resized to fit the text. If
! @code{resize-mini-windows} is the symbol @code{grow-only}, the window
! grows when necessary, but shrinks back when the minibuffer is
inactive. If its value is @code{nil}, you have to adjust the height
yourself.
@vindex max-mini-window-height
! The variable @code{max-mini-window-height} specifies the maximum
! height of the minibuffer window. A floating-point number specifies a
! fraction of the frame's height. An integer specifies the maximum
! number of lines. With @code{nil}, the minibuffer window is not
! resized automatically. The default is 0.25.
!
! The @kbd{C-M-v} command in the minibuffer scrolls the help text from
! commands that display help text of any sort in another window.
! @kbd{M-@key{PAGEUP}} and @kbd{M-@key{PAGEDOWN}} also operate on that
! help text. This is especially useful with long lists of possible
completions. @xref{Other Window}.
@vindex enable-recursive-minibuffers
! Emacs normally blocks most commands that use the minibuffer while it
! is active to avoid confusing novice users with minibuffers inside
! minibuffers (recursive minibuffers). To override this default, set
@code{enable-recursive-minibuffers} to a non-@code{nil} value.
@node Completion
@section Completion
@cindex completion
! Some arguments allow @dfn{completion} to enter their value. This
! means that after you type part of the argument, Emacs can fill in as
! much as possible (based on what you have typed so far).
!
! When completion is available, certain keys---@key{TAB}, @key{RET},
! and @key{SPC}---expand the text in the minibuffer before point into a
! longer string matched from a set of @dfn{completion alternatives}
! provided by the command that requested the argument. @kbd{?} displays
! the possible completions at any time.
!
! For example, @kbd{M-x} reads the name of a command through the
! minibuffer and provides a completion candidate list of all the
! available Emacs command names. The completion keys match the
! minibuffer text against the candidates, find any additional name
! characters implied by what's already in the minibuffer, and add those
! characters to the text so far. This is what makes it possible to type
! @kbd{M-x ins @key{SPC} b @key{RET}} instead of @kbd{M-x insert-buffer
! @key{RET}} for example. (@key{SPC} does not do completion for file
! names, because some systems use spaces frequently in file names.)
!
! Case matters for completion, because it is significant in most of
! the names that can be completed (buffer names, file names and command
! names). Thus, @samp{fo} does not complete to @samp{Foo}. Completion
! does ignores case distinctions sometimes, when case does not matter,
! depending on the command that requested the argument.
Completion acts only on the text before point. If there is text in
the minibuffer after point---i.e., if you move point backward after
***************
*** 231,271 ****
@kindex TAB @r{(completion)}
@findex minibuffer-complete
! A concrete example may help here. If you type @kbd{M-x au @key{TAB}},
! the @key{TAB} looks for alternatives (in this case, command names) that
! start with @samp{au}. There are several, including
! @code{auto-fill-mode} and @code{auto-save-mode}---but they are all the
! same as far as @code{auto-}, so the @samp{au} in the minibuffer changes
! to @samp{auto-}.@refill
!
! If you type @key{TAB} again immediately, there are multiple
! possibilities for the very next character---it could be any of
! @samp{cfilrs}---so no more characters are added; instead, @key{TAB}
! displays a list of all possible completions in another window.
!
! If you go on to type @kbd{f @key{TAB}}, this @key{TAB} sees
! @samp{auto-f}. The only command name starting this way is
! @code{auto-fill-mode}, so completion fills in the rest of that. You now
! have @samp{auto-fill-mode} in the minibuffer after typing just @kbd{au
! @key{TAB} f @key{TAB}}. Note that @key{TAB} has this effect because in
! the minibuffer it is bound to the command @code{minibuffer-complete}
! when completion is available.
@node Completion Commands
@subsection Completion Commands
! Here is a list of the completion commands defined in the minibuffer
! when completion is available.
@table @kbd
@item @key{TAB}
Complete the text before point in the minibuffer as much as possible
(@code{minibuffer-complete}).
@item @key{SPC}
! Complete the minibuffer text before point, but don't go beyond one
! word (@code{minibuffer-complete-word}). @key{SPC} for completion is
! not available when entering a file name, since some users often put
! spaces in filenames.
@item @key{RET}
Submit the text in the minibuffer as the argument, possibly completing
first as described
--- 211,250 ----
@kindex TAB @r{(completion)}
@findex minibuffer-complete
! A concrete example may help you. When you type @kbd{M-x au
! @key{TAB}}, the @key{TAB} looks for alternatives (in this case,
! command names) that start with @samp{au}. There are several,
! including @code{auto-fill-mode} and @code{auto-save-mode}---but they
! all begin with @code{auto-}, so the @samp{au} in the minibuffer
! completes to @samp{auto-}.@refill
!
! Type @key{TAB} again. Now, the next character could be and of
! @samp{cfilrs}. No more characters are added; instead, Emacs displays
! the possible completions in another window.
!
! Now type @kbd{f @key{TAB}}. @key{TAB} sees @samp{auto-f} in the
! minibuffer. The only command name that matches is
! @code{auto-fill-mode}. You will now see the completed name
! @samp{auto-fill-mode} in the minibuffer. So far, you typed just
! @kbd{au @key{TAB} f @key{TAB}} instead of the whole command name.
!
! In the minibuffer, @key{TAB} invokes @code{minibuffer-complete} when
! completion is possible.
@node Completion Commands
@subsection Completion Commands
! These are the completion commands defined in the minibuffer when
! completion is possible.
@table @kbd
@item @key{TAB}
Complete the text before point in the minibuffer as much as possible
(@code{minibuffer-complete}).
@item @key{SPC}
! Complete no more than one word with the minibuffer text before point
! (@code{minibuffer-complete-word}). @key{SPC} can't complete file
! names, since often they contain spaces.
@item @key{RET}
Submit the text in the minibuffer as the argument, possibly completing
first as described
***************
*** 277,512 ****
Completion}.
@end ifnottex
@item ?
! Display a list of all possible completions of the text in the minibuffer
(@code{minibuffer-completion-help}).
@end table
@kindex SPC
@findex minibuffer-complete-word
! @key{SPC} completes much like @key{TAB}, but never goes beyond the
! next hyphen or space. If you have @samp{auto-f} in the minibuffer and
! type @key{SPC}, it finds that the completion is @samp{auto-fill-mode},
! but it stops completing after @samp{fill-}. This gives
! @samp{auto-fill-}. Another @key{SPC} at this point completes all the
! way to @samp{auto-fill-mode}. The command that implements this
! behavior is called @code{minibuffer-complete-word}.
! Here are some commands you can use to choose a completion from a
! window that displays a list of completions:
@table @kbd
@findex mouse-choose-completion
@item Mouse-1
@itemx Mouse-2
! Clicking mouse button 1 or 2 on a completion in the list of possible
! completions chooses that completion (@code{mouse-choose-completion}).
! You normally use this command while point is in the minibuffer, but you
! must click in the list of completions, not in the minibuffer itself.
@findex switch-to-completions
@item @key{PRIOR}
@itemx M-v
! Typing @key{PRIOR} or @key{PAGE-UP}, or @kbd{M-v}, while in the
! minibuffer, selects the window showing the completion list buffer
! (@code{switch-to-completions}). This paves the way for using the
! commands below. (Selecting that window in the usual ways has the same
! effect, but this way is more convenient.)
@findex choose-completion
@item @key{RET}
! Typing @key{RET} @emph{in the completion list buffer} chooses the
! completion that point is in or next to (@code{choose-completion}). To
! use this command, you must first switch windows to the window that shows
! the list of completions.
@findex next-completion
@item @key{RIGHT}
! Typing the right-arrow key @key{RIGHT} @emph{in the completion list
! buffer} moves point to the following completion (@code{next-completion}).
@findex previous-completion
@item @key{LEFT}
! Typing the left-arrow key @key{LEFT} @emph{in the completion list
! buffer} moves point toward the beginning of the buffer, to the previous
! completion (@code{previous-completion}).
@end table
@node Strict Completion
@subsection Strict Completion
! There are three different ways that @key{RET} can work in completing
! minibuffers, depending on how the argument will be used.
@itemize @bullet
@item
! @dfn{Strict} completion is used when it is meaningless to give any
! argument except one of the known alternatives. For example, when
! @kbd{C-x k} reads the name of a buffer to kill, it is meaningless to
! give anything but the name of an existing buffer. In strict
! completion, @key{RET} refuses to exit if the text in the minibuffer
! does not complete to an exact match.
@item
@dfn{Cautious} completion is similar to strict completion, except that
! @key{RET} exits only if the text was an exact match already, not
! needing completion. If the text is not an exact match, @key{RET} does
! not exit, but it does complete the text. If it completes to an exact
! match, a second @key{RET} will exit.
Cautious completion is used for reading file names for files that must
! already exist.
@item
! @dfn{Permissive} completion is used when any string whatever is
! meaningful, and the list of completion alternatives is just a guide.
! For example, when @kbd{C-x C-f} reads the name of a file to visit, any
! file name is allowed, in case you want to create a file. In
! permissive completion, @key{RET} takes the text in the minibuffer
! exactly as given, without completing it.
@end itemize
! The completion commands display a list of all possible completions in
! a window whenever there is more than one possibility for the very next
! character. Also, typing @kbd{?} explicitly requests such a list. If
! the list of completions is long, you can scroll it with @kbd{C-M-v}
! (@pxref{Other Window}).
@node Completion Options
@subsection Completion Options
@vindex completion-ignored-extensions
@cindex ignored file names, in completion
! When completion is done on file names, certain file names are usually
! ignored. The variable @code{completion-ignored-extensions} contains a
! list of strings; a file whose name ends in any of those strings is
! ignored as a possible completion. The standard value of this variable
! has several elements including @code{".o"}, @code{".elc"}, @code{".dvi"}
! and @code{"~"}. The effect is that, for example, @samp{foo} can
! complete to @samp{foo.c} even though @samp{foo.o} exists as well.
! However, if @emph{all} the possible completions end in ``ignored''
! strings, then they are not ignored. Ignored extensions do not apply to
! lists of completions---those always mention all possible completions.
!
! If an element of the list in @code{completion-ignored-extensions} ends
! in a slash @file{/}, it indicates a subdirectory that should be ignored
! when completing file names. Elements of
! @code{completion-ignored-extensions} which do not end in a slash are
! never considered when a completion candidate is a directory; thus,
! completion returns directories whose names end in @file{.elc} even
! though there's an element @code{".elc"} in the list.
@vindex completion-auto-help
! Normally, a completion command that cannot determine even one
! additional character automatically displays a list of all possible
! completions. If the variable @code{completion-auto-help} is set to
! @code{nil}, this automatic display is disabled, so you must type
! @kbd{?} to display the list of completions.
@cindex Partial Completion mode
@vindex partial-completion-mode
@findex partial-completion-mode
Partial Completion mode implements a more powerful kind of
! completion that can complete multiple words in parallel. For example,
! it can complete the command name abbreviation @code{p-b} into
! @code{print-buffer}, because no other command starts with two words
! whose initials are @samp{p} and @samp{b}.
Partial completion of directories in file names uses @samp{*} to
! indicate the places for completion; thus, @file{/u*/b*/f*} might
! complete to @file{/usr/bin/foo}.
For remote files, partial completion enables completion of methods,
user names and host names. @xref{Remote Files}.
! To enable this mode, use the command @kbd{M-x
! partial-completion-mode}, or customize the variable
! @code{partial-completion-mode}. This binds the partial completion
! commands to @key{TAB}, @key{SPC}, @key{RET}, and @kbd{?}. The usual
! completion commands are available on @kbd{M-@key{TAB}} (or
! @kbd{C-M-i}), @kbd{M-@key{SPC}}, @kbd{M-@key{RET}} and @kbd{M-?}.
@vindex PC-include-file-path
@vindex PC-disable-includes
! Another feature of Partial Completion mode is to extend
! @code{find-file} so that @samp{<@var{include}>} stands for the
! file named @var{include} in some directory in the path
! @code{PC-include-file-path}. If you set @code{PC-disable-includes} to
! non-@code{nil}, this feature is disabled.
@cindex Icomplete mode
@findex icomplete-mode
! Icomplete mode presents a constantly-updated display that tells you
! what completions are available for the text you've entered so far. The
! command to enable or disable this minor mode is @kbd{M-x
! icomplete-mode}.
@node Minibuffer History
@section Minibuffer History
@cindex minibuffer history
@cindex history of minibuffer input
! Every argument that you enter with the minibuffer is saved on a
! @dfn{minibuffer history list} so that you can use it again later in
! another argument. Special commands load the text of an earlier argument
! in the minibuffer. They discard the old minibuffer contents, so you can
! think of them as moving through the history of previous arguments.
@table @kbd
@item @key{UP}
@itemx M-p
! Move to the next earlier argument string saved in the minibuffer history
(@code{previous-history-element}).
@item @key{DOWN}
@itemx M-n
! Move to the next later argument string saved in the minibuffer history
(@code{next-history-element}).
@item M-r @var{regexp} @key{RET}
! Move to an earlier saved argument in the minibuffer history that has a
! match for @var{regexp} (@code{previous-matching-history-element}).
@item M-s @var{regexp} @key{RET}
! Move to a later saved argument in the minibuffer history that has a
! match for @var{regexp} (@code{next-matching-history-element}).
@end table
@kindex M-p @r{(minibuffer history)}
@kindex M-n @r{(minibuffer history)}
@findex next-history-element
@findex previous-history-element
! The simplest way to reuse the saved arguments in the history list is
! to move through the history list one element at a time. While in the
! minibuffer, use @kbd{M-p} or up-arrow
! (@code{previous-history-element}) to ``move to'' the next earlier
! minibuffer input, and use @kbd{M-n} or down-arrow
! (@code{next-history-element}) to ``move to'' the next later input.
! These commands don't move the cursor, they bring different saved
! strings into the minibuffer. But you can think of them as ``moving''
! through the history list.
!
! The previous input that you fetch from the history entirely replaces
! the contents of the minibuffer. To use it as the argument, exit the
! minibuffer as usual with @key{RET}. You can also edit the text before
! you reuse it; this does not change the history element that you
! ``moved'' to, but your new argument does go at the end of the history
! list in its own right.
!
! For many minibuffer arguments there is a ``default'' value. Then
! you can insert the default value into the minibuffer as text by using
! @kbd{M-n} to move ``into the future'' in the history.
@findex previous-matching-history-element
@findex next-matching-history-element
@kindex M-r @r{(minibuffer history)}
@kindex M-s @r{(minibuffer history)}
! There are also commands to search forward or backward through the
! history; they search for history elements that match a regular
! expression that you specify with the minibuffer. @kbd{M-r}
! (@code{previous-matching-history-element}) searches older elements in
! the history, while @kbd{M-s} (@code{next-matching-history-element})
! searches newer elements. By special dispensation, these commands can
! use the minibuffer to read their arguments even though you are already
! in the minibuffer when you issue them. As with incremental searching,
! an upper-case letter in the regular expression makes the search
! case-sensitive (@pxref{Search Case}).
@ignore
We may change the precise way these commands read their arguments.
--- 256,476 ----
Completion}.
@end ifnottex
@item ?
! Display all the possible completions of the text in the minibuffer
(@code{minibuffer-completion-help}).
@end table
@kindex SPC
@findex minibuffer-complete-word
! @key{SPC} completes like @key{TAB}, up to the next hyphen or space.
! With @samp{auto-f} in the minibuffer, when you type @key{SPC}, the
! completion is @samp{auto-fill-mode}, but only @samp{auto-fill-} is
! completed. Another @key{SPC} at this point completes another word to
! produce @samp{auto-fill-mode}. @key{SPC} invokes
! @code{minibuffer-complete-word}.
! These commands let you choose a completion from the window that
! displays the list of completions:
@table @kbd
@findex mouse-choose-completion
@item Mouse-1
@itemx Mouse-2
! Clicking mouse button 1 or 2 on a completion candidate chooses that
! completion (@code{mouse-choose-completion}). Since normally you'll
! use this while point is in the minibuffer, make sure to click in the
! window with the list of completions, not in the minibuffer.
@findex switch-to-completions
@item @key{PRIOR}
@itemx M-v
! @key{PRIOR} or @key{PAGE-UP} or @kbd{M-v} in the minibuffer switches
! to the window showing the completion list buffer
! (@code{switch-to-completions}), where you can use the following
! commands. (You can also select that window in the usual ways, but
! this is more convenient.)
@findex choose-completion
@item @key{RET}
! @key{RET} @emph{in the completion list buffer} chooses the completion
! that contains point or is closest to it (@code{choose-completion}).
! Use this command in the completion list window.
@findex next-completion
@item @key{RIGHT}
! The right-arrow key @key{RIGHT} @emph{in the completion list buffer}
! moves point to the following completion (@code{next-completion}).
@findex previous-completion
@item @key{LEFT}
! The left-arrow key @key{LEFT} @emph{in the completion list buffer}
! moves point to the previous completion (@code{previous-completion}).
@end table
@node Strict Completion
@subsection Strict Completion
! In completing minibuffers, @key{RET} can work in three different
! ways depending on how the argument will be used.
@itemize @bullet
@item
! @dfn{Strict} completion only accepts one of the known
! completioncandidates. For example, when @kbd{C-x k} needs the name of
! a buffer to kill, it has to be the name of an existing buffer.
! @key{RET} refuses to exit in this completion mode if the text in the
! minibuffer is not one of the completion candidates.
@item
@dfn{Cautious} completion is similar to strict completion, except that
! @key{RET} exits only if the text was one of the completion candidates
! exactly. If the text is not, @key{RET} does not exit, but does
! complete the text as far as possible. If that completes to an exact
! match, a second @key{RET} will exit as usual.
Cautious completion is used for reading file names for files that must
! already exist, for example.
@item
! @dfn{Permissive} completion allows any string; the list of completion
! candidates is just a guide. For example, when @kbd{C-x C-f} requests
! the name of a file to visit, any file name is allowed, even if the
! corresponding file does not exist. @key{RET} in permissive
! completion does not complete, it just submits the text.
@end itemize
! The completion commands display the completion candidates in a
! window if more than one candidate matches the text so far. Also,
! @kbd{?} explicitly requests the candidate list. You can scroll the
! list of candidates with @kbd{C-M-v} if it's long (@pxref{Other
! Window}).
@node Completion Options
@subsection Completion Options
@vindex completion-ignored-extensions
@cindex ignored file names, in completion
! Some file names are usually ignored during file name completion.
! The variable @code{completion-ignored-extensions} is a list of
! strings; completion candidate file names that end with any of the
! extensions are ignored. This variable has several elements by
! default, including @code{".o"}, @code{".elc"}, @code{".dvi"} and
! @code{"~"}. The intent is that, for example, @samp{foo} should
! complete to @samp{foo.c} even when @samp{foo.o} exists as well. If
! @emph{all} the possible completion candidates match
! @code{completion-ignored-extensions}, none are ignored. The window
! with the list of completion candidates does not use
! @code{completion-ignored-extensions}.
!
! If an element of @code{completion-ignored-extensions} ends in a
! slash @file{/}, then it's a directory name and file names in it will
! not be completion candidates. Elements of
! @code{completion-ignored-extensions} which do not end in a slash
! @file{/} are not used when a completion candidate is a directory;
! thus, completion returns directory names that end in @file{.elc} even
! though when @code{completion-ignored-extensions} has an element
! @code{".elc"}.
@vindex completion-auto-help
! If @code{completion-auto-help} is set to @code{nil}, the completion
! candidates are not displayed when there is no clear choice among them.
! You must type @kbd{?} to display the list.
@cindex Partial Completion mode
@vindex partial-completion-mode
@findex partial-completion-mode
Partial Completion mode implements a more powerful kind of
! completion to complete multiple words in parallel. For example, it
! can complete the command name abbreviation @code{p-b} to
! @code{print-buffer} if no other completion candidate starts with two
! words whose initials are @samp{p} and @samp{b}.
Partial completion of directories in file names uses @samp{*} to
! indicate the places for completion (similar to shell wildcards); thus,
! @file{/u*/b*/f*} would complete to @file{/usr/bin/foo} if that
! existed.
For remote files, partial completion enables completion of methods,
user names and host names. @xref{Remote Files}.
! To enable this mode, use @kbd{M-x partial-completion-mode} or
! customize the variable @code{partial-completion-mode}. The partial
! completion commands override @key{TAB}, @key{SPC}, @key{RET}, and
! @kbd{?}. The usual completion commands are moved to @kbd{M-@key{TAB}}
! (or @kbd{C-M-i}), @kbd{M-@key{SPC}}, @kbd{M-@key{RET}} and @kbd{M-?}.
@vindex PC-include-file-path
@vindex PC-disable-includes
! Partial Completion mode extends @code{find-file} so that
! @samp{<@var{include}>} looks for the file named @var{include} in some
! directory in the path @code{PC-include-file-path}. Set
! @code{PC-disable-includes} to non-@code{nil}, to disable this feature.
@cindex Icomplete mode
@findex icomplete-mode
! With icomplete mode enabled, the minibuffer will always show the
! completion candidates so far without a separate window. Enable and
! disable (as a toggle) this minor mode with @kbd{M-x icomplete-mode}.
@node Minibuffer History
@section Minibuffer History
@cindex minibuffer history
@cindex history of minibuffer input
! Every argument entered with the minibuffer is saved in a
! @dfn{minibuffer history list} for reuse. Special commands discard the
! current minibuffer contents and load earlier arguments, providing a
! history of arguments.
@table @kbd
@item @key{UP}
@itemx M-p
! Move back (to earlier arguments) in the minibuffer history
(@code{previous-history-element}).
@item @key{DOWN}
@itemx M-n
! Move forward (to later arguments) in the minibuffer history
(@code{next-history-element}).
@item M-r @var{regexp} @key{RET}
! Move back to an earlier argument in the minibuffer history that
! matches @var{regexp} (@code{previous-matching-history-element}).
@item M-s @var{regexp} @key{RET}
! Move forward to a later argument in the minibuffer history that
! matches @var{regexp} (@code{next-matching-history-element}).
@end table
@kindex M-p @r{(minibuffer history)}
@kindex M-n @r{(minibuffer history)}
@findex next-history-element
@findex previous-history-element
! Use these commands in the minibuffer to move through the minibuffer
! history list one element at a time. Use @kbd{M-p} or @key{UP}
! (@code{previous-history-element}) to see the previous (earlier) saved
! argument, and use @kbd{M-n} or @key{DOWN}
! (@code{next-history-element}) to see the next (later) saved argument.
! These commands don't move the cursor, they just bring different saved
! strings into the minibuffer.
!
! You can also edit text from the minibuffer history as usual before
! you reuse it; this does not change the history element, but your new
! argument is added to history list regardless (even if it's unchanged).
!
! Many minibuffer arguments have a ``default'' value. Insert the
! default value with @kbd{M-n} to move ``into the future'' in the
! history.
@findex previous-matching-history-element
@findex next-matching-history-element
@kindex M-r @r{(minibuffer history)}
@kindex M-s @r{(minibuffer history)}
! Given a regular expression as an input argument, @kbd{M-r}
! (@code{previous-matching-history-element}) searches backwards in the
! minibuffer history, while @kbd{M-s}
! (@code{next-matching-history-element}) searches forwards. These
! commands are unusual: they can use the minibuffer to read their
! arguments, even though they are invoked from the minibuffer. As with
! incremental searching, an uppercase letter in the regular expression
! makes the search case-sensitive (@pxref{Search Case}).
@ignore
We may change the precise way these commands read their arguments.
***************
*** 518,610 ****
actually available, type @kbd{C-h f previous-matching-history-element}.
@end ignore
! All uses of the minibuffer record your input on a history list, but
! there are separate history lists for different kinds of arguments. For
! example, there is a list for file names, used by all the commands that
! read file names. (As a special feature, this history list records
! the absolute file name, no more and no less, even if that is not how
! you entered the file name.)
!
! There are several other very specific history lists, including one for
! command names read by @kbd{M-x}, one for buffer names, one for arguments
! of commands like @code{query-replace}, and one for compilation commands
! read by @code{compile}. Finally, there is one ``miscellaneous'' history
! list that most minibuffer arguments use.
@vindex history-length
! The variable @code{history-length} specifies the maximum length of a
! minibuffer history list; once a list gets that long, the oldest element
! is deleted each time an element is added. If the value of
! @code{history-length} is @code{t}, though, there is no maximum length
! and elements are never deleted.
@vindex history-delete-duplicates
! The variable @code{history-delete-duplicates} specifies whether to
! delete duplicates in history. If the value of @code{history-delete-duplicates}
! is @code{t}, that means when adding a new history element, all
! previous identical elements are deleted.
@node Repetition
@section Repeating Minibuffer Commands
@cindex command history
@cindex history of commands
! Every command that uses the minibuffer at least once is recorded on a
! special history list, together with the values of its arguments, so that
! you can repeat the entire command. In particular, every use of
! @kbd{M-x} is recorded there, since @kbd{M-x} uses the minibuffer to read
! the command name.
@findex list-command-history
@table @kbd
@item C-x @key{ESC} @key{ESC}
! Re-execute a recent minibuffer command (@code{repeat-complex-command}).
@item M-x list-command-history
! Display the entire command history, showing all the commands
! @kbd{C-x @key{ESC} @key{ESC}} can repeat, most recent first.
@end table
@kindex C-x ESC ESC
@findex repeat-complex-command
! @kbd{C-x @key{ESC} @key{ESC}} is used to re-execute a recent
! minibuffer-using command. With no argument, it repeats the last such
! command. A numeric argument specifies which command to repeat; one
! means the last one, and larger numbers specify earlier ones.
!
! @kbd{C-x @key{ESC} @key{ESC}} works by turning the previous command
! into a Lisp expression and then entering a minibuffer initialized with
! the text for that expression. If you type just @key{RET}, the command
! is repeated as before. You can also change the command by editing the
! Lisp expression. Whatever expression you finally submit is what will be
! executed. The repeated command is added to the front of the command
! history unless it is identical to the most recently executed command
! already there.
!
! Even if you don't understand Lisp syntax, it will probably be obvious
! which command is displayed for repetition. If you do not change the
! text, it will repeat exactly as before.
!
! Once inside the minibuffer for @kbd{C-x @key{ESC} @key{ESC}}, you can
! use the minibuffer history commands (@kbd{M-p}, @kbd{M-n}, @kbd{M-r},
! @kbd{M-s}; @pxref{Minibuffer History}) to move through the history list
! of saved entire commands. After finding the desired previous command,
! you can edit its expression as usual and then resubmit it by typing
! @key{RET} as usual.
@vindex isearch-resume-in-command-history
! Incremental search does not, strictly speaking, use the minibuffer,
! but it does something similar. Although it behaves like a complex command,
! it normally does not appear in the history list for @kbd{C-x
! @key{ESC} @key{ESC}}. You can make it appear in the history by
! setting @code{isearch-resume-in-command-history} to a non-@code{nil}
! value. @xref{Incremental Search}.
@vindex command-history
! The list of previous minibuffer-using commands is stored as a Lisp
! list in the variable @code{command-history}. Each element is a Lisp
! expression which describes one command and its arguments. Lisp programs
! can re-execute a command by calling @code{eval} with the
! @code{command-history} element.
@ignore
arch-tag: ba913cfd-b70e-400f-b663-22b2c309227f
--- 482,572 ----
actually available, type @kbd{C-h f previous-matching-history-element}.
@end ignore
! The minibuffer always records your input in its history, but there
! are separate history lists depending on the argument type. For
! example, there is a history list for file names, used by all the
! commands that read file names. (As a special feature, this history
! list records the absolute file name, even the file name was not
! absolute originally.)
!
! There are several specific history lists, including one for
! @kbd{M-x} for command names, another for buffer names, another for
! arguments of commands like @code{query-replace}, and one for
! @code{compile} compilation commands. Most other minibuffer arguments
! use a ``miscellaneous'' history list.
@vindex history-length
! The variable @code{history-length} specifies the maximum length of
! any minibuffer history list; the oldest element is deleted if a new
! element makes the list too long. If @code{history-length} is
! @code{t}, though, there is no maximum length and elements are never
! deleted.
@vindex history-delete-duplicates
! The variable @code{history-delete-duplicates} specifies whether
! duplicates are kept in the minibuffer history. If
! @code{history-delete-duplicates} is @code{t}, adding a new history
! element will remove from the list all other elements equal to it.
@node Repetition
@section Repeating Minibuffer Commands
@cindex command history
@cindex history of commands
! Every command that uses the minibuffer is recorded in a special
! history list together with the values of its arguments, so that you
! can repeat the entire command. In particular, every use of @kbd{M-x}
! is recorded there, since @kbd{M-x} uses the minibuffer to read the
! command name.
@findex list-command-history
@table @kbd
@item C-x @key{ESC} @key{ESC}
! Execute a recent minibuffer command again
! (@code{repeat-complex-command}).
@item M-x list-command-history
! Display the entire command history, showing all the commands @kbd{C-x
! @key{ESC} @key{ESC}} can repeat, starting with the most recent.
@end table
@kindex C-x ESC ESC
@findex repeat-complex-command
! @kbd{C-x @key{ESC} @key{ESC}} is used to execute a recent command
! that used the minibuffer again. With no argument, it repeats the most
! recent one. A numeric argument specifies which command to repeat;
! ``1'' means the most recent one one, ``2'' the one before it, and so
! on.
!
! @kbd{C-x @key{ESC} @key{ESC}} turns the previous command into a Lisp
! expression and then enters a minibuffer initialized with the text for
! that expression. If you type just @key{RET}, the command is repeated.
! You can also change the command by editing the Lisp expression in the
! minibuffer before you execute it. The repeated command is added to
! the command history, unless it is identical to the most recently
! executed command already there.
!
! Even if you don't understand Lisp syntax, it will probably be
! obvious which command is displayed for repetition. If you do not
! change the text, it will repeat exactly as before. You can also use
! the minibuffer history commands (@kbd{M-p}, @kbd{M-n}, @kbd{M-r},
! @kbd{M-s}; @pxref{Minibuffer History}) to move through the history
! list. After finding the desired previous command, you can edit its
! expression as usual and then resubmit it with @key{RET}.
@vindex isearch-resume-in-command-history
! Incremental search does not use the minibuffer (although it does
! something similar and behaves like a complex command), so it normally
! does not appear in the history list for @kbd{C-x @key{ESC} @key{ESC}}.
! You can set @code{isearch-resume-in-command-history} to a
! non-@code{nil} value to see incremental searches in the command
! history. @xref{Incremental Search}.
@vindex command-history
! The variable @code{command-history} is a list of the commands that
! used the minibuffer. Each element is a Lisp expression which
! describes one command and its arguments. Lisp programs can re-execute
! a command by calling @code{eval} with its @code{command-history}
! element.
@ignore
arch-tag: ba913cfd-b70e-400f-b663-22b2c309227f
[-- Attachment #3: Type: text/plain, Size: 142 bytes --]
_______________________________________________
Emacs-devel mailing list
Emacs-devel@gnu.org
http://lists.gnu.org/mailman/listinfo/emacs-devel
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2006-05-31 20:12 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2006-05-25 19:41 Emacs manual update: basic.texi Ted Zlatanov
2006-05-31 20:12 ` Emacs manual update: mini.texi Ted Zlatanov
Code repositories for project(s) associated with this external index
https://git.savannah.gnu.org/cgit/emacs.git
https://git.savannah.gnu.org/cgit/emacs/org-mode.git
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.