This is ../info/xemacs.info, produced by makeinfo version 4.0 from xemacs/xemacs.texi. INFO-DIR-SECTION XEmacs Editor START-INFO-DIR-ENTRY * XEmacs: (xemacs). XEmacs Editor. END-INFO-DIR-ENTRY This file documents the XEmacs editor. Copyright (C) 1985, 1986, 1988 Richard M. Stallman. Copyright (C) 1991, 1992, 1993, 1994 Lucid, Inc. Copyright (C) 1993, 1994 Sun Microsystems, Inc. Copyright (C) 1995 Amdahl Corporation. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the sections entitled "The GNU Manifesto", "Distribution" and "GNU General Public License" are included exactly as in the original, and provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that the sections entitled "The GNU Manifesto", "Distribution" and "GNU General Public License" may be included in a translation approved by the author instead of in the original English.  File: xemacs.info, Node: Options Menu, Next: Buffers Menu, Prev: Apps Menu, Up: Pull-down Menus The Options Menu ---------------- The Options pull-down menu contains the Read Only, Case Sensitive Search, Overstrike, Auto Delete Selection, Teach Extended Commands, Syntax Highlighting, Paren Highlighting, Font, Size, Weight, Buffers Menu Length..., Buffers Sub-Menus and Save Options menu items. When you select a menu item, Emacs executes the equivalent command. For some of the menu items, there are sub-menus which you will need to select. Read Only Selecting this item will cause the buffer to visit the file in a read-only mode. Changes to the file will not be allowed. This is equivalent to the Emacs command `toggle-read-only' (`C-x C-q'). Case Sensitive Search Selecting this item will cause searches to be case-sensitive. If its not selected then searches will ignore case. This option is local to the buffer. Overstrike After selecting this item, when you type letters they will replace existing text on a one-to-one basis, rather than pushing it to the right. At the end of a line, such characters extend the line. Before a tab, such characters insert until the tab is filled in. This is the same as Emacs command `quoted-insert' (`C-q'). Auto Delete Selection Selecting this item will cause automatic deletion of the selected region. The typed text will replace the selection if the selection is active (i.e. if its highlighted). If the option is not selected then the typed text is just inserted at the point. Teach Extended Commands After you select this item, any time you execute a command with `M-x'which has a shorter keybinding, you will be shown the alternate binding before the command executes. Syntax Highlighting You can customize your init file to include the font-lock mode so that when you select this item, the comments will be displayed in one face, strings in another, reserved words in another, and so on. *Note Init File::. When Fonts is selected, different parts of the program will appear in different Fonts. When Colors is selected, then the program will be displayed in different colors. Selecting None causes the program to appear in just one Font and Color. Selecting Less resets the Fonts and Colors to a fast, minimal set of decorations. Selecting More resets the Fonts and Colors to a larger set of decorations. For example, if Less is selected (which is the default setting) then you might have all comments in green color. Whereas, if More is selected then a function name in the comments themselves might appear in a different Color or Font. Paren Highlighting After selecting Blink from this item, if you place the cursor on a parenthesis, the matching parenthesis will blink. If you select Highlight and place the cursor on a parenthesis, the whole expression of the parenthesis under the cursor will be highlighted. Selecting None will turn off the options (regarding Paren Highlighting) which you had selected earlier. Font You can select any Font for your program by choosing from one of the available Fonts. Size You can select any size ranging from 2 to 24 by selecting the appropriate option. Weight You can choose either Bold or Medium for the weight. Buffers Menu Length... Prompts you for the number of buffers to display. Then it will display that number of most recently selected buffers. Buffers Sub-Menus After selection of this item the Buffers menu will contain several commands, as submenus of each buffer line. If this item is unselected, then there are no submenus for each buffer line, the only command available will be selecting that buffer. Save Options Selecting this item will save the current settings of your Options menu to your init file. *Note Init File::.  File: xemacs.info, Node: Buffers Menu, Next: Tools Menu, Prev: Options Menu, Up: Pull-down Menus The Buffers Menu ---------------- The Buffers menu provides a selection of up to ten buffers and the item List All Buffers, which provides a Buffer List. *Note List Buffers::, for more information.  File: xemacs.info, Node: Tools Menu, Next: Help Menu, Prev: Buffers Menu, Up: Pull-down Menus The Tools Menu -------------- The Tools pull-down menu contains the Grep..., Compile..., Shell Command..., Shell Command on Region..., Debug(GDB)... and Debug(DBX)... menu items, and the Compare, Merge, Apply Patch and Tags sub-menus. When you select a menu item, Emacs executes the equivalent command. For some of the menu items, there are sub-menus which you will need to select.  File: xemacs.info, Node: Help Menu, Next: Menu Customization, Prev: Tools Menu, Up: Pull-down Menus The Help Menu ------------- The Help Menu gives you access to Emacs Info and provides a menu equivalent for each of the choices you have when using `C-h'. *Note Help::, for more information. The Help menu also gives access to UNIX online manual pages via the UNIX Manual Page option.  File: xemacs.info, Node: Menu Customization, Prev: Help Menu, Up: Pull-down Menus Customizing XEmacs Menus ------------------------ You can customize any of the pull-down menus by adding or removing menu items and disabling or enabling existing menu items. The following functions are available: `add-menu: (MENU-PATH MENU-NAME MENU-ITEMS &optional BEFORE)' Add a menu to the menu bar or one of its submenus. `add-menu-item: (MENU-PATH ITEM-NAME FUNCTION' ENABLED-P &optional BEFORE) Add a menu item to a menu, creating the menu first if necessary. `delete-menu-item: (PATH)' Remove the menu item defined by PATH from the menu hierarchy. `disable-menu-item: (PATH)' Disable the specified menu item. `enable-menu-item: (PATH)' Enable the specified previously disabled menu item. `relabel-menu-item: (PATH NEW-NAME)' Change the string of the menu item specified by PATH to NEW-NAME. Use the function `add-menu' to add a new menu or submenu. If a menu or submenu of the given name exists already, it is changed. MENU-PATH identifies the menu under which the new menu should be inserted. It is a list of strings; for example, `("File")' names the top-level File menu. `("File" "Foo")' names a hypothetical submenu of File. If MENU-PATH is `nil', the menu is added to the menu bar itself. MENU-NAME is the string naming the menu to be added. MENU-ITEMS is a list of menu item descriptions. Each menu item should be a vector of three elements: * A string, which is the name of the menu item * A symbol naming a command, or a form to evaluate * `t' or `nil' to indicate whether the item is selectable The optional argument BEFORE is the name of the menu before which the new menu or submenu should be added. If the menu is already present, it is not moved. The function `add-menu-item' adds a menu item to the specified menu, creating the menu first if necessary. If the named item already exists, the menu remains unchanged. MENU-PATH identifies the menu into which the new menu item should be inserted. It is a list of strings; for example, `("File")' names the top-level File menu. `("File" "Foo")' names a hypothetical submenu of File. ITEM-NAME is the string naming the menu item to add. FUNCTION is the command to invoke when this menu item is selected. If it is a symbol, it is invoked with `call-interactively', in the same way that functions bound to keys are invoked. If it is a list, the list is simply evaluated. ENABLED-P controls whether the item is selectable or not. It should be `t', `nil', or a form to evaluate to decide. This form will be evaluated just before the menu is displayed, and the menu item will be selectable if that form returns non-`nil'. For example, to make the `rename-file' command available from the File menu, use the following code: (add-menu-item '("File") "Rename File" 'rename-file t) To add a submenu of file management commands using a File Management item, use the following code: (add-menu-item '("File" "File Management") "Copy File" 'copy-file t) (add-menu-item '("File" "File Management") "Delete File" 'delete-file t) (add-menu-item '("File" "File Management") "Rename File" 'rename-file t) The optional BEFORE argument is the name of a menu item before which the new item should be added. If the item is already present, it is not moved. To remove a specified menu item from the menu hierarchy, use `delete-menu-item'. PATH is a list of strings that identify the position of the menu item in the menu hierarchy. `("File" "Save")' means the menu item called Save under the top level File menu. `("Menu" "Foo" "Item")' means the menu item called Item under the Foo submenu of Menu. To disable a menu item, use `disable-menu-item'. The disabled menu item is grayed and can no longer be selected. To make the item selectable again, use `enable-menu-item'. `disable-menu-item' and `enable-menu-item' both have the argument PATH. To change the string of the specified menu item, use `relabel-menu-item'. This function also takes the argument PATH. NEW-NAME is the string to which the menu item will be changed.  File: xemacs.info, Node: Entering Emacs, Next: Exiting, Prev: Pull-down Menus, Up: Top Entering and Exiting Emacs ************************** The usual way to invoke XEmacs is to type `xemacs ' at the shell. XEmacs clears the screen and then displays an initial advisory message and copyright notice. You can begin typing XEmacs commands immediately afterward. Some operating systems insist on discarding all type-ahead when XEmacs starts up; they give XEmacs no way to prevent this. Therefore, it is advisable to wait until XEmacs clears the screen before typing your first editing command. If you run XEmacs from a shell window under the X Window System, run it in the background with `xemacs&'. This way, XEmacs does not tie up the shell window, so you can use that to run other shell commands while XEmacs operates its own X windows. You can begin typing XEmacs commands as soon as you direct your keyboard input to the XEmacs frame. Before Emacs reads the first command, you have not had a chance to give a command to specify a file to edit. Since Emacs must always have a current buffer for editing, it presents a buffer, by default, a buffer named `*scratch*'. The buffer is in Lisp Interaction mode; you can use it to type Lisp expressions and evaluate them, or you can ignore that capability and simply doodle. (You can specify a different major mode for this buffer by setting the variable `initial-major-mode' in your init file. *Note Init File::.) It is possible to specify files to be visited, Lisp files to be loaded, and functions to be called, by giving Emacs arguments in the shell command line. *Note Command Switches::. But we don't recommend doing this. The feature exists mainly for compatibility with other editors. Many other editors are designed to be started afresh each time you want to edit. You edit one file and then exit the editor. The next time you want to edit either another file or the same one, you must run the editor again. With these editors, it makes sense to use a command-line argument to say which file to edit. But starting a new Emacs each time you want to edit a different file does not make sense. For one thing, this would be annoyingly slow. For another, this would fail to take advantage of Emacs's ability to visit more than one file in a single editing session. And it would lose the other accumulated context, such as registers, undo history, and the mark ring. The recommended way to use XEmacs is to start it only once, just after you log in, and do all your editing in the same Emacs session. Each time you want to edit a different file, you visit it with the existing Emacs, which eventually comes to have many files in it ready for editing. Usually you do not kill the Emacs until you are about to log out. *Note Files::, for more information on visiting more than one file.  File: xemacs.info, Node: Exiting, Next: Command Switches, Prev: Entering Emacs, Up: Top Exiting Emacs ============= There are two commands for exiting Emacs because there are two kinds of exiting: "suspending" Emacs and "killing" Emacs. "Suspending" means stopping Emacs temporarily and returning control to its parent process (usually a shell), allowing you to resume editing later in the same Emacs job, with the same buffers, same kill ring, same undo history, and so on. This is the usual way to exit. "Killing" Emacs means destroying the Emacs job. You can run Emacs again later, but you will get a fresh Emacs; there is no way to resume the same editing session after it has been killed. `C-z' Suspend Emacs or iconify a frame (`suspend-emacs-or-iconify-frame'). If used under the X window system, shrink the X window containing the Emacs frame to an icon (see below). `C-x C-c' Kill Emacs (`save-buffers-kill-emacs'). If you use XEmacs under the X window system, `C-z' shrinks the X window containing the Emacs frame to an icon. The Emacs process is stopped temporarily, and control is returned to the window manager. If more than one frame is associated with the Emacs process, only the frame from which you used `C-z' is iconified. To activate the "suspended" Emacs, use the appropriate window manager mouse gestures. Usually left-clicking on the icon reactivates and reopens the X window containing the Emacs frame, but the window manager you use determines what exactly happens. To actually kill the Emacs process, use `C-x C-c' or the Exit XEmacs item on the File menu. To suspend Emacs, type `C-z' (`suspend-emacs'). This takes you back to the shell from which you invoked Emacs. You can resume Emacs with the shell command `%xemacs' in most common shells. On systems that do not support suspending programs, `C-z' starts an inferior shell that communicates directly with the terminal. Emacs waits until you exit the subshell. (The way to do that is probably with `C-d' or `exit', but it depends on which shell you use.) The only way on these systems to get back to the shell from which Emacs was run (to log out, for example) is to kill Emacs. Suspending also fails if you run Emacs under a shell that doesn't support suspending programs, even if the system itself does support it. In such a case, you can set the variable `cannot-suspend' to a non-`nil' value to force `C-z' to start an inferior shell. (One might also describe Emacs's parent shell as "inferior" for failing to support job control properly, but that is a matter of taste.) When Emacs communicates directly with an X server and creates its own dedicated X windows, `C-z' has a different meaning. Suspending an applications that uses its own X windows is not meaningful or useful. Instead, `C-z' runs the command `iconify-or-deiconify-frame', which temporarily closes up the selected Emacs frame. The way to get back to a shell window is with the window manager. To kill Emacs, type `C-x C-c' (`save-buffers-kill-emacs'). A two-character key is used for this to make it harder to type. Selecting the Exit XEmacs option of the File menu is an alternate way of issuing the command. Unless a numeric argument is used, this command first offers to save any modified file-visiting buffers. If you do not save all buffers, you are asked for reconfirmation with `yes' before killing Emacs, since any changes not saved will be lost forever. If any subprocesses are still running, `C-x C-c' asks you to confirm killing them, since killing Emacs will kill the subprocesses immediately. There is no way to restart an Emacs session once you have killed it. You can, however, arrange for Emacs to record certain session information, such as which files are visited, when you kill it, so that the next time you restart Emacs it will try to visit the same files and so on. The operating system usually listens for certain special characters whose meaning is to kill or suspend the program you are running. This operating system feature is turned off while you are in Emacs. The meanings of `C-z' and `C-x C-c' as keys in Emacs were inspired by the use of `C-z' and `C-c' on several operating systems as the characters for stopping or killing a program, but that is their only relationship with the operating system. You can customize these keys to run any commands of your choice (*note Keymaps::).  File: xemacs.info, Node: Command Switches, Next: Startup Paths, Prev: Exiting, Up: Top Command Line Switches and Arguments =================================== XEmacs supports command line arguments you can use to request various actions when invoking Emacs. The commands are for compatibility with other editors and for sophisticated activities. If you are using XEmacs under the X window system, you can also use a number of standard Xt command line arguments. Command line arguments are not usually needed for editing with Emacs; new users can skip this section. Many editors are designed to be started afresh each time you want to edit. You start the editor to edit one file; then exit the editor. The next time you want to edit either another file or the same one, you start the editor again. Under these circumstances, it makes sense to use a command line argument to say which file to edit. The recommended way to use XEmacs is to start it only once, just after you log in, and do all your editing in the same Emacs process. Each time you want to edit a file, you visit it using the existing Emacs. Emacs creates a new buffer for each file, and (unless you kill some of the buffers) Emacs eventually has many files in it ready for editing. Usually you do not kill the Emacs process until you are about to log out. Since you usually read files by typing commands to Emacs, command line arguments for specifying a file when Emacs is started are seldom needed. Emacs accepts command-line arguments that specify files to visit, functions to call, and other activities and operating modes. If you are running XEmacs under the X window system, a number of standard Xt command line arguments are available, as well as a few X parameters that are XEmacs-specific. Options with long names with a single initial hyphen are also recognized with the GNU double initial hyphen syntax. (The reverse is not true.) The following subsections list: * Command line arguments that you can always use * Command line arguments that have to appear at the beginning of the argument list * Command line arguments that are only relevant if you are running XEmacs under X Command Line Arguments for Any Position --------------------------------------- Command line arguments are processed in the order they appear on the command line; however, certain arguments (the ones in the second table) must be at the front of the list if they are used. Here are the arguments allowed: `FILE' Visit FILE using `find-file'. *Note Visiting::. `+LINENUM FILE' Visit FILE using `find-file', then go to line number LINENUM in it. `-load FILE' `-l FILE' Load a file FILE of Lisp code with the function `load'. *Note Lisp Libraries::. `-funcall FUNCTION' `-f FUNCTION' Call Lisp function FUNCTION with no arguments. `-eval FUNCTION' Interpret the next argument as a Lisp expression, and evaluate it. You must be very careful of the shell quoting here. `-insert FILE' `-i FILE' Insert the contents of FILE into the current buffer. This is like what `M-x insert-buffer' does; *Note Misc File Ops::. `-kill' Exit from Emacs without asking for confirmation. Always the last argument processed, no matter where it appears in the command line. `-version' `-V' Prints version information. This implies `-batch'. % xemacs -version XEmacs 19.13 of Mon Aug 21 1995 on willow (usg-unix-v) [formerly Lucid Emacs] `-help' Prints a summary of command-line options and then exits. Command Line Arguments (Beginning of Line Only) ----------------------------------------------- The following arguments are recognized only at the beginning of the command line. If more than one of them appears, they must appear in the order in which they appear in this table. `--show-dump-id' `-sd' Print the ID for the new portable dumper's dump file on the terminal and exit. (Prints an error message and exits if XEmacs was not configured `--pdump'.) `--no-dump-file' `-nd' Don't load the dump file. Roughly equivalent to old temacs. (Ignored if XEmacs was not configured `--pdump'.) `--terminal FILE' `-t FILE' Use FILE instead of the terminal for input and output. This implies the `-nw' option, documented below. `-batch' Run Emacs in "batch mode", which means that the text being edited is not displayed and the standard Unix interrupt characters such as `C-z' and `C-c' continue to have their normal effect. Emacs in batch mode outputs to `stderr' only what would normally be printed in the echo area under program control. Batch mode is used for running programs written in Emacs Lisp from shell scripts, makefiles, and so on. Normally the `-l' switch or `-f' switch will be used as well, to invoke a Lisp program to do the batch processing. `-batch' implies `-q' (do not load an init file). It also causes Emacs to kill itself after all command switches have been processed. In addition, auto-saving is not done except in buffers for which it has been explicitly requested. `--no-windows' `-nw' Start up XEmacs in TTY mode (using the TTY XEmacs was started from), rather than trying to connect to an X display. Note that this happens automatically if the `DISPLAY' environment variable is not set. `-debug-init' Enter the debugger if an error in the init file occurs. `-debug-paths' Displays information on how XEmacs constructs the various paths into its hierarchy on startup. (See also *note Startup Paths::.) `-unmapped' Do not map the initial frame. This is useful if you want to start up XEmacs as a server (e.g. for gnuserv screens or external client widgets). `-no-init-file' `-q' Do not load your Emacs init file. *Note Init File::. `-no-site-file' Do not load the site-specific init file `lisp/site-start.el'. `-no-autoloads' Do not load global symbol files (`auto-autoloads') at startup. This implies `-vanilla'. `-no-early-packages' Do not process early packages. (For more information on startup issues concerning the package system, *Note Startup Paths::.) `-vanilla' This is equivalent to `-q -no-site-file -no-early-packages'. `-user-init-file FILE' Load FILE as your Emacs init file instead of `~/.xemacs/init.el'/`~/.emacs'. `-user-init-directory DIRECTORY' Use DIRECTORY as the location of your early package hierarchies and the various user-specific initialization files. `-user USER' `-u USER' Equivalent to `-user-init-file ~USER/.xemacs/init.el -user-init-directory ~USER/.xemacs', or `-user-init-file ~USER/.emacs -user-init-directory ~USER/.xemacs', whichever init file comes first. *Note Init File::. Note that the init file can get access to the command line argument values as the elements of a list in the variable `command-line-args'. (The arguments in the second table above will already have been processed and will not be in the list.) The init file can override the normal processing of the other arguments by setting this variable. One way to use command switches is to visit many files automatically: xemacs *.c passes each `.c' file as a separate argument to Emacs, so that Emacs visits each file (*note Visiting::). Here is an advanced example that assumes you have a Lisp program file called `hack-c-program.el' which, when loaded, performs some useful operation on the current buffer, expected to be a C program. xemacs -batch foo.c -l hack-c-program -f save-buffer -kill > log Here Emacs is told to visit `foo.c', load `hack-c-program.el' (which makes changes in the visited file), save `foo.c' (note that `save-buffer' is the function that `C-x C-s' is bound to), and then exit to the shell from which the command was executed. `-batch' guarantees there will be no problem redirecting output to `log', because Emacs will not assume that it has a display terminal to work with. Command Line Arguments (for XEmacs Under X) ------------------------------------------- If you are running XEmacs under X, a number of options are available to control color, border, and window title and icon name: `-title TITLE' `-wn TITLE' `-T TITLE' Use TITLE as the window title. This sets the `frame-title-format' variable, which controls the title of the X window corresponding to the selected frame. This is the same format as `mode-line-format'. `-iconname TITLE' `-in TITLE' Use TITLE as the icon name. This sets the `frame-icon-title-format' variable, which controls the title of the icon corresponding to the selected frame. `-mc COLOR' Use COLOR as the mouse color. `-cr COLOR' Use COLOR as the text-cursor foreground color. `-private' Install a private colormap for XEmacs. In addition, XEmacs allows you to use a number of standard Xt command line arguments. `-background COLOR' `-bg COLOR' Use COLOR as the background color. `-bordercolor COLOR' `-bd COLOR' Use COLOR as the border color. `-borderwidth WIDTH' `-bw WIDTH' Use WIDTH as the border width. `-display DISPLAY' `-d DISPLAY' When running under the X window system, create the window containing the Emacs frame on the display named DISPLAY. `-foreground COLOR' `-fg COLOR' Use COLOR as the foreground color. `-font NAME' `-fn NAME' Use NAME as the default font. `-geometry SPEC' `-geom SPEC' `-g SPEC' Use the geometry (window size and/or position) specified by SPEC. `-iconic' Start up iconified. `-rv' Bring up Emacs in reverse video. `-name NAME' Use the resource manager resources specified by NAME. The default is to use the name of the program (`argv[0]') as the resource manager name. `-xrm' Read something into the resource database for this invocation of Emacs only.  File: xemacs.info, Node: Startup Paths, Next: Packages, Prev: Command Switches, Up: Top How XEmacs finds Directories and Files ====================================== XEmacs deals with a multitude of files during operation. These files are spread over many directories, and XEmacs determines the location of most of these directories at startup and organizes them into various paths. (A "path", for the purposes of this section, is simply a list of directories which XEmacs searches successively in order to locate a file.) XEmacs Directory Hierarchies ---------------------------- Many of the files XEmacs looks for are located within the XEmacs installation itself. However, there are several views of what actually constitutes the "XEmacs installation": XEmacs may be run from the compilation directory, it may be installed into arbitrary directories, spread over several directories unrelated to each other. Moreover, it may subsequently be moved to a different place. (This last case is not as uncommon as it sounds. Binary kits work this way.) Consequently, XEmacs has quite complex procedures in place to find directories, no matter where they may be hidden. XEmacs will always respect directory options passed to `configure'. However, if it cannot locate a directory at the configured place, it will initiate a search for the directory in any of a number of "hierarchies" rooted under a directory which XEmacs assumes contain parts of the XEmacs installation; it may locate several such hierarchies and search across them. (Typically, there are just one or two hierarchies: the hierarchy where XEmacs was or will be installed, and the one where it is being built.) Such a directory containing a hierarchy is called a "root". Whenever this section refers to a directory using the shorthand `', it means that XEmacs searches for it under all hierarchies XEmacs was able to scrounge up. In a running XEmacs, the hierarchy roots are stored in the variable `emacs-roots'. Package Hierarchies ------------------- Many relevant directories and files XEmacs uses are actually not part of the core installation. They are part of any of the many packages usually installed on top of an XEmacs installation. (*Note Packages::.) Hence, they play a prominent role in the various paths XEmacs sets up. XEmacs locates packages in any of a number of package hierarchies. Package hierarchies fall into three groups: "early", "late", and "last", according to the relative location at which they show up in the various XEmacs paths. Early package hierarchies are at the very front, late ones somewhere in the middle, and last hierarchies are (you guessed it) last. By default, XEmacs expects an early package hierarchy in the subdirectory `.xemacs/xemacs-packages' of the user's home directory. Moreover, XEmacs expects late hierarchies in the subdirectories `site-packages', `mule-packages', and `xemacs-packages' (in that order) of the `/lib/xemacs' subdirectory of one of the installation hierarchies. (If you run in-place, these are direct subdirectories of the build directory.) Furthermore, XEmacs will also search these subdirectories in the `/lib/xemacs-' subdirectory and prefer directories found there. By default, XEmacs does not have a pre-configured last package hierarchy. Last hierarchies are primarily for using package hierarchies of outdated versions of XEmacs as a fallback option. For example, it is possible to run XEmacs 21 with the 20.4 package hierarchy as a last hierarchy. It is possible to specify at configure-time the location of the various package hierarchies with the `--package-path' option to configure. The early, late, and last components of the package path are separated by double instead of single colons. If all three components are present, they locate the early, late, and last package hierarchies respectively. If two components are present, they locate the early and late hierarchies. If only one component is present, it locates the late hierarchy. At run time, the package path may also be specified via the `EMACSPACKAGEPATH' environment variable. An XEmacs package is laid out just like a normal installed XEmacs lisp directory. It may have `lisp', `etc', `info', and `lib-src' subdirectories. XEmacs adds these at appropriate places within the various system-wide paths. There may be any number of package hierarchy directories. Directories and Paths --------------------- Here is a list of the various directories and paths XEmacs tries to locate during startup. XEmacs distinguishes between directories and paths specific to "version", "site", and "architecture" when looking for them. `version-specific' directories are specific to the version of XEmacs they belong to and typically reside under `/lib/xemacs-'. `site-specific' directories are independent of the version of XEmacs they belong to and typically reside under `/lib/xemacs' `architecture-specific' directories are specific both to the version of XEmacs and the architecture it runs on and typically reside under `/lib/xemacs-/'. During installation, all of these directories may also reside directly under `', because that is where they are in the XEmacs tarball. If XEmacs runs with the `-debug-paths' option (*note Command Switches::), it will print the values of these variables, hopefully aiding in debugging any problems which come up. `lisp-directory' Contains the version-specific location of the Lisp files that come with the core distribution of XEmacs. XEmacs will search it recursively to a depth of 1 when setting up `load-path'. `load-path' Is where XEmacs searches for XEmacs Lisp files with commands like `load-library'. It contains the package lisp directories (see further down) and the version-specific core Lisp directories. If the environment variable `EMACSLOADPATH' is set at startup, its directories are prepended to `load-path'. `Info-directory-list' Contains the location of info files. (See *Note (info)::.) It contains the package info directories and the version-specific core documentation. Moreover, XEmacs will add `/usr/info', `/usr/local/info' as well as the directories of the environment variable `INFOPATH' to `Info-directory-list'. `exec-directory' Is the directory of architecture-dependent files that come with XEmacs, especially executable programs intended for XEmacs to invoke. `exec-path' Is the path for executables which XEmacs may want to start. It contains the package executable paths as well as `exec-directory', and the directories of the environment variables `PATH' and `EMACSPATH'. `doc-directory' Is the directory containing the architecture-specific `DOC' file that contains documentation for XEmacs' commands. `data-directory' Is the version-specific directory that contains core data files XEmacs uses. It may be initialized from the `EMACSDATA' environment variable. `data-directory-list' Is the path where XEmacs looks for data files. It contains package data directories as well as `data-directory'.  File: xemacs.info, Node: Basic, Next: Undo, Prev: Packages, Up: Top Basic Editing Commands ********************** We now give the basics of how to enter text, make corrections, and save the text in a file. If this material is new to you, you might learn it more easily by running the Emacs learn-by-doing tutorial. To use the tutorial, run Emacs and type `Control-h t' (`help-with-tutorial'). You can also use Tutorials item from the Help menu. XEmacs comes with many translations of tutorial. If your XEmacs is with MULE and you set up language environment correctly, XEmacs chooses right tutorial when available (*note Language Environments::). If you want specific translation, give `C-h t' a prefix argument, like `C-u C-h t'. To clear the screen and redisplay, type `C-l' (`recenter'). * Menu: * Inserting Text:: Inserting text by simply typing it. * Moving Point:: How to move the cursor to the place where you want to change something. * Erasing:: Deleting and killing text. * Files: Basic Files. Visiting, creating, and saving files. * Help: Basic Help. Asking what a character does. * Blank Lines:: Commands to make or delete blank lines. * Continuation Lines:: Lines too wide for the screen. * Position Info:: What page, line, row, or column is point on? * Arguments:: Numeric arguments for repeating a command.  File: xemacs.info, Node: Inserting Text, Next: Moving Point, Up: Basic Inserting Text ============== To insert printing characters into the text you are editing, just type them. This inserts the characters you type into the buffer at the cursor (that is, at "point"; *note Point::). The cursor moves forward, and any text after the cursor moves forward too. If the text in the buffer is `FOOBAR', with the cursor before the `B', then if you type `XX', you get `FOOXXBAR', with the cursor still before the `B'. To "delete" text you have just inserted, use . deletes the character _before_ the cursor (not the one that the cursor is on top of or under; that is the character AFTER the cursor). The cursor and all characters after it move backwards. Therefore, if you type a printing character and then type , they cancel out. To end a line and start typing a new one, type . This inserts a newline character in the buffer. If point is in the middle of a line, splits the line. Typing when the cursor is at the beginning of a line deletes the preceding newline, thus joining the line with the preceding line. Emacs can split lines automatically when they become too long, if you turn on a special minor mode called "Auto Fill" mode. *Note Filling::, for how to use Auto Fill mode. If you prefer to have text characters replace (overwrite) existing text rather than shove it to the right, you can enable Overwrite mode, a minor mode. *Note Minor Modes::. Direct insertion works for printing characters and , but other characters act as editing commands and do not insert themselves. If you need to insert a control character or a character whose code is above 200 octal, you must "quote" it by typing the character `Control-q' (`quoted-insert') first. (This character's name is normally written `C-q' for short.) There are two ways to use `C-q': * `C-q' followed by any non-graphic character (even `C-g') inserts that character. * `C-q' followed by a sequence of octal digits inserts the character with the specified octal character code. You can use any number of octal digits; any non-digit terminates the sequence. If the terminating character is , it serves only to terminate the sequence; any other non-digit is itself used as input after terminating the sequence. (The use of octal sequences is disabled in ordinary non-binary Overwrite mode, to give you a convenient way to insert a digit instead of overwriting with it.) A numeric argument to `C-q' specifies how many copies of the quoted character should be inserted (*note Arguments::). Customization information: , in most modes, runs the command `backward-or-forward-delete-char'; runs the command `newline', and self-inserting printing characters run the command `self-insert', which inserts whatever character was typed to invoke it. Some major modes rebind to other commands.  File: xemacs.info, Node: Moving Point, Next: Erasing, Prev: Inserting Text, Up: Basic Changing the Location of Point ============================== To do more than insert characters, you have to know how to move point (*note Point::). The simplest way to do this is with arrow keys, or by clicking the left mouse button where you want to move to. NOTE: Many of the following commands have two versions, one that uses the function keys (e.g. or ) and one that doesn't. The former versions may only be available on X terminals (i.e. not on TTY's), but the latter are available on all terminals. `C-a' `HOME' Move to the beginning of the line (`beginning-of-line'). `C-e' `END' Move to the end of the line (`end-of-line'). `C-f' `RIGHT' Move forward one character (`forward-char'). `C-b' `LEFT' Move backward one character (`backward-char'). `M-f' `C-RIGHT' Move forward one word (`forward-word'). `M-b' `C-LEFT' Move backward one word (`backward-word'). `C-n' `DOWN' Move down one line, vertically (`next-line'). This command attempts to keep the horizontal position unchanged, so if you start in the middle of one line, you end in the middle of the next. When on the last line of text, `C-n' creates a new line and moves onto it. `C-p' `UP' Move up one line, vertically (`previous-line'). `C-v' `PGDN' Move down one page, vertically (`scroll-up'). `M-v' `PGUP' Move up one page, vertically (`scroll-down'). `C-l' Clear the frame and reprint everything (`recenter'). Text moves on the frame to bring point to the center of the window. `M-r' Move point to left margin, vertically centered in the window (`move-to-window-line'). Text does not move on the screen. A numeric argument says which screen line to place point on. It counts screen lines down from the top of the window (zero for the top line). A negative argument counts lines from the bottom (-1 for the bottom line). `C-t' Transpose two characters, the ones before and after the cursor (`transpose-chars'). `M-<' `C-HOME' Move to the top of the buffer (`beginning-of-buffer'). With numeric argument N, move to N/10 of the way from the top. *Note Arguments::, for more information on numeric arguments. `M->' `C-END' Move to the end of the buffer (`end-of-buffer'). `M-x goto-char' Read a number N and move point to buffer position N. Position 1 is the beginning of the buffer. `M-g' Read a number N and move point to line number N (`goto-line'). Line 1 is the beginning of the buffer. `M-x set-goal-column' Use the current column of point as the "semi-permanent goal column" for `C-n' and `C-p' (`set-goal-column'). Henceforth, those commands always move to this column in each line moved into, or as close as possible given the contents of the line. This goal column remains in effect until canceled. `C-u M-x set-goal-column' Cancel the goal column. Henceforth, `C-n' and `C-p' once again try to avoid changing the horizontal position, as usual. If you set the variable `track-eol' to a non-`nil' value, then `C-n' and `C-p' when at the end of the starting line move to the end of another line. Normally, `track-eol' is `nil'. *Note Variables::, for how to set variables such as `track-eol'. Normally, `C-n' on the last line of a buffer appends a newline to it. If the variable `next-line-add-newlines' is `nil', then `C-n' gets an error instead (like `C-p' on the first line).  File: xemacs.info, Node: Erasing, Next: Basic Files, Prev: Moving Point, Up: Basic Erasing Text ============ `' Delete the character before or after point (`backward-or-forward-delete-char'). You can customize this behavior by setting the variable `delete-key-deletes-forward'. `C-d' Delete the character after point (`delete-char'). `C-k' Kill to the end of the line (`kill-line'). `M-d' Kill forward to the end of the next word (`kill-word'). `M-' Kill back to the beginning of the previous word (`backward-kill-word'). You already know about the key which deletes the character before point (that is, before the cursor). Another key, `Control-d' (`C-d' for short), deletes the character after point (that is, the character that the cursor is on). This shifts the rest of the text on the line to the left. If you type `C-d' at the end of a line, it joins together that line and the next line. To erase a larger amount of text, use the `C-k' key, which kills a line at a time. If you type `C-k' at the beginning or middle of a line, it kills all the text up to the end of the line. If you type `C-k' at the end of a line, it joins that line and the next line. *Note Killing::, for more flexible ways of killing text.  File: xemacs.info, Node: Basic Files, Next: Basic Help, Prev: Erasing, Up: Basic Files ===== The commands described above are sufficient for creating and altering text in an Emacs buffer; the more advanced Emacs commands just make things easier. But to keep any text permanently you must put it in a "file". Files are named units of text which are stored by the operating system for you to retrieve later by name. To look at or use the contents of a file in any way, including editing the file with Emacs, you must specify the file name. Consider a file named `/usr/rms/foo.c'. To begin editing this file from Emacs, type: C-x C-f /usr/rms/foo.c Here the file name is given as an "argument" to the command `C-x C-f' (`find-file'). That command uses the "minibuffer" to read the argument, and you type to terminate the argument (*note Minibuffer::). You can also use the Open... menu item from the File menu, then type the name of the file to the prompt. Emacs obeys the command by "visiting" the file: creating a buffer, copying the contents of the file into the buffer, and then displaying the buffer for you to edit. If you alter the text, you can "save" the new text in the file by typing `C-x C-s' (`save-buffer') or choosing Save Buffer from the File menu. This makes the changes permanent by copying the altered buffer contents back into the file `/usr/rms/foo.c'. Until you save, the changes exist only inside Emacs, and the file `foo.c' is unaltered. To create a file, visit the file with `C-x C-f' as if it already existed or choose Open... from the File menu and provide the name for the new file. Emacs will create an empty buffer in which you can insert the text you want to put in the file. When you save the buffer with `C-x C-s', or by choosing Save Buffer from the File menu, the file is created. To learn more about using files, *Note Files::.  File: xemacs.info, Node: Basic Help, Next: Blank Lines, Prev: Basic Files, Up: Basic Help ==== If you forget what a key does, you can find out with the Help character, which is `C-h' (or , which is an alias for `C-h'). Type `C-h k' followed by the key you want to know about; for example, `C-h k C-n' tells you all about what `C-n' does. `C-h' is a prefix key; `C-h k' is just one of its subcommands (the command `describe-key'). The other subcommands of `C-h' provide different kinds of help. Type `C-h' twice to get a description of all the help facilities. *Note Help::.  File: xemacs.info, Node: Blank Lines, Next: Continuation Lines, Prev: Basic Help, Up: Basic Blank Lines =========== Here are special commands and techniques for putting in and taking out blank lines. `C-o' Insert one or more blank lines after the cursor (`open-line'). `C-x C-o' Delete all but one of many consecutive blank lines (`delete-blank-lines'). When you want to insert a new line of text before an existing line, you can do it by typing the new line of text, followed by . However, it may be easier to see what you are doing if you first make a blank line and then insert the desired text into it. This is easy to do using the key `C-o' (`open-line'), which inserts a newline after point but leaves point in front of the newline. After `C-o', type the text for the new line. `C-o F O O' has the same effect as `F O O ', except for the final location of point. You can make several blank lines by typing `C-o' several times, or by giving it a numeric argument to tell it how many blank lines to make. *Note Arguments::, for how. If you have a fill prefix, then `C-o' command inserts the fill prefix on the new line, when you use it at the beginning of a line. *Note Fill Prefix::. The easy way to get rid of extra blank lines is with the command `C-x C-o' (`delete-blank-lines'). `C-x C-o' in a run of several blank lines deletes all but one of them. `C-x C-o' on a solitary blank line deletes that blank line. When point is on a nonblank line, `C-x C-o' deletes any blank lines following that nonblank line.  File: xemacs.info, Node: Continuation Lines, Next: Position Info, Prev: Blank Lines, Up: Basic Continuation Lines ================== If you add too many characters to one line without breaking it with , the line will grow to occupy two (or more) lines on the screen, with a curved arrow at the extreme right margin of all but the last of them. The curved arrow says that the following screen line is not really a distinct line in the text, but just the "continuation" of a line too long to fit the screen. Continuation is also called "line wrapping". Sometimes it is nice to have Emacs insert newlines automatically when a line gets too long. Continuation on the screen does not do that. Use Auto Fill mode (*note Filling::) if that's what you want. Instead of continuation, long lines can be displayed by "truncation". This means that all the characters that do not fit in the width of the frame or window do not appear at all. They remain in the buffer, temporarily invisible. Right arrow in the last column (instead of the curved arrow) inform you that truncation is in effect. Truncation instead of continuation happens whenever horizontal scrolling is in use, and optionally in all side-by-side windows (*note Windows::). You can enable truncation for a particular buffer by setting the variable `truncate-lines' to non-`nil' in that buffer. (*Note Variables::.) Altering the value of `truncate-lines' makes it local to the current buffer; until that time, the default value is in effect. The default is initially `nil'. *Note Locals::. *Note Display Vars::, for additional variables that affect how text is displayed.