![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to emacs-4 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / info|
Return to emacs-4 CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / info |
1.1 root 1: Info file emacs, produced by texinfo-format-buffer -*-Text-*-
2: from file emacs.tex
3:
4: This file documents the GNU Emacs editor.
5:
6: Copyright (C) 1985, 1986 Richard M. Stallman.
7:
8: Permission is granted to make and distribute verbatim copies of
9: this manual provided the copyright notice and this permission notice
10: are preserved on all copies.
11:
12: Permission is granted to copy and distribute modified versions of this
13: manual under the conditions for verbatim copying, provided also that the
14: sections entitled "The GNU Manifesto", "Distribution" and "GNU Emacs
15: General Public License" are included exactly as in the original, and
16: provided that the entire resulting derived work is distributed under the
17: terms of a permission notice identical to this one.
18:
19: Permission is granted to copy and distribute translations of this manual
20: into another language, under the above conditions for modified versions,
21: except that the sections entitled "The GNU Manifesto", "Distribution"
22: and "GNU Emacs General Public License" may be included in a translation
23: approved by the author instead of in the original English.
24:
25:
26: File: emacs Node: Regexps, Prev: Regexp Search, Up: Search, Next: Search Case
27:
28: Syntax of Regular Expressions
29: =============================
30:
31: Regular expressions have a syntax in which a few characters are special
32: constructs and the rest are "ordinary". An ordinary character is a simple
33: regular expression which matches that character and nothing else. The
34: special characters are `$', `^', `.', `*', `+', `?', `[', `]' and `\'; no
35: new special characters will be defined. Any other character appearing in a
36: regular expression is ordinary, unless a `\' precedes it.
37:
38: For example, `f' is not a special character, so it is ordinary, and
39: therefore `f' is a regular expression that matches the string `f' and no
40: other string. (It does not match the string `ff'.) Likewise, `o' is a
41: regular expression that matches only `o'.
42:
43: Any two regular expressions A and B can be concatenated. The result is a
44: regular expression which matches a string if A matches some amount of the
45: beginning of that string and B matches the rest of the string.
46:
47: As a simple example, we can concatenate the regular expressions `f'
48: and `o' to get the regular expression `fo', which matches only
49: the string `fo'. Still trivial. To do something nontrivial, you
50: need to use one of the special characters. Here is a list of them.
51:
52: `. (Period)'
53: is a special character that matches any single character except a
54: newline. Using concatenation, we can make regular expressions like
55: `a.b' which matches any three-character string which begins with `a'
56: and ends with `b'.
57:
58: `*'
59: is not a construct by itself; it is a suffix, which means the
60: preceding regular expression is to be repeated as many times as
61: possible. In `fo*', the `*' applies to the `o', so `fo*' matches one
62: `f' followed by any number of `o's. The case of zero `o's is allowed:
63: `fo*' does match `f'.
64:
65: `*' always applies to the smallest possible preceding expression.
66: Thus, `fo*' has a repeating `o', not a repeating `fo'.
67:
68: The matcher processes a `*' construct by matching, immediately, as
69: many repetitions as can be found. Then it continues with the rest of
70: the pattern. If that fails, backtracking occurs, discarding some of
71: the matches of the `*'-modified construct in case that makes it
72: possible to match the rest of the pattern. For example, matching
73: `ca*ar' against the string `caaar', the `a*' first tries to match all
74: three `a's; but the rest of the pattern is `ar' and there is only `r'
75: left to match, so this try fails. The next alternative is for `a*' to
76: match only two `a's. With this choice, the rest of the regexp matches
77: successfully.
78:
79: `+'
80: Is a suffix character similar to `*' except that it requires that the
81: preceding expression be matched at least once. So, for example,
82: `ca+r' will match the strings `car' and `caaaar' but not the string
83: `cr', whereas `ca*r' would match all three strings.
84:
85: `?'
86: Is a suffix character similar to `*' except that it can match the
87: preceding expression either once or not at all. For example,
88: `ca?r' will match `car' or `cr'; nothing else.
89:
90: `[ ... ]'
91: `[' begins a "character set", which is terminated by a `]'. In the
92: simplest case, the characters between the two form the set. Thus,
93: `[ad]' matches either one `a' or one `d', and `[ad]*' matches any
94: string composed of just `a's and `d's (including the empty string),
95: from which it follows that `c[ad]*r' matches `cr', `car', `cdr',
96: `caddaar', etc.
97:
98: Character ranges can also be included in a character set, by writing
99: two characters with a `-' between them. Thus, `[a-z]' matches any
100: lower-case letter. Ranges may be intermixed freely with individual
101: characters, as in `[a-z$%.]', which matches any lower case letter or
102: `$', `%' or period.
103:
104: Note that the usual special characters are not special any more inside
105: a character set. A completely different set of special characters
106: exists inside character sets: `]', `-' and `^'.
107:
108: To include a `]' in a character set, you must make it the first
109: character. For example, `[]a]' matches `]' or `a'. To include a `-',
110: write `---', which is a range containing only `-'. To include `^',
111: make it other than the first character in the set.
112:
113: `[^ ... ]'
114: `[^' begins a "complement character set", which matches any character
115: except the ones specified. Thus, `[^a-z0-9A-Z]' matches all
116: characters except letters and digits.
117:
118: `^' is not special in a character set unless it is the first
119: character. The character following the `^' is treated as if it
120: were first (`-' and `]' are not special there).
121:
122: Note that a complement character set can match a newline, unless
123: newline is mentioned as one of the characters not to match.
124:
125: `^'
126: is a special character that matches the empty string, but only if at
127: the beginning of a line in the text being matched. Otherwise it fails
128: to match anything. Thus, `^foo' matches a `foo' which occurs
129: at the beginning of a line.
130:
131: `$'
132: is similar to `^' but matches only at the end of a line. Thus,
133: `xx*$' matches a string of one `x' or more at the end of a line.
134:
135: `\'
136: has two functions: it quotes the special characters (including
137: `\'), and it introduces additional special constructs.
138:
139: Because `\' quotes special characters, `\$' is a regular expression
140: which matches only `$', and `\[' is a regular expression which matches
141: only `[', and so on.
142:
143: Note: for historical compatibility, special characters are treated as
144: ordinary ones if they are in contexts where their special meanings make no
145: sense. For example, `*foo' treats `*' as ordinary since there is no
146: preceding expression on which the `*' can act. It is poor practice to
147: depend on this behavior; better to quote the special character anyway,
148: regardless of where is appears.
149:
150: For the most part, `\' followed by any character matches only
151: that character. However, there are several exceptions: characters
152: which, when preceded by `\', are special constructs. Such
153: characters are always ordinary when encountered on their own. Here
154: is a table of `\' constructs.
155:
156: `\|'
157: specifies an alternative. Two regular expressions A and B with `\|'
158: in between form an expression that matches anything that either A or B
159: will match.
160:
161: Thus, `foo\|bar' matches either `foo' or `bar' but no other string.
162:
163: `\|' applies to the largest possible surrounding expressions. Only a
164: surrounding `\( ... \)' grouping can limit the grouping power of `\|'.
165:
166: Full backtracking capability exists to handle multiple uses of `\|'.
167:
168: `\( ... \)'
169: is a grouping construct that serves three purposes:
170:
171: 1. To enclose a set of `\|' alternatives for other operations.
172: Thus, `\(foo\|bar\)x' matches either `foox' or `barx'.
173:
174: 2. To enclose a complicated expression for the postfix `*' to
175: operate on. Thus, `ba\(na\)*' matches `bananana', etc., with any
176: (zero or more) number of `na' strings.
177:
178: 3. To mark a matched substring for future reference.
179:
180:
181: This last application is not a consequence of the idea of a
182: parenthetical grouping; it is a separate feature which happens to be
183: assigned as a second meaning to the same `\( ... \)' construct
184: because there is no conflict in practice between the two meanings.
185: Here is an explanation of this feature:
186:
187: `\DIGIT'
188: after the end of a `\( ... \)' construct, the matcher remembers the
189: beginning and end of the text matched by that construct. Then, later
190: on in the regular expression, you can use `\' followed by DIGIT to
191: mean "match the same text matched the DIGIT'th time by the `\( ... \)'
192: construct."
193:
194: The strings matching the first nine `\( ... \)' constructs appearing
195: in a regular expression are assigned numbers 1 through 9 in order that the
196: open-parentheses appear in the regular expression. `\1' through
197: `\9' may be used to refer to the text matched by the corresponding
198: `\( ... \)' construct.
199:
200: For example, `\(.*\)\1' matches any newline-free string that is
201: composed of two identical halves. The `\(.*\)' matches the first
202: half, which may be anything, but the `\1' that follows must match
203: the same exact text.
204:
205: `\`'
206: matches the empty string, provided it is at the beginning
207: of the buffer.
208:
209: `\''
210: matches the empty string, provided it is at the end of
211: the buffer.
212:
213: `\b'
214: matches the empty string, provided it is at the beginning or end of a
215: word. Thus, `\bfoo\b' matches any occurrence of `foo' as a separate
216: word. `\bballs?\b' matches `ball' or `balls' as a separate word.
217:
218: `\B'
219: matches the empty string, provided it is not at the beginning or
220: end of a word.
221:
222: `\<'
223: matches the empty string, provided it is at the beginning of a word.
224:
225: `\>'
226: matches the empty string, provided it is at the end of a word.
227:
228: `\w'
229: matches any word-constituent character. The editor syntax table
230: determines which characters these are.
231:
232: `\W'
233: matches any character that is not a word-constituent.
234:
235: `\sCODE'
236: matches any character whose syntax is CODE. CODE is a character which
237: represents a syntax code: thus, `w' for word constituent, `-' for
238: whitespace, `(' for open-parenthesis, etc. *Note Syntax::.
239:
240: `\SCODE'
241: matches any character whose syntax is not CODE.
242:
243: Here is a complicated regexp, used by Emacs to recognize the end of a
244: sentence together with any whitespace that follows. It is given in Lisp
245: syntax to enable you to distinguish the spaces from the tab characters. In
246: Lisp syntax, the string constant begins and ends with a double-quote.
247: `\"' stands for a double-quote as part of the regexp, `\\' for a
248: backslash as part of the regexp, `\t' for a tab and `\n' for a
249: newline.
250:
251: "[.?!][]\"')]*\\($\\|\t\\| \\)[ \t\n]*"
252:
253: This contains four parts in succession: a character set matching period,
254: `?' or `!'; a character set matching close-brackets,
255: quotes or parentheses, repeated any number of times; an alternative in
256: backslash-parentheses that matches end-of-line, a tab or two spaces; and a
257: character set matching whitespace characters, repeated any number of times.
258:
259:
260: File: emacs Node: Search Case, Prev: Regexps, Up: Search, Next: Replace
261:
262: Searching and Case
263: ==================
264:
265: All sorts of searches in Emacs normally ignore the case of the text they
266: are searching through; if you specify searching for `FOO', then `Foo' and
267: `foo' are also considered a match. Regexps, and in particular character
268: sets, are included: `[aB]' would match `a' or `A' or `b' or `B'.
269:
270: If you do not want this feature, set the variable `case-fold-search'
271: to `nil'. Then all letters must match exactly, including case. This
272: is a per-buffer variable; altering the variable affects only the current
273: buffer, but there is a default value which you can change as well.
274: *Note Locals::.
275:
276:
277: File: emacs Node: Replace, Prev: Search Case, Up: Search, Next: Other Repeating Search
278:
279: Replacement Commands
280: ====================
281:
282: Global search-and-replace operations are not needed as often in Emacs as
283: they are in other editors, but they are available. In addition to the
284: simple `replace-string' command which is like that found in most
285: editors, there is a `query-replace' command which asks you, for each
286: occurrence of the pattern, whether to replace it.
287:
288: The replace commands all replace one string (or regexp) with one
289: replacement string. It is possible to perform several replacements in
290: parallel using the command `expand-region-abbrevs'. *Note Expanding Abbrevs::.
291:
292: * Menu:
293:
294: * Unconditional Replace:: Replacing all matches for a string.
295: * Regexp Replace:: Replacing all matches for a regexp.
296: * Replacement and Case:: How replacements preserve case of letters.
297: * Query Replace:: How to use querying.
298:
299:
300: File: emacs Node: Unconditional Replace, Prev: Replace, Up: Replace, Next: Regexp Replace
301:
302: Unconditional Replacement
303: -------------------------
304:
305: `M-x replace-string RET STRING RET NEWSTRING RET'
306: Replace every occurrence of STRING with NEWSTRING.
307: `M-x replace-regexp RET REGEXP RET NEWSTRING RET'
308: Replace every match for REGEXP with NEWSTRING.
309:
310: To replace every instance of `foo' after point with `bar', use
311: the command `M-x replace-string' with the two arguments `foo' and
312: `bar'. Replacement occurs only after point, so if you want to cover
313: the whole buffer you must go to the beginning first. All occurrences up to
314: the end of the buffer are replaced; to limit replacement to part of the
315: buffer, narrow to that part of the buffer before doing the replacement
316: (*Note Narrowing::).
317:
318: When `replace-string' exits, point is left at the last occurrence
319: replaced. The value of point when the `replace-string' command was
320: issued is remembered on the mark ring; `C-u C-SPC' moves back
321: there.
322:
323: A numeric argument restricts replacement to matches that are surrounded
324: by word boundaries.
325:
326:
327: File: emacs Node: Regexp Replace, Prev: Unconditional Replace, Up: Replace, Next: Replacement and Case
328:
329: Regexp Replacement
330: ------------------
331:
332: `replace-string' replaces exact matches for a single string. The
333: similar command `replace-regexp' replaces any match for a specified
334: pattern.
335:
336: In `replace-regexp', the NEWSTRING need not be constant. It can refer to
337: all or part of what is matched by the REGEXP. `\&' in NEWSTRING stands for
338: the entire text being replaced. `\D' in NEWSTRING, where D is a digit,
339: stands for whatever matched the D'th parenthesized grouping in REGEXP. For
340: example,
341:
342: M-x replace-regexp RET c[ad]+r RET \&-safe RET
343:
344: would replace (for example) `cadr' with `cadr-safe' and `cddr'
345: with `cddr-safe'.
346:
347: M-x replace-regexp RET \(c[ad]+r\)-safe RET \1 RET
348:
349: would perform exactly the opposite replacements. To include a `\'
350: in the text to replace with, you must give `\\'.
351:
352:
353: File: emacs Node: Replacement and Case, Prev: Regexp Replace, Up: Replace, Next: Query Replace
354:
355: Replace Commands and Case
356: -------------------------
357:
358: If the arguments to a replace command are in lower case, it preserves
359: case when it makes a replacement. Thus, the command
360:
361: M-x replace-string RET foo RET bar RET
362:
363: replaces a lower case `foo' with a lower case `bar', `FOO'
364: with `BAR', and `Foo' with `Bar'. If upper case letters are
365: used in the second argument, they remain upper case every time that
366: argument is inserted. If upper case letters are used in the first
367: argument, the second argument is always substituted exactly as given, with
368: no case conversion. Likewise, if the variable `case-replace' is set
369: to `nil', replacement is done without case conversion. If
370: `case-fold-search' is set to `nil', case is significant in
371: matching occurrences of `foo' to replace; also, case conversion of the
372: replacement string is not done.
373:
374:
375: File: emacs Node: Query Replace, Prev: Replacement and Case, Up: Replace
376:
377: Query Replace
378: -------------
379:
380: `M-% STRING RET NEWSTRING RET'
381: `M-x query-replace RET STRING RET NEWSTRING RET'
382: Replace some occurrences of STRING with NEWSTRING.
383: `M-x query-replace-regexp RET REGEXP RET NEWSTRING RET'
384: Replace some matches for REGEXP with NEWSTRING.
385:
386: If you want to change only some of the occurrences of `foo' to `bar', not
387: all of them, then you cannot use an ordinary `replace-string'. Instead,
388: use `M-%' (`query-replace'). This command finds occurrences of `foo' one
389: by one, displays each occurrence and asks you whether to replace it. A
390: numeric argument to `query-replace' tells it to consider only occurrences
391: that are bounded by word-delimiter characters.
392:
393: Aside from querying, `query-replace' works just like `replace-string',
394: and `query-replace-regexp' works just like `replace-regexp'.
395:
396: The things you can type when you are shown an occurrence of STRING
397: or a match for REGEXP are:
398:
399:
400: `SPC'
401: to replace the occurrence with NEWSTRING. This preserves case, just
402: like `replace-string', provided `case-replace' is non-`nil', as it
403: normally is.
404:
405: `DEL'
406: to skip to the next occurrence without replacing this one.
407:
408: `, (Comma)'
409: to replace this occurrence and display the result. You are then asked
410: for another input character, except that since the replacement has
411: already been made, DEL and SPC are equivalent. You could
412: type `C-r' at this point (see below) to alter the replaced text. You
413: could also type `C-x u' to undo the replacement; this exits the
414: `query-replace', so if you want to do further replacement you must use
415: `C-x ESC' to restart (*Note Repetition::).
416:
417: `ESC'
418: to exit without doing any more replacements.
419:
420: `. (Period)'
421: to replace this occurrence and then exit.
422:
423: `!'
424: to replace all remaining occurrences without asking again.
425:
426: `^'
427: to go back to the location of the previous occurrence (or what used to
428: be an occurrence), in case you changed it by mistake. This works by
429: popping the mark ring. Only one `^' in a row is allowed, because
430: only one previous replacement location is kept during `query-replace'.
431:
432: `C-r'
433: to enter a recursive editing level, in case the occurrence needs to be
434: edited rather than just replaced with NEWSTRING. When you are
435: done, exit the recursive editing level with `C-M-c' and the next
436: occurrence will be displayed. *Note Recursive Edit::.
437:
438: `C-w'
439: to delete the occurrence, and then enter a recursive editing level as
440: in `C-r'. Use the recursive edit to insert text to replace the
441: deleted occurrence of STRING. When done, exit the recursive
442: editing level with `C-M-c' and the next occurrence will be
443: displayed.
444:
445: `C-l'
446: to redisplay the screen and then give another answer.
447:
448: `C-h'
449: to display a message summarizing these options, then give another
450: answer.
451:
452: If you type any other character, the `query-replace' is exited, and
453: the character executed as a command. To restart the `query-replace',
454: use `C-x ESC', which repeats the `query-replace' because it
455: used the minibuffer to read its arguments. *Note C-x ESC: Repetition.
456:
457:
458: File: emacs Node: Other Repeating Search, Prev: Replace, Up: Search
459:
460: Other Search-and-Loop Commands
461: ==============================
462:
463: Here are some other commands that find matches for a regular expression.
464: They all operate from point to the end of the buffer.
465:
466: `M-x occur'
467: Print each line that follows point and contains a match for the
468: specified regexp. A numeric argument specifies the number of context
469: lines to print before and after each matching line; the default is
470: none.
471:
472: The buffer `*Occur*' containing the output serves as a menu for
473: finding the occurrences in their original context. Find an occurrence
474: as listed in `*Occur*', position point there and type `C-c
475: C-c'; this switches to the buffer that was searched and moves point to
476: the original of the same occurrence.
477:
478: `M-x list-matching-lines'
479: Synonym for `M-x occur'.
480:
481: `M-x count-matches'
482: Print the number of matches following point for the specified regexp.
483:
484: `M-x delete-non-matching-lines'
485: Delete each line that follows point and does not contain a match for
486: the specified regexp.
487:
488: `M-x delete-matching-lines'
489: Delete each line that follows point and contains a match for the
490: specified regexp.
491:
492:
493: File: emacs Node: Fixit, Prev: Search, Up: Top, Next: Files
494:
495: Commands for Fixing Typos
496: *************************
497:
498: In this chapter we describe the commands that are especially useful for
499: the times when you catch a mistake in your text just after you have made
500: it, or change your mind while composing text on line.
501:
502: * Menu:
503:
504: * Kill Errors:: Commands to kill a batch of recently entered text.
505: * Transpose:: Exchanging two characters, words, lines, lists...
506: * Fixing Case:: Correcting case of last word entered.
507: * Spelling:: Apply spelling checker to a word, or a whole file.
508:
509:
510: File: emacs Node: Kill Errors, Prev: Fixit, Up: Fixit, Next: Transpose
511:
512: Killing Your Mistakes
513: =====================
514:
515: `DEL'
516: Delete last character (`delete-backward-char').
517: `M-DEL'
518: Kill last word (`backward-kill-word').
519: `C-x DEL'
520: Kill to beginning of sentence (`backward-kill-sentence').
521:
522: The DEL character (`delete-backward-char') is the most
523: important correction command. When used among graphic (self-inserting)
524: characters, it can be thought of as canceling the last character typed.
525:
526: When your mistake is longer than a couple of characters, it might be more
527: convenient to use `M-DEL' or `C-x DEL'. `M-DEL' kills back to the start of
528: the last word, and `C-x DEL' kills back to the start of the last sentence.
529: `C-x DEL' is particularly useful when you are thinking of what to write as
530: you type it, in case you change your mind about phrasing. `M-DEL' and `C-x
531: DEL' save the killed text for `C-y' and `M-y' to retrieve. *Note
532: Yanking::.
533:
534: `M-DEL' is often useful even when you have typed only a few
535: characters wrong, if you know you are confused in your typing and aren't
536: sure exactly what you typed. At such a time, you cannot correct with
537: DEL except by looking at the screen to see what you did. It requires
538: less thought to kill the whole word and start over again.
539:
540:
541: File: emacs Node: Transpose, Prev: Kill Errors, Up: Fixit, Next: Fixing Case
542:
543: Transposing Text
544: ================
545:
546: `C-t'
547: Transpose two characters (`transpose-chars').
548: `M-t'
549: Transpose two words (`transpose-words').
550: `C-M-t'
551: Transpose two balanced expressions (`transpose-sexps').
552: `C-x C-t'
553: Transpose two lines (`transpose-lines').
554:
555: The common error of transposing two characters can be fixed, when they
556: are adjacent, with the `C-t' command (`transpose-chars'). Normally,
557: `C-t' transposes the two characters on either side of point. When
558: given at the end of a line, rather than transposing the last character of
559: the line with the newline, which would be useless, `C-t' transposes the
560: last two characters on the line. So, if you catch your transposition error
561: right away, you can fix it with just a `C-t'. If you don't catch it so
562: fast, you must move the cursor back to between the two transposed
563: characters. If you transposed a space with the last character of the word
564: before it, the word motion commands are a good way of getting there.
565: Otherwise, a reverse search (`C-r') is often the best way.
566: *Note Search::.
567:
568:
569: `Meta-t' (`transpose-words') transposes the word before point
570: with the word after point. It moves point forward over a word, dragging
571: the word preceding or containing point forward as well. The punctuation
572: characters between the words do not move. For example, `FOO, BAR'
573: transposes into `BAR, FOO' rather than `BAR FOO,'.
574:
575: `C-M-t' (`transpose-sexps') is a similar command for transposing
576: two expressions (*Note Lists::), and `{C-x C-t} (`transpose-lines')'exchanges lines. They work like `M-t' except in determining the
577: division of the text into syntactic units.
578:
579: A numeric argument to a transpose command serves as a repeat count: it
580: tells the transpose command to move the character (word, sexp, line) before
581: or containing point across several other characters (words, sexps, lines).
582: For example, `C-u 3 C-t' moves the character before point forward across
583: three other characters. This is equivalent to repeating `C-t' three times.
584: `C-u - 4 M-t' moves the word before point backward across four words. `C-u
585: - C-M-t' would cancel the effect of plain `C-M-t'.
586:
587: A numeric argument of zero is assigned a special meaning (because
588: otherwise a command with a repeat count of zero would do nothing): to
589: transpose the character (word, sexp, line) ending after point with the
590: one ending after the mark.
591:
592:
593: File: emacs Node: Fixing Case, Prev: Transpose, Up: Fixit, Next: Spelling
594:
595: Case Conversion
596: ===============
597:
598: `M-- M-l'
599: Convert last word to lower case. Note `Meta--' is Meta-minus.
600: `M-- M-u'
601: Convert last word to all upper case.
602: `M-- M-c'
603: Convert last word to lower case with capital initial.
604:
605: A very common error is to type words in the wrong case. Because of this,
606: the word case-conversion commands `M-l', `M-u' and `M-c' have a special
607: feature when used with a negative argument: they do not move the cursor.
608: As soon as you see you have mistyped the last word, you can simply
609: case-convert it and go on typing. *Note Case::.
610:
611:
612: File: emacs Node: Spelling, Prev: Fixing Case, Up: Fixit
613:
614: Checking and Correcting Spelling
615: ================================
616:
617: `M-$'
618: Check and correct spelling of word (`spell-word').
619: `M-x spell-buffer'
620: Check and correct spelling of each word in the buffer.
621: `M-x spell-region'
622: Check and correct spelling of each word in the region.
623: `M-x spell-string'
624: Check spelling of specified word.
625:
626: To check the spelling of the word before point, and optionally correct it
627: as well, use the command `M-$' (`spell-word'). This command runs
628: an inferior process containing the `spell' program to see whether the
629: word is correct English. If it is not, it asks you to edit the word (in
630: the minibuffer) into a corrected spelling, and then does a `query-replace'
631: to substitute the corrected spelling for the old one throughout the buffer.
632:
633: If you exit the minibuffer without altering the original spelling, it
634: means you do not want to do anything to that word. Then the `query-replace'
635: is not done.
636:
637: `M-x spell-buffer' checks each word in the buffer the same way that
638: `spell-word' does, doing a `query-replace' if appropriate for every
639: incorrect word.
640:
641: `M-x spell-region' is similar but operates only on the region, not
642: the entire buffer.
643:
644: `M-x spell-string' reads a string as an argument and checks whether
645: that is a correctly spelled English word. It prints in the echo area a
646: message giving the answer.
647:
648:
649: File: emacs Node: Files, Prev: Fixit, Up: Top, Next: Buffers
650:
651: File Handling
652: *************
653:
654: The basic unit of stored data in Unix is the "file". To edit a file,
655: you must tell Emacs to examine the file and prepare a buffer containing a
656: copy of the file's text. This is called "visiting" the file. Editing
657: commands apply directly to text in the buffer; that is, to the copy inside
658: Emacs. Your changes appear in the file itself only when you "save" the
659: buffer back into the file.
660:
661: In addition to visiting and saving files, Emacs can delete, copy, rename,
662: and append to files, and operate on file directories.
663:
664: * Menu:
665:
666: * File Names:: How to type and edit file name arguments.
667: * Visiting:: Visiting a file prepares Emacs to edit the file.
668: * Saving:: Saving makes your changes permanent.
669: * Reverting:: Reverting cancels all the changes not saved.
670: * Auto Save:: Auto Save periodically protects against loss of data.
671: * ListDir:: Listing the contents of a file directory.
672: * Dired:: "Editing" a directory to delete, rename, etc.
673: the files in it.
674: * Misc File Ops:: Other things you can do on files.
675:
676:
677: File: emacs Node: File Names, Prev: Files, Up: Files, Next: Visiting
678:
679: File Names
680: ==========
681:
682: Most Emacs commands that operate on a file require you to specify the
683: file name. (Saving and reverting are exceptions; the buffer knows which
684: file name to use for them.) File names are specified using the minibuffer
685: (*Note Minibuffer::). "Completion" is available, to make it easier to
686: specify long file names. *Note Completion::.
687:
688: There is always a "default file name" which will be used if you type
689: just RET, entering an empty argument. Normally the default file name
690: is the name of the file visited in the current buffer; this makes it easy
691: to operate on that file with any of the Emacs file commands.
692:
693: Each buffer has a default directory, normally the same as the directory
694: of the file visited in that buffer. When Emacs reads a file name, if you
695: do not specify a directory, the default directory is used. If you specify
696: a directory in a relative fashion, with a name that does not start with a
697: slash, it is interpreted with respect to the default directory. The
698: default directory is kept in the variable `default-directory', which
699: has a separate value in every buffer.
700:
701: For example, if the default file name is `/u/rms/gnu/gnu.tasks' then
702: the default directory is `/u/rms/gnu/'. If you type just `foo',
703: which does not specify a directory, it is short for `/u/rms/gnu/foo'.
704: `../.login' would stand for `/u/rms/.login'. `new/foo'
705: would stand for the filename `/u/rms/gnu/new/foo'.
706:
707: The command `M-x pwd' prints the current buffer's default directory,
708: and the command `M-x cd' sets it (to a value read using the
709: minibuffer). A buffer's default directory changes only when the `cd'
710: command is used. A file-visiting buffer's default directory is initialized
711: to the directory of the file that is visited there. If a buffer is made
712: randomly with `C-x b', its default directory is copied from that of the
713: buffer that was current at the time.
714:
715: The default directory actually appears in the minibuffer when the
716: minibuffer becomes active to read a file name. This serves two purposes:
717: it shows you what the default is, so that you can type a relative file name
718: and know with certainty what it will mean, and it allows you to edit the
719: default to specify a different directory. This insertion of the default
720: directory is inhibited if the variable `insert-default-directory' is
721: set to `nil'.
722:
723: Note that it is legitimate to type an absolute file name after you enter
724: the minibuffer, ignoring the presence of the default directory name as part
725: of the text. The final minibuffer contents may look invalid, but that is
726: not so. *Note Minibuffer File::.
727:
728: `$' in a file name is used to substitute environment variables. For
729: example, if you have used the shell command `setenv FOO rms/hacks' to
730: set up an environment variable named `FOO', then you can use
731: `/u/$FOO/test.c' or `/u/${FOO}/test.c' as an abbreviation for
732: `/u/rms/hacks/test.c'. The environment variable name consists of all
733: the alphanumeric characters after the `$'; alternatively, it may be
734: enclosed in braces after the `$'. Note that the `setenv' command
735: affects Emacs only if done before Emacs is started.
736:
737: To access a file with `$' in its name, type `$$'. This pair
738: is converted to a single `$' at the same time as variable substitution
739: is performed for single `$'. The Lisp function that performs the
740: substitution is called `substitute-in-file-name'. The substitution
741: is performed only on filenames read as such using the minibuffer.
742:
743:
744: File: emacs Node: Visiting, Prev: File Names, Up: Files, Next: Saving
745:
746: Visiting Files
747: ==============
748:
749: `C-x C-f'
750: Visit a file (`find-file').
751: `C-x C-v'
752: Visit a different file instead of the one visited last
753: (`find-alternate-file').
754: `C-x 4 C-f'
755: Visit a file, in another window (`find-file-other-window'). Don't
756: change this window.
757:
758: "Visiting" a file means copying its contents into Emacs where you can
759: edit them. Emacs makes a new buffer for each file that you visit. We say
760: that the buffer is visiting the file that it was created to hold. Emacs
761: constructs the buffer name from the file name by throwing away the
762: directory, keeping just the name proper. For example, a file named
763: `/usr/rms/emacs.tex' would get a buffer named `emacs.tex'. If
764: there is already a buffer with that name, a unique name is constructed by
765: appending `<2>', `<3>', or so on, using the lowest number that
766: makes a name that is not already in use.
767:
768: Each window's mode line shows the name of the buffer that is being displayed
769: in that window, so you can always tell what buffer you are editing.
770:
771: The changes you make with Emacs are made in the Emacs buffer. They do
772: not take effect in the file that you visited, or any place permanent, until
773: you "save" the buffer. Saving the buffer means that Emacs writes the
774: current contents of the buffer into its visited file. *Note Saving::.
775:
776: If a buffer contains changes that have not been saved, the buffer is said
777: to be "modified". This is important because it implies that some
778: changes will be lost if the buffer is not saved. The mode line displays
779: two stars near the left margin if the buffer is modified.
780:
781: To visit a file, use the command `C-x C-f' (`find-file'). Follow
782: the command with the name of the file you wish to visit, terminated by a
783: RET.
784:
785: The file name is read using the minibuffer (*Note Minibuffer::), with
786: defaulting and completion in the standard manner (*Note File Names::).
787: While in the minibuffer, you can abort `C-x C-f' by typing `C-g'.
788:
789: Your confirmation that `C-x C-f' has completed successfully is the
790: appearance of new text on the screen and a new buffer name in the mode
791: line. If the specified file does not exist and could not be created, or
792: cannot be read, then an error results. The error message is printed in the
793: echo area, and includes the file name which Emacs was trying to visit.
794:
795: If you visit a file that is already in Emacs, `C-x C-f' does not make
796: another copy. It selects the existing buffer containing that file.
797: However, before doing so, it checks that the file itself has not changed
798: since you visited or saved it last. If the file has changed, a warning
799: message is printed. *Note Simultaneous Editing: Interlocking.
800:
801: What if you want to create a file? Just visit it. Emacs prints
802: `(New File)' in the echo area, but in other respects behaves as if you
803: had visited an existing empty file. If you make any changes and save them,
804: the file is created.
805:
806: If you visit a nonexistent file unintentionally (because you typed the
807: wrong file name), use the `C-x C-v' (`find-alternate-file')
808: command to visit the file you wanted. `C-x C-v' is similar to `C-x
809: C-f', but it kills the current buffer (after first offering to save it if
810: it is modified). `C-x C-v' is allowed even if the current buffer
811: is not visiting a file.
812:
813: If the file you specify is actually a directory, Dired is called on that
814: directory (*Note Dired::). This can be inhibited by setting the variable
815: `find-file-run-dired' to `nil'; then it is an error to try to
816: visit a directory.
817:
818: `C-x 4 f' (`find-file-other-window') is like `C-x C-f'
819: except that the buffer containing the specified file is selected in another
820: window. The window that was selected before `C-x 4 f' continues to
821: show the same buffer it was already showing. If this command is used when
822: only one window is being displayed, that window is split in two, with one
823: window showing the same before as before, and the other one showing the
824: newly requested file. *Note Windows::.
825:
826: There are two hook variables that allow extensions to modify the
827: operation of visiting files. Visiting a file that does not exist runs the
828: functions in the list `find-file-not-found-hooks'; the value of this
829: variable is expected to be a list of functions, and the functions are
830: called one by one until one of them returns non-`nil'. Any visiting
831: of a file, whether extant or not, expects `find-file-hooks' to
832: contain list of functions and calls them all, one by one. In both cases
833: the functions receive no arguments. Visiting a nonexistent file
834: runs the `find-file-not-found-hooks' first.
835:
836:
837: File: emacs Node: Saving, Prev: Visiting, Up: Files, Next: Reverting
838:
839: Saving Files
840: ============
841:
842: "Saving" a buffer in Emacs means writing its contents back into the file
843: that was visited in the buffer.
844:
845: `C-x C-s'
846: Save the current buffer in its visited file (`save-buffer').
847: `C-x s'
848: Save any or all buffers in their visited files (`save-some-buffers').
849: `M-~'
850: Forget that the current buffer has been changed (`not-modified').
851: `C-x C-w'
852: Save the current buffer in a specified file, and record that file as
853: the one visited in the buffer (`write-file').
854: `M-x set-visited-file-name'
855: Change file the name under which the current buffer will be saved.
856:
857: When you wish to save the file and make your changes permanent, type
858: `C-x C-s' (`save-buffer'). After saving is finished, `C-x C-s'
859: prints a message such as
860:
861: Wrote /u/rms/gnu/gnu.tasks
862:
863: If the selected buffer is not modified (no changes have been made in it
864: since the buffer was created or last saved), saving is not really done,
865: because it would have no effect. Instead, `C-x C-s' prints a message
866: in the echo area saying
867:
868: (No changes need to be written)
869:
870: The command `C-x s' (`save-some-buffers') can save any or all modified
871: buffers. First it asks, for each modified buffer, whether to save it.
872: These questions should be answered with `y' or `n'. `C-x C-c',
873: the key that kills Emacs, invokes `save-some-buffers' and therefore
874: asks the same questions.
875:
876: If you have changed a buffer and do not want the changes to be saved, you
877: should take some action to prevent it. Otherwise, each time you use
878: `save-some-buffers' you are liable to save it by mistake. One thing
879: you can do is type `M-~' (`not-modified'), which clears out the
880: indication that the buffer is modified. If you do this, none of the save
881: commands will believe that the buffer needs to be saved. (`~' is often
882: used as a mathematical symbol for `not'; thus `Meta-~' is `not', metafied.)
883: You could also use `set-visited-file-name' (see below) to mark the
884: buffer as visiting a different file name, one which is not in use for
885: anything important. Alternatively, you can undo all the changes made since
886: the file was visited or saved, by reading the text from the file again.
887: This is called "reverting". *Note Reverting::. You could also undo all
888: the changes by repeating the undo command `C-x u' until you have undone
889: all the changes; but this only works if you have not made more changes than
890: the undo mechanism can remember.
891:
892: `M-x set-visited-file-name' alters the name of the file that the
893: current buffer is visiting. It reads the new file name using the
894: minibuffer. It can be used on a buffer that is not visiting a file, too.
895: The buffer's name is changed to correspond to the file it is now visiting
896: in the usual fashion (unless the new name is in use already for some other
897: buffer; in that case, the buffer name is not changed).
898: `set-visited-file-name' does not save the buffer in the newly visited
899: file; it just alters the records inside Emacs so that, if you save the
900: buffer, it will be saved in that file. It also marks the buffer as
901: "modified" so that `C-x C-s' will save.
902:
903: If you wish to mark the buffer as visiting a different file and save it
904: right away, use `C-x C-w' (`write-file'). It is precisely
905: equivalent to `set-visited-file-name' followed by `C-x C-s'.
906: `C-x C-s' used on a buffer that is not visiting with a file has the
907: same effect as `C-x C-w'; that is, it reads a file name, marks the
908: buffer as visiting that file, and saves it there. The default file name in
909: a buffer that is not visiting a file is made by combining the buffer name
910: with the buffer's default directory.
911:
912: If Emacs is about to save a file and sees that the date of the latest
913: version on disk does not match what Emacs last read or wrote, Emacs
914: notifies you of this fact, because it probably indicates a problem caused
915: by simultaneous editing and requires your immediate attention.
916: *Note Simultaneous Editing: Interlocking.
917:
918: If the variable `require-final-newline' is non-`nil', Emacs
919: puts a newline at the end of any file that doesn't already end in one,
920: every time a file is saved or written.
921:
922: You can implement other ways to write files, and other things to be done
923: before writing them, using the hook variable `write-file-hooks'. The
924: value of this variable should be a list of Lisp functions. When a file is
925: to be written, the functions in the list are called, one by one, with no
926: arguments. If one of them returns a non-`nil' value, Emacs takes this
927: to mean that the file has been written in some suitable fashion; the rest
928: of the functions are not called, and normal writing is not done.
929:
930: * Menu:
931:
932: * Backup:: How Emacs saves the old version of your file.
933: * Interlocking:: How Emacs protects against simultaneous editing
934: of one file by two users.
935:
936:
937: File: emacs Node: Backup, Prev: Saving, Up: Saving, Next: Interlocking
938:
939: Backup Files
940: ------------
941:
942: Because Unix does not provide version numbers in file names, rewriting a
943: file in Unix automatically destroys all record of what the file used to
944: contain. Thus, saving a file from Emacs throws away the old contents of
945: the file---or it would, except that Emacs carefully copies the old contents
946: to another file, called the "backup" file, before actually saving.
947: (Provided the variable `make-backup-files' is non-`nil'.
948: Backup files are not written if this variable is `nil').
949:
950: At your option, Emacs can keep either a single backup file or a series of
951: numbered backup files for each file that you edit.
952:
953: Emacs makes a backup for a file only the first time the file is saved
954: from one buffer. No matter how many times you save a file, its backup file
955: continues to contain the contents from before the file was visited.
956: Normally this means that the backup file contains the contents from before
957: the current editing session; however, if you kill the buffer and then visit
958: the file again, a new backup file will be made by the next save.
959:
960: * Menu:
961:
962: * Names: Backup Names. How backup files are named;
963: Choosing single or numbered backup files.
964: * Deletion: Backup Deletion. Emacs deletes excess numbered backups.
965: * Copying: Backup Copying. Backups can be made by copying or renaming.
966:
967:
968: File: emacs Node: Backup Names, Prev: Backup, Up: Backup, Next: Backup Deletion
969:
970: Single or Numbered Backups
971: ..........................
972:
973: If you choose to have a single backup file (this is the default),
974: the backup file's name is constructed by appending `~' to the
975: file name being edited; thus, the backup file for `eval.c' would
976: be `eval.c~'.
977:
978: If you choose to have a series of numbered backup files, backup file
979: names are made by appending `.~', the number, and another `~' to
980: the original file name. Thus, the backup files of `eval.c' would be
981: called `eval.c.~1~', `eval.c.~2~', and so on, through names
982: like `eval.c.~259~' and beyond.
983:
984: If protection stops you from writing backup files under the usual names,
985: the backup file is written as `%backup%~' in your home directory.
986: Only one such file can exist, so only the most recently made such backup is
987: available.
988:
989: The choice of single backup or numbered backups is controlled by the
990: variable `version-control'. Its possible values are
991:
992: `t'
993: Make numbered backups.
994: `nil'
995: Make numbered backups for files that have numbered backups already.
996: Otherwise, make single backups.
997: `never'
998: Do not in any case make numbered backups; always make single backups.
999:
1000: `version-control' may be set locally in an individual buffer to
1001: control the making of backups for that buffer's file. For example,
1002: Rmail mode locally sets `version-control' to `never' to make sure
1003: that there is only one backup for an Rmail file. *Note Locals::.
1004:
1005:
1006: File: emacs Node: Backup Deletion, Prev: Backup Names, Up: Backup, Next: Backup Copying
1007:
1008: Automatic Deletion of Backups
1009: .............................
1010:
1011: To prevent unlimited consumption of disk space, Emacs can delete numbered
1012: backup versions automatically. Generally Emacs keeps the first few backups
1013: and the latest few backups, deleting any in between. This happens every
1014: time a new backup is made. The two variables that control the deletion are
1015: `kept-old-versions' and `kept-new-versions'. Their values are, respectively
1016: the number of oldest (lowest-numbered) backups to keep and the number of
1017: newest (highest-numbered) ones to keep, each time a new backup is made.
1018: Recall that these values are used just after a new backup version is made;
1019: that newly made backup is included in the count in `kept-new-versions'.
1020: By default, both variables are 2.
1021:
1022: If `trim-versions-without-asking' is non-`nil', the excess
1023: middle versions are deleted without a murmur. If it is `nil', the
1024: default, then you are asked whether the excess middle versions should
1025: really be deleted.
1026:
1027: Dired's `.' (Period) command can also be used to delete old versions.
1028: *Note Dired::.
1029:
1030:
1031: File: emacs Node: Backup Copying, Prev: Backup Deletion, Up: Backup
1032:
1033: Copying vs. Renaming
1034: ....................
1035:
1036: Backup files can be made by copying the old file or by renaming it. This
1037: makes a difference when the old file has multiple names. If the old file
1038: is renamed into the backup file, then the alternate names become names for
1039: the backup file. If the old file is copied instead, then the alternate
1040: names remain names for the file that you are editing, and the contents
1041: accessed by those names will be the new contents.
1042:
1043: The method of making a backup file may also affect the file's owner
1044: and group. If copying is used, these do not change. If renaming is used,
1045: you become the file's owner, and the file's group becomes the default
1046: (different operating systems have different defaults for the group).
1047:
1048: Having the owner change is usually a good idea, because then the owner
1049: always shows who last edited the file. Also, the owners of the backups
1050: show who produced those versions. Occasionally there is a file whose
1051: owner should not change; it is a good idea for such files to contain
1052: local variable lists to set `backup-by-copying-when-mismatch' for
1053: them alone (*Note File Variables::).
1054:
1055: The choice of renaming or copying is controlled by three variables.
1056: Normally, renaming is done. If the variable `backup-by-copying' is
1057: non-`nil', copying is used. Otherwise, if the variable
1058: `backup-by-copying-when-linked' is non-`nil', then copying is done for
1059: files that have multiple names, but renaming may still done when the file
1060: being edited has only one name. If the variable
1061: `backup-by-copying-when-mismatch' is non-`nil', then copying is done if
1062: renaming would cause the file's owner or group to change.
1063:
1064:
1065: File: emacs Node: Interlocking, Prev: Backup, Up: Saving
1066:
1067: Protection against Simultaneous Editing
1068: ---------------------------------------
1069:
1070: Simultaneous editing occurs when two users visit the same file, both make
1071: changes, and then both save them. If nobody were informed that this was
1072: happening, whichever user saved first would later find that his changes
1073: were lost. On some systems, Emacs notices immediately when the second user
1074: starts to change the file, and issues an immediate warning. When this is
1075: not possible, or if the second user has gone on to change the file despite
1076: the warning, Emacs checks later when the file is saved, and issues a second
1077: warning when a user is about to overwrite a file containing another user's
1078: changes. If the editing user takes the proper corrective action at this
1079: point, he can prevent actual loss of work.
1080:
1081: When you make the first modification in an Emacs buffer that is visiting
1082: a file, Emacs records that you have locked the file. (It does this by
1083: writing another file in a directory reserved for this purpose.) The lock
1084: is removed when you save the changes. The idea is that the file is locked
1085: whenever the buffer is modified. If you begin to modify the buffer while
1086: the visited file is locked by someone else, this constitutes a collision,
1087: and Emacs asks you what to do. It does this by calling the Lisp function
1088: `ask-user-about-lock', which you can redefine for the sake of
1089: customization. The standard definition of this function asks you a
1090: question and accepts three possible answers:
1091:
1092: `s'
1093: Steal the lock. Whoever was already changing the file loses the lock,
1094: and you gain the lock.
1095: `p'
1096: Proceed. Go ahead and edit the file despite its being locked by someone else.
1097: `q'
1098: Quit. This causes an error (`file-locked') and the modification you
1099: were trying to make in the buffer does not actually take place.
1100:
1101: Note that locking works on the basis of a file name; if a file has
1102: multiple names, Emacs does not realize that the two names are the same file
1103: and cannot prevent two user from editing it simultaneously under different
1104: names. However, basing locking on names means that Emacs can interlock the
1105: editing of new files that will not really exist until they are saved.
1106:
1107: Some systems are not configured to allow Emacs to make locks. On
1108: these systems, Emacs cannot detect trouble in advance, but it still can
1109: detect it in time to prevent you from overwriting someone else's changes.
1110:
1111: Every time Emacs saves a buffer, it first checks the last-modification
1112: date of the existing file on disk to see that it has not changed since the
1113: file was last visited or saved. If the date does not match, it implies
1114: that changes were made in the file in some other way, and these changes are
1115: about to be lost if Emacs actually does save. To prevent this, Emacs
1116: prints a warning message and asks for confirmation before saving.
1117: Occasionally you will know why the file was changed and know that it does
1118: not matter; then you can answer `yes' and proceed. Otherwise, you should
1119: cancel the save with `C-g' and investigate the situation.
1120:
1121: The first thing you should do when notified that simultaneous editing has
1122: already taken place is to list the directory with `C-u C-x C-d' (*Note
1123: Directory Listing: ListDir.). This will show the file's current author.
1124: You should attempt to contact him to warn him not to continue editing.
1125: Often the next step is to save the contents of your Emacs buffer under a
1126: different name, and use `diff' to compare the two files.
1127:
1128: Simultaneous editing checks are also made when you visit with `C-x
1129: C-f' a file that is already visited and when you start to modify a file.
1130: This is not strictly necessary, but it can cause you to find out about the
1131: problem earlier, when perhaps correction takes less work.
1132:
1133:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.