![[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 [Apple XNU] / GNUtools / emacs / info|
Return to emacs-4 CVS log | Up to [Apple XNU] / GNUtools / emacs / info |
1.1 root 1: This is Info file ../info/emacs, produced by Makeinfo-1.49 from the
2: input file emacs.texi.
3:
4: This file documents the GNU Emacs editor.
5:
6: Copyright (C) 1985, 1986, 1988, 1992 Richard M. Stallman.
7:
8: Permission is granted to make and distribute verbatim copies of this
9: manual provided the copyright notice and this permission notice are
10: preserved on all copies.
11:
12: Permission is granted to copy and distribute modified versions of
13: this manual under the conditions for verbatim copying, provided also
14: that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
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
20: manual into another language, under the above conditions for modified
21: versions, except that the sections entitled "The GNU Manifesto",
22: "Distribution" and "GNU General Public License" may be included in a
23: translation approved by the author instead of in the original English.
24:
25:
26: File: emacs, Node: Horizontal Scrolling, Prev: Scrolling, Up: Display
27:
28: Horizontal Scrolling
29: ====================
30:
31: `C-x <'
32: Scroll text in current window to the left (`scroll-left').
33:
34: `C-x >'
35: Scroll to the right (`scroll-right').
36:
37: The text in a window can also be scrolled horizontally. This means
38: that each line of text is shifted sideways in the window, and one or
39: more characters at the beginning of each line are not displayed at all.
40: When a window has been scrolled horizontally in this way, text lines
41: are truncated rather than continued (*note Continuation Lines::.), with
42: a `$' appearing in the first column when there is text truncated to the
43: left, and in the last column when there is text truncated to the right.
44:
45: The command `C-x <' (`scroll-left') scrolls the selected window to
46: the left by N columns with argument N. With no argument, it scrolls by
47: almost the full width of the window (two columns less, to be precise).
48: `C-x >' (`scroll-right') scrolls similarly to the right. The window
49: cannot be scrolled any farther to the right once it is displaying
50: normally (with each line starting at the window's left margin);
51: attempting to do so has no effect.
52:
53:
54: File: emacs, Node: Selective Display, Next: Display Vars, Prev: Display, Up: Display
55:
56: Selective Display
57: =================
58:
59: Emacs has the ability to hide lines indented more than a certain
60: number of columns (you specify how many columns). You can use this to
61: get an overview of a part of a program.
62:
63: To hide lines, type `C-x $' (`set-selective-display') with a numeric
64: argument N. (*Note Arguments::, for how to give the argument.) Then
65: lines with at least N columns of indentation disappear from the screen.
66: The only indication of their presence is that three dots (`...')
67: appear at the end of each visible line that is followed by one or more
68: invisible ones.
69:
70: The invisible lines are still present in the buffer, and most editing
71: commands see them as usual, so it is very easy to put point in the
72: middle of invisible text. When this happens, the cursor appears at the
73: end of the previous line, after the three dots. If point is at the end
74: of the visible line, before the newline that ends it, the cursor
75: appears before the three dots.
76:
77: The commands `C-n' and `C-p' move across the invisible lines as if
78: they were not there.
79:
80: To make everything visible again, type `C-x $' with no argument.
81:
82:
83: File: emacs, Node: Display Vars, Prev: Selective Display, Up: Display
84:
85: Variables Controlling Display
86: =============================
87:
88: This section contains information for customization only. Beginning
89: users should skip it.
90:
91: The variable `mode-line-inverse-video' controls whether the mode
92: line is displayed in inverse video (assuming the terminal supports it);
93: `nil' means don't do so. *Note Mode Line::.
94:
95: If the variable `inverse-video' is non-`nil', Emacs attempts to
96: invert all the lines of the display from what they normally are.
97:
98: If the variable `visible-bell' is non-`nil', Emacs attempts to make
99: the whole screen blink when it would normally make an audible bell
100: sound. This variable has no effect if your terminal does not have a way
101: to make the screen blink.
102:
103: When you reenter Emacs after suspending, Emacs normally clears the
104: screen and redraws the entire display. On some terminals with more
105: than one page of memory, it is possible to arrange the termcap entry so
106: that the `ti' and `te' strings (output to the terminal when Emacs is
107: entered and exited, respectively) switch between pages of memory so as
108: to use one page for Emacs and another page for other output. Then you
109: might want to set the variable `no-redraw-on-reenter' non-`nil' so that
110: Emacs will assume, when resumed, that the screen page it is using still
111: contains what Emacs last wrote there.
112:
113: The variable `echo-keystrokes' controls the echoing of
114: multi-character keys; its value is the number of seconds of pause
115: required to cause echoing to start, or zero meaning don't echo at all.
116: *Note Echo Area::.
117:
118: If the variable `ctl-arrow' is `nil', control characters in the
119: buffer are displayed with octal escape sequences, all except newline and
120: tab. Altering the value of `ctl-arrow' makes it local to the current
121: buffer; until that time, the default value is in effect. The default is
122: initially `t'. *Note Locals::.
123:
124: Normally, a tab character in the buffer is displayed as whitespace
125: which extends to the next display tab stop position, and display tab
126: stops come at intervals equal to eight spaces. The number of spaces
127: per tab is controlled by the variable `tab-width', which is made local
128: by changing it, just like `ctl-arrow'. Note that how the tab character
129: in the buffer is displayed has nothing to do with the definition of TAB
130: as a command.
131:
132: If you set the variable `selective-display-ellipses' to `nil', the
133: three dots do not appear at the end of a line that precedes invisible
134: lines. Then there is no visible indication of the invisible lines.
135: This variable too becomes local automatically when set.
136:
137:
138: File: emacs, Node: Search, Next: Fixit, Prev: Display, Up: Top
139:
140: Searching and Replacement
141: *************************
142:
143: Like other editors, Emacs has commands for searching for occurrences
144: of a string. The principal search command is unusual in that it is
145: "incremental"; it begins to search before you have finished typing the
146: search string. There are also nonincremental search commands more like
147: those of other editors.
148:
149: Besides the usual `replace-string' command that finds all
150: occurrences of one string and replaces them with another, Emacs has a
151: fancy replacement command called `query-replace' which asks
152: interactively which occurrences to replace.
153:
154: * Menu:
155:
156: * Incremental Search:: Search happens as you type the string.
157: * Nonincremental Search:: Specify entire string and then search.
158: * Word Search:: Search for sequence of words.
159: * Regexp Search:: Search for match for a regexp.
160: * Regexps:: Syntax of regular expressions.
161: * Search Case:: To ignore case while searching, or not.
162: * Replace:: Search, and replace some or all matches.
163: * Other Repeating Search:: Operating on all matches for some regexp.
164:
165:
166: File: emacs, Node: Incremental Search, Next: Nonincremental Search, Prev: Search, Up: Search
167:
168: Incremental Search
169: ==================
170:
171: An incremental search begins searching as soon as you type the first
172: character of the search string. As you type in the search string, Emacs
173: shows you where the string (as you have typed it so far) would be found.
174: When you have typed enough characters to identify the place you want,
175: you can stop. Depending on what you will do next, you may or may not
176: need to terminate the search explicitly with an ESC first.
177:
178: `C-s'
179: Incremental search forward (`isearch-forward').
180:
181: `C-r'
182: Incremental search backward (`isearch-backward').
183:
184: `C-s' starts an incremental search. `C-s' reads characters from the
185: keyboard and positions the cursor at the first occurrence of the
186: characters that you have typed. If you type `C-s' and then `F', the
187: cursor moves right after the first `F'. Type an `O', and see the
188: cursor move to after the first `FO'. After another `O', the cursor is
189: after the first `FOO' after the place where you started the search.
190: Meanwhile, the search string `FOO' has been echoed in the echo area.
191:
192: The echo area display ends with three dots when actual searching is
193: going on. When search is waiting for more input, the three dots are
194: removed. (On slow terminals, the three dots are not displayed.)
195:
196: If you make a mistake in typing the search string, you can erase
197: characters with DEL. Each DEL cancels the last character of search
198: string. This does not happen until Emacs is ready to read another
199: input character; first it must either find, or fail to find, the
200: character you want to erase. If you do not want to wait for this to
201: happen, use `C-g' as described below.
202:
203: When you are satisfied with the place you have reached, you can type
204: ESC, which stops searching, leaving the cursor where the search brought
205: it. Also, any command not specially meaningful in searches stops the
206: searching and is then executed. Thus, typing `C-a' would exit the
207: search and then move to the beginning of the line. ESC is necessary
208: only if the next command you want to type is a printing character, DEL,
209: ESC, or another control character that is special within searches
210: (`C-q', `C-w', `C-r', `C-s' or `C-y').
211:
212: Sometimes you search for `FOO' and find it, but not the one you
213: expected to find. There was a second `FOO' that you forgot about,
214: before the one you were looking for. In this event, type another `C-s'
215: to move to the next occurrence of the search string. This can be done
216: any number of times. If you overshoot, you can cancel some `C-s'
217: characters with DEL.
218:
219: After you exit a search, you can search for the same string again by
220: typing just `C-s C-s': the first `C-s' is the key that invokes
221: incremental search, and the second `C-s' means "search again".
222:
223: If your string is not found at all, the echo area says `Failing
224: I-Search'. The cursor is after the place where Emacs found as much of
225: your string as it could. Thus, if you search for `FOOT', and there is
226: no `FOOT', you might see the cursor after the `FOO' in `FOOL'. At this
227: point there are several things you can do. If your string was
228: mistyped, you can rub some of it out and correct it. If you like the
229: place you have found, you can type ESC or some other Emacs command to
230: "accept what the search offered". Or you can type `C-g', which removes
231: from the search string the characters that could not be found (the `T'
232: in `FOOT'), leaving those that were found (the `FOO' in `FOOT'). A
233: second `C-g' at that point cancels the search entirely, returning point
234: to where it was when the search started.
235:
236: If a search is failing and you ask to repeat it by typing another
237: `C-s', it starts again from the beginning of the buffer. Repeating a
238: failing reverse search with `C-r' starts again from the end. This is
239: called "wrapping around". `Wrapped' appears in the search prompt once
240: this has happened.
241:
242: The `C-g' "quit" character does special things during searches; just
243: what it does depends on the status of the search. If the search has
244: found what you specified and is waiting for input, `C-g' cancels the
245: entire search. The cursor moves back to where you started the search.
246: If `C-g' is typed when there are characters in the search string that
247: have not been found--because Emacs is still searching for them, or
248: because it has failed to find them--then the search string characters
249: which have not been found are discarded from the search string. With
250: them gone, the search is now successful and waiting for more input, so
251: a second `C-g' will cancel the entire search.
252:
253: To search for a control character such as `C-s' or DEL or ESC, you
254: must quote it by typing `C-q' first. This function of `C-q' is
255: analogous to its meaning as an Emacs command: it causes the following
256: character to be treated the way a graphic character would normally be
257: treated in the same context. You can also specify a quoted character
258: in octal while searching, just as you can for insertion. *Note Basic::.
259:
260: You can change to searching backwards with `C-r'. If a search fails
261: because the place you started was too late in the file, you should do
262: this. Repeated `C-r' keeps looking for more occurrences backwards. A
263: `C-s' starts going forwards again. `C-r' in a search can be cancelled
264: with DEL.
265:
266: If you know initially that you want to search backwards, you can use
267: `C-r' instead of `C-s' to start the search, because `C-r' is also a key
268: running a command (`isearch-backward') to search backward.
269:
270: The characters `C-y' and `C-w' can be used in incremental search to
271: grab text from the buffer into the search string. This makes it
272: convenient to search for another occurrence of text at point. `C-w'
273: copies the word after point as part of the search string, advancing
274: point over that word. Another `C-s' to repeat the search will then
275: search for a string including that word. `C-y' is similar to `C-w' but
276: copies all the rest of the current line into the search string.
277:
278: All the characters special in incremental search can be changed by
279: setting the following variables:
280:
281: `search-delete-char'
282: Character to delete from incremental search string (normally DEL).
283:
284: `search-exit-char'
285: Character to exit incremental search (normally ESC).
286:
287: `search-quote-char'
288: Character to quote special characters for incremental search
289: (normally `C-q').
290:
291: `search-repeat-char'
292: Character to repeat incremental search forwards (normally `C-s').
293:
294: `search-reverse-char'
295: Character to repeat incremental search backwards (normally `C-r').
296:
297: `search-yank-line-char'
298: Character to pull rest of line from buffer into search string
299: (normally `C-y').
300:
301: `search-yank-word-char'
302: Character to pull next word from buffer into search string
303: (normally `C-w').
304:
305: Slow Terminal Incremental Search
306: --------------------------------
307:
308: Incremental search on a slow terminal uses a modified style of
309: display that is designed to take less time. Instead of redisplaying
310: the buffer at each place the search gets to, it creates a new
311: single-line window and uses that to display the line that the search
312: has found. The single-line window comes into play as soon as point
313: gets outside of the text that is already on the screen.
314:
315: When the search is terminated, the single-line window is removed.
316: Only at this time is the window in which the search was done
317: redisplayed to show its new value of point.
318:
319: The three dots at the end of the search string, normally used to
320: indicate that searching is going on, are not displayed in slow style
321: display.
322:
323: The slow terminal style of display is used when the terminal baud
324: rate is less than or equal to the value of the variable
325: `search-slow-speed', initially 1200.
326:
327: The number of lines to use in slow terminal search display is
328: controlled by the variable `search-slow-window-lines'. 1 is its normal
329: value.
330:
331:
332: File: emacs, Node: Nonincremental Search, Next: Word Search, Prev: Incremental Search, Up: Search
333:
334: Nonincremental Search
335: =====================
336:
337: Emacs also has conventional nonincremental search commands, which
338: require you to type the entire search string before searching begins.
339:
340: `C-s ESC STRING RET'
341: Search for STRING.
342:
343: `C-r ESC STRING RET'
344: Search backward for STRING.
345:
346: To do a nonincremental search, first type `C-s ESC'. This enters
347: the minibuffer to read the search string; terminate the string with
348: RET, and then the search is done. If the string is not found the
349: search command gets an error.
350:
351: The way `C-s ESC' works is that the `C-s' invokes incremental
352: search, which is specially programmed to invoke nonincremental search
353: if the argument you give it is empty. (Such an empty argument would
354: otherwise be useless.) `C-r ESC' also works this way.
355:
356: Forward and backward nonincremental searches are implemented by the
357: commands `search-forward' and `search-backward'. These commands may be
358: bound to keys in the usual manner. The reason that incremental search
359: is programmed to invoke them as well is that `C-s ESC' is the
360: traditional sequence of characters used in Emacs to invoke
361: nonincremental search.
362:
363: However, nonincremental searches performed using `C-s ESC' do not
364: call `search-forward' right away. The first thing done is to see if
365: the next character is `C-w', which requests a word search. *Note Word
366: Search::.
367:
368:
369: File: emacs, Node: Word Search, Next: Regexp Search, Prev: Nonincremental Search, Up: Search
370:
371: Word Search
372: ===========
373:
374: Word search searches for a sequence of words without regard to how
375: the words are separated. More precisely, you type a string of many
376: words, using single spaces to separate them, and the string can be
377: found even if there are multiple spaces, newlines or other punctuation
378: between the words.
379:
380: Word search is useful in editing documents formatted by text
381: formatters. If you edit while looking at the printed, formatted
382: version, you can't tell where the line breaks are in the source file.
383: With word search, you can search without having to know them.
384:
385: `C-s ESC C-w WORDS RET'
386: Search for WORDS, ignoring differences in punctuation.
387:
388: `C-r ESC C-w WORDS RET'
389: Search backward for WORDS, ignoring differences in punctuation.
390:
391: Word search is a special case of nonincremental search and is invoked
392: with `C-s ESC C-w'. This is followed by the search string, which must
393: always be terminated with RET. Being nonincremental, this search does
394: not start until the argument is terminated. It works by constructing a
395: regular expression and searching for that. *Note Regexp Search::.
396:
397: A backward word search can be done by `C-r ESC C-w'.
398:
399: Forward and backward word searches are implemented by the commands
400: `word-search-forward' and `word-search-backward'. These commands may
401: be bound to keys in the usual manner. The reason that incremental
402: search is programmed to invoke them as well is that `C-s ESC C-w' is
403: the traditional Emacs sequence of keys for word search.
404:
405:
406: File: emacs, Node: Regexp Search, Next: Regexps, Prev: Word Search, Up: Search
407:
408: Regular Expression Search
409: =========================
410:
411: A "regular expression" ("regexp", for short) is a pattern that
412: denotes a set of strings, possibly an infinite set. Searching for
413: matches for a regexp is a very powerful operation that editors on Unix
414: systems have traditionally offered. In GNU Emacs, you can search for
415: the next match for a regexp either incrementally or not.
416:
417: Incremental search for a regexp is done by typing `C-M-s'
418: (`isearch-forward-regexp'). This command reads a search string
419: incrementally just like `C-s', but it treats the search string as a
420: regexp rather than looking for an exact match against the text in the
421: buffer. Each time you add text to the search string, you make the
422: regexp longer, and the new regexp is searched for. A reverse regexp
423: search command, `isearch-backward-regexp', also exists but no key runs
424: it.
425:
426: All of the control characters that do special things within an
427: ordinary incremental search have the same function in incremental
428: regexp search. Typing `C-s' or `C-r' immediately after starting the
429: search retrieves the last incremental search regexp used; that is to
430: say, incremental regexp and non-regexp searches have independent
431: defaults.
432:
433: Note that adding characters to the regexp in an incremental regexp
434: search does not make the cursor move back and start again. Perhaps it
435: ought to; I am not sure. As it stands, if you have searched for `foo'
436: and you add `\|bar', the search will not check for a `bar' in the
437: buffer before the `foo'.
438:
439: Nonincremental search for a regexp is done by the functions
440: `re-search-forward' and `re-search-backward'. You can invoke these
441: with `M-x', or bind them to keys. Also, you can call
442: `re-search-forward' by way of incremental regexp search with `C-M-s
443: ESC'.
444:
445:
446: File: emacs, Node: Regexps, Next: Search Case, Prev: Regexp Search, Up: Search
447:
448: Syntax of Regular Expressions
449: =============================
450:
451: Regular expressions have a syntax in which a few characters are
452: special constructs and the rest are "ordinary". An ordinary character
453: is a simple regular expression which matches that character and nothing
454: else. The special characters are `$', `^', `.', `*', `+', `?', `[', `]'
455: and `\'; no new special characters will be defined. Any other
456: character appearing in a regular expression is ordinary, unless a `\'
457: precedes it.
458:
459: For example, `f' is not a special character, so it is ordinary, and
460: therefore `f' is a regular expression that matches the string `f' and
461: no other string. (It does not match the string `ff'.) Likewise, `o'
462: is a regular expression that matches only `o'.
463:
464: Any two regular expressions A and B can be concatenated. The result
465: is a regular expression which matches a string if A matches some amount
466: of the beginning of that string and B matches the rest of the string.
467:
468: As a simple example, we can concatenate the regular expressions `f'
469: and `o' to get the regular expression `fo', which matches only the
470: string `fo'. Still trivial. To do something nontrivial, you need to
471: use one of the special characters. Here is a list of them.
472:
473: `. (Period)'
474: is a special character that matches any single character except a
475: newline. Using concatenation, we can make regular expressions like
476: `a.b' which matches any three-character string which begins with
477: `a' and ends with `b'.
478:
479: `*'
480: is not a construct by itself; it is a suffix, which means the
481: preceding regular expression is to be repeated as many times as
482: possible. In `fo*', the `*' applies to the `o', so `fo*' matches
483: one `f' followed by any number of `o's. The case of zero `o's is
484: allowed: `fo*' does match `f'.
485:
486: `*' always applies to the smallest possible preceding expression.
487: Thus, `fo*' has a repeating `o', not a repeating `fo'.
488:
489: The matcher processes a `*' construct by matching, immediately, as
490: many repetitions as can be found. Then it continues with the rest
491: of the pattern. If that fails, backtracking occurs, discarding
492: some of the matches of the `*'-modified construct in case that
493: makes it possible to match the rest of the pattern. For example,
494: matching `ca*ar' against the string `caaar', the `a*' first tries
495: to match all three `a's; but the rest of the pattern is `ar' and
496: there is only `r' left to match, so this try fails. The next
497: alternative is for `a*' to match only two `a's. With this choice,
498: the rest of the regexp matches successfully.
499:
500: `+'
501: Is a suffix character similar to `*' except that it requires that
502: the preceding expression be matched at least once. So, for
503: example, `ca+r' will match the strings `car' and `caaaar' but not
504: the string `cr', whereas `ca*r' would match all three strings.
505:
506: `?'
507: Is a suffix character similar to `*' except that it can match the
508: preceding expression either once or not at all. For example,
509: `ca?r' will match `car' or `cr'; nothing else.
510:
511: `[ ... ]'
512: `[' begins a "character set", which is terminated by a `]'. In
513: the simplest case, the characters between the two form the set.
514: Thus, `[ad]' matches either one `a' or one `d', and `[ad]*'
515: matches any string composed of just `a's and `d's (including the
516: empty string), from which it follows that `c[ad]*r' matches `cr',
517: `car', `cdr', `caddaar', etc.
518:
519: Character ranges can also be included in a character set, by
520: writing two characters with a `-' between them. Thus, `[a-z]'
521: matches any lower-case letter. Ranges may be intermixed freely
522: with individual characters, as in `[a-z$%.]', which matches any
523: lower case letter or `$', `%' or period.
524:
525: Note that the usual special characters are not special any more
526: inside a character set. A completely different set of special
527: characters exists inside character sets: `]', `-' and `^'.
528:
529: To include a `]' in a character set, you must make it the first
530: character. For example, `[]a]' matches `]' or `a'. To include a
531: `-', write `---', which is a range containing only `-'. To
532: include `^', make it other than the first character in the set.
533:
534: `[^ ... ]'
535: `[^' begins a "complement character set", which matches any
536: character except the ones specified. Thus, `[^a-z0-9A-Z]' matches
537: all characters except letters and digits.
538:
539: `^' is not special in a character set unless it is the first
540: character. The character following the `^' is treated as if it
541: were first (`-' and `]' are not special there).
542:
543: Note that a complement character set can match a newline, unless
544: newline is mentioned as one of the characters not to match.
545:
546: `^'
547: is a special character that matches the empty string, but only if
548: at the beginning of a line in the text being matched. Otherwise
549: it fails to match anything. Thus, `^foo' matches a `foo' which
550: occurs at the beginning of a line.
551:
552: `$'
553: is similar to `^' but matches only at the end of a line. Thus,
554: `xx*$' matches a string of one `x' or more at the end of a line.
555:
556: `\'
557: has two functions: it quotes the special characters (including
558: `\'), and it introduces additional special constructs.
559:
560: Because `\' quotes special characters, `\$' is a regular
561: expression which matches only `$', and `\[' is a regular
562: expression which matches only `[', and so on.
563:
564: Note: for historical compatibility, special characters are treated as
565: ordinary ones if they are in contexts where their special meanings make
566: no sense. For example, `*foo' treats `*' as ordinary since there is no
567: preceding expression on which the `*' can act. It is poor practice to
568: depend on this behavior; better to quote the special character anyway,
569: regardless of where is appears.
570:
571: For the most part, `\' followed by any character matches only that
572: character. However, there are several exceptions: characters which,
573: when preceded by `\', are special constructs. Such characters are
574: always ordinary when encountered on their own. Here is a table of `\'
575: constructs.
576:
577: `\|'
578: specifies an alternative. Two regular expressions A and B with
579: `\|' in between form an expression that matches anything that
580: either A or B will match.
581:
582: Thus, `foo\|bar' matches either `foo' or `bar' but no other string.
583:
584: `\|' applies to the largest possible surrounding expressions.
585: Only a surrounding `\( ... \)' grouping can limit the grouping
586: power of `\|'.
587:
588: Full backtracking capability exists to handle multiple uses of
589: `\|'.
590:
591: `\( ... \)'
592: is a grouping construct that serves three purposes:
593:
594: 1. To enclose a set of `\|' alternatives for other operations.
595: Thus, `\(foo\|bar\)x' matches either `foox' or `barx'.
596:
597: 2. To enclose a complicated expression for the postfix `*' to
598: operate on. Thus, `ba\(na\)*' matches `bananana', etc., with
599: any (zero or more) number of `na' strings.
600:
601: 3. To mark a matched substring for future reference.
602:
603:
604: This last application is not a consequence of the idea of a
605: parenthetical grouping; it is a separate feature which happens to
606: be assigned as a second meaning to the same `\( ... \)' construct
607: because there is no conflict in practice between the two meanings.
608: Here is an explanation of this feature:
609:
610: `\DIGIT'
611: after the end of a `\( ... \)' construct, the matcher remembers the
612: beginning and end of the text matched by that construct. Then,
613: later on in the regular expression, you can use `\' followed by
614: DIGIT to mean "match the same text matched the DIGIT'th time by the
615: `\( ... \)' construct."
616:
617: The strings matching the first nine `\( ... \)' constructs
618: appearing in a regular expression are assigned numbers 1 through 9
619: in order that the open-parentheses appear in the regular
620: expression. `\1' through `\9' may be used to refer to the text
621: matched by the corresponding `\( ... \)' construct.
622:
623: For example, `\(.*\)\1' matches any newline-free string that is
624: composed of two identical halves. The `\(.*\)' matches the first
625: half, which may be anything, but the `\1' that follows must match
626: the same exact text.
627:
628: `\`'
629: matches the empty string, provided it is at the beginning of the
630: buffer.
631:
632: `\''
633: matches the empty string, provided it is at the end of the buffer.
634:
635: `\b'
636: matches the empty string, provided it is at the beginning or end
637: of a word. Thus, `\bfoo\b' matches any occurrence of `foo' as a
638: separate word. `\bballs?\b' matches `ball' or `balls' as a
639: separate word.
640:
641: `\B'
642: matches the empty string, provided it is not at the beginning or
643: end of a word.
644:
645: `\<'
646: matches the empty string, provided it is at the beginning of a
647: word.
648:
649: `\>'
650: matches the empty string, provided it is at the end of a word.
651:
652: `\w'
653: matches any word-constituent character. The editor syntax table
654: determines which characters these are.
655:
656: `\W'
657: matches any character that is not a word-constituent.
658:
659: `\sCODE'
660: matches any character whose syntax is CODE. CODE is a character
661: which represents a syntax code: thus, `w' for word constituent,
662: `-' for whitespace, `(' for open-parenthesis, etc. *Note Syntax::.
663:
664: `\SCODE'
665: matches any character whose syntax is not CODE.
666:
667: Here is a complicated regexp, used by Emacs to recognize the end of a
668: sentence together with any whitespace that follows. It is given in Lisp
669: syntax to enable you to distinguish the spaces from the tab characters.
670: In Lisp syntax, the string constant begins and ends with a
671: double-quote. `\"' stands for a double-quote as part of the regexp,
672: `\\' for a backslash as part of the regexp, `\t' for a tab and `\n' for
673: a newline.
674:
675: "[.?!][]\"')]*\\($\\|\t\\| \\)[ \t\n]*"
676:
677: This contains four parts in succession: a character set matching period,
678: `?' or `!'; a character set matching close-brackets, quotes or
679: parentheses, repeated any number of times; an alternative in
680: backslash-parentheses that matches end-of-line, a tab or two spaces;
681: and a character set matching whitespace characters, repeated any number
682: of times.
683:
684: Note that the above example shows how to write this regexp when
685: entering it as part of an Emacs Lisp program. To enter the same regexp
686: in an interactive command such as `re-search-forward' you must spell it
687: differently:
688:
689: [.?!][]"')]*\($\|^Q^I\| \)[ ^Q^I^Q^J]*
690:
691:
692: File: emacs, Node: Search Case, Next: Replace, Prev: Regexps, Up: Search
693:
694: Searching and Case
695: ==================
696:
697: All sorts of searches in Emacs normally ignore the case of the text
698: they are searching through; if you specify searching for `FOO', then
699: `Foo' and `foo' are also considered a match. Regexps, and in
700: particular character sets, are included: `[aB]' would match `a' or `A'
701: or `b' or `B'.
702:
703: If you do not want this feature, set the variable `case-fold-search'
704: to `nil'. Then all letters must match exactly, including case. This
705: is a per-buffer variable; altering the variable affects only the current
706: buffer, but there is a default value which you can change as well.
707: *Note Locals::.
708:
709:
710: File: emacs, Node: Replace, Next: Other Repeating Search, Prev: Search Case, Up: Search
711:
712: Replacement Commands
713: ====================
714:
715: Global search-and-replace operations are not needed as often in
716: Emacs as they are in other editors, but they are available. In
717: addition to the simple `replace-string' command which is like that
718: found in most editors, there is a `query-replace' command which asks
719: you, for each occurrence of the pattern, whether to replace it.
720:
721: The replace commands all replace one string (or regexp) with one
722: replacement string. It is possible to perform several replacements in
723: parallel using the command `expand-region-abbrevs'. *Note Expanding
724: Abbrevs::.
725:
726: * Menu:
727:
728: * Unconditional Replace:: Replacing all matches for a string.
729: * Regexp Replace:: Replacing all matches for a regexp.
730: * Replacement and Case:: How replacements preserve case of letters.
731: * Query Replace:: How to use querying.
732:
733:
734: File: emacs, Node: Unconditional Replace, Next: Regexp Replace, Prev: Replace, Up: Replace
735:
736: Unconditional Replacement
737: -------------------------
738:
739: `M-x replace-string RET STRING RET NEWSTRING RET'
740: Replace every occurrence of STRING with NEWSTRING.
741:
742: `M-x replace-regexp RET REGEXP RET NEWSTRING RET'
743: Replace every match for REGEXP with NEWSTRING.
744:
745: To replace every instance of `foo' after point with `bar', use the
746: command `M-x replace-string' with the two arguments `foo' and `bar'.
747: Replacement occurs only after point, so if you want to cover the whole
748: buffer you must go to the beginning first. All occurrences up to the
749: end of the buffer are replaced; to limit replacement to part of the
750: buffer, narrow to that part of the buffer before doing the replacement
751: (*note Narrowing::.).
752:
753: When `replace-string' exits, point is left at the last occurrence
754: replaced. The value of point when the `replace-string' command was
755: issued is remembered on the mark ring; `C-u C-SPC' moves back there.
756:
757: A numeric argument restricts replacement to matches that are
758: surrounded by word boundaries.
759:
760:
761: File: emacs, Node: Regexp Replace, Next: Replacement and Case, Prev: Unconditional Replace, Up: Replace
762:
763: Regexp Replacement
764: ------------------
765:
766: `replace-string' replaces exact matches for a single string. The
767: similar command `replace-regexp' replaces any match for a specified
768: pattern.
769:
770: In `replace-regexp', the NEWSTRING need not be constant. It can
771: refer to all or part of what is matched by the REGEXP. `\&' in
772: NEWSTRING stands for the entire text being replaced. `\D' in NEWSTRING,
773: where D is a digit, stands for whatever matched the D'th parenthesized
774: grouping in REGEXP. For example,
775:
776: M-x replace-regexp RET c[ad]+r RET \&-safe RET
777:
778: would replace (for example) `cadr' with `cadr-safe' and `cddr' with
779: `cddr-safe'.
780:
781: M-x replace-regexp RET \(c[ad]+r\)-safe RET \1 RET
782:
783: would perform exactly the opposite replacements. To include a `\' in
784: the text to replace with, you must give `\\'.
785:
786:
787: File: emacs, Node: Replacement and Case, Next: Query Replace, Prev: Regexp Replace, Up: Replace
788:
789: Replace Commands and Case
790: -------------------------
791:
792: If the arguments to a replace command are in lower case, it preserves
793: case when it makes a replacement. Thus, the command
794:
795: M-x replace-string RET foo RET bar RET
796:
797: replaces a lower case `foo' with a lower case `bar', `FOO' with `BAR',
798: and `Foo' with `Bar'. If upper case letters are used in the second
799: argument, they remain upper case every time that argument is inserted.
800: If upper case letters are used in the first argument, the second
801: argument is always substituted exactly as given, with no case
802: conversion. Likewise, if the variable `case-replace' is set to `nil',
803: replacement is done without case conversion. If `case-fold-search' is
804: set to `nil', case is significant in matching occurrences of `foo' to
805: replace; also, case conversion of the replacement string is not done.
806:
807:
808: File: emacs, Node: Query Replace, Prev: Replacement and Case, Up: Replace
809:
810: Query Replace
811: -------------
812:
813: `M-% STRING RET NEWSTRING RET'
814: `M-x query-replace RET STRING RET NEWSTRING RET'
815: Replace some occurrences of STRING with NEWSTRING.
816:
817: `M-x query-replace-regexp RET REGEXP RET NEWSTRING RET'
818: Replace some matches for REGEXP with NEWSTRING.
819:
820: If you want to change only some of the occurrences of `foo' to
821: `bar', not all of them, then you cannot use an ordinary
822: `replace-string'. Instead, use `M-%' (`query-replace'). This command
823: finds occurrences of `foo' one by one, displays each occurrence and
824: asks you whether to replace it. A numeric argument to `query-replace'
825: tells it to consider only occurrences that are bounded by
826: word-delimiter characters.
827:
828: Aside from querying, `query-replace' works just like
829: `replace-string', and `query-replace-regexp' works just like
830: `replace-regexp'.
831:
832: The things you can type when you are shown an occurrence of STRING
833: or a match for REGEXP are:
834:
835: `SPC'
836: to replace the occurrence with NEWSTRING. This preserves case,
837: just like `replace-string', provided `case-replace' is non-`nil',
838: as it normally is.
839:
840: `DEL'
841: to skip to the next occurrence without replacing this one.
842:
843: `, (Comma)'
844: to replace this occurrence and display the result. You are then
845: asked for another input character, except that since the
846: replacement has already been made, DEL and SPC are equivalent.
847: You could type `C-r' at this point (see below) to alter the
848: replaced text. You could also type `C-x u' to undo the
849: replacement; this exits the `query-replace', so if you want to do
850: further replacement you must use `C-x ESC' to restart (*note
851: Repetition::.).
852:
853: `ESC'
854: to exit without doing any more replacements.
855:
856: `. (Period)'
857: to replace this occurrence and then exit.
858:
859: `!'
860: to replace all remaining occurrences without asking again.
861:
862: `^'
863: to go back to the location of the previous occurrence (or what
864: used to be an occurrence), in case you changed it by mistake.
865: This works by popping the mark ring. Only one `^' in a row is
866: allowed, because only one previous replacement location is kept
867: during `query-replace'.
868:
869: `C-r'
870: to enter a recursive editing level, in case the occurrence needs
871: to be edited rather than just replaced with NEWSTRING. When you
872: are done, exit the recursive editing level with `C-M-c' and the
873: next occurrence will be displayed. *Note Recursive Edit::.
874:
875: `C-w'
876: to delete the occurrence, and then enter a recursive editing level
877: as in `C-r'. Use the recursive edit to insert text to replace the
878: deleted occurrence of STRING. When done, exit the recursive
879: editing level with `C-M-c' and the next occurrence will be
880: displayed.
881:
882: `C-l'
883: to redisplay the screen and then give another answer.
884:
885: `C-h'
886: to display a message summarizing these options, then give another
887: answer.
888:
889: If you type any other character, the `query-replace' is exited, and
890: the character executed as a command. To restart the `query-replace',
891: use `C-x ESC', which repeats the `query-replace' because it used the
892: minibuffer to read its arguments. *Note C-x ESC: Repetition.
893:
894: To replace every occurrence, you can start `query-replace' at the
895: beginning of the buffer and type `!', or you can use the
896: `replace-string' command at the beginning of the buffer. To replace
897: every occurrence in a part of the buffer, narrow to that part and then
898: run `replace-string' or `query-replace' at the beginning of it. *Note
899: Narrowing::.
900:
901:
902: File: emacs, Node: Other Repeating Search, Prev: Replace, Up: Search
903:
904: Other Search-and-Loop Commands
905: ==============================
906:
907: Here are some other commands that find matches for a regular
908: expression. They all operate from point to the end of the buffer.
909:
910: `M-x occur'
911: Print each line that follows point and contains a match for the
912: specified regexp. A numeric argument specifies the number of
913: context lines to print before and after each matching line; the
914: default is none.
915:
916: The buffer `*Occur*' containing the output serves as a menu for
917: finding the occurrences in their original context. Find an
918: occurrence as listed in `*Occur*', position point there and type
919: `C-c C-c'; this switches to the buffer that was searched and moves
920: point to the original of the same occurrence.
921:
922: `M-x list-matching-lines'
923: Synonym for `M-x occur'.
924:
925: `M-x count-matches'
926: Print the number of matches following point for the specified
927: regexp.
928:
929: `M-x delete-non-matching-lines'
930: Delete each line that follows point and does not contain a match
931: for the specified regexp.
932:
933: `M-x delete-matching-lines'
934: Delete each line that follows point and contains a match for the
935: specified regexp.
936:
937:
938: File: emacs, Node: Fixit, Next: Files, Prev: Search, Up: Top
939:
940: Commands for Fixing Typos
941: *************************
942:
943: In this chapter we describe the commands that are especially useful
944: for the times when you catch a mistake in your text just after you have
945: made it, or change your mind while composing text on line.
946:
947: * Menu:
948:
949: * Kill Errors:: Commands to kill a batch of recently entered text.
950: * Transpose:: Exchanging two characters, words, lines, lists...
951: * Fixing Case:: Correcting case of last word entered.
952: * Spelling:: Apply spelling checker to a word, or a whole file.
953:
954:
955: File: emacs, Node: Kill Errors, Next: Transpose, Prev: Fixit, Up: Fixit
956:
957: Killing Your Mistakes
958: =====================
959:
960: `DEL'
961: Delete last character (`delete-backward-char').
962:
963: `M-DEL'
964: Kill last word (`backward-kill-word').
965:
966: `C-x DEL'
967: Kill to beginning of sentence (`backward-kill-sentence').
968:
969: The DEL character (`delete-backward-char') is the most important
970: correction command. When used among graphic (self-inserting)
971: characters, it can be thought of as canceling the last character typed.
972:
973: When your mistake is longer than a couple of characters, it might be
974: more convenient to use `M-DEL' or `C-x DEL'. `M-DEL' kills back to the
975: start of the last word, and `C-x DEL' kills back to the start of the
976: last sentence. `C-x DEL' is particularly useful when you are thinking
977: of what to write as you type it, in case you change your mind about
978: phrasing. `M-DEL' and `C-x DEL' save the killed text for `C-y' and
979: `M-y' to retrieve. *Note Yanking::.
980:
981: `M-DEL' is often useful even when you have typed only a few
982: characters wrong, if you know you are confused in your typing and aren't
983: sure exactly what you typed. At such a time, you cannot correct with
984: DEL except by looking at the screen to see what you did. It requires
985: less thought to kill the whole word and start over again.
986:
987:
988: File: emacs, Node: Transpose, Next: Fixing Case, Prev: Kill Errors, Up: Fixit
989:
990: Transposing Text
991: ================
992:
993: `C-t'
994: Transpose two characters (`transpose-chars').
995:
996: `M-t'
997: Transpose two words (`transpose-words').
998:
999: `C-M-t'
1000: Transpose two balanced expressions (`transpose-sexps').
1001:
1002: `C-x C-t'
1003: Transpose two lines (`transpose-lines').
1004:
1005: The common error of transposing two characters can be fixed, when
1006: they are adjacent, with the `C-t' command (`transpose-chars').
1007: Normally, `C-t' transposes the two characters on either side of point.
1008: When given at the end of a line, rather than transposing the last
1009: character of the line with the newline, which would be useless, `C-t'
1010: transposes the last two characters on the line. So, if you catch your
1011: transposition error right away, you can fix it with just a `C-t'. If
1012: you don't catch it so fast, you must move the cursor back to between
1013: the two transposed characters. If you transposed a space with the last
1014: character of the word before it, the word motion commands are a good
1015: way of getting there. Otherwise, a reverse search (`C-r') is often the
1016: best way. *Note Search::.
1017:
1018: `Meta-t' (`transpose-words') transposes the word before point with
1019: the word after point. It moves point forward over a word, dragging the
1020: word preceding or containing point forward as well. The punctuation
1021: characters between the words do not move. For example, `FOO, BAR'
1022: transposes into `BAR, FOO' rather than `BAR FOO,'.
1023:
1024: `C-M-t' (`transpose-sexps') is a similar command for transposing two
1025: expressions (*note Lists::.), and `C-x C-t' (`transpose-lines')
1026: exchanges lines. They work like `M-t' except in determining the
1027: division of the text into syntactic units.
1028:
1029: A numeric argument to a transpose command serves as a repeat count:
1030: it tells the transpose command to move the character (word, sexp, line)
1031: before or containing point across several other characters (words,
1032: sexps, lines). For example, `C-u 3 C-t' moves the character before
1033: point forward across three other characters. This is equivalent to
1034: repeating `C-t' three times. `C-u - 4 M-t' moves the word before point
1035: backward across four words. `C-u - C-M-t' would cancel the effect of
1036: plain `C-M-t'.
1037:
1038: A numeric argument of zero is assigned a special meaning (because
1039: otherwise a command with a repeat count of zero would do nothing): to
1040: transpose the character (word, sexp, line) ending after point with the
1041: one ending after the mark.
1042:
1043:
1044: File: emacs, Node: Fixing Case, Next: Spelling, Prev: Transpose, Up: Fixit
1045:
1046: Case Conversion
1047: ===============
1048:
1049: `M-- M-l'
1050: Convert last word to lower case. Note `Meta--' is Meta-minus.
1051:
1052: `M-- M-u'
1053: Convert last word to all upper case.
1054:
1055: `M-- M-c'
1056: Convert last word to lower case with capital initial.
1057:
1058: A very common error is to type words in the wrong case. Because of
1059: this, the word case-conversion commands `M-l', `M-u' and `M-c' have a
1060: special feature when used with a negative argument: they do not move the
1061: cursor. As soon as you see you have mistyped the last word, you can
1062: simply case-convert it and go on typing. *Note Case::.
1063:
1064:
1065: File: emacs, Node: Spelling, Prev: Fixing Case, Up: Fixit
1066:
1067: Checking and Correcting Spelling
1068: ================================
1069:
1070: `M-$'
1071: Check and correct spelling of word (`spell-word').
1072:
1073: `M-x spell-buffer'
1074: Check and correct spelling of each word in the buffer.
1075:
1076: `M-x spell-region'
1077: Check and correct spelling of each word in the region.
1078:
1079: `M-x spell-string'
1080: Check spelling of specified word.
1081:
1082: To check the spelling of the word before point, and optionally
1083: correct it as well, use the command `M-$' (`spell-word'). This command
1084: runs an inferior process containing the `spell' program to see whether
1085: the word is correct English. If it is not, it asks you to edit the
1086: word (in the minibuffer) into a corrected spelling, and then does a
1087: `query-replace' to substitute the corrected spelling for the old one
1088: throughout the buffer.
1089:
1090: If you exit the minibuffer without altering the original spelling, it
1091: means you do not want to do anything to that word. Then the
1092: `query-replace' is not done.
1093:
1094: `M-x spell-buffer' checks each word in the buffer the same way that
1095: `spell-word' does, doing a `query-replace' if appropriate for every
1096: incorrect word.
1097:
1098: `M-x spell-region' is similar but operates only on the region, not
1099: the entire buffer.
1100:
1101: `M-x spell-string' reads a string as an argument and checks whether
1102: that is a correctly spelled English word. It prints in the echo area a
1103: message giving the answer.
1104:
1105:
1106: File: emacs, Node: Files, Next: Buffers, Prev: Fixit, Up: Top
1107:
1108: File Handling
1109: *************
1110:
1111: The basic unit of stored data in Unix is the "file". To edit a file,
1112: you must tell Emacs to examine the file and prepare a buffer containing
1113: a copy of the file's text. This is called "visiting" the file. Editing
1114: commands apply directly to text in the buffer; that is, to the copy
1115: inside Emacs. Your changes appear in the file itself only when you
1116: "save" the buffer back into the file.
1117:
1118: In addition to visiting and saving files, Emacs can delete, copy,
1119: rename, and append to files, and operate on file directories.
1120:
1121: * Menu:
1122:
1123: * File Names:: How to type and edit file name arguments.
1124: * Visiting:: Visiting a file prepares Emacs to edit the file.
1125: * Saving:: Saving makes your changes permanent.
1126: * Reverting:: Reverting cancels all the changes not saved.
1127: * Auto Save:: Auto Save periodically protects against loss of data.
1128: * ListDir:: Listing the contents of a file directory.
1129: * Dired:: "Editing" a directory to delete, rename, etc.
1130: the files in it.
1131: * Misc File Ops:: Other things you can do on files.
1132:
1133:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.