-way of incremental regexp search with `M-C-s <RET>'.
-
-\1f
-File: xemacs.info, Node: Regexps, Next: Search Case, Prev: Regexp Search, Up: Search
-
-Syntax of Regular Expressions
-=============================
-
- Regular expressions have a syntax in which a few characters are
-special constructs and the rest are "ordinary". An ordinary character
-is a simple regular expression which matches that character and nothing
-else. The special characters are `$', `^', `.', `*', `+', `?', `[',
-`]' and `\'; no new special characters will be defined. Any other
-character appearing in a regular expression is ordinary, unless a `\'
-precedes it.
-
- For example, `f' is not a special character, so it is ordinary, and
-therefore `f' is a regular expression that matches the string `f' and
-no other string. (It does not match the string `ff'.) Likewise, `o'
-is a regular expression that matches only `o'.
-
- Any two regular expressions A and B can be concatenated. The result
-is a regular expression which matches a string if A matches some amount
-of the beginning of that string and B matches the rest of the string.
-
- As a simple example, you can concatenate the regular expressions `f'
-and `o' to get the regular expression `fo', which matches only the
-string `fo'. To do something nontrivial, you need to use one of the
-following special characters:
-
-`. (Period)'
- is a special character that matches any single character except a
- newline. Using concatenation, you can make regular expressions
- like `a.b', which matches any three-character string which begins
- with `a' and ends with `b'.
-
-`*'
- is not a construct by itself; it is a suffix, which means the
- preceding regular expression is to be repeated as many times as
- possible. In `fo*', the `*' applies to the `o', so `fo*' matches
- one `f' followed by any number of `o's. The case of zero `o's is
- allowed: `fo*' does match `f'.
-
- `*' always applies to the smallest possible preceding expression.
- Thus, `fo*' has a repeating `o', not a repeating `fo'.
-
- The matcher processes a `*' construct by immediately matching as
- many repetitions as it can find. Then it continues with the rest
- of the pattern. If that fails, backtracking occurs, discarding
- some of the matches of the `*'-modified construct in case that
- makes it possible to match the rest of the pattern. For example,
- matching `ca*ar' against the string `caaar', the `a*' first tries
- to match all three `a's; but the rest of the pattern is `ar' and
- there is only `r' left to match, so this try fails. The next
- alternative is for `a*' to match only two `a's. With this choice,
- the rest of the regexp matches successfully.
-
-`+'
- is a suffix character similar to `*' except that it requires that
- the preceding expression be matched at least once. For example,
- `ca+r' will match the strings `car' and `caaaar' but not the
- string `cr', whereas `ca*r' would match all three strings.
-
-`?'
- is a suffix character similar to `*' except that it can match the
- preceding expression either once or not at all. For example,
- `ca?r' will match `car' or `cr'; nothing else.
-
-`[ ... ]'
- `[' begins a "character set", which is terminated by a `]'. In
- the simplest case, the characters between the two form the set.
- Thus, `[ad]' matches either one `a' or one `d', and `[ad]*'
- matches any string composed of just `a's and `d's (including the
- empty string), from which it follows that `c[ad]*r' matches `cr',
- `car', `cdr', `caddaar', etc.
-
- You can include character ranges in a character set by writing two
- characters with a `-' between them. Thus, `[a-z]' matches any
- lower-case letter. Ranges may be intermixed freely with individual
- characters, as in `[a-z$%.]', which matches any lower-case letter
- or `$', `%', or period.
-
- Note that inside a character set the usual special characters are
- not special any more. A completely different set of special
- characters exists inside character sets: `]', `-', and `^'.
-
- To include a `]' in a character set, you must make it the first
- character. For example, `[]a]' matches `]' or `a'. To include a
- `-', write `---', which is a range containing only `-'. To
- include `^', make it other than the first character in the set.
-
-`[^ ... ]'
- `[^' begins a "complement character set", which matches any
- character except the ones specified. Thus, `[^a-z0-9A-Z]' matches
- all characters except letters and digits.
-
- `^' is not special in a character set unless it is the first
- character. The character following the `^' is treated as if it
- were first (`-' and `]' are not special there).
-
- Note that a complement character set can match a newline, unless
- newline is mentioned as one of the characters not to match.
-
-`^'
- is a special character that matches the empty string, but only if
- at the beginning of a line in the text being matched. Otherwise,
- it fails to match anything. Thus, `^foo' matches a `foo' that
- occurs at the beginning of a line.
-
-`$'
- is similar to `^' but matches only at the end of a line. Thus,
- `xx*$' matches a string of one `x' or more at the end of a line.
-
-`\'
- does two things: it quotes the special characters (including `\'),
- and it introduces additional special constructs.
-
- Because `\' quotes special characters, `\$' is a regular
- expression that matches only `$', and `\[' is a regular expression
- that matches only `[', and so on.
-
- Note: for historical compatibility, special characters are treated as
-ordinary ones if they are in contexts where their special meanings make
-no sense. For example, `*foo' treats `*' as ordinary since there is no
-preceding expression on which the `*' can act. It is poor practice to
-depend on this behavior; better to quote the special character anyway,
-regardless of where is appears.
-
- Usually, `\' followed by any character matches only that character.
-However, there are several exceptions: characters which, when preceded
-by `\', are special constructs. Such characters are always ordinary
-when encountered on their own. Here is a table of `\' constructs.
-
-`\|'
- specifies an alternative. Two regular expressions A and B with
- `\|' in between form an expression that matches anything A or B
- matches.
-
- Thus, `foo\|bar' matches either `foo' or `bar' but no other string.
-
- `\|' applies to the largest possible surrounding expressions.
- Only a surrounding `\( ... \)' grouping can limit the grouping
- power of `\|'.
-
- Full backtracking capability exists to handle multiple uses of
- `\|'.
-
-`\( ... \)'
- is a grouping construct that serves three purposes:
-
- 1. To enclose a set of `\|' alternatives for other operations.
- Thus, `\(foo\|bar\)x' matches either `foox' or `barx'.
-
- 2. To enclose a complicated expression for the postfix `*' to
- operate on. Thus, `ba\(na\)*' matches `bananana', etc., with
- any (zero or more) number of `na' strings.
-
- 3. To mark a matched substring for future reference.
-
-
- This last application is not a consequence of the idea of a
- parenthetical grouping; it is a separate feature which happens to
- be assigned as a second meaning to the same `\( ... \)' construct
- because in practice there is no conflict between the two meanings.
- Here is an explanation:
-
-`\DIGIT'
- after the end of a `\( ... \)' construct, the matcher remembers the
- beginning and end of the text matched by that construct. Then,
- later on in the regular expression, you can use `\' followed by
- DIGIT to mean "match the same text matched the DIGIT'th time by the
- `\( ... \)' construct."
-
- The strings matching the first nine `\( ... \)' constructs
- appearing in a regular expression are assigned numbers 1 through 9
- in order that the open-parentheses appear in the regular
- expression. `\1' through `\9' may be used to refer to the text
- matched by the corresponding `\( ... \)' construct.
-
- For example, `\(.*\)\1' matches any newline-free string that is
- composed of two identical halves. The `\(.*\)' matches the first
- half, which may be anything, but the `\1' that follows must match
- the same exact text.
-
-`\`'
- matches the empty string, provided it is at the beginning of the
- buffer.
-
-`\''
- matches the empty string, provided it is at the end of the buffer.
-
-`\b'
- matches the empty string, provided it is at the beginning or end
- of a word. Thus, `\bfoo\b' matches any occurrence of `foo' as a
- separate word. `\bballs?\b' matches `ball' or `balls' as a
- separate word.
-
-`\B'
- matches the empty string, provided it is not at the beginning or
- end of a word.
-
-`\<'
- matches the empty string, provided it is at the beginning of a
- word.
-
-`\>'
- matches the empty string, provided it is at the end of a word.
-
-`\w'
- matches any word-constituent character. The editor syntax table
- determines which characters these are.
-
-`\W'
- matches any character that is not a word-constituent.
-
-`\sCODE'
- matches any character whose syntax is CODE. CODE is a character
- which represents a syntax code: thus, `w' for word constituent,
- `-' for whitespace, `(' for open-parenthesis, etc. *Note Syntax::.
-
-`\SCODE'
- matches any character whose syntax is not CODE.
-
- Here is a complicated regexp used by Emacs to recognize the end of a
-sentence together with any whitespace that follows. It is given in Lisp
-syntax to enable you to distinguish the spaces from the tab characters.
-In Lisp syntax, the string constant begins and ends with a
-double-quote. `\"' stands for a double-quote as part of the regexp,
-`\\' for a backslash as part of the regexp, `\t' for a tab and `\n' for
-a newline.
-
- "[.?!][]\"')]*\\($\\|\t\\| \\)[ \t\n]*"
-
-This regexp contains four parts: a character set matching period, `?'
-or `!'; a character set matching close-brackets, quotes or parentheses,
-repeated any number of times; an alternative in backslash-parentheses
-that matches end-of-line, a tab or two spaces; and a character set
-matching whitespace characters, repeated any number of times.
-
-\1f
-File: xemacs.info, Node: Search Case, Next: Replace, Prev: Regexps, Up: Search
-
-Searching and Case
-==================
-
- All searches in Emacs normally ignore the case of the text they are
-searching through; if you specify searching for `FOO', `Foo' and `foo'
-are also considered a match. Regexps, and in particular character
-sets, are included: `[aB]' matches `a' or `A' or `b' or `B'.
-
- If you want a case-sensitive search, set the variable
-`case-fold-search' to `nil'. Then all letters must match exactly,
-including case. `case-fold-search' is a per-buffer variable; altering
-it affects only the current buffer, but there is a default value which
-you can change as well. *Note Locals::. You can also use Case
-Sensitive Search from the Options menu on your screen.
-
-\1f
-File: xemacs.info, Node: Replace, Next: Other Repeating Search, Prev: Search Case, Up: Search
-
-Replacement Commands
-====================
-
- Global search-and-replace operations are not needed as often in
-Emacs as they are in other editors, but they are available. In
-addition to the simple `replace-string' command which is like that
-found in most editors, there is a `query-replace' command which asks
-you, for each occurrence of a pattern, whether to replace it.
-
- The replace commands all replace one string (or regexp) with one
-replacement string. It is possible to perform several replacements in
-parallel using the command `expand-region-abbrevs'. *Note Expanding
-Abbrevs::.
-
-* Menu:
-
-* Unconditional Replace:: Replacing all matches for a string.
-* Regexp Replace:: Replacing all matches for a regexp.
-* Replacement and Case:: How replacements preserve case of letters.
-* Query Replace:: How to use querying.
-
-\1f
-File: xemacs.info, Node: Unconditional Replace, Next: Regexp Replace, Prev: Replace, Up: Replace
-
-Unconditional Replacement
--------------------------
-
-`M-x replace-string <RET> STRING <RET> NEWSTRING <RET>'
- Replace every occurrence of STRING with NEWSTRING.
-
-`M-x replace-regexp <RET> REGEXP <RET> NEWSTRING <RET>'
- Replace every match for REGEXP with NEWSTRING.
-
- To replace every instance of `foo' after point with `bar', use the
-command `M-x replace-string' with the two arguments `foo' and `bar'.
-Replacement occurs only after point: if you want to cover the whole
-buffer you must go to the beginning first. By default, all occurrences
-up to the end of the buffer are replaced. To limit replacement to part
-of the buffer, narrow to that part of the buffer before doing the
-replacement (*note Narrowing::.).
-
- When `replace-string' exits, point is left at the last occurrence
-replaced. The value of point when the `replace-string' command was
-issued is remembered on the mark ring; `C-u C-<SPC>' moves back there.
-
- A numeric argument restricts replacement to matches that are
-surrounded by word boundaries.
-
-\1f
-File: xemacs.info, Node: Regexp Replace, Next: Replacement and Case, Prev: Unconditional Replace, Up: Replace
-
-Regexp Replacement
-------------------
-
- `replace-string' replaces exact matches for a single string. The
-similar command `replace-regexp' replaces any match for a specified
-pattern.
-
- In `replace-regexp', the NEWSTRING need not be constant. It can
-refer to all or part of what is matched by the REGEXP. `\&' in
-NEWSTRING stands for the entire text being replaced. `\D' in
-NEWSTRING, where D is a digit, stands for whatever matched the D'th
-parenthesized grouping in REGEXP. For example,
-
- M-x replace-regexp <RET> c[ad]+r <RET> \&-safe <RET>
-
-would replace (for example) `cadr' with `cadr-safe' and `cddr' with
-`cddr-safe'.
-
- M-x replace-regexp <RET> \(c[ad]+r\)-safe <RET> \1 <RET>
-
-would perform exactly the opposite replacements. To include a `\' in
-the text to replace with, you must give `\\'.
-
-\1f
-File: xemacs.info, Node: Replacement and Case, Next: Query Replace, Prev: Regexp Replace, Up: Replace
-
-Replace Commands and Case
--------------------------
-
- If the arguments to a replace command are in lower case, the command
-preserves case when it makes a replacement. Thus, the following
-command:
-
- M-x replace-string <RET> foo <RET> bar <RET>
-
-replaces a lower-case `foo' with a lower case `bar', `FOO' with `BAR',
-and `Foo' with `Bar'. If upper-case letters are used in the second
-argument, they remain upper-case every time that argument is inserted.
-If upper-case letters are used in the first argument, the second
-argument is always substituted exactly as given, with no case
-conversion. Likewise, if the variable `case-replace' is set to `nil',
-replacement is done without case conversion. If `case-fold-search' is
-set to `nil', case is significant in matching occurrences of `foo' to
-replace; also, case conversion of the replacement string is not done.
-
-\1f
-File: xemacs.info, Node: Query Replace, Prev: Replacement and Case, Up: Replace
-
-Query Replace
--------------
-
-`M-% STRING <RET> NEWSTRING <RET>'
-`M-x query-replace <RET> STRING <RET> NEWSTRING <RET>'
- Replace some occurrences of STRING with NEWSTRING.
-
-`M-x query-replace-regexp <RET> REGEXP <RET> NEWSTRING <RET>'
- Replace some matches for REGEXP with NEWSTRING.
-
- If you want to change only some of the occurrences of `foo' to
-`bar', not all of them, you can use `query-replace' instead of `M-%'.
-This command finds occurrences of `foo' one by one, displays each
-occurrence, and asks you whether to replace it. A numeric argument to
-`query-replace' tells it to consider only occurrences that are bounded
-by word-delimiter characters.
-
- Aside from querying, `query-replace' works just like
-`replace-string', and `query-replace-regexp' works just like
-`replace-regexp'.
-
- The things you can type when you are shown an occurrence of STRING
-or a match for REGEXP are:
-
-`<SPC>'
- to replace the occurrence with NEWSTRING. This preserves case,
- just like `replace-string', provided `case-replace' is non-`nil',
- as it normally is.
-
-`<DEL>'
- to skip to the next occurrence without replacing this one.
-
-`, (Comma)'
- to replace this occurrence and display the result. You are then
- prompted for another input character. However, since the
- replacement has already been made, <DEL> and <SPC> are equivalent.
- At this point, you can type `C-r' (see below) to alter the
- replaced text. To undo the replacement, you can type `C-x u'.
- This exits the `query-replace'. If you want to do further
- replacement you must use `C-x ESC' to restart (*note
- Repetition::.).
-
-`<ESC>'
- to exit without doing any more replacements.
-
-`. (Period)'
- to replace this occurrence and then exit.
-
-`!'
- to replace all remaining occurrences without asking again.
-
-`^'
- to go back to the location of the previous occurrence (or what
- used to be an occurrence), in case you changed it by mistake.
- This works by popping the mark ring. Only one `^' in a row is
- allowed, because only one previous replacement location is kept
- during `query-replace'.
-
-`C-r'
- to enter a recursive editing level, in case the occurrence needs
- to be edited rather than just replaced with NEWSTRING. When you
- are done, exit the recursive editing level with `C-M-c' and the
- next occurrence will be displayed. *Note Recursive Edit::.
-
-`C-w'
- to delete the occurrence, and then enter a recursive editing level
- as in `C-r'. Use the recursive edit to insert text to replace the
- deleted occurrence of STRING. When done, exit the recursive
- editing level with `C-M-c' and the next occurrence will be
- displayed.
-
-`C-l'
- to redisplay the screen and then give another answer.
-
-`C-h'
- to display a message summarizing these options, then give another
- answer.
-
- If you type any other character, Emacs exits the `query-replace', and
-executes the character as a command. To restart the `query-replace',
-use `C-x <ESC>', which repeats the `query-replace' because it used the
-minibuffer to read its arguments. *Note C-x ESC: Repetition.
-
-\1f
-File: xemacs.info, Node: Other Repeating Search, Prev: Replace, Up: Search
-
-Other Search-and-Loop Commands
-==============================
-
- Here are some other commands that find matches for a regular
-expression. They all operate from point to the end of the buffer.
-
-`M-x occur'
- Print each line that follows point and contains a match for the
- specified regexp. A numeric argument specifies the number of
- context lines to print before and after each matching line; the
- default is none.
-
- The buffer `*Occur*' containing the output serves as a menu for
- finding occurrences in their original context. Find an occurrence
- as listed in `*Occur*', position point there, and type `C-c C-c';
- this switches to the buffer that was searched and moves point to
- the original of the same occurrence.
-
-`M-x list-matching-lines'
- Synonym for `M-x occur'.
-
-`M-x count-matches'
- Print the number of matches following point for the specified
- regexp.
-
-`M-x delete-non-matching-lines'
- Delete each line that follows point and does not contain a match
- for the specified regexp.
-
-`M-x delete-matching-lines'
- Delete each line that follows point and contains a match for the
- specified regexp.
-
-\1f
-File: xemacs.info, Node: Fixit, Next: Files, Prev: Search, Up: Top
-
-Commands for Fixing Typos
-*************************
-
- This chapter describes commands that are especially useful when you
-catch a mistake in your text just after you have made it, or when you
-change your mind while composing text on line.
-
-* Menu:
-
-* Kill Errors:: Commands to kill a batch of recently entered text.
-* Transpose:: Exchanging two characters, words, lines, lists...
-* Fixing Case:: Correcting case of last word entered.
-* Spelling:: Apply spelling checker to a word, or a whole file.
-
-\1f
-File: xemacs.info, Node: Kill Errors, Next: Transpose, Prev: Fixit, Up: Fixit
-
-Killing Your Mistakes
-=====================
-
-`<DEL>'
- Delete last character (`delete-backward-char').
-
-`M-<DEL>'
- Kill last word (`backward-kill-word').
-
-`C-x <DEL>'
- Kill to beginning of sentence (`backward-kill-sentence').
-
- The <DEL> character (`delete-backward-char') is the most important
-correction command. When used among graphic (self-inserting)
-characters, it can be thought of as canceling the last character typed.
-
- When your mistake is longer than a couple of characters, it might be
-more convenient to use `M-<DEL>' or `C-x <DEL>'. `M-<DEL>' kills back
-to the start of the last word, and `C-x <DEL>' kills back to the start
-of the last sentence. `C-x <DEL>' is particularly useful when you are
-thinking of what to write as you type it, in case you change your mind
-about phrasing. `M-<DEL>' and `C-x <DEL>' save the killed text for
-`C-y' and `M-y' to retrieve. *Note Yanking::.
-
- `M-<DEL>' is often useful even when you have typed only a few
-characters wrong, if you know you are confused in your typing and aren't
-sure exactly what you typed. At such a time, you cannot correct with
-<DEL> except by looking at the screen to see what you did. It requires
-less thought to kill the whole word and start over.
-
-\1f
-File: xemacs.info, Node: Transpose, Next: Fixing Case, Prev: Kill Errors, Up: Fixit
-
-Transposing Text
-================
-
-`C-t'
- Transpose two characters (`transpose-chars').
-
-`M-t'
- Transpose two words (`transpose-words').
-
-`C-M-t'
- Transpose two balanced expressions (`transpose-sexps').
-
-`C-x C-t'
- Transpose two lines (`transpose-lines').
-
- The common error of transposing two adjacent characters can be fixed
-with the `C-t' command (`transpose-chars'). Normally, `C-t' transposes
-the two characters on either side of point. When given at the end of a
-line, `C-t' transposes the last two characters on the line, rather than
-transposing the last character of the line with the newline, which
-would be useless. If you catch a transposition error right away, you
-can fix it with just `C-t'. If you catch the error later, move the
-cursor back to between the two transposed characters. If you
-transposed a space with the last character of the word before it, the
-word motion commands are a good way of getting there. Otherwise, a
-reverse search (`C-r') is often the best way. *Note Search::.
-
- `Meta-t' (`transpose-words') transposes the word before point with
-the word after point. It moves point forward over a word, dragging the
-word preceding or containing point forward as well. The punctuation
-characters between the words do not move. For example, `FOO, BAR'
-transposes into `BAR, FOO' rather than `BAR FOO,'.
-
- `C-M-t' (`transpose-sexps') is a similar command for transposing two
-expressions (*note Lists::.), and `C-x C-t' (`transpose-lines')
-exchanges lines. It works like `M-t' but in determines the division of
-the text into syntactic units differently.
-
- A numeric argument to a transpose command serves as a repeat count:
-it tells the transpose command to move the character (word, sexp, line)
-before or containing point across several other characters (words,
-sexps, lines). For example, `C-u 3 C-t' moves the character before
-point forward across three other characters. This is equivalent to
-repeating `C-t' three times. `C-u - 4 M-t' moves the word before point
-backward across four words. `C-u - C-M-t' would cancel the effect of
-plain `C-M-t'.
-
- A numeric argument of zero transposes the character (word, sexp,
-line) ending after point with the one ending after the mark (otherwise a
-command with a repeat count of zero would do nothing).
-
-\1f
-File: xemacs.info, Node: Fixing Case, Next: Spelling, Prev: Transpose, Up: Fixit
-
-Case Conversion
-===============
-
-`M-- M-l'
- Convert last word to lower case. Note that `Meta--' is
- "Meta-minus."
-
-`M-- M-u'
- Convert last word to all upper case.
-
-`M-- M-c'
- Convert last word to lower case with capital initial.
-
- A common error is to type words in the wrong case. Because of this,
-the word case-conversion commands `M-l', `M-u', and `M-c' do not move
-the cursor when used with a negative argument. As soon as you see you
-have mistyped the last word, you can simply case-convert it and
-continue typing. *Note Case::.
-
-\1f
-File: xemacs.info, Node: Spelling, Prev: Fixing Case, Up: Fixit
-
-Checking and Correcting Spelling
-================================
-
-`M-$'
- Check and correct spelling of word (`spell-word').
-
-`M-x spell-buffer'
- Check and correct spelling of each word in the buffer.
-
-`M-x spell-region'
- Check and correct spelling of each word in the region.
-
-`M-x spell-string'
- Check spelling of specified word.
-
- To check the spelling of the word before point, and optionally
-correct it, use the command `M-$' (`spell-word'). This command runs an
-inferior process containing the `spell' program to see whether the word
-is correct English. If it is not, it asks you to edit the word (in the
-minibuffer) into a corrected spelling, and then performs a
-`query-replace' to substitute the corrected spelling for the old one
-throughout the buffer.
-
- If you exit the minibuffer without altering the original spelling, it
-means you do not want to do anything to that word. In that case, the
-`query-replace' is not done.
-
- `M-x spell-buffer' checks each word in the buffer the same way that
-`spell-word' does, doing a `query-replace' for every incorrect word if
-appropriate.
-
- `M-x spell-region' is similar to `spell-buffer' but operates only on
-the region, not the entire buffer.
-
- `M-x spell-string' reads a string as an argument and checks whether
-that is a correctly spelled English word. It prints a message giving
-the answer in the echo area.
-
-\1f
-File: xemacs.info, Node: Files, Next: Buffers, Prev: Fixit, Up: Top
-
-File Handling
-*************
-
- The basic unit of stored data in Unix is the "file". To edit a file,
-you must tell Emacs to examine the file and prepare a buffer containing
-a copy of the file's text. This is called "visiting" the file. Editing
-commands apply directly to text in the buffer; that is, to the copy
-inside Emacs. Your changes appear in the file itself only when you
-"save" the buffer back into the file.
-
- In addition to visiting and saving files, Emacs can delete, copy,
-rename, and append to files, and operate on file directories.
-
-* Menu:
-
-* File Names:: How to type and edit file name arguments.
-* Visiting:: Visiting a file prepares Emacs to edit the file.
-* Saving:: Saving makes your changes permanent.
-* Reverting:: Reverting cancels all the changes not saved.
-* Auto Save:: Auto Save periodically protects against loss of data.
-* Version Control:: Version control systems (RCS and SCCS).
-* ListDir:: Listing the contents of a file directory.
-* Comparing Files:: Finding where two files differ.
-* Dired:: "Editing" a directory to delete, rename, etc.
- the files in it.
-* Misc File Ops:: Other things you can do on files.
-
-\1f
-File: xemacs.info, Node: File Names, Next: Visiting, Prev: Files, Up: Files
-
-File Names
-==========
-
- Most Emacs commands that operate on a file require you to specify the
-file name. (Saving and reverting are exceptions; the buffer knows which
-file name to use for them.) File names are specified in the minibuffer
-(*note Minibuffer::.). "Completion" is available, to make it easier to
-specify long file names. *Note Completion::.
-
- There is always a "default file name" which is used if you enter an
-empty argument by typing just <RET>. Normally the default file name is
-the name of the file visited in the current buffer; this makes it easy
-to operate on that file with any of the Emacs file commands.
-
- Each buffer has a default directory, normally the same as the
-directory of the file visited in that buffer. When Emacs reads a file
-name, the default directory is used if you do not specify a directory.
-If you specify a directory in a relative fashion, with a name that does
-not start with a slash, it is interpreted with respect to the default
-directory. The default directory of the current buffer is kept in the
-variable `default-directory', which has a separate value in every
-buffer. The value of the variable should end with a slash.
-
- For example, if the default file name is `/u/rms/gnu/gnu.tasks' then
-the default directory is `/u/rms/gnu/'. If you type just `foo', which
-does not specify a directory, it is short for `/u/rms/gnu/foo'.
-`../.login' would stand for `/u/rms/.login'. `new/foo' would stand for
-the filename `/u/rms/gnu/new/foo'.
-
- The variable `default-directory-alist' takes an alist of major modes
-and their opinions on `default-directory' as a Lisp expression to
-evaluate. A resulting value of `nil' is ignored in favor of
-`default-directory'.
-
- You can create a new directory with the function `make-directory',
-which takes as an argument a file name string. The current directory is
-displayed in the minibuffer when the function is called; you can delete
-the old directory name and supply a new directory name. For example, if
-the current directory is `/u/rms/gnu', you can delete `gnu' and type
-`oryx' and <RET> to create `/u/rms/oryx'. Removing a directory is
-similar to creating one. To remove a directory, use
-`remove-directory'; it takes one argument, a file name string.
-
- The command `M-x pwd' prints the current buffer's default directory,
-and the command `M-x cd' sets it (to a value read using the
-minibuffer). A buffer's default directory changes only when the `cd'
-command is used. A file-visiting buffer's default directory is
-initialized to the directory of the file that is visited there. If a
-buffer is created with `C-x b', its default directory is copied from
-that of the buffer that was current at the time.
-
- The default directory name actually appears in the minibuffer when
-the minibuffer becomes active to read a file name. This serves two
-purposes: it shows you what the default is, so that you can type a
-relative file name and know with certainty what it will mean, and it
-allows you to edit the default to specify a different directory. To
-inhibit the insertion of the default directory, set the variable
-`insert-default-directory' to `nil'.
-
- Note that it is legitimate to type an absolute file name after you
-enter the minibuffer, ignoring the presence of the default directory
-name. The final minibuffer contents may look invalid, but that is not
-so. *Note Minibuffer File::.
-
- `$' in a file name is used to substitute environment variables. For
-example, if you have used the shell command `setenv FOO rms/hacks' to
-set up an environment variable named `FOO', then you can use
-`/u/$FOO/test.c' or `/u/${FOO}/test.c' as an abbreviation for
-`/u/rms/hacks/test.c'. The environment variable name consists of all
-the alphanumeric characters after the `$'; alternatively, it may be
-enclosed in braces after the `$'. Note that the `setenv' command
-affects Emacs only if done before Emacs is started.
-
- To access a file with `$' in its name, type `$$'. This pair is
-converted to a single `$' at the same time variable substitution is
-performed for single `$'. The Lisp function that performs the
-substitution is called `substitute-in-file-name'. The substitution is
-performed only on filenames read as such using the minibuffer.