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 `~/.emacs'.
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 `~/.emacs'.
279 `-user-init-directory DIRECTORY'
280 Use DIRECTORY as the location of your early package hierarchies
281 and the various user-specific initialization files.
285 Equivalent to `-user-init-file ~USER/.emacs -user-init-directory
288 Note that the init file can get access to the command line argument
289 values as the elements of a list in the variable `command-line-args'.
290 (The arguments in the second table above will already have been
291 processed and will not be in the list.) The init file can override the
292 normal processing of the other arguments by setting this variable.
294 One way to use command switches is to visit many files automatically:
298 passes each `.c' file as a separate argument to Emacs, so that Emacs
299 visits each file (*note Visiting::).
301 Here is an advanced example that assumes you have a Lisp program file
302 called `hack-c-program.el' which, when loaded, performs some useful
303 operation on the current buffer, expected to be a C program.
305 xemacs -batch foo.c -l hack-c-program -f save-buffer -kill > log
307 Here Emacs is told to visit `foo.c', load `hack-c-program.el' (which
308 makes changes in the visited file), save `foo.c' (note that
309 `save-buffer' is the function that `C-x C-s' is bound to), and then
310 exit to the shell from which the command was executed. `-batch'
311 guarantees there will be no problem redirecting output to `log',
312 because Emacs will not assume that it has a display terminal to work
315 Command Line Arguments (for XEmacs Under X)
316 -------------------------------------------
318 If you are running XEmacs under X, a number of options are available
319 to control color, border, and window title and icon name:
324 Use TITLE as the window title. This sets the `frame-title-format'
325 variable, which controls the title of the X window corresponding
326 to the selected frame. This is the same format as
331 Use TITLE as the icon name. This sets the
332 `frame-icon-title-format' variable, which controls the title of
333 the icon corresponding to the selected frame.
336 Use COLOR as the mouse color.
339 Use COLOR as the text-cursor foreground color.
342 Install a private colormap for XEmacs.
344 In addition, XEmacs allows you to use a number of standard Xt
345 command line arguments.
349 Use COLOR as the background color.
353 Use COLOR as the border color.
357 Use WIDTH as the border width.
361 When running under the X window system, create the window
362 containing the Emacs frame on the display named DISPLAY.
366 Use COLOR as the foreground color.
370 Use NAME as the default font.
375 Use the geometry (window size and/or position) specified by SPEC.
381 Bring up Emacs in reverse video.
384 Use the resource manager resources specified by NAME. The default
385 is to use the name of the program (`argv[0]') as the resource
389 Read something into the resource database for this invocation of
393 File: xemacs.info, Node: Startup Paths, Next: Basic, Prev: Command Switches, Up: Top
395 How XEmacs finds Directories and Files
396 ======================================
398 XEmacs deals with a multitude of files during operation. These files
399 are spread over many directories, and XEmacs determines the location of
400 most of these directories at startup and organizes them into various
401 paths. (A "path", for the purposes of this section, is simply a list
402 of directories which XEmacs searches successively in order to locate a
405 XEmacs Directory Hierarchies
406 ----------------------------
408 Many of the files XEmacs looks for are located within the XEmacs
409 installation itself. However, there are several views of what actually
410 constitutes the "XEmacs installation": XEmacs may be run from the
411 compilation directory, it may be installed into arbitrary directories,
412 spread over several directories unrelated to each other. Moreover, it
413 may subsequently be moved to a different place. (This last case is not
414 as uncommon as it sounds. Binary kits work this way.) Consequently,
415 XEmacs has quite complex procedures in place to find directories, no
416 matter where they may be hidden.
418 XEmacs will always respect directory options passed to `configure'.
419 However, if it cannot locate a directory at the configured place, it
420 will initiate a search for the directory in any of a number of
421 "hierarchies" rooted under a directory which XEmacs assumes contain
422 parts of the XEmacs installation; it may locate several such hierarchies
423 and search across them. (Typically, there are just one or two
424 hierarchies: the hierarchy where XEmacs was or will be installed, and
425 the one where it is being built.) Such a directory containing a
426 hierarchy is called a "root". Whenever this section refers to a
427 directory using the shorthand `<root>', it means that XEmacs searches
428 for it under all hierarchies under all hierarchies XEmacs was able to
429 scrounge up. In a running XEmacs, the hierarchy roots are stored in
430 the variable `emacs-roots'.
435 Many relevant directories and files XEmacs uses are actually not
436 part of the core installation. They are part of any of the many
437 packages usually installed on top of an XEmacs installation. (*Note
438 Packages::.) Hence, they play a prominent role in the various paths
441 XEmacs locates packages in any of a number of package hierarchies.
442 Package hierarchies fall into three groups: "early", "late", and "last",
443 according to the relative location at which they show up in the various
444 XEmacs paths. Early package hierarchies are at the very front, late
445 ones somewhere in the middle, and last hierarchies are (you guessed it)
448 By default, XEmacs expects an early package hierarchy in the a
449 subdirectory `.xemacs' of the user's home directory.
451 Moreover, XEmacs expects late hierarchies in the subdirectories
452 `site-packages', `mule-packages', and `xemacs-packages' (in that order)
453 of the `<root>/lib/xemacs' subdirectory of one of the installation
454 hierarchies. (If you run in-place, these are direct subdirectories of
455 the build directory.) Furthermore, XEmacs will also search these
456 subdirectories in the `<root>/lib/xemacs-<VERSION>' subdirectory and
457 prefer directories found there.
459 By default, XEmacs does not have a pre-configured last package
460 hierarchy. Last hierarchies are primarily for using package hierarchies
461 of outdated versions of XEmacs as a fallback option. For example, it is
462 possible to run XEmacs 21.0 with the 20.4 package hierarchy as a last
465 It is possible to specify at configure-time the location of the
466 various package hierarchies with the `--package-path' option to
467 configure. The early, late, and last components of the package path
468 are separated by double instead of single colons. If three components
469 are present, they are locate the early, late, and last package
470 hierarchies respectively. If two components are present, they locate
471 the early and late hierarchies. If only one component is present, it
472 locates the late hierarchy. At run time, the package path may also be
473 specified via the `EMACSPACKAGEPATH' environment variable.
475 An XEmacs package is laid out just like a normal installed XEmacs
476 lisp directory. It may have `lisp', `etc', `info', and `lib-src'
477 subdirectories. XEmacs adds these at appropriate places within the
478 various system-wide paths.
480 There may be any number of package hierarchy directories.
482 Directories and Paths
483 ---------------------
485 Here is a list of the various directories and paths XEmacs tries to
486 locate during startup. XEmacs distinguishes between directories and
487 paths specific to "version", "site", and "architecture" when looking
491 directories are specific to the version of XEmacs they belong to
492 and typically reside under `<root>/lib/xemacs-<VERSION>'.
495 directories are independent of the version of XEmacs they belong
496 to and typically reside under `<root>/lib/xemacs'
498 `architecture-specific'
499 directories are specific both to the version of XEmacs and the
500 architecture it runs on and typically reside under
501 `<root>/lib/xemacs-<VERSION>/<ARCHITECTURE>'.
503 During installation, all of these directories may also reside
504 directly under `<root>', because that is where they are in the XEmacs
507 If XEmacs runs with the `-debug-paths' option (*note Command
508 Switches::), it will print the values of these variables, hopefully
509 aiding in debugging any problems which come up.
512 Contains the version-specific location of the Lisp files that come
513 with the core distribution of XEmacs. XEmacs will search it
514 recursively to a depth of 1 when setting up `load-path'.
517 Is where XEmacs searches for XEmacs Lisp files with commands like
518 `load-library'. It contains the package lisp directories (see
519 further down) and the version-specific core Lisp directories. If
520 the environment variable `EMACSLOADPATH' is set at startup, its
521 directories are prepended to `load-path'.
523 `Info-directory-list'
524 Contains the location of info files. (See *Note (info)::.) It
525 contains the package info directories and the version-specific core
526 documentation. Moreover, XEmacs will add `/usr/info',
527 `/usr/local/info' as well as the directories of the environment
528 variable `INFOPATH' to `Info-directory-list'.
531 Is the directory of architecture-dependent files that come with
532 XEmacs, especially executable programs intended for XEmacs to
536 Is the path for executables which XEmacs may want to start. It
537 contains the package executable paths as well as `exec-directory',
538 and the directories of the environment variables `PATH' and
542 Is the directory containing the architecture-specific `DOC' file
543 that contains documentation for XEmacs' commands.
546 Is the version-specific directory that contains core data files
547 XEmacs uses. It may be initialized from the `EMACSDATA'
548 environment variable.
550 `data-directory-list'
551 Is the path where XEmacs looks for data files. It contains
552 package data directories as well as `data-directory'.
555 File: xemacs.info, Node: Basic, Next: Undo, Prev: Startup Paths, Up: Top
557 Basic Editing Commands
558 **********************
560 We now give the basics of how to enter text, make corrections, and
561 save the text in a file. If this material is new to you, you might
562 learn it more easily by running the Emacs learn-by-doing tutorial. To
563 use the tutorial, run Emacs and type `Control-h t'
564 (`help-with-tutorial'). You can also use Tutorials item from the Help
567 XEmacs comes with many translations of tutorial. If your XEmacs is
568 with MULE and you set up language environment correctly, XEmacs choses
569 right tutorial when available (*note Language Environments::). If you
570 want specific translation, give `C-h t' a prefix argument, like `C-u
573 To clear the screen and redisplay, type `C-l' (`recenter').
578 * Inserting Text:: Inserting text by simply typing it.
579 * Moving Point:: How to move the cursor to the place where you want to
581 * Erasing:: Deleting and killing text.
582 * Files: Basic Files. Visiting, creating, and saving files.
583 * Help: Basic Help. Asking what a character does.
584 * Blank Lines:: Commands to make or delete blank lines.
585 * Continuation Lines:: Lines too wide for the screen.
586 * Position Info:: What page, line, row, or column is point on?
587 * Arguments:: Numeric arguments for repeating a command.
590 File: xemacs.info, Node: Inserting Text, Next: Moving Point, Up: Basic
595 To insert printing characters into the text you are editing, just
596 type them. This inserts the characters you type into the buffer at the
597 cursor (that is, at "point"; *note Point::). The cursor moves forward,
598 and any text after the cursor moves forward too. If the text in the
599 buffer is `FOOBAR', with the cursor before the `B', then if you type
600 `XX', you get `FOOXXBAR', with the cursor still before the `B'.
602 To "delete" text you have just inserted, use <BS>. <BS> deletes the
603 character _before_ the cursor (not the one that the cursor is on top of
604 or under; that is the character AFTER the cursor). The cursor and all
605 characters after it move backwards. Therefore, if you type a printing
606 character and then type <BS>, they cancel out.
608 To end a line and start typing a new one, type <RET>. This inserts
609 a newline character in the buffer. If point is in the middle of a
610 line, <RET> splits the line. Typing <DEL> when the cursor is at the
611 beginning of a line deletes the preceding newline, thus joining the
612 line with the preceding line.
614 Emacs can split lines automatically when they become too long, if you
615 turn on a special minor mode called "Auto Fill" mode. *Note Filling::,
616 for how to use Auto Fill mode.
618 If you prefer to have text characters replace (overwrite) existing
619 text rather than shove it to the right, you can enable Overwrite mode,
620 a minor mode. *Note Minor Modes::.
622 Direct insertion works for printing characters and <SPC>, but other
623 characters act as editing commands and do not insert themselves. If you
624 need to insert a control character or a character whose code is above
625 200 octal, you must "quote" it by typing the character `Control-q'
626 (`quoted-insert') first. (This character's name is normally written
627 `C-q' for short.) There are two ways to use `C-q':
629 * `C-q' followed by any non-graphic character (even `C-g') inserts
632 * `C-q' followed by a sequence of octal digits inserts the character
633 with the specified octal character code. You can use any number of
634 octal digits; any non-digit terminates the sequence. If the
635 terminating character is <RET>, it serves only to terminate the
636 sequence; any other non-digit is itself used as input after
637 terminating the sequence. (The use of octal sequences is disabled
638 in ordinary non-binary Overwrite mode, to give you a convenient
639 way to insert a digit instead of overwriting with it.)
641 A numeric argument to `C-q' specifies how many copies of the quoted
642 character should be inserted (*note Arguments::).
644 Customization information: <DEL>, in most modes, runs the command
645 `backward-or-forward-delete-char'; <RET> runs the command `newline',
646 and self-inserting printing characters run the command `self-insert',
647 which inserts whatever character was typed to invoke it. Some major
648 modes rebind <DEL> to other commands.
651 File: xemacs.info, Node: Moving Point, Next: Erasing, Prev: Inserting Text, Up: Basic
653 Changing the Location of Point
654 ==============================
656 To do more than insert characters, you have to know how to move point
657 (*note Point::). The simplest way to do this is with arrow keys, or by
658 clicking the left mouse button where you want to move to.
660 NOTE: Many of the following commands have two versions, one that uses
661 the function keys (e.g. <LEFT> or <END>) and one that doesn't. The
662 former versions may only be available on X terminals (i.e. not on
663 TTY's), but the latter are available on all terminals.
667 Move to the beginning of the line (`beginning-of-line').
671 Move to the end of the line (`end-of-line').
675 Move forward one character (`forward-char').
679 Move backward one character (`backward-char').
683 Move forward one word (`forward-word').
687 Move backward one word (`backward-word').
691 Move down one line, vertically (`next-line'). This command
692 attempts to keep the horizontal position unchanged, so if you
693 start in the middle of one line, you end in the middle of the
694 next. When on the last line of text, `C-n' creates a new line and
699 Move up one line, vertically (`previous-line').
703 Move down one page, vertically (`scroll-up').
707 Move up one page, vertically (`scroll-down').
710 Clear the frame and reprint everything (`recenter'). Text moves
711 on the frame to bring point to the center of the window.
714 Move point to left margin, vertically centered in the window
715 (`move-to-window-line'). Text does not move on the screen.
717 A numeric argument says which screen line to place point on. It
718 counts screen lines down from the top of the window (zero for the
719 top line). A negative argument counts lines from the bottom (-1
720 for the bottom line).
723 Transpose two characters, the ones before and after the cursor
728 Move to the top of the buffer (`beginning-of-buffer'). With
729 numeric argument N, move to N/10 of the way from the top. *Note
730 Arguments::, for more information on numeric arguments.
734 Move to the end of the buffer (`end-of-buffer').
737 Read a number N and move point to buffer position N. Position 1
738 is the beginning of the buffer.
741 Read a number N and move point to line number N (`goto-line').
742 Line 1 is the beginning of the buffer.
744 `M-x set-goal-column'
745 Use the current column of point as the "semi-permanent goal
746 column" for `C-n' and `C-p' (`set-goal-column'). Henceforth, those
747 commands always move to this column in each line moved into, or as
748 close as possible given the contents of the line. This goal
749 column remains in effect until canceled.
751 `C-u M-x set-goal-column'
752 Cancel the goal column. Henceforth, `C-n' and `C-p' once again
753 try to avoid changing the horizontal position, as usual.
755 If you set the variable `track-eol' to a non-`nil' value, then `C-n'
756 and `C-p' when at the end of the starting line move to the end of
757 another line. Normally, `track-eol' is `nil'. *Note Variables::, for
758 how to set variables such as `track-eol'.
760 Normally, `C-n' on the last line of a buffer appends a newline to
761 it. If the variable `next-line-add-newlines' is `nil', then `C-n' gets
762 an error instead (like `C-p' on the first line).
765 File: xemacs.info, Node: Erasing, Next: Basic Files, Prev: Moving Point, Up: Basic
771 Delete the character before or after point
772 (`backward-or-forward-delete-char'). You can customize this
773 behavior by setting the variable `delete-key-deletes-forward'.
776 Delete the character after point (`delete-char').
779 Kill to the end of the line (`kill-line').
782 Kill forward to the end of the next word (`kill-word').
785 Kill back to the beginning of the previous word
786 (`backward-kill-word').
788 You already know about the <DEL> key which deletes the character
789 before point (that is, before the cursor). Another key, `Control-d'
790 (`C-d' for short), deletes the character after point (that is, the
791 character that the cursor is on). This shifts the rest of the text on
792 the line to the left. If you type `C-d' at the end of a line, it joins
793 together that line and the next line.
795 To erase a larger amount of text, use the `C-k' key, which kills a
796 line at a time. If you type `C-k' at the beginning or middle of a
797 line, it kills all the text up to the end of the line. If you type
798 `C-k' at the end of a line, it joins that line and the next line.
800 *Note Killing::, for more flexible ways of killing text.
803 File: xemacs.info, Node: Basic Files, Next: Basic Help, Prev: Erasing, Up: Basic
808 The commands described above are sufficient for creating and altering
809 text in an Emacs buffer; the more advanced Emacs commands just make
810 things easier. But to keep any text permanently you must put it in a
811 "file". Files are named units of text which are stored by the
812 operating system for you to retrieve later by name. To look at or use
813 the contents of a file in any way, including editing the file with
814 Emacs, you must specify the file name.
816 Consider a file named `/usr/rms/foo.c'. To begin editing this file
819 C-x C-f /usr/rms/foo.c <RET>
821 Here the file name is given as an "argument" to the command `C-x C-f'
822 (`find-file'). That command uses the "minibuffer" to read the
823 argument, and you type <RET> to terminate the argument (*note
826 You can also use the Open... menu item from the File menu, then type
827 the name of the file to the prompt.
829 Emacs obeys the command by "visiting" the file: creating a buffer,
830 copying the contents of the file into the buffer, and then displaying
831 the buffer for you to edit. If you alter the text, you can "save" the
832 new text in the file by typing `C-x C-s' (`save-buffer') or choosing
833 Save Buffer from the File menu. This makes the changes permanent by
834 copying the altered buffer contents back into the file
835 `/usr/rms/foo.c'. Until you save, the changes exist only inside Emacs,
836 and the file `foo.c' is unaltered.
838 To create a file, visit the file with `C-x C-f' as if it already
839 existed or choose Open... from the File menu and provide the name for
840 the new file. Emacs will create an empty buffer in which you can
841 insert the text you want to put in the file. When you save the buffer
842 with `C-x C-s', or by choosing Save Buffer from the File menu, the file
845 To learn more about using files, *Note Files::.
848 File: xemacs.info, Node: Basic Help, Next: Blank Lines, Prev: Basic Files, Up: Basic
853 If you forget what a key does, you can find out with the Help
854 character, which is `C-h' (or <F1>, which is an alias for `C-h'). Type
855 `C-h k' followed by the key you want to know about; for example, `C-h k
856 C-n' tells you all about what `C-n' does. `C-h' is a prefix key; `C-h
857 k' is just one of its subcommands (the command `describe-key'). The
858 other subcommands of `C-h' provide different kinds of help. Type `C-h'
859 twice to get a description of all the help facilities. *Note Help::.
862 File: xemacs.info, Node: Blank Lines, Next: Continuation Lines, Prev: Basic Help, Up: Basic
867 Here are special commands and techniques for putting in and taking
871 Insert one or more blank lines after the cursor (`open-line').
874 Delete all but one of many consecutive blank lines
875 (`delete-blank-lines').
877 When you want to insert a new line of text before an existing line,
878 you can do it by typing the new line of text, followed by <RET>.
879 However, it may be easier to see what you are doing if you first make a
880 blank line and then insert the desired text into it. This is easy to do
881 using the key `C-o' (`open-line'), which inserts a newline after point
882 but leaves point in front of the newline. After `C-o', type the text
883 for the new line. `C-o F O O' has the same effect as `F O O <RET>',
884 except for the final location of point.
886 You can make several blank lines by typing `C-o' several times, or
887 by giving it a numeric argument to tell it how many blank lines to make.
888 *Note Arguments::, for how. If you have a fill prefix, then `C-o'
889 command inserts the fill prefix on the new line, when you use it at the
890 beginning of a line. *Note Fill Prefix::.
892 The easy way to get rid of extra blank lines is with the command
893 `C-x C-o' (`delete-blank-lines'). `C-x C-o' in a run of several blank
894 lines deletes all but one of them. `C-x C-o' on a solitary blank line
895 deletes that blank line. When point is on a nonblank line, `C-x C-o'
896 deletes any blank lines following that nonblank line.
899 File: xemacs.info, Node: Continuation Lines, Next: Position Info, Prev: Blank Lines, Up: Basic
904 If you add too many characters to one line without breaking it with
905 <RET>, the line will grow to occupy two (or more) lines on the screen,
906 with a curved arrow at the extreme right margin of all but the last of
907 them. The curved arrow says that the following screen line is not
908 really a distinct line in the text, but just the "continuation" of a
909 line too long to fit the screen. Continuation is also called "line
912 Sometimes it is nice to have Emacs insert newlines automatically when
913 a line gets too long. Continuation on the screen does not do that. Use
914 Auto Fill mode (*note Filling::) if that's what you want.
916 Instead of continuation, long lines can be displayed by "truncation".
917 This means that all the characters that do not fit in the width of the
918 frame or window do not appear at all. They remain in the buffer,
919 temporarily invisible. Right arrow in the last column (instead of the
920 curved arrow) inform you that truncation is in effect.
922 Truncation instead of continuation happens whenever horizontal
923 scrolling is in use, and optionally in all side-by-side windows (*note
924 Windows::). You can enable truncation for a particular buffer by
925 setting the variable `truncate-lines' to non-`nil' in that buffer.
926 (*Note Variables::.) Altering the value of `truncate-lines' makes it
927 local to the current buffer; until that time, the default value is in
928 effect. The default is initially `nil'. *Note Locals::.
930 *Note Display Vars::, for additional variables that affect how text
934 File: xemacs.info, Node: Position Info, Next: Arguments, Prev: Continuation Lines, Up: Basic
936 Cursor Position Information
937 ===========================
939 If you are accustomed to other display editors, you may be surprised
940 that Emacs does not always display the page number or line number of
941 point in the mode line. In Emacs, this information is only rarely
942 needed, and a number of commands are available to compute and print it.
943 Since text is stored in a way that makes it difficult to compute the
944 information, it is not displayed all the time.
947 Print page number of point, and line number within page.
950 Print line number of point in the buffer.
952 `M-x line-number-mode'
953 Toggle automatic display of current line number.
956 Print number of lines and characters in the current region
957 (`count-lines-region'). *Note Mark::, for information about the
961 Print character code of character after point, character position
962 of point, and column of point (`what-cursor-position').
964 There are several commands for printing line numbers:
966 * `M-x what-line' counts lines from the beginning of the file and
967 prints the line number point is on. The first line of the file is
968 line number 1. You can use these numbers as arguments to `M-x
971 * `M-x what-page' counts pages from the beginning of the file, and
972 counts lines within the page, printing both of them. *Note
973 Pages::, for the command `C-x l', which counts the lines in the
976 * `M-=' (`count-lines-region') prints the number of lines in the
977 region (*note Mark::). *Note Pages::, for the command `C-x l'
978 which counts the lines in the
980 The command `C-x =' (`what-cursor-position') can be used to find out
981 the column that the cursor is in, and other miscellaneous information
982 about point. It prints a line in the echo area that looks like this:
984 Char: c (0143, 99, 0x63) point=18862 of 24800(76%) column 53
986 (In fact, this is the output produced when point is before `column 53'
989 The four values after `Char:' describe the character that follows
990 point, first by showing it and then by giving its character code in
991 octal, decimal and hex.
993 `point=' is followed by the position of point expressed as a
994 character count. The front of the buffer counts as position 1, one
995 character later as 2, and so on. The next, larger number is the total
996 number of characters in the buffer. Afterward in parentheses comes the
997 position expressed as a percentage of the total size.
999 `column' is followed by the horizontal position of point, in columns
1000 from the left edge of the window.
1002 If the buffer has been narrowed, making some of the text at the
1003 beginning and the end temporarily invisible, `C-x =' prints additional
1004 text describing the current visible range. For example, it might say:
1006 Char: c (0143, 99, 0x63) point=19674 of 24575(80%) <19591 - 19703> column 69
1008 where the two extra numbers give the smallest and largest character
1009 position that point is allowed to assume. The characters between those
1010 two positions are the visible ones. *Note Narrowing::.
1012 If point is at the end of the buffer (or the end of the visible
1013 part), `C-x =' omits any description of the character after point. The
1016 point=563026 of 563025(100%) column 0
1019 File: xemacs.info, Node: Arguments, Prev: Position Info, Up: Basic
1024 In mathematics and computer usage, the word "argument" means "data
1025 provided to a function or operation." Any Emacs command can be given a
1026 "numeric argument" (also called a "prefix argument"). Some commands
1027 interpret the argument as a repetition count. For example, giving an
1028 argument of ten to the key `C-f' (the command `forward-char', move
1029 forward one character) moves forward ten characters. With these
1030 commands, no argument is equivalent to an argument of one. Negative
1031 arguments are allowed. Often they tell a command to move or act in
1032 the opposite direction.
1034 If your keyboard has a <META> key (labelled with a diamond on
1035 Sun-type keyboards and labelled `Alt' on some other keyboards), the
1036 easiest way to specify a numeric argument is to type digits and/or a
1037 minus sign while holding down the <META> key. For example,
1040 would move down five lines. The characters `Meta-1', `Meta-2', and so
1041 on, as well as `Meta--', do this because they are keys bound to
1042 commands (`digit-argument' and `negative-argument') that are defined to
1043 contribute to an argument for the next command. Digits and `-'
1044 modified with Control, or Control and Meta, also specify numeric
1047 Another way of specifying an argument is to use the `C-u'
1048 (`universal-argument') command followed by the digits of the argument.
1049 With `C-u', you can type the argument digits without holding down
1050 modifier keys; `C-u' works on all terminals. To type a negative
1051 argument, type a minus sign after `C-u'. Just a minus sign without
1052 digits normally means -1.
1054 `C-u' followed by a character which is neither a digit nor a minus
1055 sign has the special meaning of "multiply by four". It multiplies the
1056 argument for the next command by four. `C-u' twice multiplies it by
1057 sixteen. Thus, `C-u C-u C-f' moves forward sixteen characters. This
1058 is a good way to move forward "fast", since it moves about 1/5 of a line
1059 in the usual size frame. Other useful combinations are `C-u C-n', `C-u
1060 C-u C-n' (move down a good fraction of a frame), `C-u C-u C-o' (make "a
1061 lot" of blank lines), and `C-u C-k' (kill four lines).
1063 Some commands care only about whether there is an argument and not
1064 about its value. For example, the command `M-q' (`fill-paragraph') with
1065 no argument fills text; with an argument, it justifies the text as well.
1066 (*Note Filling::, for more information on `M-q'.) Just `C-u' is a
1067 handy way of providing an argument for such commands.
1069 Some commands use the value of the argument as a repeat count, but do
1070 something peculiar when there is no argument. For example, the command
1071 `C-k' (`kill-line') with argument N kills N lines, including their
1072 terminating newlines. But `C-k' with no argument is special: it kills
1073 the text up to the next newline, or, if point is right at the end of
1074 the line, it kills the newline itself. Thus, two `C-k' commands with
1075 no arguments can kill a non-blank line, just like `C-k' with an
1076 argument of one. (*Note Killing::, for more information on `C-k'.)
1078 A few commands treat a plain `C-u' differently from an ordinary
1079 argument. A few others may treat an argument of just a minus sign
1080 differently from an argument of -1. These unusual cases are described
1081 when they come up; they are always for reasons of convenience of use of
1082 the individual command.
1084 You can use a numeric argument to insert multiple copies of a
1085 character. This is straightforward unless the character is a digit; for
1086 example, `C-u 6 4 a' inserts 64 copies of the character `a'. But this
1087 does not work for inserting digits; `C-u 6 4 1' specifies an argument
1088 of 641, rather than inserting anything. To separate the digit to
1089 insert from the argument, type another `C-u'; for example, `C-u 6 4 C-u
1090 1' does insert 64 copies of the character `1'.
1092 We use the term "prefix argument" as well as "numeric argument" to
1093 emphasize that you type the argument before the command, and to
1094 distinguish these arguments from minibuffer arguments that come after
1098 File: xemacs.info, Node: Undo, Next: Minibuffer, Prev: Basic, Up: Top
1103 Emacs allows you to undo all changes you make to the text of a
1104 buffer, up to a certain amount of change (8000 characters). Each
1105 buffer records changes individually, and the undo command always
1106 applies to the current buffer. Usually each editing command makes a
1107 separate entry in the undo records, but some commands such as
1108 `query-replace' make many entries, and very simple commands such as
1109 self-inserting characters are often grouped to make undoing less
1113 Undo one batch of changes (usually, one command's worth) (`undo').
1118 The command `C-x u' or `C-_' allows you to undo changes. The first
1119 time you give this command, it undoes the last change. Point moves to
1120 the text affected by the undo, so you can see what was undone.
1122 Consecutive repetitions of the `C-_' or `C-x u' commands undo
1123 earlier and earlier changes, back to the limit of what has been
1124 recorded. If all recorded changes have already been undone, the undo
1125 command prints an error message and does nothing.
1127 Any command other than an undo command breaks the sequence of undo
1128 commands. Starting at this moment, the previous undo commands are
1129 considered ordinary changes that can themselves be undone. Thus, you
1130 can redo changes you have undone by typing `C-f' or any other command
1131 that have no important effect, and then using more undo commands.
1133 If you notice that a buffer has been modified accidentally, the
1134 easiest way to recover is to type `C-_' repeatedly until the stars
1135 disappear from the front of the mode line. When that happens, all the
1136 modifications you made have been canceled. If you do not remember
1137 whether you changed the buffer deliberately, type `C-_' once. When you
1138 see Emacs undo the last change you made, you probably remember why you
1139 made it. If the change was an accident, leave it undone. If it was
1140 deliberate, redo the change as described in the preceding paragraph.
1142 Whenever an undo command makes the stars disappear from the mode
1143 line, the buffer contents is the same as it was when the file was last
1146 Not all buffers record undo information. Buffers whose names start
1147 with spaces don't; these buffers are used internally by Emacs and its
1148 extensions to hold text that users don't normally look at or edit.
1149 Minibuffers, help buffers, and documentation buffers also don't record
1152 Emacs can remember at most 8000 or so characters of deleted or
1153 modified text in any one buffer for reinsertion by the undo command.
1154 There is also a limit on the number of individual insert, delete, or
1155 change actions that Emacs can remember.
1157 There are two keys to run the `undo' command, `C-x u' and `C-_',
1158 because on some keyboards, it is not obvious how to type `C-_'. `C-x u'
1159 is an alternative you can type in the same fashion on any terminal.
1162 File: xemacs.info, Node: Minibuffer, Next: M-x, Prev: Undo, Up: Top
1167 The "minibuffer" is the facility used by XEmacs commands to read
1168 arguments more complicated than a single number. Minibuffer arguments
1169 can be file names, buffer names, Lisp function names, XEmacs command
1170 names, Lisp expressions, and many other things, depending on the command
1171 reading the argument. You can use the usual XEmacs editing commands in
1172 the minibuffer to edit the argument text.
1174 When the minibuffer is in use, it appears in the echo area, and the
1175 cursor moves there. The beginning of the minibuffer line displays a
1176 "prompt" which says what kind of input you should supply and how it
1177 will be used. Often this prompt is derived from the name of the command
1178 that the argument is for. The prompt normally ends with a colon.
1180 Sometimes a "default argument" appears in parentheses after the
1181 colon; it, too, is part of the prompt. The default is used as the
1182 argument value if you enter an empty argument (e.g., by just typing
1183 <RET>). For example, commands that read buffer names always show a
1184 default, which is the name of the buffer that will be used if you type
1187 The simplest way to enter a minibuffer argument is to type the text
1188 you want, terminated by <RET> which exits the minibuffer. You can
1189 cancel the command that wants the argument, and get out of the
1190 minibuffer, by typing `C-g'.
1192 Since the minibuffer uses the screen space of the echo area, it can
1193 conflict with other ways XEmacs customarily uses the echo area. Here is
1194 how XEmacs handles such conflicts:
1196 * If a command gets an error while you are in the minibuffer, this
1197 does not cancel the minibuffer. However, the echo area is needed
1198 for the error message and therefore the minibuffer itself is
1199 hidden for a while. It comes back after a few seconds, or as soon
1200 as you type anything.
1202 * If in the minibuffer you use a command whose purpose is to print a
1203 message in the echo area, such as `C-x =', the message is printed
1204 normally, and the minibuffer is hidden for a while. It comes back
1205 after a few seconds, or as soon as you type anything.
1207 * Echoing of keystrokes does not take place while the minibuffer is
1212 * File: Minibuffer File. Entering file names with the minibuffer.
1213 * Edit: Minibuffer Edit. How to edit in the minibuffer.
1214 * Completion:: An abbreviation facility for minibuffer input.
1215 * Minibuffer History:: Reusing recent minibuffer arguments.
1216 * Repetition:: Re-executing commands that used the minibuffer.
projects / chise / xemacs-chise.git.1 / blob