-This is ../info/xemacs.info, produced by makeinfo version 4.0 from
-xemacs/xemacs.texi.
+This is Info file ../../info/xemacs.info, produced by Makeinfo version
+1.68 from the input file xemacs.texi.
INFO-DIR-SECTION XEmacs Editor
START-INFO-DIR-ENTRY
=============
There are two commands for exiting Emacs because there are two kinds
-of exiting: "suspending" Emacs and "killing" Emacs.
-
- "Suspending" means stopping Emacs temporarily and returning control
-to its parent process (usually a shell), allowing you to resume editing
-later in the same Emacs job, with the same buffers, same kill ring,
-same undo history, and so on. This is the usual way to exit.
-
- "Killing" Emacs means destroying the Emacs job. You can run Emacs
-again later, but you will get a fresh Emacs; there is no way to resume
-the same editing session after it has been killed.
+of exiting: "suspending" Emacs and "killing" Emacs. "Suspending" means
+stopping Emacs temporarily and returning control to its superior
+(usually the shell), allowing you to resume editing later in the same
+Emacs job, with the same files, same kill ring, same undo history, and
+so on. This is the usual way to exit. "Killing" Emacs means
+destroying the Emacs job. You can run Emacs again later, but you will
+get a fresh Emacs; there is no way to resume the same editing session
+after it has been killed.
`C-z'
- Suspend Emacs or iconify a frame
- (`suspend-emacs-or-iconify-frame'). If used under the X window
+ Suspend Emacs (`suspend-emacs'). If used under the X window
system, shrink the X window containing the Emacs frame to an icon
(see below).
window containing the Emacs frame to an icon. The Emacs process is
stopped temporarily, and control is returned to the window manager. If
more than one frame is associated with the Emacs process, only the
-frame from which you used `C-z' is iconified.
+frame from which you used `C-z' is retained. The X windows containing
+the other Emacs frames are closed.
To activate the "suspended" Emacs, use the appropriate window manager
mouse gestures. Usually left-clicking on the icon reactivates and
reopens the X window containing the Emacs frame, but the window manager
you use determines what exactly happens. To actually kill the Emacs
-process, use `C-x C-c' or the Exit XEmacs item on the File menu.
-
- To suspend Emacs, type `C-z' (`suspend-emacs'). This takes you back
-to the shell from which you invoked Emacs. You can resume Emacs with
-the shell command `%xemacs' in most common shells.
-
- On systems that do not support suspending programs, `C-z' starts an
-inferior shell that communicates directly with the terminal. Emacs
-waits until you exit the subshell. (The way to do that is probably
-with `C-d' or `exit', but it depends on which shell you use.) The only
-way on these systems to get back to the shell from which Emacs was run
-(to log out, for example) is to kill Emacs.
-
- Suspending also fails if you run Emacs under a shell that doesn't
-support suspending programs, even if the system itself does support it.
-In such a case, you can set the variable `cannot-suspend' to a
-non-`nil' value to force `C-z' to start an inferior shell. (One might
-also describe Emacs's parent shell as "inferior" for failing to support
-job control properly, but that is a matter of taste.)
-
- When Emacs communicates directly with an X server and creates its own
-dedicated X windows, `C-z' has a different meaning. Suspending an
-applications that uses its own X windows is not meaningful or useful.
-Instead, `C-z' runs the command `iconify-or-deiconify-frame', which
-temporarily closes up the selected Emacs frame. The way to get back to
-a shell window is with the window manager.
+process, use `C-x C-c' or the Exit Emacs item on the File menu.
+
+ On systems that do not permit programs to be suspended, `C-z' runs
+an inferior shell that communicates directly with the terminal, and
+Emacs waits until you exit the subshell. On these systems, the only way
+to return to the shell from which Emacs was started (to log out, for
+example) is to kill Emacs. `C-d' or `exit' are typical commands to
+exit a subshell.
To kill Emacs, type `C-x C-c' (`save-buffers-kill-emacs'). A
-two-character key is used for this to make it harder to type. Selecting
-the Exit XEmacs option of the File menu is an alternate way of issuing
-the command.
+two-character key is used for this to make it harder to type. In
+XEmacs, selecting the Exit Emacs option of the File menu is an
+alternate way of issuing the command.
Unless a numeric argument is used, this command first offers to save
-any modified file-visiting buffers. If you do not save all buffers,
-you are asked for reconfirmation with `yes' before killing Emacs, since
-any changes not saved will be lost forever. If any subprocesses are
-still running, `C-x C-c' asks you to confirm killing them, since killing
-Emacs will kill the subprocesses immediately.
-
- There is no way to restart an Emacs session once you have killed it.
-You can, however, arrange for Emacs to record certain session
-information, such as which files are visited, when you kill it, so that
-the next time you restart Emacs it will try to visit the same files and
-so on.
-
- The operating system usually listens for certain special characters
-whose meaning is to kill or suspend the program you are running. This
-operating system feature is turned off while you are in Emacs. The
-meanings of `C-z' and `C-x C-c' as keys in Emacs were inspired by the
-use of `C-z' and `C-c' on several operating systems as the characters
-for stopping or killing a program, but that is their only relationship
-with the operating system. You can customize these keys to run any
-commands of your choice (*note Keymaps::).
+any modified buffers. If you do not save all buffers, you are asked for
+reconfirmation with `yes' before killing Emacs, since any changes not
+saved will be lost. If any subprocesses are still running, `C-x C-c'
+asks you to confirm killing them, since killing Emacs kills the
+subprocesses simultaneously.
+
+ In most programs running on Unix, certain characters may instantly
+suspend or kill the program. (In Berkeley Unix these characters are
+normally `C-z' and `C-c'.) This Unix feature is turned off while you
+are in Emacs. The meanings of `C-z' and `C-x C-c' as keys in Emacs were
+inspired by the standard Berkeley Unix meanings of `C-z' and `C-c', but
+that is their only relationship with Unix. You could customize these
+keys to do anything (*note Keymaps::.).
\1f
File: xemacs.info, Node: Command Switches, Next: Startup Paths, Prev: Exiting, Up: Top
`-debug-paths'
Displays information on how XEmacs constructs the various paths
- into its hierarchy on startup. (See also *note Startup Paths::.)
+ into its hierarchy on startup. (See also *note Startup Paths::..)
`-unmapped'
Do not map the initial frame. This is useful if you want to start
`-no-init-file'
`-q'
- Do not load your Emacs init file. *Note Init File::.
+ Do not load your Emacs init file `~/.emacs'.
`-no-site-file'
Do not load the site-specific init file `lisp/site-start.el'.
This is equivalent to `-q -no-site-file -no-early-packages'.
`-user-init-file FILE'
- Load FILE as your Emacs init file instead of
- `~/.xemacs/init.el'/`~/.emacs'.
+ Load FILE as your Emacs init file instead of `~/.emacs'.
`-user-init-directory DIRECTORY'
Use DIRECTORY as the location of your early package hierarchies
`-user USER'
`-u USER'
- Equivalent to `-user-init-file ~USER/.xemacs/init.el
- -user-init-directory ~USER/.xemacs', or `-user-init-file
- ~USER/.emacs -user-init-directory ~USER/.xemacs'. whichever init
- file comes first. *Note Init File::.
+ Equivalent to `-user-init-file ~USER/.emacs -user-init-directory
+ ~USER/.xemacs'.
Note that the init file can get access to the command line argument
values as the elements of a list in the variable `command-line-args'.
xemacs *.c
passes each `.c' file as a separate argument to Emacs, so that Emacs
-visits each file (*note Visiting::).
+visits each file (*note Visiting::.).
Here is an advanced example that assumes you have a Lisp program file
called `hack-c-program.el' which, when loaded, performs some useful
the one where it is being built.) Such a directory containing a
hierarchy is called a "root". Whenever this section refers to a
directory using the shorthand `<root>', it means that XEmacs searches
-for it under all hierarchies XEmacs was able to scrounge up. In a
-running XEmacs, the hierarchy roots are stored in the variable
-`emacs-roots'.
+for it under all hierarchies under all hierarchies XEmacs was able to
+scrounge up. In a running XEmacs, the hierarchy roots are stored in
+the variable `emacs-roots'.
Package Hierarchies
-------------------
ones somewhere in the middle, and last hierarchies are (you guessed it)
last.
- By default, XEmacs expects an early package hierarchy in the
-subdirectory `.xemacs/xemacs-packages' of the user's home directory.
+ By default, XEmacs expects an early package hierarchy in the a
+subdirectory `.xemacs' of the user's home directory.
Moreover, XEmacs expects late hierarchies in the subdirectories
`site-packages', `mule-packages', and `xemacs-packages' (in that order)
By default, XEmacs does not have a pre-configured last package
hierarchy. Last hierarchies are primarily for using package hierarchies
of outdated versions of XEmacs as a fallback option. For example, it is
-possible to run XEmacs 21 with the 20.4 package hierarchy as a last
+possible to run XEmacs 21.0 with the 20.4 package hierarchy as a last
hierarchy.
It is possible to specify at configure-time the location of the
various package hierarchies with the `--package-path' option to
configure. The early, late, and last components of the package path
-are separated by double instead of single colons. If all three
-components are present, they locate the early, late, and last package
+are separated by double instead of single colons. If three components
+are present, they are locate the early, late, and last package
hierarchies respectively. If two components are present, they locate
the early and late hierarchies. If only one component is present, it
locates the late hierarchy. At run time, the package path may also be
-specified via the `EMACSPACKAGEPATH' environment variable.
+specified via the `PACKAGEPATH' environment variable.
An XEmacs package is laid out just like a normal installed XEmacs
lisp directory. It may have `lisp', `etc', `info', and `lib-src'
tarball.
If XEmacs runs with the `-debug-paths' option (*note Command
-Switches::), it will print the values of these variables, hopefully
+Switches::.), it will print the values of these variables, hopefully
aiding in debugging any problems which come up.
`lisp-directory'
`/usr/local/info' as well as the directories of the environment
variable `INFOPATH' to `Info-directory-list'.
+`lock-directory'
+`superlock-file'
+ Are the site-specific locations of the lock directory and the
+ superlock file, respectively. The `lock-directory' variable may
+ also be initialized from the `EMACSLOCKDIR' environment variable.
+
`exec-directory'
Is the directory of architecture-dependent files that come with
XEmacs, especially executable programs intended for XEmacs to
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 `Control-h t'
-(`help-with-tutorial'). You can also use Tutorials item from the Help
-menu.
-
- XEmacs comes with many translations of tutorial. If your XEmacs is
-with MULE and you set up language environment correctly, XEmacs chooses
-right tutorial when available (*note Language Environments::). If you
-want specific translation, give `C-h t' a prefix argument, like `C-u
-C-h t'.
-
- To clear the screen and redisplay, type `C-l' (`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.
-* 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.
-
-\1f
-File: xemacs.info, Node: Inserting Text, Next: Moving Point, Up: Basic
+do this, type `Control-h t' (`help-with-tutorial').
Inserting Text
==============
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 "point"; *note Point::). The cursor moves forward,
-and any text after the cursor moves forward too. If the text in the
-buffer is `FOOBAR', with the cursor before the `B', then if you type
-`XX', you get `FOOXXBAR', with the cursor still before the `B'.
-
- To "delete" text you have just inserted, use <BS>. <BS> deletes the
-character _before_ the cursor (not the one that the cursor is on top of
-or under; that is the character AFTER the cursor). The cursor and all
-characters after it move backwards. Therefore, if you type a printing
-character and then type <BS>, they cancel out.
+type them. This inserts the characters into the buffer at the cursor
+(that is, at "point"; *note Point::.). The cursor moves forward. Any
+characters after the cursor move forward too. If the text in the buffer
+is `FOOBAR', with the cursor before the `B', and you type `XX', the
+result is `FOOXXBAR', with the cursor still before the `B'.
+
+ To "delete" text you have just inserted, use <DEL>. <DEL> deletes
+the character BEFORE the cursor (not the one that the cursor is on top
+of or under; that is the character AFTER the cursor). The cursor and
+all characters after it move backwards. Therefore, if you type a
+printing character and then type <DEL>, they cancel out.
To end a line and start typing a new one, type <RET>. This inserts
a newline character in the buffer. If point is in the middle of a
line, <RET> splits the line. Typing <DEL> when the cursor is at the
-beginning of a line deletes the preceding newline, thus joining the
-line with the preceding line.
+beginning of a line rubs out the newline before the line, 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 "Auto Fill" mode. *Note Filling::,
-for how to use Auto Fill mode.
+ Emacs automatically splits lines when they become too long, if you
+turn on a special mode called "Auto Fill" mode. *Note Filling::, for
+information on using Auto Fill mode.
- 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. *Note Minor Modes::.
+ Customization information: <DEL>, in most modes, runs the command
+`delete-backward-char'; <RET> runs the command `newline', and
+self-inserting printing characters run the command `self-insert', which
+inserts whatever character was typed to invoke it. Some major modes
+rebind <DEL> to other commands.
Direct insertion works for printing characters and <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 "quote" it by typing the character `Control-q'
-(`quoted-insert') first. (This character's name is normally written
-`C-q' for short.) There are two ways to use `C-q':
-
- * `C-q' followed by any non-graphic character (even `C-g') inserts
- that character.
-
- * `C-q' followed by a sequence of octal digits inserts the character
- with the specified octal character code. You can use any number of
- octal digits; any non-digit terminates the sequence. If the
- terminating character is <RET>, it serves only to terminate the
- sequence; any other non-digit is itself used as input after
- terminating the sequence. (The use of octal sequences is disabled
- in ordinary non-binary Overwrite mode, to give you a convenient
- way to insert a digit instead of overwriting with it.)
+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 "quote" it by typing the character
+`control-q' (`quoted-insert') first. There are two ways to use `C-q':
-A numeric argument to `C-q' specifies how many copies of the quoted
-character should be inserted (*note Arguments::).
+ * `Control-q' followed by any non-graphic character (even `C-g')
+ inserts that character.
- Customization information: <DEL>, in most modes, runs the command
-`backward-or-forward-delete-char'; <RET> runs the command `newline',
-and self-inserting printing characters run the command `self-insert',
-which inserts whatever character was typed to invoke it. Some major
-modes rebind <DEL> to other commands.
+ * `Control-q' followed by three octal digits inserts the character
+ with the specified character code.
-\1f
-File: xemacs.info, Node: Moving Point, Next: Erasing, Prev: Inserting Text, Up: Basic
+A numeric argument to `C-q' specifies how many copies of the quoted
+character should be inserted (*note Arguments::.).
+
+ If you prefer to have text characters replace (overwrite) existing
+text instead of moving it to the right, you can enable Overwrite mode, a
+minor mode. *Note Minor Modes::.
Changing the Location of Point
==============================
To do more than insert characters, you have to know how to move point
-(*note Point::). The simplest way to do this is with arrow keys, or by
-clicking the left mouse button where you want to move to.
+(*note Point::.). Here are a few of the available commands.
NOTE: Many of the following commands have two versions, one that uses
the function keys (e.g. <LEFT> or <END>) and one that doesn't. The
on the frame to bring point to the center of the window.
`M-r'
- Move point to left margin, vertically centered in the window
- (`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 (-1
- for the bottom line).
+ Move point to left margin on the line halfway down the frame or
+ window (`move-to-window-line'). Text does not move on the frame.
+ A numeric argument says how many screen lines down from the top of
+ the window (zero for the top). A negative argument counts from
+ the bottom (-1 for the bottom).
`C-t'
Transpose two characters, the ones before and after the cursor
Move to the end of the buffer (`end-of-buffer').
`M-x goto-char'
- Read a number N and move point to buffer position N. Position 1
- is the beginning of the buffer.
+ Read a number N and move the cursor to character number N.
+ Position 1 is the beginning of the buffer.
`M-g'
- Read a number N and move point to line number N (`goto-line').
+ Read a number N and move cursor to line number N (`goto-line').
Line 1 is the beginning of the buffer.
-`M-x set-goal-column'
+`C-x C-n'
Use the current column of point as the "semi-permanent goal
column" for `C-n' and `C-p' (`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.
-`C-u M-x set-goal-column'
+`C-u C-x C-n'
Cancel the goal column. Henceforth, `C-n' and `C-p' once again
try to avoid changing the horizontal position, as usual.
- If you set the variable `track-eol' to a non-`nil' value, then `C-n'
-and `C-p' when at the end of the starting line move to the end of
-another line. Normally, `track-eol' is `nil'. *Note Variables::, for
-how to set variables such as `track-eol'.
-
- Normally, `C-n' on the last line of a buffer appends a newline to
-it. If the variable `next-line-add-newlines' is `nil', then `C-n' gets
-an error instead (like `C-p' on the first line).
-
-\1f
-File: xemacs.info, Node: Erasing, Next: Basic Files, Prev: Moving Point, Up: Basic
+ If you set the variable `track-eol' to a non-`nil' value, `C-n' and
+`C-p' move to the end of the line when at the end of the starting line.
+By default, `track-eol' is `nil'.
Erasing Text
============
`<DEL>'
- Delete the character before or after point
- (`backward-or-forward-delete-char'). You can customize this
- behavior by setting the variable `delete-key-deletes-forward'.
+ Delete the character before the cursor (`delete-backward-char').
`C-d'
- Delete the character after point (`delete-char').
+ Delete the character after the cursor (`delete-char').
`C-k'
Kill to the end of the line (`kill-line').
Kill back to the beginning of the previous word
(`backward-kill-word').
- You already know about the <DEL> key which deletes the character
-before point (that is, before the cursor). Another key, `Control-d'
-(`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 `C-d' at the end of a line, it joins
-together that line and the next line.
+ In contrast to the <DEL> key, which deletes the character before the
+cursor, `Control-d' deletes the character after the cursor, causing the
+rest of the text on the line to shift left. If `Control-d' is typed at
+the end of a line, that line and the next line are joined.
- To erase a larger amount of text, use the `C-k' key, which kills a
-line at a time. If you type `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
+ To erase a larger amount of text, use `Control-k', which kills a
+line at a time. If you use `C-k' at the beginning or in the middle of
+a line, it kills all the text up to the end of the line. If you use
`C-k' at the end of a line, it joins that line and the next line.
*Note Killing::, for more flexible ways of killing text.
-\1f
-File: xemacs.info, Node: Basic Files, Next: Basic Help, Prev: Erasing, Up: Basic
-
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. But to keep any text permanently you must put it in a
-"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.
+ The commands above are sufficient for creating and altering text in
+an Emacs buffer. More advanced Emacs commands just make things easier.
+But to keep any text permanently you must put it in a "file". Files
+are named units of text which are stored by the operating system and
+which you can retrieve 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 `/usr/rms/foo.c'. To begin editing this file
from Emacs, type:
C-x C-f /usr/rms/foo.c <RET>
-Here the file name is given as an "argument" to the command `C-x C-f'
-(`find-file'). That command uses the "minibuffer" to read the
-argument, and you type <RET> to terminate the argument (*note
-Minibuffer::).
+The file name is given as an "argument" to the command `C-x C-f'
+(`find-file'). The command uses the "minibuffer" to read the argument.
+You have to type <RET> to terminate the argument (*note Minibuffer::.).
You can also use the Open... menu item from the File menu, then type
the name of the file to the prompt.
- Emacs obeys the command by "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 "save" the
-new text in the file by typing `C-x C-s' (`save-buffer') or choosing
-Save Buffer from the File menu. This makes the changes permanent by
-copying the altered buffer contents back into the file
-`/usr/rms/foo.c'. Until you save, the changes exist only inside Emacs,
-and the file `foo.c' is unaltered.
+ Emacs obeys the command by "visiting" the file: it creates a buffer,
+copies the contents of the file into the buffer, and then displays the
+buffer for you to edit. You can make changes in the buffer, and then
+"save" the file by typing `C-x C-s' (`save-buffer') or choosing Save
+Buffer from the File menu. This makes the changes permanent by copying
+the altered contents of the buffer back into the file `/usr/rms/foo.c'.
+Until then, the changes are only inside your Emacs buffer, and the
+file `foo.c' is not changed.
To create a file, visit the file with `C-x C-f' as if it already
existed or choose Open... from the File menu and provide the name for
-the new file. Emacs will create an empty buffer in which you can
-insert the text you want to put in the file. When you save the buffer
-with `C-x C-s', or by choosing Save Buffer from the File menu, the file
-is created.
-
- To learn more about using files, *Note Files::.
+the new file in the minibuffer. Emacs will create an empty buffer in
+which you can insert the text you want to put in the file. When you
+save the buffer with `C-x C-s', or by choosing Save Buffer from the
+File menu, the file is created.
-\1f
-File: xemacs.info, Node: Basic Help, Next: Blank Lines, Prev: Basic Files, Up: Basic
+ To learn more about using files, *note Files::..
Help
====
- If you forget what a key does, you can find out with the Help
-character, which is `C-h' (or <F1>, which is an alias for `C-h'). Type
-`C-h k' followed by the key you want to know about; for example, `C-h k
-C-n' tells you all about what `C-n' does. `C-h' is a prefix key; `C-h
-k' is just one of its subcommands (the command `describe-key'). The
-other subcommands of `C-h' provide different kinds of help. Type `C-h'
-twice to get a description of all the help facilities. *Note Help::.
+ If you forget what a key does, you can use the Help character
+(`C-h') to find out: Type `C-h k' followed by the key you want to know
+about. For example, `C-h k C-n' tells you what `C-n' does. `C-h' is a
+prefix key; `C-h k' is just one of its subcommands (the command
+`describe-key'). The other subcommands of `C-h' provide different
+kinds of help. Type `C-h' three times to get a description of all the
+help facilities. *Note Help::.
+
+* Menu:
+
+* Blank Lines:: Commands to make or delete blank lines.
+* Continuation Lines:: Lines too wide for the frame.
+* Position Info:: What page, line, row, or column is point on?
+* Arguments:: Numeric arguments for repeating a command.
\1f
-File: xemacs.info, Node: Blank Lines, Next: Continuation Lines, Prev: Basic Help, Up: Basic
+File: xemacs.info, Node: Blank Lines, Next: Continuation Lines, Prev: Basic, Up: Basic
Blank Lines
===========
- Here are special commands and techniques for putting in and taking
-out blank lines.
+ Here are special commands and techniques for entering and removing
+blank lines.
`C-o'
Insert one or more blank lines after the cursor (`open-line').
(`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 <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 `C-o' (`open-line'), which inserts a newline after point
-but leaves point in front of the newline. After `C-o', type the text
-for the new line. `C-o F O O' has the same effect as `F O O <RET>',
-except for the final location of point.
-
- You can make several blank lines by typing `C-o' several times, or
-by giving it a numeric argument to tell it how many blank lines to make.
-*Note Arguments::, for how. If you have a fill prefix, then `C-o'
-command inserts the fill prefix on the new line, when you use it at the
-beginning of a line. *Note Fill Prefix::.
-
- The easy way to get rid of extra blank lines is with the command
-`C-x C-o' (`delete-blank-lines'). `C-x C-o' in a run of several blank
-lines deletes all but one of them. `C-x C-o' on a solitary blank line
-deletes that blank line. When point is on a nonblank line, `C-x C-o'
-deletes any blank lines following that nonblank line.
+you just type the new line of text, followed by <RET>. If you prefer
+to create a blank line first and then insert the desired text, use the
+key `C-o' (`open-line'), which inserts a newline after point but leaves
+point in front of the newline. Then type the text into the new line.
+`C-o F O O' has the same effect as `F O O <RET>', except for the final
+location of point.
+
+ To create several blank lines, type `C-o' several times, or give
+`C-o' an argument indicating how many blank lines to create. *Note
+Arguments::, for more information.
+
+ If you have many blank lines in a row and want to get rid of them,
+use `C-x C-o' (`delete-blank-lines'). If point is on a blank line
+which is adjacent to at least one other blank line, `C-x C-o' deletes
+all but one of the blank lines. If point is on a blank line with no
+other adjacent blank line, the sole blank line is deleted. If point is
+on a non-blank line, `C-x C-o' deletes any blank lines following that
+non-blank line.
\1f
File: xemacs.info, Node: Continuation Lines, Next: Position Info, Prev: Blank Lines, Up: Basic
Continuation Lines
==================
- If you add too many characters to one line without breaking it with
-<RET>, the line will grow to occupy two (or more) lines on the screen,
-with a curved arrow at the extreme right margin of all but the last of
-them. The curved arrow says that the following screen line is not
-really a distinct line in the text, but just the "continuation" of a
-line too long to fit the screen. Continuation is also called "line
-wrapping".
-
- Sometimes it is nice to have Emacs insert newlines automatically when
-a line gets too long. Continuation on the screen does not do that. Use
-Auto Fill mode (*note Filling::) if that's what you want.
+ If you add too many characters to one line without breaking with a
+<RET>, the line grows to occupy two (or more) screen lines, with a
+curved arrow at the extreme right margin of all but the last line. The
+curved arrow indicates that the following screen line is not really a
+distinct line in the text, but just the "continuation" of a line too
+long to fit the frame. You can use Auto Fill mode (*note Filling::.)
+to have Emacs insert newlines automatically when a line gets too long.
Instead of continuation, long lines can be displayed by "truncation".
This means that all the characters that do not fit in the width of the
frame or window do not appear at all. They remain in the buffer,
-temporarily invisible. Right arrow in the last column (instead of the
-curved arrow) inform you that truncation is in effect.
-
- Truncation instead of continuation happens whenever horizontal
-scrolling is in use, and optionally in all side-by-side windows (*note
-Windows::). You can enable truncation for a particular buffer by
-setting the variable `truncate-lines' to non-`nil' in that buffer.
-(*Note Variables::.) Altering the value of `truncate-lines' makes it
-local to the current buffer; until that time, the default value is in
-effect. The default is initially `nil'. *Note Locals::.
+temporarily invisible. Three diagonal dots in the last column (instead
+of the curved arrow inform you that truncation is in effect.
- *Note Display Vars::, for additional variables that affect how text
-is displayed.
+ To turn off continuation for a particular buffer, set the variable
+`truncate-lines' to non-`nil' in that buffer. Truncation instead of
+continuation also happens whenever horizontal scrolling is in use, and
+optionally whenever side-by-side windows are in use (*note Windows::.).
+Altering the value of `truncate-lines' makes it local to the current
+buffer; until that time, the default value is in effect. The default
+is initially `nil'. *Note Locals::.
\1f
File: xemacs.info, Node: Position Info, Next: Arguments, Prev: Continuation Lines, Up: Basic
`M-x what-line'
Print line number of point in the buffer.
-`M-x line-number-mode'
- Toggle automatic display of current line number.
-
`M-='
Print number of lines and characters in the current region
- (`count-lines-region'). *Note Mark::, for information about the
- region.
+ (`count-lines-region').
`C-x ='
Print character code of character after point, character position
of point, and column of point (`what-cursor-position').
There are several commands for printing line numbers:
-
* `M-x what-line' counts lines from the beginning of the file and
prints the line number point is on. The first line of the file is
line number 1. You can use these numbers as arguments to `M-x
current page.
* `M-=' (`count-lines-region') prints the number of lines in the
- region (*note Mark::). *Note Pages::, for the command `C-x l'
- which counts the lines in the
+ region (*note Mark::.).
- The command `C-x =' (`what-cursor-position') can be used to find out
-the column that the cursor is in, and other miscellaneous information
-about point. It prints a line in the echo area that looks like this:
+ The command `C-x =' (`what-cursor-position') provides information
+about point and about the column the cursor is in. It prints a line in
+the echo area that looks like this:
- Char: c (0143, 99, 0x63) point=18862 of 24800(76%) column 53
+ Char: x (0170) point=65986 of 563027(12%) column 44
-(In fact, this is the output produced when point is before `column 53'
+(In fact, this is the output produced when point is before `column 44'
in the example.)
- The four values after `Char:' describe the character that follows
-point, first by showing it and then by giving its character code in
-octal, decimal and hex.
+ The two values after `Char:' describe the character following point,
+first by showing it and second by giving its octal character code.
`point=' is followed by the position of point expressed as a
character count. The front of the buffer counts as position 1, one
beginning and the end temporarily invisible, `C-x =' prints additional
text describing the current visible range. For example, it might say:
- Char: c (0143, 99, 0x63) point=19674 of 24575(80%) <19591 - 19703> column 69
+ Char: x (0170) point=65986 of 563025(12%) <65102 - 68533> column 44
where the two extra numbers give the smallest and largest character
position that point is allowed to assume. The characters between those
Numeric Arguments
=================
- In mathematics and computer usage, the word "argument" means "data
-provided to a function or operation." Any Emacs command can be given a
-"numeric argument" (also called a "prefix argument"). Some commands
+ Any Emacs command can be given a "numeric argument". Some commands
interpret the argument as a repetition count. For example, giving an
argument of ten to the key `C-f' (the command `forward-char', move
forward one character) moves forward ten characters. With these
commands, no argument is equivalent to an argument of one. Negative
-arguments are allowed. Often they tell a command to move or act in
-the opposite direction.
+arguments are allowed. Often they tell a command to move or act
+backwards.
If your keyboard has a <META> key (labelled with a diamond on
Sun-type keyboards and labelled `Alt' on some other keyboards), the
minus sign while holding down the <META> key. For example,
M-5 C-n
-would move down five lines. The characters `Meta-1', `Meta-2', and so
-on, as well as `Meta--', do this because they are keys bound to
-commands (`digit-argument' and `negative-argument') that are defined to
-contribute to an argument for the next command. Digits and `-'
-modified with Control, or Control and Meta, also specify numeric
-arguments.
+moves down five lines. The characters `Meta-1', `Meta-2', and so on,
+as well as `Meta--', do this because they are keys bound to commands
+(`digit-argument' and `negative-argument') that are defined to
+contribute to an argument for the next command.
Another way of specifying an argument is to use the `C-u'
(`universal-argument') command followed by the digits of the argument.
-With `C-u', you can type the argument digits without holding down
-modifier keys; `C-u' works on all terminals. To type a negative
-argument, type a minus sign after `C-u'. Just a minus sign without
-digits normally means -1.
+With `C-u', you can type the argument digits without holding down shift
+keys. To type a negative argument, start with a minus sign. Just a
+minus sign normally means -1. `C-u' works on all terminals.
`C-u' followed by a character which is neither a digit nor a minus
sign has the special meaning of "multiply by four". It multiplies the
A few commands treat a plain `C-u' differently from an ordinary
argument. A few others may treat an argument of just a minus sign
-differently from an argument of -1. These unusual cases are described
-when they come up; they are always for reasons of convenience of use of
-the individual command.
-
- You can use a numeric argument to insert multiple copies of a
-character. This is straightforward unless the character is a digit; for
-example, `C-u 6 4 a' inserts 64 copies of the character `a'. But this
-does not work for inserting digits; `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 `C-u'; for example, `C-u 6 4 C-u
-1' does insert 64 copies of the character `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.
+differently from an argument of -1. These unusual cases will be
+described when they come up; they are always to make the individual
+command more convenient to use.
\1f
File: xemacs.info, Node: Undo, Next: Minibuffer, Prev: Basic, Up: Top
The Minibuffer
**************
- The "minibuffer" is the facility used by XEmacs commands to read
-arguments more complicated than a single number. Minibuffer arguments
-can be file names, buffer names, Lisp function names, XEmacs command
-names, Lisp expressions, and many other things, depending on the command
-reading the argument. You can use the usual XEmacs editing commands in
-the minibuffer to edit the argument text.
+ Emacs commands use the "minibuffer" 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. To edit the argument in the minibuffer, you can use Emacs
+editing commands.
When the minibuffer is in use, it appears in the echo area, and the
cursor moves there. The beginning of the minibuffer line displays a
-"prompt" which says 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.
+"prompt" indicating what kind of input you should supply and how it
+will be used. The prompt is often derived from the name of the command
+the argument is for. The prompt normally ends with a colon.
Sometimes a "default argument" appears in parentheses after the
colon; it, too, is part of the prompt. The default is used as the
default, which is the name of the buffer that will be used if you type
just <RET>.
- The simplest way to enter a minibuffer argument is to type the text
-you want, terminated by <RET> which exits the minibuffer. You can
-cancel the command that wants the argument, and get out of the
-minibuffer, by typing `C-g'.
+ The simplest way to give a minibuffer argument is to type the text
+you want, terminated by <RET> to exit the minibuffer. To get out of
+the minibuffer and cancel the command that it was for, type `C-g'.
Since the minibuffer uses the screen space of the echo area, it can
-conflict with other ways XEmacs customarily uses the echo area. Here is
-how XEmacs handles such conflicts:
+conflict with other ways Emacs customarily uses the echo area. Here is
+how Emacs handles such conflicts:
* If a command gets an error while you are in the minibuffer, this
does not cancel the minibuffer. However, the echo area is needed
hidden for a while. It comes back after a few seconds, or as soon
as you type anything.
- * If in the minibuffer you use a command whose purpose is to print a
- message in the echo area, such as `C-x =', the message is printed
- normally, and the minibuffer is hidden for a while. It comes back
- after a few seconds, or as soon as you type anything.
+ * If you use a command in the minibuffer whose purpose is to print a
+ message in the echo area (for example `C-x =') the message is
+ displayed normally, and the minibuffer is hidden for a while. It
+ comes back after a few seconds, or as soon as you type anything.
* Echoing of keystrokes does not take place while the minibuffer is
in use.
* File: Minibuffer File. Entering file names with the minibuffer.
* Edit: Minibuffer Edit. How to edit in the minibuffer.
* Completion:: An abbreviation facility for minibuffer input.
-* Minibuffer History:: Reusing recent minibuffer arguments.
* Repetition:: Re-executing commands that used the minibuffer.
+\1f
+File: xemacs.info, Node: Minibuffer File, Next: Minibuffer Edit, Prev: Minibuffer, Up: Minibuffer
+
+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 "default directory", which ends with a slash. This
+informs you in which directory the file will be looked for if you do
+not specify a different one. For example, the minibuffer might start
+out with:
+
+ Find File: /u2/emacs/src/
+
+where `Find File: ' is the prompt. Typing `buffer.c' specifies the file
+`/u2/emacs/src/buffer.c'. To find files in nearby directories, use
+`..'; thus, if you type `../lisp/simple.el', the file that you visit
+will be the one named
+`/u2/emacs/lisp/simple.el'. Alternatively, you can use `M-<DEL>' to
+kill directory names you don't want (*note Words::.).
+
+ You can also type an absolute file name, one starting with a slash
+or a tilde, ignoring the default directory. For example, to find the
+file `/etc/termcap', just type the name, giving:
+
+ Find File: /u2/emacs/src//etc/termcap
+
+Two slashes in a row are not normally meaningful in Unix file names, but
+they are allowed in XEmacs. They mean, "ignore everything before the
+second slash in the pair." Thus, `/u2/emacs/src/' is ignored, and you
+get the file `/etc/termcap'.
+
+ If you set `insert-default-directory' to `nil', the default
+directory is not inserted in the minibuffer. This way, the minibuffer
+starts out empty. But the name you type, if relative, is still
+interpreted with respect to the same default directory.
+
+\1f
+File: xemacs.info, Node: Minibuffer Edit, Next: Completion, Prev: Minibuffer File, Up: Minibuffer
+
+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 <RET> in the minibuffer is defined to exit the minibuffer, you
+must use `C-o' or `C-q <LFD>' to insert a newline into the minibuffer.
+(Recall that a newline is really the <LFD> character.)
+
+ The minibuffer has its own window, which always has space on the
+screen but acts as if it were not there when the minibuffer is not in
+use. The minibuffer window is just like the others; you can switch to
+another window with `C-x o', edit text in other windows, and perhaps
+even visit more files 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. *Note
+Windows::.
+
+ There are, however, some restrictions on the use of the minibuffer
+window. You cannot switch buffers in it--the minibuffer and its window
+are permanently attached. You also cannot split or kill the minibuffer
+window, but you can make it taller with `C-x ^'.
+
+ If you are in the minibuffer and issue a command that displays help
+text in another window, that window will be scrolled if you type
+`M-C-v' while in the minibuffer until you exit the minibuffer. This
+feature is helpful if a completing minibuffer gives you a long list of
+possible completions.
+
+ If the variable `minibuffer-confirm-incomplete' is `t', you are
+asked for confirmation if there is no known completion for the text you
+typed. For example, if you attempted to visit a non-existent file, the
+minibuffer might read:
+ Find File:chocolate_bar.c [no completions, confirm]
+ If you press `Return' again, that confirms the filename. Otherwise,
+you can continue editing it.
+
+ Emacs supports recursive use of the minibuffer. However, it is easy
+to do this by accident (because of autorepeating keyboards, for
+example) and get confused. Therefore, most Emacs commands that use the
+minibuffer refuse to operate if the minibuffer window is selected. If
+the minibuffer is active but you have switched to a different window,
+recursive use of the minibuffer is allowed--if you know enough to try
+to do this, you probably will not get confused.
+
+ If you set the variable `enable-recursive-minibuffers' to be
+non-`nil', recursive use of the minibuffer is always allowed.
+
projects / chise / xemacs-chise.git.1 / blobdiff