Mercurial > emacs
diff etc/OTHER.EMACSES @ 25853:e96ffe544684
#
| author | Dave Love <fx@gnu.org> |
|---|---|
| date | Sun, 03 Oct 1999 12:39:42 +0000 |
| parents | |
| children | 23a1cea22d13 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/etc/OTHER.EMACSES Sun Oct 03 12:39:42 1999 +0000 @@ -0,0 +1,1049 @@ +How is this Emacs different from all other Emacses? -*-Outline-*- + +This file describes the differences between GNU Emacs 19, Twenex +Emacs, Gosling Emacs (including the commercial versions by Unipress) +and CCA Emacs. + +* Copyright (c) 1985 Richard M. Stallman + + Permission is granted to anyone to make or distribute verbatim copies + of this document as received, in any medium, provided that the + copyright notice and permission notice are preserved, + and that the distributor grants the recipient permission + for further redistribution as permitted by this notice. + + Permission is granted to distribute modified versions + of this document, or of portions of it, + under the above conditions, provided also that they + carry prominent notices stating who last changed them. + +Updated March 1993 for Emacs 19 by Eric S. Raymond + + +* How is this Emacs different from Twenex Emacs? + +** Fundamental concepts. + +*** There is no concept of "typeout" in GNU Emacs. + +Any time that a command wants to display some output, +it creates a buffer (usually with a name surrounded by asterisks) +and displays it in a window. + +This provides some advantages: + you can edit some more while looking at the output; + you can copy parts of the output into other buffers. + +It also has a disadvantage that you must type a command +in order to make the output disappear. +You can use C-x 1 to get rid of all windows except the +selected one. To be more selective, you can switch to +the window you want to get rid of and then type C-x 0 +(delete-window). + +You also need to type a command to scroll the other +window if not all the output fits in it. Meta-Control-v +will usually do the job. + +*** There is no concept of a "subsystem" in GNU Emacs. + +Where Twenex Emacs would use a subsystem, GNU Emacs +instead creates a buffer and redefines commands in it. + +For example, when you send mail in GNU Emacs, you use +a buffer named *mail* which is in Mail Mode. You can +switch away from this buffer to any other buffer and +resume normal editing; then switch back and resume +composing mail. You do not have to "exit" from +composing mail in order to do ordinary editing. + +This has many advantages, but it also has a disadvantage: +Subsystems in Emacs tend to have "exit" commands that return you +to whatever you were doing before entering the subsystem. +In GNU Emacs the idea of what to return to is not well defined, +so it is not clear what an "exit" command should do. +The only way to "exit" in general is to type C-x b, C-x C-f, or +some other suitable command to switch buffers. Some +subsystem-like major modes, such as Info and Mail mode, provide +commands to "exit" by switching to the previously selected +buffer. + +*** Files are always visited in their own buffers. + +Beginning users of Twenex Emacs were told how to edit +using a single buffer and reading one file after another +into that buffer. Use of a new buffer for each file was +regarded as a more advanced mode. + +In GNU Emacs, the idea of using a single buffer for various +files, one by one, has been dropped, given that the address +space is expected to be large enough for many buffers. C-x +C-f (find-file), which behaves nearly the same as in Twenex +Emacs, is in GNU Emacs the canonical way for all users to +visit files. + +Various commands need to read files into Emacs in the course +of their execution. In Twenex Emacs the user must tell them +whether to reuse buffers or create new ones, using the variable +Tags Find File. In GNU Emacs, these commands always use +C-x C-f. + +The command C-x C-v does still exist; it kills the current +buffer and reads the specified file into a new buffer. +It is equivalent to kill-buffer followed by find-file. + +Since there is no reusing of buffers, there is no point in +calling the initial buffer "main". So the initial buffer +in GNU Emacs is called "*scratch*" and is intended for typing +Lisp expressions to be evaluated. + +*** File name defaulting. + +GNU Emacs records a separate working directory for each buffer. +Normally this is the directory on which the buffer's file +resides; for buffers not visiting any file, it is copied from +the buffer that was current when it was created. The current buffer's +working directory can be printed with M-x pwd and set with M-x cd. + +GNU Emacs shows you the default directory by inserting it in +the minibuffer when a file name is being read. You can type +the filename you want at the end of the default as if the +default were not there, or you can edit and alter the default. + +If you want file /lose/big when the default /foo/defaultdir/ +has been inserted for you, you need not kill the default; simply +type at the end of it: /foo/defaultdir//lose/big. Such a file +name is not ordinarily considered valid, but GNU Emacs +considers it equivalent to /lose/big. + +Likewise, if you want file quux in your home directory, just add +~/quux to the end of the supplied text, to get +/foo/defaultdir/~/quux. GNU Emacs sees "/~" and throws away +everything before the "~". + +You can refer to environment variables also within file names. +$ followed by the environment variable name is replaced by the +variable's value. The variable name should either be followed +by a nonalphanumeric character (which counts as part of the +file name) or be surrounded by braces {...} (which do not count +as part of the file name). Thus, if variable USER has value "rms", +"x/$USER-foo" is expanded to "x/rms-foo", and "x${USER}foo" +is expanded to "xrmsfoo". Note that this substitution is not +performed by the primitive file operation functions of GNU Emacs, +but rather by the interactive file name reader. It is also +available as a separate primitive, in the function +substitute-in-file-name. + +*** Exit commands C-z, C-x C-c and C-x C-z. + +There are two ways to exit GNU Emacs: killing and suspending. +Killing is like what Control-c does to ordinary Unix programs. +In GNU Emacs, you type C-x C-c to kill it. (This offers to +save any modified file buffers before really killing Emacs.) +Suspending is like what Control-z does to ordinary Unix programs. +To suspend GNU Emacs, type C-x C-z, or type just C-z. +Note that C-z suspends ordinary programs instantly, but +Emacs does not suspend until it reads the C-z. + +Usually it is better to suspend: once a system is smart +enough to have job control, why ever kill an editor? +You'll just have to make a new one in a minute. +This is why the convenient command C-z is provided for +suspending. + +C-c is used as a prefix key for mode-specific commands and for users' +own commands. We deliberately do not make C-c ever kill Emacs, +because it should not be so easy to do something irreversible. + +*** Quitting with C-g. + +If you type C-g while GNU Emacs is waiting for input, it +is an ordinary command (which is defined to beep). If you +type C-g while Lisp code is executing, it sets a flag which +causes a special signal, nearly the same as an error, to +happen at the next safe place in Lisp execution. This usually +has the effect of aborting the current command in a safe way. + +Because at times there have been bugs causing GNU Emacs to loop +without checking the quit flag, a special feature causes +GNU Emacs to be suspended immediately if you type a second C-g +while the flag is already set. So you can always get out +of GNU Emacs. Normally GNU Emacs recognizes and clears the quit flag +quickly enough to prevent this from happening. + +When you resume GNU Emacs after a suspension caused by multiple C-g, it +asks two questions before resuming execution: + Checkpoint? + Dump core? +Answer each one with `y' or `n' and a Return. + `y' to Checkpoint? causes immediate auto-saving of all + buffers in which auto-saving is enabled. + `y' to Dump core? causes an illegal instruction to be executed. + This is to enable a wizard to figure out why GNU Emacs was + looping without checking for quits. Execution does not continue + after a core dump. If you answer `n', execution continues. +With luck, GNU Emacs will ultimately check the quit flag, +and quit normally. If not, and you type another C-g, it +is suspended again. + +If GNU Emacs is not really hung, just slow, you may invoke +the double C-g feature without really meaning to. Then just +resume and answer `n' to both questions, and you will +arrive at your former state. Presumably the quit you +wanted will finish happening soon. + +These questions are not asked if you suspend GNU Emacs with the C-z +command. Continuing GNU Emacs after a C-z takes you straight back +into editing. + +*** Undoing with C-x u or C-_ + +You can undo many commands--up to 10,000 characters worth. +Each time you type C-x u or C-_, another command or batch of change +is undone. Undo information is stored per buffer, and the undo +command always applies to the current buffer. A numeric argument +serves as a repeat count. + +Consecutive self-inserting characters are undone in groups of twenty. + +*** Different character set. + +GNU Emacs does not expect anyone ever to have a keyboard in which +the Control key sets an independent bit which may accompany any +character. The only control characters that can exist are the +ASCII control characters. + +There is, as a result, no "control prefix" character. + +*** Control-h is the Help character. + +I'm amazed it took me so long to get this idea. In Twenex Emacs, C-h +and C-b are equivalent commands, making C-h redundant. C-h is not +only easy to type, it is mnemonic for "Help". So in GNU Emacs the +Help character is C-h. + +*** Completion is done by TAB, not ESC. + +ESC in the minibuffer is a Meta prefix, same as at top level. + +*** The string-argument reader is the minibuffer is an editor window. + +In GNU Emacs, the line at the bottom of the screen is the minibuffer. +Commands that want string arguments always use this line to read them, +and you can use the ordinary Emacs editing commands to edit the +input. You can terminate input with Return because Return is defined +as the exit-minibuffer command when in the minibuffer. If you +are using a command that needs several arguments, terminate each +one with Return. You cannot separate arguments with Escape +the way you would in Twenex Emacs. + +The minibuffer window does not overlay other editor windows; +it is a nearly ordinary editor window which lacks a mode line +and is "turned off" when not in use. While it IS in use, you +can switch windows to and from the minibuffer, kill text in other +windows and yank in the minibuffer, etc. + +You can even issue a command that uses the minibuffer while in the +minibuffer. This gets you temporarily into a recursive minibuffer. +However, this is allowed only if you enable it, since it could be +confusing for beginners. + +When you exit the minibuffer, the cursor immediately moves back to +column zero of the minibuffer line, to show you that the exit +command has been obeyed. The minibuffer contents remain on the screen +until the end of the command, unless some other text is displayed there. + +A single Control-g exits the minibuffer. + +*** There are no &'s or ^R's or spaces in function names. + +For example, the function which is called ^R Forward Word +in Twenex Emacs is called forward-word in GNU Emacs. + +*** The extension language is Lisp rather than TECO. + +Libraries must be written in Lisp. Meta-ESC reads a Lisp +expression, evaluates it, and prints the result. Note that +Meta-ESC is "disabled" by default, so that beginning users +do not get into the minibuffer by accident in a confusing way. + +Data types available include integers (which double as characters), +strings, symbols, lists, vectors, buffers, buffer pointers, +windows, and process channels. + +For now, to learn about writing Lisp code for GNU Emacs, read some of +the source code, which is in directory ../lisp. Read the GNU Emacs Lisp +Reference Manual. Also, all Lisp primitives have self-documentation you can +read with C-h f. + +*** Enabling the error handler. + +GNU Emacs has a Lisp debugger/stepper/trace package, but normally +errors do not enter the debugger because that is slow, and unlikely to +be of interest to most users. Set the variable debug-on-error to t to +cause errors to invoke the debugger. Set debug-on-quit to cause quit +signals (caused by C-g) to invoke the debugger. + +** Other changes. + +*** More than two windows are allowed. + +C-x 2 splits the current window into two windows, + one above the other. Initially they both display + the same buffer. + + C-x 2 now accepts a numeric argument to specify the number of + lines to give to the uppermost of the two windows it makes. + +C-x 0 kills the current window, making all others larger. +C-x 1 kills all windows except the current one. +C-x O switches to the next window down. + It rotates from the bottom one to the top one. + An argument serves as a repeat count; negative arguments + circulate in the reverse order. + +If the same buffer is displayed in several windows, +changes made in it are redisplayed in all of them. + +*** Side by side windows are supported. + +The command C-x 3 splits the current window into +two side-by-side windows. + +C-x } makes the selected window ARG columns wider at the +expense of the windows at its sides. C-x { makes the selected +window ARG columns narrower. An argument to C-x 5 specifies +how many columns to give to the leftmost of the two windows made. + +*** Horizontal scrolling of the lines in a window is implemented. + +C-x < (scroll-left) scrolls all displayed lines left, +with the numeric argument (default 1) saying how far to scroll. +When the window is scrolled left, some amount of the beginning +of each nonempty line is replaced by an "$". +C-x > scrolls right. If a window has no text hidden at the left +margin, it cannot be scrolled any farther right than that. +When nonzero leftwards scrolling is in effect in a window. +lines are automatically truncated at the window's right margin +regardless of the value of the variable truncate-lines in the +buffer being displayed. + +*** Return key does not use up empty lines. + +In Twenex Emacs, the Return command advances over an existing +empty line in some cases. In GNU Emacs, the Return command always +makes inserts a newline. Twenex Emacs was designed at a time when +most display terminals did not have the ability to scroll part +of the screen, and using existing empty lines made redisplay faster. +Nowadays, terminals that cannot scroll part of the screen are rare, +so there is no need to make Return behave in a more complicated manner. + +*** Help m. + +Typing C-h m displays documentation of the current major mode., +telling you what special commands and features are available +and how to use them or get more information on them. + +This is simply the documentation, as a function, of the +symbol which is the value of major-mode. Each major mode +function has been given documentation intended for C-h m. + +*** Display-hiding features. + +**** Hiding indented lines + +The command C-x $ with numeric argument N causes lines indented by N +or more columns to become invisible. All you see is " ..." appended +to the previous line, in place of any number of consecutive invisible +lines. + +**** Outline Mode. + +Outline mode is designed for editing outline-structured +files, such as this one. + +Headings should be lines starting with one or more asterisks. +Major headings have one asterisk, subheadings two, etc. +Lines not starting with asterisks are body text. + +You can make the body under a heading, or the subheadings +under a heading, temporarily invisible, or visible again. +Invisible lines are attached to the end of the previous line +so they go with it if you kill it and yank it back. + +Commands: +Meta-} next-visible-heading move by visible headings +Meta-{ previous-visible-heading move by visible headings + +Meta-x hide-body make all body text invisible (not headings). +Meta-x show-all make everything in buffer visible. + +The remaining commands are used when dot is on a heading line. +They apply to some of the body or subheadings of that heading. +C-c C-h hide-subtree make text and subheadings invisible. +C-c C-s show-subtree make text and subheadings visible. +C-c C-i show-children make direct subheadings visible. + No effect on body, or subheadings 2 or more levels down. + With arg N, affects subheadings N levels down. +M-x hide-entry make immediately following body invisible. +M-x show-entry make it visible. +M-x hide-leaves make text under heading and under its subheadings invisible. + The subheadings remain visible. +M-x show-branches make all subheadings at all levels visible. + +*** C mode is fancy. + +C mode assumes that you put the initial open-brace of +a function definition at the beginning of a line. +If you use the popular indenting style that puts this +open-brace at the end of a line containing a type declaration, +YOU WILL LOSE: C mode does not know a function starts there. + +Open-brace at the beginning of a line makes it possible +for C mode to find function boundaries with total reliability; +something I consider vital and which cannot be done +if the other style is used. + +The Tab command indents C code very cleverly. +I know of only one cases in which Tab does not indent C code nicely: + Expressions continued over several lines with few parentheses. + Tab does not know the precedences of C operators, so it does + not know which lines of the expression should go where. + Using parentheses to indicate the nesting of operators + except within a line makes this problem go away. + +The indenting algorithm is entirely written in Lisp. + +Tab with a numeric argument in Twenex Emacs indents +that many lines. It is different in GNU Emacs: it means +to shift all the lines of a bracketed expression by the +same amount as the line being indented. For example, if you have + if (foo) + { + hack (); + /** Well? */ + } +and type C-u Tab on the line with the open brace, you get + if (foo) + { + hack (); + /* Well? */ + } +from indenting the brace line and then shifting the +lines within the braces rigidly with the first one. + +Meta-Control-q works as in Lisp mode; it should be +used with dot just before a bracketed grouping, and +indents each line INSIDE that grouping using Tab. +If used instead of C-u Tab in the previous example, it makes + if (foo) + { + hack (); + /* Well? */ + } + +Meta-Control-h puts mark at the end of the current C function +and puts dot before it. + +Most other Meta-Control commands intended for Lisp expressions +work usefully in C mode as well. + +*** Meta-g (fill-region) is different. + +In Twenex Emacs, Meta-g fills the region with no paragraph +boundaries except for blank and indented lines. In GNU Emacs, +it divides the region into paragraphs in the same manner as +Meta-], and fills each paragraph separately. There is also +the function fill-region-as-paragraph which fills the region +regarding at as a single paragraph regardless even of blank +or indented lines. + +*** Indented Text Mode instead of Edit Indented Text. + +Twenex Emacs has a command Edit Indented Text which temporarily +alters some commands for editing indented paragraphs. +GNU Emacs has instead a separate major mode, Indented Text Mode, +which is different from ordinary Text Mode in just the same +alterations. Specifically, in Indented Text Mode, +Tab runs the function indent-relative, and auto filling indents +the newly created lines. + +*** But rectangle commands are implemented. + +C-x r r stores the rectangle described by dot and mark +into a register; it reads the register name from the keyboard. +C-x r g, the command to insert the contents of a register, +can be used to reinsert the rectangle elsewhere. + +Other rectangle commands include + open-rectangle: + insert a blank rectangle in the position and size + described by dot and mark, at its corners; + the existing text is pushed to the right. + clear-rectangle: + replace the rectangle described by dot ane mark + with blanks. The previous text is deleted. + delete-rectangle: + delete the text of the specified rectangle, + moving the text beyond it on each line leftward. + kill-rectangle + like delete-rectangle but also stores the text of + the rectangle in the "rectangle kill buffer". + More precisely, it stores the text as a list of strings + (one string for each line) in the variable killed-rectangle. + yank-rectangle + inserts the text of the last killed rectangle. + extract-rectangle and delete-extract-rectangle + these functions return the text of a rectangle + as a list of strings. They are for use in writing + other functions that operate on rectangles. + +*** Keyboard Macros + +The C-x ( command for defining a keyboard macro can in GNU Emacs +be given a numeric argument, which means that the new macro +starts out not empty but rather as the same as the last +keyboard macro entered. In addition, that last keyboard +macro is replayed when the C-x ( is typed. C-x ( with an +argument is thus equivalent to typing plain C-x ( and then +retyping the last keyboard macro entered. + +The command write-kbd-macro and append-kbd-macro can be used to +save a keyboard macro definition in a file. It is represented as +a Lisp expression which, when evaluated, will define the keyboard +macro. write-kbd-macro writes the specified file from scratch, +whereas append-kbd-macro adds to any existing text in the file. +Both expect the keyboard macro to be saved to be specified by +name; this means you must use the command name-last-kbd-macro to +give the macro a name before you can save it. + +*** The command to resume a terminated tags-search or tags-query-replace + +is Meta-comma in GNU Emacs. + +*** Auto Save is on by default. + +Auto Save mode is enabled by default in all buffers +that are visiting files. + +The file name used for auto saving is made by prepending +"#" to the file name visited. + +*** Backup files. + +Since Unix stupidly fails to have file version numbers, +GNU Emacs compensates slightly in the customary fashion: +when a file is modified and saved for the first time in +a particular GNU Emacs run, the original file is renamed, +appending "~" to its name. Thus, foo.c becomes foo.c~. + +Emacs can also put a version number into the name of the backup file, +as in foo.c.~69~ for version number 69. This is an optional feature +that the user has to enable. + +*** Mode Line differences. + +Each window in GNU Emacs has its own mode line, which always +displays the status of that window's buffer and nothing else. +The mode line appears at the bottom of the window. It is +full of dashes, to emphasize the boundaries between windows, +and is displayed in inverse video if the terminal supports it. +The information usually available includes: + +*** Local Modes feature changed slightly. + +GNU Emacs supports local mode lists much like those in Twenex Emacs, +but you can only set variables, not commands. You write + +Local variables: +tab-width: 10 +end: + +in the last page of a file, if you want to make tab-width be ten in a +file's buffer. The value you specify must be a Lisp object! +It will be read, but not evaluated. So, to specify a string, +you MUST use doublequotes. For "false", in variables whose +meanings are true or false, you MUST write nil . + +Two variable names are special: "mode" and "eval". +Mode is used for specifying the major mode (as in Twenex Emacs). + +mode: text + +specifies text mode. Eval is used for requesting the evaluation +of a Lisp expression; its value is ignored. Thus, + +eval: (set-syntax-table lisp-mode-syntax-table) + +causes Lisp Mode syntax to be used. + + +Note that GNU Emacs looks for the string "Local variables:" +whereas Twenex Emacs looks for "Local modes:". This incompatibility +id deliberate, so that neither one will see local settings +intended for the other. + +*** Lisp code libraries. + +Libraries of commands, and init files, are written in Lisp. +libraries conventionally have names ending in .el, while the +init file is named .emacs and is in your home directory. + +Use Meta-x load-library to load a library. Most standard libraries +load automatically if you try to use the commands in them. + +Meta-x byte-compile-file filename +compiles the file into byte code which loads and runs faster +than Lisp source code. The file of byte code is given a name +made by appending "c" to the end of the input file name. + +Meta-x byte-recompile-directory directoryname +compiles all files in the specified directory (globbing not allowed) +which have been compiled before but have been changed since then. + +Meta-x load-library automatically checks for a compiled file +before loading the source file. + +Libraries once loaded do not retain their identity within GNU +Emacs. Therefore, you cannot tell just what was loaded from a +library, and you cannot un-load a library. Normally, libraries +are written so that loading one has no effect on the editing +operations that you would have used if you had not loaded the +library. + +*** Dired features. + +You can do dired on partial directories --- any pattern +the shell can glob. Dired creates a buffer named after +the directory or pattern, so you can dired several different +directories. If you repeat dired on the same directory or +pattern, it just reselects the same buffer. Use Meta-x Revert +on that buffer to read in the current contents of the directory. + +*** Directory listing features. + +C-x C-d now uses the default output format of `ls', +which gives just file names in multiple columns. +C-u C-x C-d passes the -l switch to `ls'. + +Both read a directory spec from the minibuffer. It can +be any pattern that the shell can glob. + +*** Compiling other programs. + +Meta-x compile allows you to run make, or any other compilation +command, underneath GNU Emacs. Error messages go into a buffer whose +name is *compilation*. If you get error messages, you can use the +command C-x ` (that is a backquote) to find the text of the next +error message. + +You must specify the command to be run as an argument to M-x compile. +A default is placed in the minibuffer; you can kill it and start +fresh, edit it, or just type Return if it is what you want. +The default is the last compilation command you used; initially, +it is "make -k". + +*** Searching multiple files. + +Meta-x grep searches many files for a regexp by invoking grep +and reading the output of grep into a buffer. You can then +move to the text lines that grep found, using the C-x ` command +just as after M-x compile. + +*** Running inferior shells. + +Do Meta-x shell to make an inferior shell together with a buffer +which serves to hold "terminal" input and output of the shell. +The shell used is specified by the environment variable ESHELL, +or by SHELL if ESHELL is not set. + +Use C-h m whilst in the *shell* buffer to get more detailed info. + +The inferior shell loads the file .emacs_csh or.emacs_sh +(or similar using whatever name the shell has) when it starts up. + +M-! executes a shell command in an inferior shell +and displays the output from it. With a prefix argument, +it inserts the output in the current buffer after dot +and sets the mark after the output. The shell command +gets /dev/null as its standard input. + +M-| is like M-! but passes the contents of the region +as input to the shell command. A prefix argument makes +the output from the command replace the contents of the region. + +*** Sending mail. + +Once you enter Mail Mode using C-x m or C-x 4 m or M-x mail, +C-c becomes a prefix character for mail-related editing commands. +C-c C-s is vital; that's how you send the message. C-c C-c sends +and then switches buffers or kills the current window. +Use C-h m to get a list of the others. + +*** Regular expressions. + +GNU Emacs has regular expression facilities like those of most +Unix editors, but more powerful: + +**** -- + -- + ++ specifies repetition of the preceding expression 1 or more +times. It is in other respect like *, which specifies repetition +0 or more times. + +**** -- ? -- + +? is like * but matches at most one repetition of the preceding +expression. + +**** -- \| -- + +\| specifies an alternative. Two regular expressions A and B with \| in +between form an expression that matches anything that either A or B will +match. Thus, "foo\|bar" matches either "foo" or "bar" but no other +string. + +\| applies to the larges possible surrounding expressions. Only a +surrounding \( ... \) grouping can limit the grouping power of \|. + +Full backtracking capability exists when multiple \|'s are used. + +**** -- \( ... \) -- + +\( ... \) are a grouping construct that serves three purposes: + +1. To enclose a set of \| alternatives for other operations. + Thus, "\(foo\|bar\)x" matches either "foox" or "barx". +2. To enclose a complicated expression for * to operate on. + Thus, "ba\(na\)*" matches "bananana", etc., with any number + of na's (zero or more). +3. To mark a matched substring for future reference. + +Application 3 is not a consequence of the idea of a parenthetical +grouping; it is a separate feature which happens to be assigned as a +second meaning to the same \( ... \) construct because there is no +conflict in practice between the two meanings. Here is an explanation +of this feature. + + -- \digit -- + +After the end of a \( ... \) construct, the matcher remembers the +beginning and end of the text matched by that construct. Then, later on +in the regular expression, you can use \ followed by a digit to mean, +``match the same text matched this time by the \( ... \) construct.'' +The first nine \( ... \) constructs that appear in a regular expression +are assigned numbers 1 through 9 in order of their beginnings. \1 +through \9 can be used to refer to the text matched by the corresponding +\( ... \) construct. + +For example, "\(.*\)\1" matches any string that is composed of two +identical halves. The "\(.*\)" matches the first half, which can be +anything, but the \1 that follows must match the same exact text. + +**** -- \` -- + +Matches the empty string, but only if it is at the beginning of the buffer. + +**** -- \' -- + +Matches the empty string, but only if it is at the end of the buffer. + +**** -- \b -- + +Matches the empty string, but only if it is at the beginning or end of +a word. Thus, "\bfoo\b" matches any occurrence of "foo" as a separate word. +"\bball\(s\|\)\b" matches "ball" or "balls" as a separate word. + +**** -- \B -- + +Matches the empty string, provided it is NOT at the beginning or end of +a word. + +**** -- \< -- + +Matches the empty string, provided it is at the beginning of a word. + +**** -- \> -- + +Matches the empty string, provided it is at the end of a word. + +**** -- \w -- + +Matches any word-constituent character. The editor syntax table determines +which characters these are. + +**** -- \W -- + +Matches any character that is not a word-constituent. + +**** -- \s<code> -- + +Matches any character whose syntax is <code>. <code> is a letter that +represents a syntax code: thus, "w" for word constituent, "-" for +whitespace, "(" for open-parenthesis, etc. Thus, "\s(" matches any +character with open-parenthesis syntax. + +**** -- \S<code> -- + +Matches any character whose syntax is not <code>. + +* How is this Emacs different from Gosling Emacs? + +** Advantages of Gosling Emacs: + +1. The program itself is much smaller. +GNU Emacs uses about 250k more pure storage. +As a result, Gosling Emacs can run on machines +that cannot run GNU Emacs. There is not much difference +in the amount of impure storage in the two programs. + +2. In some versions there is support for other forks to +establish communications channels to Emacs (using sockets?). + +3. There is a direct interface to dbm (data bases). + +** Advantages of GNU Emacs: + +*** True Lisp, not Mocklisp. + +GNU Emacs's extension language has real symbols, lists +and vectors. Many extensions are much simpler, and some +become possible that were nearly impossible in Gosling Emacs. +Many primitives can have cleaner interfaces, and some features +need not be put in as special primitives because you can do +them easily yourself. + +*** But Mocklisp still works. + +An automatic conversion package plus a run-time library +allows you to convert a Mocklisp library into a Lisp library. + +*** Commands are better crafted. + +For example, nearly every editing function for which a +numeric argument would make sense as a repeat count does +accept a repeat count, and does handle a negative argument +in the way you would expect. + +*** The manual is clearer. + +Everyone tells me it is a very good manual. + +*** Better on-line documentation. + +Both functions and variables have documentation strings that +describe exactly how to use them. + +*** C mode is smart. + +It really knows how to indent each line correctly, +for most popular indentation styles. (Some variables +control which style is used; popular named styles are also supported.) + +*** Compatible with PDP-10 Emacs, Multics Emacs and Zmacs. + +The commands in GNU Emacs are nearly the same as in the +original Emacs and the other Emacses which imitated it. +(A few have been changed to fit the Unix environment better.) + +*** Support for Gosling's Emacs commands. + +M-x set-gosmacs-bindings rebinds many editing commands for +compatibility with Gosling's Emacs. +M-x set-gnu-bindings reverses the change. + +*** Side-by-side windows. + +You can split a GNU Emacs window either horizontally or +vertically. + +*** Redisplay is faster. + +GNU Emacs sends about the same stuff to the terminal that +Gosling's does, but GNU Emacs uses much less CPU time to +decide what to do. + +*** Entirely termcap-driven. + +GNU Emacs has nearly no special code for any terminal type. Various +new termcap strings make it possible to handle all terminals nearly as +fast as they could be handled by special-case code. + +*** Display-hiding features. + +For example, Outline Mode makes it possible for you to edit +an outline, making entire sub-branches of the outline visible +or invisible when you wish. + +*** You can interrupt with Control-G. + +Even a looping Lisp program can be stopped this way. +And even a loop in C code does not stop you from killing +Emacs and getting back to your shell. + +*** Per-buffer Undo. + +You can undo the last several changes, in each buffer +independently. + +*** The editor code itself is clean. + +Many people have remarked on how much they enjoy reading +the code for GNU Emacs. + +One other note: The program etc/cvtmail that comes with GNU Emacs can +be used to convert a mail directory for Gosling Emacs's Rmail into a +Unix mail file that you could read into GNU Emacs's Rmail. + +* How is this Emacs different from CCA Emacs? + +** GNU Emacs Lisp vs CCA Elisp. + +GNU Emacs Lisp does not have a distinction between Lisp functions +and Emacs functions, or between Lisp variables and Emacs variables. +The Lisp and the editor are integrated. A Lisp function defined +with defun is callable as an editor command if you put an +interactive calling spec in it; for example, + (defun forward-character (n) + (interactive "p") + (goto-char (+ (point) n))) +defines a function of one argument that moves point forward by +a specified number of characters. Programs could call this function, +as in (forward-character 6), or it could be assigned to a key, +in which case the "p" says to pass the prefix numeric arg as +the function's argument. As a result of this feature, you often +need not have two different functions, one to be called by programs +and another to read arguments from the user conveniently; the same +function can do both. + +CCA Elisp tries to be a subset of Common Lisp and tries to +have as many Common Lisp functions as possible (though it is still +only a small fraction of full Common Lisp). GNU Emacs Lisp +is somewhat similar to Common Lisp just because of my Maclisp +and Lisp Machine background, but it has several distinct incompatibilities +in both syntax and semantics. Also, I have not attempted to +provide many Common Lisp functions that you could write in Lisp, +or others that provide no new capability in the circumstances. + +GNU Emacs Lisp does not have packages, readtables, or character objects +(it uses integers to represent characters). + +On the other hand, windows, buffers, relocatable markers and processes +are first class objects in GNU Emacs Lisp. You can get information about them +and do things to them in a Lispy fashion. Not so in CCA Emacs. + +In GNU Emacs Lisp, you cannot open a file and read or write characters +or Lisp objects from it. This feature is painful to support, and +is not fundamentally necessary in an Emacs, because instead you +can read the file into a buffer, read or write characters or +Lisp objects in the buffer, and then write the buffer into the file. + +On the other hand, GNU Emacs Lisp does allow you to rename, delete, add +names to, and copy files; also to find out whether a file is a +directory, whether it is a symbolic link and to what name, whether +you can read it or write it, find out its directory component, +expand a relative pathname, find completions of a file name, etc., +which you cannot do in CCA Elisp. + +GNU Emacs Lisp uses dynamic scope exclusively. This enables you to +bind variables which affect the execution of the editor, such as +indent-tabs-mode. + +GNU Emacs Lisp code is normally compiled into byte code. Most of the +standard editing commands are written in Lisp, and many are +dumped, pure, in the Emacs that users normally run. + +GNU Emacs allows you to interrupt a runaway Lisp program with +Control-g. + +** GNU Emacs Editing Advantages + +GNU Emacs is faster for many things, especially insertion of text +and file I/O. + +GNU Emacs allows you to undo more than just the last command +with the undo command (C-x u, or C-_). You can undo quite a ways back. +Undo information is separate for each buffer; changes in one buffer +do not affect your ability to undo in another buffer. + +GNU Emacs commands that want to display some output do so by putting +it in a buffer and displaying that buffer in a window. This +technique comes from Gosling Emacs. It has both advantages and +disadvantages when compared with the technique, copied by CCA Emacs +from my original Emacs which inherited it from TECO, of having "type +out" which appears on top of the text in the current window but +disappears automatically at the next input character. + +GNU Emacs does not use the concept of "subsystems". Instead, it uses +highly specialized major modes. For example, dired in GNU Emacs has +the same commands as dired does in other versions of Emacs, give or +take a few, but it is a major mode, not a subsystem. The advantage +of this is that you do not have to "exit" from dired and lose the +state of dired in order to edit files again. You can simply switch +to another buffer, and switch back to the dired buffer later. You +can also have several dired buffers, looking at different directories. + +It is still possible to write a subsystem--your own command loop-- +in GNU Emacs, but it is not recommended, since writing a major mode +for a special buffer is better. + +Recursive edits are also rarely used, for the same reason: it is better +to make a new buffer and put it in a special major mode. Sending +mail is done this way. + +GNU Emacs expects everyone to use find-file (C-x C-f) for reading +in files; its C-x C-v command kills the current buffer and then finds +the specified file. + +As a result, users do not need to think about the complexities +of subsystems, recursive edits, and various ways to read in files +or what to do if a buffer contains changes to some other file. + +GNU Emacs uses its own format of tag table, made by the "etags" +program. This format makes finding a tag much faster. + +Dissociated Press is supported. + + +** GNU Emacs Editing Disadvantages. + +GNU Emacs does not display the location of the mark. + +GNU Emacs does not have a concept of numbers of buffers, +or a permanent ordering of buffers, or searching through multiple +buffers. The tags-search command provides a way to search +through several buffers automatically. + +GNU Emacs does not provide commands to visit files without +setting the buffer's default directory. Users can write such +commands in Lisp by copying the code of the standard file +visiting commands and modifying them. + +GNU Emacs does not support "plus options" in the command +arguments or in buffer-selection commands, except for line numbers. + +GNU Emacs does not support encryption. Down with security! + +GNU Emacs does not support replaying keystroke files, +and does not normally write keystroke files. + + +** Neutral Differences + +GNU Emacs uses TAB, not ESC, to complete file names, buffer names, +command names, etc. + +GNU Emacs uses LFD to terminate searches, instead of +the C-d uses by CCA Emacs. (Actually, this character is controlled +by a parameter in GNU Emacs.) C-M-s in GNU Emacs is an interactive +regular expression search, but you can get to a noninteractive +one by typing ESC right after the C-M-s. + +In GNU Emacs, C-x s asks, for each modified file buffer, whether +to save it. + +GNU Emacs indicates line continuation with "\" and line +truncation (at either margin) with "$". + +The command to resume a tags-search or tags-query-replace in +GNU Emacs is Meta-Comma.