![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to DIFF CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / etc|
Return to DIFF CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / etc |
1.1 root 1: How is this Emacs different from all other Emacses? -*-Outline-*-
2: (Actually, from Twenex Emacs)
3:
4: * Copyright (c) 1985 Richard M. Stallman
5:
6: Permission is granted to anyone to make or distribute verbatim copies
7: of this document as received, in any medium, provided that the
8: copyright notice and permission notice are preserved,
9: and that the distributor grants the recipient permission
10: for further redistribution as permitted by this notice.
11:
12: Permission is granted to distribute modified versions
13: of this document, or of portions of it,
14: under the above conditions, provided also that they
15: carry prominent notices stating who last changed them.
16:
17: * Fundamental concepts.
18:
19: ** There is no concept of "typeout" in GNU Emacs.
20:
21: Any time that a command wants to display some output,
22: it creates a buffer (usually with a name surrounded by asterisks)
23: and displays it in a window.
24:
25: This provides some advantages:
26: you can edit some more while looking at the output;
27: you can copy parts of the output into other buffers.
28:
29: It also has a disadvantage that you must type a command
30: in order to make the output disappear.
31: You can use C-x 1 to get rid of all windows except the
32: selected one. To be more selective, you can switch to
33: the window you want to get rid of and then type C-x 0
34: (delete-window).
35:
36: You also need to type a command to scroll the other
37: window if not all the output fits in it. Meta-Control-v
38: will usually do the job.
39:
40: ** There is no concept of a "subsystem" in GNU Emacs.
41:
42: Where Twenex Emacs would use a subsystem, GNU Emacs
43: instead creates a buffer and redefines commands in it.
44:
45: For example, when you send mail in GNU Emacs, you use
46: a buffer named *mail* which is in Mail Mode. You can
47: switch away from this buffer to any other buffer and
48: resume normal editing; then switch back and resume
49: composing mail. You do not have to "exit" from
50: composing mail in order to do ordinary editing.
51:
52: This has many advantages, but it also has a disadvantage:
53: Subsystems in Emacs tend to have "exit" commands that return you
54: to whatever you were doing before entering the subsystem.
55: In GNU Emacs the idea of what to return to is not well defined,
56: so it is not clear what an "exit" command should do.
57: The only way to "exit" in general is to type C-x b, C-x C-f, or
58: some other suitable command to switch buffers. Some
59: subsystem-like major modes, such as Info and Mail mode, provide
60: commands to "exit" by switching to the previously selected
61: buffer.
62:
63: ** Files are always visited in their own buffers.
64:
65: Beginning users of Twenex Emacs were told how to edit
66: using a single buffer and reading one file after another
67: into that buffer. Use of a new buffer for each file was
68: regarded as a more advanced mode.
69:
70: In GNU Emacs, the idea of using a single buffer for various
71: files, one by one, has been dropped, given that the address
72: space is expected to be large enough for many buffers. C-x
73: C-f (find-file), which behaves nearly the same as in Twenex
74: Emacs, is in GNU Emacs the canonical way for all users to
75: visit files.
76:
77: Various commands need to read files into Emacs in the course
78: of their execution. In Twenex Emacs the user must tell them
79: whether to reuse buffers or create new ones, using the variable
80: Tags Find File. In GNU Emacs, these commands always use
81: C-x C-f.
82:
83: The command C-x C-v does still exist; it kills the current
84: buffer and reads the specified file into a new buffer.
85: It is equivalent to kill-buffer followed by find-file.
86:
87: Since there is no reusing of buffers, there is no point in
88: calling the initial buffer "main". So the initial buffer
89: in GNU Emacs is called "*scratch*" and is intended for typing
90: Lisp expressions to be evaluated.
91:
92: ** File name defaulting.
93:
94: GNU Emacs records a separate working directory for each buffer.
95: Normally this is the directory on which the buffer's file
96: resides; for buffers not visiting any file, it is copied from
97: the buffer that was current when it was created. The current buffer's
98: working directory can be printed with M-x pwd and set with M-x cd.
99:
100: GNU Emacs shows you the default directory by inserting it in
101: the minibuffer when a file name is being read. You can type
102: the filename you want at the end of the default as if the
103: default were not there, or you can edit and alter the default.
104:
105: If you want file /lose/big when the default /foo/defaultdir/
106: has been inserted for you, you need not kill the default; simply
107: type at the end of it: /foo/defaultdir//lose/big. Such a file
108: name is not ordinarily considered valid, but GNU Emacs
109: considers it equivalent to /lose/big.
110:
111: Likewise, if you want file quux in your home directory, just add
112: ~/quux to the end of the supplied text, to get
113: /foo/defaultdir/~/quux. GNU Emacs sees "/~" and throws away
114: everything before the "~".
115:
116: You can refer to environment variables also within file names.
117: $ followed by the environment variable name is replaced by the
118: variable's value. The variable name should either be followed
119: by a nonalphanumeric character (which counts as part of the
120: file name) or be surrounded by braces {...} (which do not count
121: as part of the file name). Thus, if variable USER has value "rms",
122: "x/$USER-foo" is expanded to "x/rms-foo", and "x${USER}foo"
123: is expanded to "xrmsfoo". Note that this substitution is not
124: performed by the primitive file operation functions of GNU Emacs,
125: but rather by the interactive file name reader. It is also
126: available as a separate primitive, in the function
127: substitute-in-file-name.
128:
129: ** Exit commands C-z, C-x C-c and C-x C-z.
130:
131: There are two ways to exit GNU Emacs: killing and suspending.
132: Killing is like what Control-c does to ordinary Unix programs.
133: In GNU Emacs, you type C-x C-c to kill it. (This offers to
134: save any modified file buffers before really killing Emacs.)
135: Suspending is like what Control-z does to ordinary Unix programs.
136: To suspend GNU Emacs, type C-x C-z, or type just C-z.
137: Note that C-z suspends ordinary programs instantly, but
138: Emacs does not suspend until it reads the C-z.
139:
140: Usually it is better to suspend: once a system is smart
141: enough to have job control, why ever kill an editor?
142: You'll just have to make a new one in a minute.
143: This is why the convenient command C-z is provided for
144: suspending.
145:
146: C-c is used as a prefix key for mode-specific commands and for users'
147: own commands. We deliberately do not make C-c ever kill Emacs,
148: because it should not be so easy to do something irreversible.
149:
150: ** Quitting with C-g.
151:
152: If you type C-g while GNU Emacs is waiting for input, it
153: is an ordinary command (which is defined to beep). If you
154: type C-g while Lisp code is executing, it sets a flag which
155: causes a special signal, nearly the same as an error, to
156: happen atthe next safe place in Lisp execution. This usually
157: has the effect of aborting the current command in a safe way.
158:
159: Because at times there have been bugs causing GNU Emacs to loop
160: without checking the quit flag, a special feature causes
161: GNU Emacs to be suspended immediately if you type a second C-g
162: while the flag is already set. So you can always get out
163: of GNU Emacs. Normally GNU Emacs recognizes and clears the quit flag
164: quickly enough to prevent this from happening.
165:
166: When you resume GNU Emacs after a suspension caused by multiple C-g, it
167: asks two questions before resuming execution:
168: Checkpoint?
169: Dump core?
170: Answer each one with `y' or `n' and a Return.
171: `y' to Checkpoint? causes immediate auto-saving of all
172: buffers in which auto-saving is enabled.
173: `y' to Dump core? causes an illegal instruction to be executed.
174: This is to enable a wizard to figure out why GNU Emacs was
175: looping without checking for quits. Execution does not continue
176: after a core dump. If you answer `n', execution continues.
177: With luck, GNU Emacs will ultimately check the quit flag,
178: and quit normally. If not, and you type another C-g, it
179: is suspended again.
180:
181: If GNU Emacs is not really hung, just slow, you may invoke
182: the double C-g feature without really meaning to. Then just
183: resume and answer `n' to both questions, and you will
184: arrive at your former state. Presumably the quit you
185: wanted will finish happening soon.
186:
187: These questions are not asked if you suspend GNU Emacs with the C-z
188: command. Continuing GNU Emacs after a C-z takes you straight back
189: into editing.
190:
191: ** Undoing with C-x u or C-_
192:
193: You can undo many commands--up to 10,000 characters worth.
194: Each time you type C-x u or C-_, another command or batch of change
195: is undone. Undo information is stored per buffer, and the undo
196: command always applies to the current buffer. A numeric argument
197: serves as a repeat count.
198:
199: Consecutive self-inserting characters are undone in groups of twenty.
200:
201: ** Different character set.
202:
203: GNU Emacs does not expect anyone ever to have a keyboard in which
204: the Control key sets an independent bit which may accompany any
205: character. The only control characters that can exist are the
206: ASCII control characters.
207:
208: There is, as a result, no "control prefix" character.
209:
210: ** Control-h is the Help character.
211:
212: I'm amazed it took me so long to get this idea. In Twenex Emacs, C-h
213: and C-b are equivalent commands, making C-h redundant. C-h is not
214: only easy to type, it is mnemonic for "Help". So in GNU Emacs the
215: Help character is C-h.
216:
217: ** Completion is done by TAB, not ESC.
218:
219: ESC in the minibuffer is a Meta prefix, same as at top level.
220:
221: ** The string-argument reader is the minibuffer is an editor window.
222:
223: In GNU Emacs, the line at the bottom of the screen is the minibuffer.
224: Commands that want string arguments always use this line to read them,
225: and you can use the ordinary Emacs editing commands to edit the
226: input. You can terminate input with Return because Return is defined
227: as the exit-minibuffer command when in the minibuffer. If you
228: are using a command that needs several arguments, terminate each
229: one with Return. You cannot separate arguments with Escape
230: the way you would in Twenex Emacs.
231:
232: The minibuffer window does not overlay other editor windows;
233: it is a nearly ordinary editor window which lacks a mode line
234: and is "turned off" when not in use. While it IS in use, you
235: can switch windows to and from the minibuffer, kill text in other
236: windows and yank in the minibuffer, etc.
237:
238: You can even issue a command that uses the minibuffer while in the
239: minibuffer. This gets you temporarily into a recursive minibuffer.
240: However, this is allowed only if you enable it, since it could be
241: confusing for beginners.
242:
243: When you exit the minibuffer, the cursor immediately moves back to
244: column zero of the minibuffer line, to show you that the exit
245: command has been obeyed. The minibuffer contents remain on the screen
246: until the end of the command, unless some other text is displayed there.
247:
248: A single Control-g exits the minibuffer.
249:
250: ** There are no &'s or ^R's or spaces in function names.
251:
252: For example, the function which is called ^R Forward Word
253: in Twenex Emacs is called forward-word in GNU Emacs.
254:
255: ** The extension language is Lisp rather than TECO.
256:
257: Libraries must be written in Lisp. Meta-ESC reads a Lisp
258: expression, evaluates it, and prints the result. Note that
259: Meta-ESC is "disabled" by default, so that beginning users
260: do not get into the minibuffer by accident in a confusing way.
261:
262: Data types available include integers (which double as characters),
263: strings, symbols, lists, vectors, buffers, buffer pointers,
264: windows, and process channels.
265:
266: For now, to learn about writing Lisp code for GNU Emacs, read some of
267: the source code, which is in directory ../lisp. Also, all Lisp
268: primitives have self-documentation you can read with C-h f.
269:
270: ** Enabling the error handler.
271:
272: GNU Emacs has a Lisp debugger/stepper/trace package, but normally
273: errors do not enter the debugger because that is slow, and unlikely to
274: be of interest to most users. Set the variable debug-on-error to t to
275: cause errors to invoke the debugger. Set debug-on-quit to cause quit
276: signals (caused by C-g) to invoke the debugger.
277:
278: * Other changes.
279:
280: ** More than two windows are allowed.
281:
282: C-x 2 splits the current window into two windows,
283: one above the other. Initially they both display
284: the same buffer.
285:
286: C-x 2 now accepts a numeric argument to specify the number of
287: lines to give to the uppermost of the two windows it makes.
288:
289: C-x 0 kills the current window, making all others larger.
290: C-x 1 kills all windows except the current one.
291: C-x O switches to the next window down.
292: It rotates from the bottom one to the top one.
293: An argument serves as a repeat count; negative arguments
294: circulate in the reverse order.
295:
296: If the same buffer is displayed in several windows,
297: changes made in it are redisplayed in all of them.
298:
299: ** Side by side windows are supported.
300:
301: The command C-x 5 splits the current window into
302: two side-by-side windows.
303:
304: C-x } makes the selected window ARG columns wider at the
305: expense of the windows at its sides. C-x { makes the selected
306: window ARG columns narrower. An argument to C-x 5 specifies
307: how many columns to give to the leftmost of the two windows made.
308:
309: ** Horizontal scrolling of the lines in a window is implemented.
310:
311: C-x < (scroll-left) scrolls all displayed lines left,
312: with the numeric argument (default 1) saying how far to scroll.
313: When the window is scrolled left, some amount of the beginning
314: of each nonempty line is replaced by an "$".
315: C-x > scrolls right. If a window has no text hidden at the left
316: margin, it cannot be scrolled any farther right than that.
317: When nonzero leftwards scrolling is in effect in a window.
318: lines are automatically truncated at the window's right margin
319: regardless of the value of the variable truncate-lines in the
320: buffer being displayed.
321:
322: ** Return key does not use up empty lines.
323:
324: In Twenex Emacs, the Return command advances over an existing
325: empty line in some cases. In GNU Emacs, the Return command always
326: makes inserts a newline. Twenex Emacs was designed at a time when
327: most display terminals did not have the ability to scroll part
328: of the screen, and using existing empty lines made redisplay faster.
329: Nowadays, terminals that cannot scroll part of the screen are rare,
330: so there is no need to make Return behave in a more complicated manner.
331:
332: ** Help m.
333:
334: Typing C-h m displays documentation of the current major mode.,
335: telling you what special commands and features are available
336: and how to use them or get more information on them.
337:
338: This is simply the documentation, as a function, of the
339: symbol which is the value of major-mode. Each major mode
340: function has been given documentation intended for C-h m.
341:
342: ** Display-hiding features.
343:
344: *** Hiding indented lines
345:
346: The command C-x $ with numeric argument N causes lines indented by N
347: or more columns to become invisible. All you see is " ..." appended
348: to the previous line, in place of any number of consecutive invisible
349: lines.
350:
351: *** Outline Mode.
352:
353: Outline mode is designed for editing outline-structured
354: files, such as this one.
355:
356: Headings should be lines starting with one or more asterisks.
357: Major headings have one asterisk, subheadings two, etc.
358: Lines not starting with asterisks are body text.
359:
360: You can make the body under a heading, or the subheadings
361: under a heading, temporarily invisible, or visible again.
362: Invisible lines are attached to the end of the previous line
363: so they go with it if you kill it and yank it back.
364:
365: Commands:
366: Meta-} next-visible-heading move by visible headings
367: Meta-{ previous-visible-heading move by visible headings
368:
369: Meta-x hide-body make all body text invisible (not headings).
370: Meta-x show-all make everything in buffer visible.
371:
372: The remaining commands are used when dot is on a heading line.
373: They apply to some of the body or subheadings of that heading.
374: C-c C-h hide-subtree make text and subheadings invisible.
375: C-c C-s show-subtree make text and subheadings visible.
376: C-c C-i show-children make direct subheadings visible.
377: No effect on body, or subheadings 2 or more levels down.
378: With arg N, affects subheadings N levels down.
379: M-x hide-entry make immediately following body invisible.
380: M-x show-entry make it visible.
381: M-x hide-leaves make text under heading and under its subheadings invisible.
382: The subheadings remain visible.
383: M-x show-branches make all subheadings at all levels visible.
384:
385: ** C mode is fancy.
386:
387: C mode assumes that you put the initial open-brace of
388: a function definition at the beginning of a line.
389: If you use the popular indenting style that puts this
390: open-brace at the end of a line containing a type declaration,
391: YOU WILL LOSE: C mode does not know a function starts there.
392:
393: Open-brace at the beginning of a line makes it possible
394: for C mode to find function boundaries with total reliability;
395: something I consider vital and which cannot be done
396: if the other style is used.
397:
398: The Tab command indents C code very cleverly.
399: I know of only one cases in which Tab does not indent C code nicely:
400: Expressions continued over several lines with few parentheses.
401: Tab does not know the precedences of C operators, so it does
402: not know which lines of the expression should go where.
403: Using parentheses to indicate the nesting of operators
404: except within a line makes this problem go away.
405:
406: The indenting algorithm is entirely written in Lisp.
407:
408: Tab with a numeric argument in Twenex Emacs indents
409: that many lines. It is different in GNU Emacs: it means
410: to shift all the lines of a bracketed expression by the
411: same amount as the line being indented. For example, if you have
412: if (foo)
413: {
414: hack ();
415: /** Well? */
416: }
417: and type C-u Tab on the line with the open brace, you get
418: if (foo)
419: {
420: hack ();
421: /* Well? */
422: }
423: from indenting the brace line and then shifting the
424: lines within the braces rigidly with the first one.
425:
426: Meta-Control-q works as in Lisp mode; it should be
427: used with dot just before a bracketed grouping, and
428: indents each line INSIDE that grouping using Tab.
429: If used instead of C-u Tab in the previous example, it makes
430: if (foo)
431: {
432: hack ();
433: /* Well? */
434: }
435:
436: Meta-Control-h puts mark at the end of the current C function
437: and puts dot before it.
438:
439: Most other Meta-Control commands intended for Lisp expressions
440: work usefully in C mode as well.
441:
442: ** Meta-g (fill-region) is different.
443:
444: In Twenex Emacs, Meta-g fills the region with no paragraph
445: boundaries except for blank and indented lines. In GNU Emacs,
446: it divides the region into paragraphs in the same manner as
447: Meta-], and fills each paragraph separately. There is also
448: the function fill-region-as-paragraph which fills the region
449: regarding at as a single paragraph regardless even of blank
450: or indented lines.
451:
452: ** Indented Text Mode instead of Edit Indented Text.
453:
454: Twenex Emacs has a command Edit Indented Text which temporarily
455: alters some commands for editing indented paragraphs.
456: GNU Emacs has instead a separate major mode, Indented Text Mode,
457: which is different from ordinary Text Mode in just the same
458: alterations. Specifically, in Indented Text Mode,
459: Tab runs the function indent-relative, and auto filling indents
460: the newly created lines.
461:
462: ** But rectangle commands are implemented.
463:
464: C-x r stores the rectangle described by dot and mark
465: into a register; it reads the register name from the keyboard.
466: C-x g, the command to insert the contents of a register,
467: can be used to reinsert the rectangle elsewhere.
468:
469: Other rectangle commands include
470: open-rectangle:
471: insert a blank rectangle in the position and size
472: described by dot and mark, at its corners;
473: the existing text is pushed to the right.
474: clear-rectangle:
475: replace the rectangle described by dot ane mark
476: with blanks. The previous text is deleted.
477: delete-rectangle:
478: delete the text of the specified rectangle,
479: moving the text beyond it on each line leftward.
480: kill-rectangle
481: like delete-rectangle but also stores the text of
482: the rectangle in the "rectangle kill buffer".
483: More precisely, it stores the text as a list of strings
484: (one string for each line) in the variable killed-rectangle.
485: yank-rectangle
486: inserts the text of the last killed rectangle.
487: extract-rectangle and delete-extract-rectangle
488: these functions return the text of a rectangle
489: as a list of strings. They are for use in writing
490: other functions that operate on rectangles.
491:
492: ** Keyboard Macros
493:
494: The C-x ( command for defining a keyboard macro can in GNU Emacs
495: be given a numeric argument, which means that the new macro
496: starts out not empty but rather as the same as the last
497: keyboard macro entered. In addition, that last keyboard
498: macro is replayed when the C-x ( is typed. C-x ( with an
499: argument is thus equivalent to typing plain C-x ( and then
500: retyping the last keyboard macro entered.
501:
502: The command write-kbd-macro and append-kbd-macro can be used to
503: save a keyboard macro definition in a file. It is represented as
504: a Lisp expression which, when evaluated, will define the keyboard
505: macro. write-kbd-macro writes the specified file from scratch,
506: whereas append-kbd-macro adds to any existing text in the file.
507: Both expect the keyboard macro to be saved to be specified by
508: name; this means you must use the command name-last-kbd-macro to
509: give the macro a name before you can save it.
510:
511: ** The command to resume a terminated tags-search or tags-query-replace
512:
513: is Meta-comma in GNU Emacs.
514:
515: ** Auto Save is on by default.
516:
517: Auto Save mode is enabled by default in all buffers
518: that are visiting files.
519:
520: The file name used for auto saving is made by prepending
521: "#" to the file name visited.
522:
523: ** Backup files.
524:
525: Since Unix stupidly fails to have file version numbers,
526: GNU Emacs compensates slightly in the customary fashion:
527: when a file is modified and saved for the first time in
528: a particular GNU Emacs run, the original file is renamed,
529: appending "~" to its name. Thus, foo.c becomes foo.c~.
530:
531: Emacs can also put a version number into the name of the backup file,
532: as in foo.c.~69~ for version number 69. This is an optional feature
533: that the user has to enable.
534:
535: ** Mode Line differences.
536:
537: Each window in GNU Emacs has its own mode line, which always
538: displays the status of that window's buffer and nothing else.
539: The mode line appears at the bottom of the window. It is
540: full of dashes, to emphasize the boundaries between windows,
541: and is displayed in inverse video if the terminal supports it.
542: The information usually available includes:
543:
544: ** Local Modes feature changed slightly.
545:
546: GNU Emacs supports local mode lists much like those in Twenex Emacs,
547: but you can only set variables, not commands. You write
548:
549: Local variables:
550: tab-width: 10
551: end:
552:
553: in the last page of a file, if you want to make tab-width be ten in a
554: file's buffer. The value you specify must be a Lisp object!
555: It will be read, but not evaluated. So, to specify a string,
556: you MUST use doublequotes. For "false", in variables whose
557: meanings are true or false, you MUST write nil .
558:
559: Two variable names are special: "mode" and "eval".
560: Mode is used for specifying the major mode (as in Twenex Emacs).
561:
562: mode: text
563:
564: specifies text mode. Eval is used for requesting the evaluation
565: of a Lisp expression; its value is ignored. Thus,
566:
567: eval: (set-syntax-table lisp-mode-syntax-table)
568:
569: causes Lisp Mode syntax to be used.
570:
571:
572: Note that GNU Emacs looks for the string "Local variables:"
573: whereas Twenex Emacs looks for "Local modes:". This incompatibility
574: id deliberate, so that neither one will see local settings
575: intended for the other.
576:
577: ** Lisp code libraries.
578:
579: Libraries of commands, and init files, are written in Lisp.
580: libraries conventionally have names ending in .el, while the
581: init file is named .emacs and is in your home directory.
582:
583: Use Meta-x load to load a library. Most standard libararies load
584: automatically if you try to use the commands in them.
585:
586: Meta-x byte-compile-file filename
587: compiles the file into byte code which loads and runs faster
588: than Lisp source code. The file of byte code is given a name
589: made by appending "c" to the end of the input file name.
590:
591: Meta-x byte-recompile-directory directoryname
592: compiles all files in the specified directory (globbing not allowed)
593: which have been compiled before but have been changed since then.
594:
595: Meta-x load automatically checks for a compiled file
596: before loading the source file.
597:
598: Libraries once loaded do not retain their identity within GNU
599: Emacs. Therefore, you cannot tell just what was loaded from a
600: library, and you cannot un-load a library. Normally, libraries
601: are written so that loading one has no effect on the editing
602: operations that you would have used if you had not loaded the
603: library.
604:
605: ** Dired features.
606:
607: You can do dired on partial directories --- any pattern
608: the shell can glob. Dired creates a buffer named after
609: the directory or pattern, so you can dired several different
610: directories. If you repeat dired on the same directory or
611: pattern, it just reselects the same buffer. Use Meta-x Revert
612: on that buffer to read in the current contents of the directory.
613:
614: ** Directory listing features.
615:
616: C-x C-d now uses the default output format of `ls',
617: which gives just file names in multiple columns.
618: C-u C-x C-d passes the -l switch to `ls'.
619:
620: Both read a directory spec from the minibuffer. It can
621: be any pattern that the shell can glob.
622:
623: ** Compiling other programs.
624:
625: Meta-x compile allows you to run make, or any other compilation
626: command, underneath GNU Emacs. Error messages go into a buffer whose
627: name is *compilation*. If you get error messages, you can use the
628: command C-x ` (that is a backquote) to find the text of the next
629: error message.
630:
631: You must specify the command to be run as an argument to M-x compile.
632: A default is placed in the minibuffer; you can kill it and start
633: fresh, edit it, or just type Return if it is what you want.
634: The default is the last compilation command you used; initially,
635: it is "make -k".
636:
637: ** Searching multiple files.
638:
639: Meta-x grep searches many files for a regexp by invoking grep
640: and reading the output of grep into a buffer. You can then
641: move to the text lines that grep found, using the C-x ` command
642: just as after M-x compile.
643:
644: ** Running inferior shells.
645:
646: Do Meta-x shell to make an inferior shell together with a buffer
647: which serves to hold "terminal" input and output of the shell.
648: The shell used is specified by the environment variable ESHELL,
649: or by SHELL if ESHELL is not set.
650:
651: Use C-h m whilst in the *shell* buffer to get more detailed info.
652:
653: The inferior shell loads the file .emacs_csh or.emacs_sh
654: (or similar using whatever name the shell has) when it starts up.
655:
656: M-! executes a shell command in an inferior shell
657: and displays the output from it. With a prefix argument,
658: it inserts the output in the current buffer after dot
659: and sets the mark after the output. The shell command
660: gets /dev/null as its standard input.
661:
662: M-| is like M-! but passes the contents of the region
663: as input to the shell command. A prefix argument makes
664: the output from the command replace the contents of the region.
665:
666: ** Sending mail.
667:
668: Once you enter Mail Mode using C-x m or C-x 4 m or M-x mail,
669: C-c becomes a prefix character for mail-related editing commands.
670: C-c C-s is vital; that's how you send the message. C-c C-c sends
671: and then switches buffers or kills the current window.
672: Use C-h m to get a list of the others.
673:
674: ** Regular expressions.
675:
676: GNU Emacs has regular expression facilities like those of most
677: Unix editors, but more powerful:
678:
679: *** -- + --
680:
681: + specifies repetition of the preceding expression 1 or more
682: times. It is in other respect like *, which specifies repetition
683: 0 or more times.
684:
685: *** -- ? --
686:
687: ? is like * but matches at most one repetition of the preceding
688: expression.
689:
690: *** -- \| --
691:
692: \| specifies an alternative. Two regular expressions A and B with \| in
693: between form an expression that matches anything that either A or B will
694: match. Thus, "foo\|bar" matches either "foo" or "bar" but no other
695: string.
696:
697: \| applies to the larges possible surrounding expressions. Only a
698: surrounding \( ... \) grouping can limit the grouping power of \|.
699:
700: Full backtracking capability exists when multiple \|'s are used.
701:
702: *** -- \( ... \) --
703:
704: \( ... \) are a grouping construct that serves three purposes:
705:
706: 1. To enclose a set of \| alternatives for other operations.
707: Thus, "\(foo\|bar\)x" matches either "foox" or "barx".
708: 2. To enclose a complicated expression for * to operate on.
709: Thus, "ba\(na\)*" matches "bananana", etc., with any number
710: of na's (zero or more).
711: 3. To mark a matched substring for future reference.
712:
713: Application 3 is not a consequence of the idea of a parenthetical
714: grouping; it is a separate feature which happens to be assigned as a
715: second meaning to the same \( ... \) construct because there is no
716: conflict in practice between the two meanings. Here is an explanation
717: of this feature.
718:
719: -- \digit --
720:
721: After the end of a \( ... \) construct, the matcher remembers the
722: beginning and end of the text matched by that construct. Then, later on
723: in the regular expression, you can use \ followed by a digit to mean,
724: ``match the same text matched this time by the \( ... \) construct.''
725: The first nine \( ... \) constructs that appear in a regular expression
726: are assigned numbers 1 through 9 in order of their beginnings. \1
727: through \9 can be used to refer to the text matched by the corresponding
728: \( ... \) construct.
729:
730: For example, "\(.*\)\1" matches any string that is composed of two
731: identical halves. The "\(.*\)" matches the first half, which can be
732: anything, but the \1 that follows must match the same exact text.
733:
734: *** -- \` --
735:
736: Matches the empty string, but only if it is at the beginning of the buffer.
737:
738: *** -- \' --
739:
740: Matches the empty string, but only if it is at the end of the buffer.
741:
742: *** -- \b --
743:
744: Matches the empty string, but only if it is at the beginning or end of
745: a word. Thus, "\bfoo\b" matches any occurrence of "foo" as a separate word.
746: "\bball\(s\|\)\b" matches "ball" or "balls" as a separate word.
747:
748: *** -- \B --
749:
750: Matches the empty string, provided it is NOT at the beginning or end of
751: a word.
752:
753: *** -- \< --
754:
755: Matches the empty string, provided it is at the beginning of a word.
756:
757: *** -- \> --
758:
759: Matches the empty string, provided it is at the end of a word.
760:
761: *** -- \w --
762:
763: Matches any word-constituent character. The editor syntax table determines
764: which characters these are.
765:
766: *** -- \W --
767:
768: Matches any character that is not a word-constituent.
769:
770: *** -- \s<code> --
771:
772: Matches any character whose syntax is <code>. <code> is a letter that
773: represents a syntax code: thus, "w" for word constituent, "-" for
774: whitespace, "(" for open-parenthesis, etc. Thus, "\s(" matches any
775: character with open-parenthesis syntax.
776:
777: *** -- \S<code> --
778:
779: Matches any character whose syntax is not <code>.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.