1 This is ../info/xemacs.info, produced by makeinfo version 4.0 from
4 INFO-DIR-SECTION XEmacs Editor
6 * XEmacs: (xemacs). XEmacs Editor.
9 This file documents the XEmacs editor.
11 Copyright (C) 1985, 1986, 1988 Richard M. Stallman. Copyright (C)
12 1991, 1992, 1993, 1994 Lucid, Inc. Copyright (C) 1993, 1994 Sun
13 Microsystems, Inc. Copyright (C) 1995 Amdahl Corporation.
15 Permission is granted to make and distribute verbatim copies of this
16 manual provided the copyright notice and this permission notice are
17 preserved on all copies.
19 Permission is granted to copy and distribute modified versions of
20 this manual under the conditions for verbatim copying, provided also
21 that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
22 General Public License" are included exactly as in the original, and
23 provided that the entire resulting derived work is distributed under the
24 terms of a permission notice identical to this one.
26 Permission is granted to copy and distribute translations of this
27 manual into another language, under the above conditions for modified
28 versions, except that the sections entitled "The GNU Manifesto",
29 "Distribution" and "GNU General Public License" may be included in a
30 translation approved by the author instead of in the original English.
33 File: xemacs.info, Node: Exiting, Next: Command Switches, Prev: Entering Emacs, Up: Top
38 There are two commands for exiting Emacs because there are two kinds
39 of exiting: "suspending" Emacs and "killing" Emacs.
41 "Suspending" means stopping Emacs temporarily and returning control
42 to its parent process (usually a shell), allowing you to resume editing
43 later in the same Emacs job, with the same buffers, same kill ring,
44 same undo history, and so on. This is the usual way to exit.
46 "Killing" Emacs means destroying the Emacs job. You can run Emacs
47 again later, but you will get a fresh Emacs; there is no way to resume
48 the same editing session after it has been killed.
51 Suspend Emacs or iconify a frame
52 (`suspend-emacs-or-iconify-frame'). If used under the X window
53 system, shrink the X window containing the Emacs frame to an icon
57 Kill Emacs (`save-buffers-kill-emacs').
59 If you use XEmacs under the X window system, `C-z' shrinks the X
60 window containing the Emacs frame to an icon. The Emacs process is
61 stopped temporarily, and control is returned to the window manager. If
62 more than one frame is associated with the Emacs process, only the
63 frame from which you used `C-z' is iconified.
65 To activate the "suspended" Emacs, use the appropriate window manager
66 mouse gestures. Usually left-clicking on the icon reactivates and
67 reopens the X window containing the Emacs frame, but the window manager
68 you use determines what exactly happens. To actually kill the Emacs
69 process, use `C-x C-c' or the Exit XEmacs item on the File menu.
71 To suspend Emacs, type `C-z' (`suspend-emacs'). This takes you back
72 to the shell from which you invoked Emacs. You can resume Emacs with
73 the shell command `%xemacs' in most common shells.
75 On systems that do not support suspending programs, `C-z' starts an
76 inferior shell that communicates directly with the terminal. Emacs
77 waits until you exit the subshell. (The way to do that is probably
78 with `C-d' or `exit', but it depends on which shell you use.) The only
79 way on these systems to get back to the shell from which Emacs was run
80 (to log out, for example) is to kill Emacs.
82 Suspending also fails if you run Emacs under a shell that doesn't
83 support suspending programs, even if the system itself does support it.
84 In such a case, you can set the variable `cannot-suspend' to a
85 non-`nil' value to force `C-z' to start an inferior shell. (One might
86 also describe Emacs's parent shell as "inferior" for failing to support
87 job control properly, but that is a matter of taste.)
89 When Emacs communicates directly with an X server and creates its own
90 dedicated X windows, `C-z' has a different meaning. Suspending an
91 applications that uses its own X windows is not meaningful or useful.
92 Instead, `C-z' runs the command `iconify-or-deiconify-frame', which
93 temporarily closes up the selected Emacs frame. The way to get back to
94 a shell window is with the window manager.
96 To kill Emacs, type `C-x C-c' (`save-buffers-kill-emacs'). A
97 two-character key is used for this to make it harder to type. Selecting
98 the Exit XEmacs option of the File menu is an alternate way of issuing
101 Unless a numeric argument is used, this command first offers to save
102 any modified file-visiting buffers. If you do not save all buffers,
103 you are asked for reconfirmation with `yes' before killing Emacs, since
104 any changes not saved will be lost forever. If any subprocesses are
105 still running, `C-x C-c' asks you to confirm killing them, since killing
106 Emacs will kill the subprocesses immediately.
108 There is no way to restart an Emacs session once you have killed it.
109 You can, however, arrange for Emacs to record certain session
110 information, such as which files are visited, when you kill it, so that
111 the next time you restart Emacs it will try to visit the same files and
114 The operating system usually listens for certain special characters
115 whose meaning is to kill or suspend the program you are running. This
116 operating system feature is turned off while you are in Emacs. The
117 meanings of `C-z' and `C-x C-c' as keys in Emacs were inspired by the
118 use of `C-z' and `C-c' on several operating systems as the characters
119 for stopping or killing a program, but that is their only relationship
120 with the operating system. You can customize these keys to run any
121 commands of your choice (*note Keymaps::).
124 File: xemacs.info, Node: Command Switches, Next: Startup Paths, Prev: Exiting, Up: Top
126 Command Line Switches and Arguments
127 ===================================
129 XEmacs supports command line arguments you can use to request
130 various actions when invoking Emacs. The commands are for compatibility
131 with other editors and for sophisticated activities. If you are using
132 XEmacs under the X window system, you can also use a number of standard
133 Xt command line arguments. Command line arguments are not usually
134 needed for editing with Emacs; new users can skip this section.
136 Many editors are designed to be started afresh each time you want to
137 edit. You start the editor to edit one file; then exit the editor. The
138 next time you want to edit either another file or the same one, you
139 start the editor again. Under these circumstances, it makes sense to
140 use a command line argument to say which file to edit.
142 The recommended way to use XEmacs is to start it only once, just
143 after you log in, and do all your editing in the same Emacs process.
144 Each time you want to edit a file, you visit it using the existing
145 Emacs. Emacs creates a new buffer for each file, and (unless you kill
146 some of the buffers) Emacs eventually has many files in it ready for
147 editing. Usually you do not kill the Emacs process until you are about
148 to log out. Since you usually read files by typing commands to Emacs,
149 command line arguments for specifying a file when Emacs is started are
152 Emacs accepts command-line arguments that specify files to visit,
153 functions to call, and other activities and operating modes. If you are
154 running XEmacs under the X window system, a number of standard Xt
155 command line arguments are available as well.
157 The following subsections list:
158 * Command line arguments that you can always use
160 * Command line arguments that have to appear at the beginning of the
163 * Command line arguments that are only relevant if you are running
166 Command Line Arguments for Any Position
167 ---------------------------------------
169 Command line arguments are processed in the order they appear on the
170 command line; however, certain arguments (the ones in the second table)
171 must be at the front of the list if they are used.
173 Here are the arguments allowed:
176 Visit FILE using `find-file'. *Note Visiting::.
179 Visit FILE using `find-file', then go to line number LINENUM in it.
183 Load a file FILE of Lisp code with the function `load'. *Note
188 Call Lisp function FUNCTION with no arguments.
191 Interpret the next argument as a Lisp expression, and evaluate it.
192 You must be very careful of the shell quoting here.
196 Insert the contents of FILE into the current buffer. This is like
197 what `M-x insert-buffer' does; *Note Misc File Ops::.
200 Exit from Emacs without asking for confirmation.
204 Prints version information. This implies `-batch'.
207 XEmacs 19.13 of Mon Aug 21 1995 on willow (usg-unix-v) [formerly Lucid Emacs]
210 Prints a summary of command-line options and then exits.
212 Command Line Arguments (Beginning of Line Only)
213 -----------------------------------------------
215 The following arguments are recognized only at the beginning of the
216 command line. If more than one of them appears, they must appear in the
217 order in which they appear in this table.
220 Use FILE instead of the terminal for input and output. This
221 implies the `-nw' option, documented below.
224 Run Emacs in "batch mode", which means that the text being edited
225 is not displayed and the standard Unix interrupt characters such as
226 `C-z' and `C-c' continue to have their normal effect. Emacs in
227 batch mode outputs to `stderr' only what would normally be printed
228 in the echo area under program control.
230 Batch mode is used for running programs written in Emacs Lisp from
231 shell scripts, makefiles, and so on. Normally the `-l' switch or
232 `-f' switch will be used as well, to invoke a Lisp program to do
233 the batch processing.
235 `-batch' implies `-q' (do not load an init file). It also causes
236 Emacs to kill itself after all command switches have been
237 processed. In addition, auto-saving is not done except in buffers
238 for which it has been explicitly requested.
241 Start up XEmacs in TTY mode (using the TTY XEmacs was started
242 from), rather than trying to connect to an X display. Note that
243 this happens automatically if the `DISPLAY' environment variable
247 Enter the debugger if an error in the init file occurs.
250 Displays information on how XEmacs constructs the various paths
251 into its hierarchy on startup. (See also *note Startup Paths::.)
254 Do not map the initial frame. This is useful if you want to start
255 up XEmacs as a server (e.g. for gnuserv screens or external client
260 Do not load your Emacs init file. *Note Init File::.
263 Do not load the site-specific init file `lisp/site-start.el'.
266 Do not load global symbol files (`auto-autoloads') at startup.
267 This implies `-vanilla'.
270 Do not process early packages. (For more information on startup
271 issues concerning the package system, *Note Startup Paths::.)
274 This is equivalent to `-q -no-site-file -no-early-packages'.
276 `-user-init-file FILE'
277 Load FILE as your Emacs init file instead of
278 `~/.xemacs/init.el'/`~/.emacs'.
280 `-user-init-directory DIRECTORY'
281 Use DIRECTORY as the location of your early package hierarchies
282 and the various user-specific initialization files.
286 Equivalent to `-user-init-file ~USER/.xemacs/init.el
287 -user-init-directory ~USER/.xemacs', or `-user-init-file
288 ~USER/.emacs -user-init-directory ~USER/.xemacs'. whichever init
289 file comes first. *Note Init File::.
291 Note that the init file can get access to the command line argument
292 values as the elements of a list in the variable `command-line-args'.
293 (The arguments in the second table above will already have been
294 processed and will not be in the list.) The init file can override the
295 normal processing of the other arguments by setting this variable.
297 One way to use command switches is to visit many files automatically:
301 passes each `.c' file as a separate argument to Emacs, so that Emacs
302 visits each file (*note Visiting::).
304 Here is an advanced example that assumes you have a Lisp program file
305 called `hack-c-program.el' which, when loaded, performs some useful
306 operation on the current buffer, expected to be a C program.
308 xemacs -batch foo.c -l hack-c-program -f save-buffer -kill > log
310 Here Emacs is told to visit `foo.c', load `hack-c-program.el' (which
311 makes changes in the visited file), save `foo.c' (note that
312 `save-buffer' is the function that `C-x C-s' is bound to), and then
313 exit to the shell from which the command was executed. `-batch'
314 guarantees there will be no problem redirecting output to `log',
315 because Emacs will not assume that it has a display terminal to work
318 Command Line Arguments (for XEmacs Under X)
319 -------------------------------------------
321 If you are running XEmacs under X, a number of options are available
322 to control color, border, and window title and icon name:
327 Use TITLE as the window title. This sets the `frame-title-format'
328 variable, which controls the title of the X window corresponding
329 to the selected frame. This is the same format as
334 Use TITLE as the icon name. This sets the
335 `frame-icon-title-format' variable, which controls the title of
336 the icon corresponding to the selected frame.
339 Use COLOR as the mouse color.
342 Use COLOR as the text-cursor foreground color.
345 Install a private colormap for XEmacs.
347 In addition, XEmacs allows you to use a number of standard Xt
348 command line arguments.
352 Use COLOR as the background color.
356 Use COLOR as the border color.
360 Use WIDTH as the border width.
364 When running under the X window system, create the window
365 containing the Emacs frame on the display named DISPLAY.
369 Use COLOR as the foreground color.
373 Use NAME as the default font.
378 Use the geometry (window size and/or position) specified by SPEC.
384 Bring up Emacs in reverse video.
387 Use the resource manager resources specified by NAME. The default
388 is to use the name of the program (`argv[0]') as the resource
392 Read something into the resource database for this invocation of
396 File: xemacs.info, Node: Startup Paths, Next: Packages, Prev: Command Switches, Up: Top
398 How XEmacs finds Directories and Files
399 ======================================
401 XEmacs deals with a multitude of files during operation. These files
402 are spread over many directories, and XEmacs determines the location of
403 most of these directories at startup and organizes them into various
404 paths. (A "path", for the purposes of this section, is simply a list
405 of directories which XEmacs searches successively in order to locate a
408 XEmacs Directory Hierarchies
409 ----------------------------
411 Many of the files XEmacs looks for are located within the XEmacs
412 installation itself. However, there are several views of what actually
413 constitutes the "XEmacs installation": XEmacs may be run from the
414 compilation directory, it may be installed into arbitrary directories,
415 spread over several directories unrelated to each other. Moreover, it
416 may subsequently be moved to a different place. (This last case is not
417 as uncommon as it sounds. Binary kits work this way.) Consequently,
418 XEmacs has quite complex procedures in place to find directories, no
419 matter where they may be hidden.
421 XEmacs will always respect directory options passed to `configure'.
422 However, if it cannot locate a directory at the configured place, it
423 will initiate a search for the directory in any of a number of
424 "hierarchies" rooted under a directory which XEmacs assumes contain
425 parts of the XEmacs installation; it may locate several such hierarchies
426 and search across them. (Typically, there are just one or two
427 hierarchies: the hierarchy where XEmacs was or will be installed, and
428 the one where it is being built.) Such a directory containing a
429 hierarchy is called a "root". Whenever this section refers to a
430 directory using the shorthand `<root>', it means that XEmacs searches
431 for it under all hierarchies XEmacs was able to scrounge up. In a
432 running XEmacs, the hierarchy roots are stored in the variable
438 Many relevant directories and files XEmacs uses are actually not
439 part of the core installation. They are part of any of the many
440 packages usually installed on top of an XEmacs installation. (*Note
441 Packages::.) Hence, they play a prominent role in the various paths
444 XEmacs locates packages in any of a number of package hierarchies.
445 Package hierarchies fall into three groups: "early", "late", and "last",
446 according to the relative location at which they show up in the various
447 XEmacs paths. Early package hierarchies are at the very front, late
448 ones somewhere in the middle, and last hierarchies are (you guessed it)
451 By default, XEmacs expects an early package hierarchy in the
452 subdirectory `.xemacs/xemacs-packages' of the user's home directory.
454 Moreover, XEmacs expects late hierarchies in the subdirectories
455 `site-packages', `mule-packages', and `xemacs-packages' (in that order)
456 of the `<root>/lib/xemacs' subdirectory of one of the installation
457 hierarchies. (If you run in-place, these are direct subdirectories of
458 the build directory.) Furthermore, XEmacs will also search these
459 subdirectories in the `<root>/lib/xemacs-<VERSION>' subdirectory and
460 prefer directories found there.
462 By default, XEmacs does not have a pre-configured last package
463 hierarchy. Last hierarchies are primarily for using package hierarchies
464 of outdated versions of XEmacs as a fallback option. For example, it is
465 possible to run XEmacs 21 with the 20.4 package hierarchy as a last
468 It is possible to specify at configure-time the location of the
469 various package hierarchies with the `--package-path' option to
470 configure. The early, late, and last components of the package path
471 are separated by double instead of single colons. If all three
472 components are present, they locate the early, late, and last package
473 hierarchies respectively. If two components are present, they locate
474 the early and late hierarchies. If only one component is present, it
475 locates the late hierarchy. At run time, the package path may also be
476 specified via the `EMACSPACKAGEPATH' environment variable.
478 An XEmacs package is laid out just like a normal installed XEmacs
479 lisp directory. It may have `lisp', `etc', `info', and `lib-src'
480 subdirectories. XEmacs adds these at appropriate places within the
481 various system-wide paths.
483 There may be any number of package hierarchy directories.
485 Directories and Paths
486 ---------------------
488 Here is a list of the various directories and paths XEmacs tries to
489 locate during startup. XEmacs distinguishes between directories and
490 paths specific to "version", "site", and "architecture" when looking
494 directories are specific to the version of XEmacs they belong to
495 and typically reside under `<root>/lib/xemacs-<VERSION>'.
498 directories are independent of the version of XEmacs they belong
499 to and typically reside under `<root>/lib/xemacs'
501 `architecture-specific'
502 directories are specific both to the version of XEmacs and the
503 architecture it runs on and typically reside under
504 `<root>/lib/xemacs-<VERSION>/<ARCHITECTURE>'.
506 During installation, all of these directories may also reside
507 directly under `<root>', because that is where they are in the XEmacs
510 If XEmacs runs with the `-debug-paths' option (*note Command
511 Switches::), it will print the values of these variables, hopefully
512 aiding in debugging any problems which come up.
515 Contains the version-specific location of the Lisp files that come
516 with the core distribution of XEmacs. XEmacs will search it
517 recursively to a depth of 1 when setting up `load-path'.
520 Is where XEmacs searches for XEmacs Lisp files with commands like
521 `load-library'. It contains the package lisp directories (see
522 further down) and the version-specific core Lisp directories. If
523 the environment variable `EMACSLOADPATH' is set at startup, its
524 directories are prepended to `load-path'.
526 `Info-directory-list'
527 Contains the location of info files. (See *Note (info)::.) It
528 contains the package info directories and the version-specific core
529 documentation. Moreover, XEmacs will add `/usr/info',
530 `/usr/local/info' as well as the directories of the environment
531 variable `INFOPATH' to `Info-directory-list'.
534 Is the directory of architecture-dependent files that come with
535 XEmacs, especially executable programs intended for XEmacs to
539 Is the path for executables which XEmacs may want to start. It
540 contains the package executable paths as well as `exec-directory',
541 and the directories of the environment variables `PATH' and
545 Is the directory containing the architecture-specific `DOC' file
546 that contains documentation for XEmacs' commands.
549 Is the version-specific directory that contains core data files
550 XEmacs uses. It may be initialized from the `EMACSDATA'
551 environment variable.
553 `data-directory-list'
554 Is the path where XEmacs looks for data files. It contains
555 package data directories as well as `data-directory'.
558 File: xemacs.info, Node: Basic, Next: Undo, Prev: Packages, Up: Top
560 Basic Editing Commands
561 **********************
563 We now give the basics of how to enter text, make corrections, and
564 save the text in a file. If this material is new to you, you might
565 learn it more easily by running the Emacs learn-by-doing tutorial. To
566 use the tutorial, run Emacs and type `Control-h t'
567 (`help-with-tutorial'). You can also use Tutorials item from the Help
570 XEmacs comes with many translations of tutorial. If your XEmacs is
571 with MULE and you set up language environment correctly, XEmacs chooses
572 right tutorial when available (*note Language Environments::). If you
573 want specific translation, give `C-h t' a prefix argument, like `C-u
576 To clear the screen and redisplay, type `C-l' (`recenter').
581 * Inserting Text:: Inserting text by simply typing it.
582 * Moving Point:: How to move the cursor to the place where you want to
584 * Erasing:: Deleting and killing text.
585 * Files: Basic Files. Visiting, creating, and saving files.
586 * Help: Basic Help. Asking what a character does.
587 * Blank Lines:: Commands to make or delete blank lines.
588 * Continuation Lines:: Lines too wide for the screen.
589 * Position Info:: What page, line, row, or column is point on?
590 * Arguments:: Numeric arguments for repeating a command.
593 File: xemacs.info, Node: Inserting Text, Next: Moving Point, Up: Basic
598 To insert printing characters into the text you are editing, just
599 type them. This inserts the characters you type into the buffer at the
600 cursor (that is, at "point"; *note Point::). The cursor moves forward,
601 and any text after the cursor moves forward too. If the text in the
602 buffer is `FOOBAR', with the cursor before the `B', then if you type
603 `XX', you get `FOOXXBAR', with the cursor still before the `B'.
605 To "delete" text you have just inserted, use <BS>. <BS> deletes the
606 character _before_ the cursor (not the one that the cursor is on top of
607 or under; that is the character AFTER the cursor). The cursor and all
608 characters after it move backwards. Therefore, if you type a printing
609 character and then type <BS>, they cancel out.
611 To end a line and start typing a new one, type <RET>. This inserts
612 a newline character in the buffer. If point is in the middle of a
613 line, <RET> splits the line. Typing <DEL> when the cursor is at the
614 beginning of a line deletes the preceding newline, thus joining the
615 line with the preceding line.
617 Emacs can split lines automatically when they become too long, if you
618 turn on a special minor mode called "Auto Fill" mode. *Note Filling::,
619 for how to use Auto Fill mode.
621 If you prefer to have text characters replace (overwrite) existing
622 text rather than shove it to the right, you can enable Overwrite mode,
623 a minor mode. *Note Minor Modes::.
625 Direct insertion works for printing characters and <SPC>, but other
626 characters act as editing commands and do not insert themselves. If you
627 need to insert a control character or a character whose code is above
628 200 octal, you must "quote" it by typing the character `Control-q'
629 (`quoted-insert') first. (This character's name is normally written
630 `C-q' for short.) There are two ways to use `C-q':
632 * `C-q' followed by any non-graphic character (even `C-g') inserts
635 * `C-q' followed by a sequence of octal digits inserts the character
636 with the specified octal character code. You can use any number of
637 octal digits; any non-digit terminates the sequence. If the
638 terminating character is <RET>, it serves only to terminate the
639 sequence; any other non-digit is itself used as input after
640 terminating the sequence. (The use of octal sequences is disabled
641 in ordinary non-binary Overwrite mode, to give you a convenient
642 way to insert a digit instead of overwriting with it.)
644 A numeric argument to `C-q' specifies how many copies of the quoted
645 character should be inserted (*note Arguments::).
647 Customization information: <DEL>, in most modes, runs the command
648 `backward-or-forward-delete-char'; <RET> runs the command `newline',
649 and self-inserting printing characters run the command `self-insert',
650 which inserts whatever character was typed to invoke it. Some major
651 modes rebind <DEL> to other commands.
654 File: xemacs.info, Node: Moving Point, Next: Erasing, Prev: Inserting Text, Up: Basic
656 Changing the Location of Point
657 ==============================
659 To do more than insert characters, you have to know how to move point
660 (*note Point::). The simplest way to do this is with arrow keys, or by
661 clicking the left mouse button where you want to move to.
663 NOTE: Many of the following commands have two versions, one that uses
664 the function keys (e.g. <LEFT> or <END>) and one that doesn't. The
665 former versions may only be available on X terminals (i.e. not on
666 TTY's), but the latter are available on all terminals.
670 Move to the beginning of the line (`beginning-of-line').
674 Move to the end of the line (`end-of-line').
678 Move forward one character (`forward-char').
682 Move backward one character (`backward-char').
686 Move forward one word (`forward-word').
690 Move backward one word (`backward-word').
694 Move down one line, vertically (`next-line'). This command
695 attempts to keep the horizontal position unchanged, so if you
696 start in the middle of one line, you end in the middle of the
697 next. When on the last line of text, `C-n' creates a new line and
702 Move up one line, vertically (`previous-line').
706 Move down one page, vertically (`scroll-up').
710 Move up one page, vertically (`scroll-down').
713 Clear the frame and reprint everything (`recenter'). Text moves
714 on the frame to bring point to the center of the window.
717 Move point to left margin, vertically centered in the window
718 (`move-to-window-line'). Text does not move on the screen.
720 A numeric argument says which screen line to place point on. It
721 counts screen lines down from the top of the window (zero for the
722 top line). A negative argument counts lines from the bottom (-1
723 for the bottom line).
726 Transpose two characters, the ones before and after the cursor
731 Move to the top of the buffer (`beginning-of-buffer'). With
732 numeric argument N, move to N/10 of the way from the top. *Note
733 Arguments::, for more information on numeric arguments.
737 Move to the end of the buffer (`end-of-buffer').
740 Read a number N and move point to buffer position N. Position 1
741 is the beginning of the buffer.
744 Read a number N and move point to line number N (`goto-line').
745 Line 1 is the beginning of the buffer.
747 `M-x set-goal-column'
748 Use the current column of point as the "semi-permanent goal
749 column" for `C-n' and `C-p' (`set-goal-column'). Henceforth, those
750 commands always move to this column in each line moved into, or as
751 close as possible given the contents of the line. This goal
752 column remains in effect until canceled.
754 `C-u M-x set-goal-column'
755 Cancel the goal column. Henceforth, `C-n' and `C-p' once again
756 try to avoid changing the horizontal position, as usual.
758 If you set the variable `track-eol' to a non-`nil' value, then `C-n'
759 and `C-p' when at the end of the starting line move to the end of
760 another line. Normally, `track-eol' is `nil'. *Note Variables::, for
761 how to set variables such as `track-eol'.
763 Normally, `C-n' on the last line of a buffer appends a newline to
764 it. If the variable `next-line-add-newlines' is `nil', then `C-n' gets
765 an error instead (like `C-p' on the first line).
768 File: xemacs.info, Node: Erasing, Next: Basic Files, Prev: Moving Point, Up: Basic
774 Delete the character before or after point
775 (`backward-or-forward-delete-char'). You can customize this
776 behavior by setting the variable `delete-key-deletes-forward'.
779 Delete the character after point (`delete-char').
782 Kill to the end of the line (`kill-line').
785 Kill forward to the end of the next word (`kill-word').
788 Kill back to the beginning of the previous word
789 (`backward-kill-word').
791 You already know about the <DEL> key which deletes the character
792 before point (that is, before the cursor). Another key, `Control-d'
793 (`C-d' for short), deletes the character after point (that is, the
794 character that the cursor is on). This shifts the rest of the text on
795 the line to the left. If you type `C-d' at the end of a line, it joins
796 together that line and the next line.
798 To erase a larger amount of text, use the `C-k' key, which kills a
799 line at a time. If you type `C-k' at the beginning or middle of a
800 line, it kills all the text up to the end of the line. If you type
801 `C-k' at the end of a line, it joins that line and the next line.
803 *Note Killing::, for more flexible ways of killing text.
806 File: xemacs.info, Node: Basic Files, Next: Basic Help, Prev: Erasing, Up: Basic
811 The commands described above are sufficient for creating and altering
812 text in an Emacs buffer; the more advanced Emacs commands just make
813 things easier. But to keep any text permanently you must put it in a
814 "file". Files are named units of text which are stored by the
815 operating system for you to retrieve later by name. To look at or use
816 the contents of a file in any way, including editing the file with
817 Emacs, you must specify the file name.
819 Consider a file named `/usr/rms/foo.c'. To begin editing this file
822 C-x C-f /usr/rms/foo.c <RET>
824 Here the file name is given as an "argument" to the command `C-x C-f'
825 (`find-file'). That command uses the "minibuffer" to read the
826 argument, and you type <RET> to terminate the argument (*note
829 You can also use the Open... menu item from the File menu, then type
830 the name of the file to the prompt.
832 Emacs obeys the command by "visiting" the file: creating a buffer,
833 copying the contents of the file into the buffer, and then displaying
834 the buffer for you to edit. If you alter the text, you can "save" the
835 new text in the file by typing `C-x C-s' (`save-buffer') or choosing
836 Save Buffer from the File menu. This makes the changes permanent by
837 copying the altered buffer contents back into the file
838 `/usr/rms/foo.c'. Until you save, the changes exist only inside Emacs,
839 and the file `foo.c' is unaltered.
841 To create a file, visit the file with `C-x C-f' as if it already
842 existed or choose Open... from the File menu and provide the name for
843 the new file. Emacs will create an empty buffer in which you can
844 insert the text you want to put in the file. When you save the buffer
845 with `C-x C-s', or by choosing Save Buffer from the File menu, the file
848 To learn more about using files, *Note Files::.
851 File: xemacs.info, Node: Basic Help, Next: Blank Lines, Prev: Basic Files, Up: Basic
856 If you forget what a key does, you can find out with the Help
857 character, which is `C-h' (or <F1>, which is an alias for `C-h'). Type
858 `C-h k' followed by the key you want to know about; for example, `C-h k
859 C-n' tells you all about what `C-n' does. `C-h' is a prefix key; `C-h
860 k' is just one of its subcommands (the command `describe-key'). The
861 other subcommands of `C-h' provide different kinds of help. Type `C-h'
862 twice to get a description of all the help facilities. *Note Help::.
865 File: xemacs.info, Node: Blank Lines, Next: Continuation Lines, Prev: Basic Help, Up: Basic
870 Here are special commands and techniques for putting in and taking
874 Insert one or more blank lines after the cursor (`open-line').
877 Delete all but one of many consecutive blank lines
878 (`delete-blank-lines').
880 When you want to insert a new line of text before an existing line,
881 you can do it by typing the new line of text, followed by <RET>.
882 However, it may be easier to see what you are doing if you first make a
883 blank line and then insert the desired text into it. This is easy to do
884 using the key `C-o' (`open-line'), which inserts a newline after point
885 but leaves point in front of the newline. After `C-o', type the text
886 for the new line. `C-o F O O' has the same effect as `F O O <RET>',
887 except for the final location of point.
889 You can make several blank lines by typing `C-o' several times, or
890 by giving it a numeric argument to tell it how many blank lines to make.
891 *Note Arguments::, for how. If you have a fill prefix, then `C-o'
892 command inserts the fill prefix on the new line, when you use it at the
893 beginning of a line. *Note Fill Prefix::.
895 The easy way to get rid of extra blank lines is with the command
896 `C-x C-o' (`delete-blank-lines'). `C-x C-o' in a run of several blank
897 lines deletes all but one of them. `C-x C-o' on a solitary blank line
898 deletes that blank line. When point is on a nonblank line, `C-x C-o'
899 deletes any blank lines following that nonblank line.
902 File: xemacs.info, Node: Continuation Lines, Next: Position Info, Prev: Blank Lines, Up: Basic
907 If you add too many characters to one line without breaking it with
908 <RET>, the line will grow to occupy two (or more) lines on the screen,
909 with a curved arrow at the extreme right margin of all but the last of
910 them. The curved arrow says that the following screen line is not
911 really a distinct line in the text, but just the "continuation" of a
912 line too long to fit the screen. Continuation is also called "line
915 Sometimes it is nice to have Emacs insert newlines automatically when
916 a line gets too long. Continuation on the screen does not do that. Use
917 Auto Fill mode (*note Filling::) if that's what you want.
919 Instead of continuation, long lines can be displayed by "truncation".
920 This means that all the characters that do not fit in the width of the
921 frame or window do not appear at all. They remain in the buffer,
922 temporarily invisible. Right arrow in the last column (instead of the
923 curved arrow) inform you that truncation is in effect.
925 Truncation instead of continuation happens whenever horizontal
926 scrolling is in use, and optionally in all side-by-side windows (*note
927 Windows::). You can enable truncation for a particular buffer by
928 setting the variable `truncate-lines' to non-`nil' in that buffer.
929 (*Note Variables::.) Altering the value of `truncate-lines' makes it
930 local to the current buffer; until that time, the default value is in
931 effect. The default is initially `nil'. *Note Locals::.
933 *Note Display Vars::, for additional variables that affect how text
937 File: xemacs.info, Node: Position Info, Next: Arguments, Prev: Continuation Lines, Up: Basic
939 Cursor Position Information
940 ===========================
942 If you are accustomed to other display editors, you may be surprised
943 that Emacs does not always display the page number or line number of
944 point in the mode line. In Emacs, this information is only rarely
945 needed, and a number of commands are available to compute and print it.
946 Since text is stored in a way that makes it difficult to compute the
947 information, it is not displayed all the time.
950 Print page number of point, and line number within page.
953 Print line number of point in the buffer.
955 `M-x line-number-mode'
956 Toggle automatic display of current line number.
959 Print number of lines and characters in the current region
960 (`count-lines-region'). *Note Mark::, for information about the
964 Print character code of character after point, character position
965 of point, and column of point (`what-cursor-position').
967 There are several commands for printing line numbers:
969 * `M-x what-line' counts lines from the beginning of the file and
970 prints the line number point is on. The first line of the file is
971 line number 1. You can use these numbers as arguments to `M-x
974 * `M-x what-page' counts pages from the beginning of the file, and
975 counts lines within the page, printing both of them. *Note
976 Pages::, for the command `C-x l', which counts the lines in the
979 * `M-=' (`count-lines-region') prints the number of lines in the
980 region (*note Mark::). *Note Pages::, for the command `C-x l'
981 which counts the lines in the
983 The command `C-x =' (`what-cursor-position') can be used to find out
984 the column that the cursor is in, and other miscellaneous information
985 about point. It prints a line in the echo area that looks like this:
987 Char: c (0143, 99, 0x63) point=18862 of 24800(76%) column 53
989 (In fact, this is the output produced when point is before `column 53'
992 The four values after `Char:' describe the character that follows
993 point, first by showing it and then by giving its character code in
994 octal, decimal and hex.
996 `point=' is followed by the position of point expressed as a
997 character count. The front of the buffer counts as position 1, one
998 character later as 2, and so on. The next, larger number is the total
999 number of characters in the buffer. Afterward in parentheses comes the
1000 position expressed as a percentage of the total size.
1002 `column' is followed by the horizontal position of point, in columns
1003 from the left edge of the window.
1005 If the buffer has been narrowed, making some of the text at the
1006 beginning and the end temporarily invisible, `C-x =' prints additional
1007 text describing the current visible range. For example, it might say:
1009 Char: c (0143, 99, 0x63) point=19674 of 24575(80%) <19591 - 19703> column 69
1011 where the two extra numbers give the smallest and largest character
1012 position that point is allowed to assume. The characters between those
1013 two positions are the visible ones. *Note Narrowing::.
1015 If point is at the end of the buffer (or the end of the visible
1016 part), `C-x =' omits any description of the character after point. The
1019 point=563026 of 563025(100%) column 0
1022 File: xemacs.info, Node: Arguments, Prev: Position Info, Up: Basic
1027 In mathematics and computer usage, the word "argument" means "data
1028 provided to a function or operation." Any Emacs command can be given a
1029 "numeric argument" (also called a "prefix argument"). Some commands
1030 interpret the argument as a repetition count. For example, giving an
1031 argument of ten to the key `C-f' (the command `forward-char', move
1032 forward one character) moves forward ten characters. With these
1033 commands, no argument is equivalent to an argument of one. Negative
1034 arguments are allowed. Often they tell a command to move or act in
1035 the opposite direction.
1037 If your keyboard has a <META> key (labelled with a diamond on
1038 Sun-type keyboards and labelled `Alt' on some other keyboards), the
1039 easiest way to specify a numeric argument is to type digits and/or a
1040 minus sign while holding down the <META> key. For example,
1043 would move down five lines. The characters `Meta-1', `Meta-2', and so
1044 on, as well as `Meta--', do this because they are keys bound to
1045 commands (`digit-argument' and `negative-argument') that are defined to
1046 contribute to an argument for the next command. Digits and `-'
1047 modified with Control, or Control and Meta, also specify numeric
1050 Another way of specifying an argument is to use the `C-u'
1051 (`universal-argument') command followed by the digits of the argument.
1052 With `C-u', you can type the argument digits without holding down
1053 modifier keys; `C-u' works on all terminals. To type a negative
1054 argument, type a minus sign after `C-u'. Just a minus sign without
1055 digits normally means -1.
1057 `C-u' followed by a character which is neither a digit nor a minus
1058 sign has the special meaning of "multiply by four". It multiplies the
1059 argument for the next command by four. `C-u' twice multiplies it by
1060 sixteen. Thus, `C-u C-u C-f' moves forward sixteen characters. This
1061 is a good way to move forward "fast", since it moves about 1/5 of a line
1062 in the usual size frame. Other useful combinations are `C-u C-n', `C-u
1063 C-u C-n' (move down a good fraction of a frame), `C-u C-u C-o' (make "a
1064 lot" of blank lines), and `C-u C-k' (kill four lines).
1066 Some commands care only about whether there is an argument and not
1067 about its value. For example, the command `M-q' (`fill-paragraph') with
1068 no argument fills text; with an argument, it justifies the text as well.
1069 (*Note Filling::, for more information on `M-q'.) Just `C-u' is a
1070 handy way of providing an argument for such commands.
1072 Some commands use the value of the argument as a repeat count, but do
1073 something peculiar when there is no argument. For example, the command
1074 `C-k' (`kill-line') with argument N kills N lines, including their
1075 terminating newlines. But `C-k' with no argument is special: it kills
1076 the text up to the next newline, or, if point is right at the end of
1077 the line, it kills the newline itself. Thus, two `C-k' commands with
1078 no arguments can kill a non-blank line, just like `C-k' with an
1079 argument of one. (*Note Killing::, for more information on `C-k'.)
1081 A few commands treat a plain `C-u' differently from an ordinary
1082 argument. A few others may treat an argument of just a minus sign
1083 differently from an argument of -1. These unusual cases are described
1084 when they come up; they are always for reasons of convenience of use of
1085 the individual command.
1087 You can use a numeric argument to insert multiple copies of a
1088 character. This is straightforward unless the character is a digit; for
1089 example, `C-u 6 4 a' inserts 64 copies of the character `a'. But this
1090 does not work for inserting digits; `C-u 6 4 1' specifies an argument
1091 of 641, rather than inserting anything. To separate the digit to
1092 insert from the argument, type another `C-u'; for example, `C-u 6 4 C-u
1093 1' does insert 64 copies of the character `1'.
1095 We use the term "prefix argument" as well as "numeric argument" to
1096 emphasize that you type the argument before the command, and to
1097 distinguish these arguments from minibuffer arguments that come after
1101 File: xemacs.info, Node: Undo, Next: Minibuffer, Prev: Basic, Up: Top
1106 Emacs allows you to undo all changes you make to the text of a
1107 buffer, up to a certain amount of change (8000 characters). Each
1108 buffer records changes individually, and the undo command always
1109 applies to the current buffer. Usually each editing command makes a
1110 separate entry in the undo records, but some commands such as
1111 `query-replace' make many entries, and very simple commands such as
1112 self-inserting characters are often grouped to make undoing less
1116 Undo one batch of changes (usually, one command's worth) (`undo').
1121 The command `C-x u' or `C-_' allows you to undo changes. The first
1122 time you give this command, it undoes the last change. Point moves to
1123 the text affected by the undo, so you can see what was undone.
1125 Consecutive repetitions of the `C-_' or `C-x u' commands undo
1126 earlier and earlier changes, back to the limit of what has been
1127 recorded. If all recorded changes have already been undone, the undo
1128 command prints an error message and does nothing.
1130 Any command other than an undo command breaks the sequence of undo
1131 commands. Starting at this moment, the previous undo commands are
1132 considered ordinary changes that can themselves be undone. Thus, you
1133 can redo changes you have undone by typing `C-f' or any other command
1134 that have no important effect, and then using more undo commands.
1136 If you notice that a buffer has been modified accidentally, the
1137 easiest way to recover is to type `C-_' repeatedly until the stars
1138 disappear from the front of the mode line. When that happens, all the
1139 modifications you made have been canceled. If you do not remember
1140 whether you changed the buffer deliberately, type `C-_' once. When you
1141 see Emacs undo the last change you made, you probably remember why you
1142 made it. If the change was an accident, leave it undone. If it was
1143 deliberate, redo the change as described in the preceding paragraph.
1145 Whenever an undo command makes the stars disappear from the mode
1146 line, the buffer contents is the same as it was when the file was last
1149 Not all buffers record undo information. Buffers whose names start
1150 with spaces don't; these buffers are used internally by Emacs and its
1151 extensions to hold text that users don't normally look at or edit.
1152 Minibuffers, help buffers, and documentation buffers also don't record
1155 Emacs can remember at most 8000 or so characters of deleted or
1156 modified text in any one buffer for reinsertion by the undo command.
1157 There is also a limit on the number of individual insert, delete, or
1158 change actions that Emacs can remember.
1160 There are two keys to run the `undo' command, `C-x u' and `C-_',
1161 because on some keyboards, it is not obvious how to type `C-_'. `C-x u'
1162 is an alternative you can type in the same fashion on any terminal.
1165 File: xemacs.info, Node: Minibuffer, Next: M-x, Prev: Undo, Up: Top
1170 The "minibuffer" is the facility used by XEmacs commands to read
1171 arguments more complicated than a single number. Minibuffer arguments
1172 can be file names, buffer names, Lisp function names, XEmacs command
1173 names, Lisp expressions, and many other things, depending on the command
1174 reading the argument. You can use the usual XEmacs editing commands in
1175 the minibuffer to edit the argument text.
1177 When the minibuffer is in use, it appears in the echo area, and the
1178 cursor moves there. The beginning of the minibuffer line displays a
1179 "prompt" which says what kind of input you should supply and how it
1180 will be used. Often this prompt is derived from the name of the command
1181 that the argument is for. The prompt normally ends with a colon.
1183 Sometimes a "default argument" appears in parentheses after the
1184 colon; it, too, is part of the prompt. The default is used as the
1185 argument value if you enter an empty argument (e.g., by just typing
1186 <RET>). For example, commands that read buffer names always show a
1187 default, which is the name of the buffer that will be used if you type
1190 The simplest way to enter a minibuffer argument is to type the text
1191 you want, terminated by <RET> which exits the minibuffer. You can
1192 cancel the command that wants the argument, and get out of the
1193 minibuffer, by typing `C-g'.
1195 Since the minibuffer uses the screen space of the echo area, it can
1196 conflict with other ways XEmacs customarily uses the echo area. Here is
1197 how XEmacs handles such conflicts:
1199 * If a command gets an error while you are in the minibuffer, this
1200 does not cancel the minibuffer. However, the echo area is needed
1201 for the error message and therefore the minibuffer itself is
1202 hidden for a while. It comes back after a few seconds, or as soon
1203 as you type anything.
1205 * If in the minibuffer you use a command whose purpose is to print a
1206 message in the echo area, such as `C-x =', the message is printed
1207 normally, and the minibuffer is hidden for a while. It comes back
1208 after a few seconds, or as soon as you type anything.
1210 * Echoing of keystrokes does not take place while the minibuffer is
1215 * File: Minibuffer File. Entering file names with the minibuffer.
1216 * Edit: Minibuffer Edit. How to edit in the minibuffer.
1217 * Completion:: An abbreviation facility for minibuffer input.
1218 * Minibuffer History:: Reusing recent minibuffer arguments.
1219 * Repetition:: Re-executing commands that used the minibuffer.