-This is ../info/xemacs.info, produced by makeinfo version 3.12s from
+This is ../info/xemacs.info, produced by makeinfo version 4.0 from
xemacs/xemacs.texi.
INFO-DIR-SECTION XEmacs Editor
translation approved by the author instead of in the original English.
\1f
+File: xemacs.info, Node: TeX Editing, Next: TeX Print, Prev: TeX Mode, Up: TeX Mode
+
+TeX Editing Commands
+....................
+
+ Here are the special commands provided in TeX mode for editing the
+text of the file.
+
+`"'
+ Insert, according to context, either ```' or `"' or `'''
+ (`TeX-insert-quote').
+
+`<LFD>'
+ Insert a paragraph break (two newlines) and check the previous
+ paragraph for unbalanced braces or dollar signs (`tex-terminate-
+ paragraph').
+
+`M-x validate-tex-buffer'
+ Check each paragraph in the buffer for unbalanced braces or dollar
+ signs.
+
+`C-c {'
+ Insert `{}' and position point between them (`tex-insert-braces').
+
+`C-c }'
+ Move forward past the next unmatched close brace (`up-list').
+
+`C-c C-e'
+ Close a block for LaTeX (`tex-close-latex-block').
+
+ In TeX, the character `"' is not normally used; you use ```' to
+start a quotation and `''' to end one. TeX mode defines the key `"' to
+insert ```' after whitespace or an open brace, `"' after a backslash,
+or `''' otherwise. This is done by the command `tex-insert-quote'. If
+you need the character `"' itself in unusual contexts, use `C-q' to
+insert it. Also, `"' with a numeric argument always inserts that
+number of `"' characters.
+
+ In TeX mode, `$' has a special syntax code which attempts to
+understand the way TeX math mode delimiters match. When you insert a
+`$' that is meant to exit math mode, the position of the matching `$'
+that entered math mode is displayed for a second. This is the same
+feature that displays the open brace that matches a close brace that is
+inserted. However, there is no way to tell whether a `$' enters math
+mode or leaves it; so when you insert a `$' that enters math mode, the
+previous `$' position is shown as if it were a match, even though they
+are actually unrelated.
+
+ If you prefer to keep braces balanced at all times, you can use `C-c
+{' (`tex-insert-braces') to insert a pair of braces. It leaves point
+between the two braces so you can insert the text that belongs inside.
+Afterward, use the command `C-c }' (`up-list') to move forward past the
+close brace.
+
+ There are two commands for checking the matching of braces. <LFD>
+(`tex-terminate-paragraph') checks the paragraph before point, and
+inserts two newlines to start a new paragraph. It prints a message in
+the echo area if any mismatch is found. `M-x validate-tex-buffer'
+checks the entire buffer, paragraph by paragraph. When it finds a
+paragraph that contains a mismatch, it displays point at the beginning
+of the paragraph for a few seconds and pushes a mark at that spot.
+Scanning continues until the whole buffer has been checked or until you
+type another key. The positions of the last several paragraphs with
+mismatches can be found in the mark ring (*note Mark Ring::).
+
+ Note that square brackets and parentheses, not just braces, are
+matched in TeX mode. This is wrong if you want to check TeX syntax.
+However, parentheses and square brackets are likely to be used in text
+as matching delimiters and it is useful for the various motion commands
+and automatic match display to work with them.
+
+ In LaTeX input, `\begin' and `\end' commands must balance. After
+you insert a `\begin', use `C-c C-f' (`tex-close-latex-block') to
+insert automatically a matching `\end' (on a new line following the
+`\begin'). A blank line is inserted between the two, and point is left
+there.
+
+\1f
+File: xemacs.info, Node: TeX Print, Prev: TeX Editing, Up: TeX Mode
+
+TeX Printing Commands
+.....................
+
+ You can invoke TeX as an inferior of Emacs on either the entire
+contents of the buffer or just a region at a time. Running TeX in this
+way on just one chapter is a good way to see what your changes look
+like without taking the time to format the entire file.
+
+`C-c C-r'
+ Invoke TeX on the current region, plus the buffer's header
+ (`tex-region').
+
+`C-c C-b'
+ Invoke TeX on the entire current buffer (`tex-buffer').
+
+`C-c C-l'
+ Recenter the window showing output from the inferior TeX so that
+ the last line can be seen (`tex-recenter-output-buffer').
+
+`C-c C-k'
+ Kill the inferior TeX (`tex-kill-job').
+
+`C-c C-p'
+ Print the output from the last `C-c C-r' or `C-c C-b' command
+ (`tex-print').
+
+`C-c C-q'
+ Show the printer queue (`tex-show-print-queue').
+
+ You can pass the current buffer through an inferior TeX using `C-c
+C-b' (`tex-buffer'). The formatted output appears in a file in `/tmp';
+to print it, type `C-c C-p' (`tex-print'). Afterward use `C-c C-q'
+(`tex-show-print-queue') to view the progress of your output towards
+being printed.
+
+ The console output from TeX, including any error messages, appears
+in a buffer called `*TeX-shell*'. If TeX gets an error, you can switch
+to this buffer and feed it input (this works as in Shell mode; *note
+Interactive Shell::). Without switching to this buffer, you can scroll
+it so that its last line is visible by typing `C-c C-l'.
+
+ Type `C-c C-k' (`tex-kill-job') to kill the TeX process if you see
+that its output is no longer useful. Using `C-c C-b' or `C-c C-r' also
+kills any TeX process still running.
+
+ You can pass an arbitrary region through an inferior TeX by typing
+`C-c C-r' (`tex-region'). This is tricky, however, because most files
+of TeX input contain commands at the beginning to set parameters and
+define macros. Without them, no later part of the file will format
+correctly. To solve this problem, `C-c C-r' allows you to designate a
+part of the file as containing essential commands; it is included
+before the specified region as part of the input to TeX. The
+designated part of the file is called the "header".
+
+ To indicate the bounds of the header in Plain TeX mode, insert two
+special strings in the file: `%**start of header' before the header,
+and `%**end of header' after it. Each string must appear entirely on
+one line, but there may be other text on the line before or after. The
+lines containing the two strings are included in the header. If
+`%**start of header' does not appear within the first 100 lines of the
+buffer, `C-c C-r' assumes there is no header.
+
+ In LaTeX mode, the header begins with `\documentstyle' and ends with
+`\begin{document}'. These are commands that LaTeX requires you to use,
+so you don't need to do anything special to identify the header.
+
+ When you enter either kind of TeX mode, Emacs calls with no
+arguments the value of the variable `text-mode-hook', if that value
+exists and is not `nil'. Emacs then calls the variable `TeX-mode-hook'
+and either `plain-TeX-mode-hook' or `LaTeX-mode-hook' under the same
+conditions.
+
+\1f
+File: xemacs.info, Node: Outline Mode, Prev: TeX Mode, Up: Text Mode
+
+Outline Mode
+------------
+
+ Outline mode is a major mode similar to Text mode but intended for
+editing outlines. It allows you to make parts of the text temporarily
+invisible so that you can see just the overall structure of the
+outline. Type `M-x outline-mode' to turn on Outline mode in the
+current buffer.
+
+ When you enter Outline mode, Emacs calls with no arguments the value
+of the variable `text-mode-hook', if that value exists and is not
+`nil'; then it does the same with the variable `outline-mode-hook'.
+
+ When a line is invisible in outline mode, it does not appear on the
+screen. The screen appears exactly as if the invisible line were
+deleted, except that an ellipsis (three periods in a row) appears at
+the end of the previous visible line (only one ellipsis no matter how
+many invisible lines follow).
+
+ All editing commands treat the text of the invisible line as part of
+the previous visible line. For example, `C-n' moves onto the next
+visible line. Killing an entire visible line, including its
+terminating newline, really kills all the following invisible lines as
+well; yanking everything back yanks the invisible lines and they remain
+invisible.
+
+* Menu:
+
+* Format: Outline Format. What the text of an outline looks like.
+* Motion: Outline Motion. Special commands for moving through outlines.
+* Visibility: Outline Visibility. Commands to control what is visible.
+
+\1f
+File: xemacs.info, Node: Outline Format, Next: Outline Motion, Prev: Outline Mode, Up: Outline Mode
+
+Format of Outlines
+..................
+
+ Outline mode assumes that the lines in the buffer are of two types:
+"heading lines" and "body lines". A heading line represents a topic in
+the outline. Heading lines start with one or more stars; the number of
+stars determines the depth of the heading in the outline structure.
+Thus, a heading line with one star is a major topic; all the heading
+lines with two stars between it and the next one-star heading are its
+subtopics; and so on. Any line that is not a heading line is a body
+line. Body lines belong to the preceding heading line. Here is an
+example:
+
+ * Food
+
+ This is the body,
+ which says something about the topic of food.
+
+ ** Delicious Food
+
+ This is the body of the second-level header.
+
+ ** Distasteful Food
+
+ This could have
+ a body too, with
+ several lines.
+
+ *** Dormitory Food
+
+ * Shelter
+
+ A second first-level topic with its header line.
+
+ A heading line together with all following body lines is called
+collectively an "entry". A heading line together with all following
+deeper heading lines and their body lines is called a "subtree".
+
+ You can customize the criterion for distinguishing heading lines by
+setting the variable `outline-regexp'. Any line whose beginning has a
+match for this regexp is considered a heading line. Matches that start
+within a line (not at the beginning) do not count. The length of the
+matching text determines the level of the heading; longer matches make
+a more deeply nested level. Thus, for example, if a text formatter has
+commands `@chapter', `@section' and `@subsection' to divide the
+document into chapters and sections, you can make those lines count as
+heading lines by setting `outline-regexp' to
+`"@chap\\|@\\(sub\\)*section"'. Note the trick: the two words
+`chapter' and `section' are the same length, but by defining the regexp
+to match only `chap' we ensure that the length of the text matched on a
+chapter heading is shorter, so that Outline mode will know that
+sections are contained in chapters. This works as long as no other
+command starts with `@chap'.
+
+ Outline mode makes a line invisible by changing the newline before it
+into an ASCII Control-M (code 015). Most editing commands that work on
+lines treat an invisible line as part of the previous line because,
+strictly speaking, it is part of that line, since there is no longer a
+newline in between. When you save the file in Outline mode, Control-M
+characters are saved as newlines, so the invisible lines become ordinary
+lines in the file. Saving does not change the visibility status of a
+line inside Emacs.
+
+\1f
+File: xemacs.info, Node: Outline Motion, Next: Outline Visibility, Prev: Outline Format, Up: Outline Mode
+
+Outline Motion Commands
+.......................
+
+ Some special commands in Outline mode move backward and forward to
+heading lines.
+
+`C-c C-n'
+ Move point to the next visible heading line
+ (`outline-next-visible-heading').
+
+`C-c C-p'
+ Move point to the previous visible heading line
+ (`outline-previous-visible-heading').
+
+`C-c C-f'
+ Move point to the next visible heading line at the same level as
+ the one point is on (`outline-forward-same-level').
+
+`C-c C-b'
+ Move point to the previous visible heading line at the same level
+ (`outline-backward-same-level').
+
+`C-c C-u'
+ Move point up to a lower-level (more inclusive) visible heading
+ line (`outline-up-heading').
+
+ `C-c C-n' (`next-visible-heading') moves down to the next heading
+line. `C-c C-p' (`previous-visible-heading') moves similarly backward.
+Both accept numeric arguments as repeat counts. The names emphasize
+that invisible headings are skipped, but this is not really a special
+feature. All editing commands that look for lines ignore the invisible
+lines automatically.
+
+ More advanced motion commands understand the levels of headings.
+The commands `C-c C-f' (`outline-forward-same-level') and `C-c C-b'
+(`outline-backward-same-level') move from one heading line to another
+visible heading at the same depth in the outline. `C-c C-u'
+(`outline-up-heading') moves backward to another heading that is less
+deeply nested.
+
+\1f
+File: xemacs.info, Node: Outline Visibility, Prev: Outline Motion, Up: Outline Mode
+
+Outline Visibility Commands
+...........................
+
+ The other special commands of outline mode are used to make lines
+visible or invisible. Their names all start with `hide' or `show'.
+Most of them exist as pairs of opposites. They are not undoable;
+instead, you can undo right past them. Making lines visible or
+invisible is simply not recorded by the undo mechanism.
+
+`M-x hide-body'
+ Make all body lines in the buffer invisible.
+
+`M-x show-all'
+ Make all lines in the buffer visible.
+
+`C-c C-d'
+ Make everything under this heading invisible, not including this
+ heading itself (`hide-subtree').
+
+`C-c C-s'
+ Make everything under this heading visible, including body,
+ subheadings, and their bodies (`show-subtree').
+
+`M-x hide-leaves'
+ Make the body of this heading line, and of all its subheadings,
+ invisible.
+
+`M-x show-branches'
+ Make all subheadings of this heading line, at all levels, visible.
+
+`C-c C-i'
+ Make immediate subheadings (one level down) of this heading line
+ visible (`show-children').
+
+`M-x hide-entry'
+ Make this heading line's body invisible.
+
+`M-x show-entry'
+ Make this heading line's body visible.
+
+ Two commands that are exact opposites are `M-x hide-entry' and `M-x
+show-entry'. They are used with point on a heading line, and apply
+only to the body lines of that heading. The subtopics and their bodies
+are not affected.
+
+ Two more powerful opposites are `C-c C-h' (`hide-subtree') and `C-c
+C-s' (`show-subtree'). Both should be used when point is on a heading
+line, and both apply to all the lines of that heading's "subtree": its
+body, all its subheadings, both direct and indirect, and all of their
+bodies. In other words, the subtree contains everything following this
+heading line, up to and not including the next heading of the same or
+higher rank.
+
+ Intermediate between a visible subtree and an invisible one is having
+all the subheadings visible but none of the body. There are two
+commands for doing this, one that hides the bodies and one that makes
+the subheadings visible. They are `M-x hide-leaves' and `M-x
+show-branches'.
+
+ A little weaker than `show-branches' is `C-c C-i' (`show-children').
+It makes just the direct subheadings visible--those one level down.
+Deeper subheadings remain invisible.
+
+ Two commands have a blanket effect on the whole file. `M-x
+hide-body' makes all body lines invisible, so that you see just the
+outline structure. `M-x show-all' makes all lines visible. You can
+think of these commands as a pair of opposites even though `M-x
+show-all' applies to more than just body lines.
+
+ You can turn off the use of ellipses at the ends of visible lines by
+setting `selective-display-ellipses' to `nil'. The result is no
+visible indication of the presence of invisible lines.
+
+\1f
+File: xemacs.info, Node: Words, Next: Sentences, Prev: Text Mode, Up: Text
+
+Words
+=====
+
+ Emacs has commands for moving over or operating on words. By
+convention, the keys for them are all `Meta-' characters.
+
+`M-f'
+ Move forward over a word (`forward-word').
+
+`M-b'
+ Move backward over a word (`backward-word').
+
+`M-d'
+ Kill up to the end of a word (`kill-word').
+
+`M-<DEL>'
+ Kill back to the beginning of a word (`backward-kill-word').
+
+`M-@'
+ Mark the end of the next word (`mark-word').
+
+`M-t'
+ Transpose two words; drag a word forward or backward across other
+ words (`transpose-words').
+
+ Notice how these keys form a series that parallels the
+character-based `C-f', `C-b', `C-d', `C-t' and <DEL>. `M-@' is related
+to `C-@', which is an alias for `C-<SPC>'.
+
+ The commands `Meta-f' (`forward-word') and `Meta-b'
+(`backward-word') move forward and backward over words. They are
+analogous to `Control-f' and `Control-b', which move over single
+characters. Like their `Control-' analogues, `Meta-f' and `Meta-b'
+move several words if given an argument. `Meta-f' with a negative
+argument moves backward, and `Meta-b' with a negative argument moves
+forward. Forward motion stops after the last letter of the word, while
+backward motion stops before the first letter.
+
+ `Meta-d' (`kill-word') kills the word after point. To be precise,
+it kills everything from point to the place `Meta-f' would move to.
+Thus, if point is in the middle of a word, `Meta-d' kills just the part
+after point. If some punctuation comes between point and the next
+word, it is killed along with the word. (To kill only the next word
+but not the punctuation before it, simply type `Meta-f' to get to the
+end and kill the word backwards with `Meta-<DEL>'.) `Meta-d' takes
+arguments just like `Meta-f'.
+
+ `Meta-<DEL>' (`backward-kill-word') kills the word before point. It
+kills everything from point back to where `Meta-b' would move to. If
+point is after the space in `FOO, BAR', then `FOO, ' is killed. To
+kill just `FOO', type `Meta-b Meta-d' instead of `Meta-<DEL>'.
+
+ `Meta-t' (`transpose-words') exchanges the word before or containing
+point with the following word. The delimiter characters between the
+words do not move. For example, transposing `FOO, BAR' results in
+`BAR, FOO' rather than `BAR FOO,'. *Note Transpose::, for more on
+transposition and on arguments to transposition commands.
+
+ To operate on the next N words with an operation which applies
+between point and mark, you can either set the mark at point and then
+move over the words, or you can use the command `Meta-@' (`mark-word')
+which does not move point but sets the mark where `Meta-f' would move
+to. It can be given arguments just like `Meta-f'.
+
+ The word commands' understanding of syntax is completely controlled
+by the syntax table. For example, any character can be declared to be
+a word delimiter. *Note Syntax::.
+
+\1f
+File: xemacs.info, Node: Sentences, Next: Paragraphs, Prev: Words, Up: Text
+
+Sentences
+=========
+
+ The Emacs commands for manipulating sentences and paragraphs are
+mostly on `Meta-' keys, and therefore are like the word-handling
+commands.
+
+`M-a'
+ Move back to the beginning of the sentence (`backward-sentence').
+
+`M-e'
+ Move forward to the end of the sentence (`forward-sentence').
+
+`M-k'
+ Kill forward to the end of the sentence (`kill-sentence').
+
+`C-x <DEL>'
+ Kill back to the beginning of the sentence
+ (`backward-kill-sentence').
+
+ The commands `Meta-a' and `Meta-e' (`backward-sentence' and
+`forward-sentence') move to the beginning and end of the current
+sentence, respectively. They resemble `Control-a' and `Control-e',
+which move to the beginning and end of a line. Unlike their
+counterparts, `Meta-a' and `Meta-e' move over successive sentences if
+repeated or given numeric arguments. Emacs assumes the typist's
+convention is followed, and thus considers a sentence to end wherever
+there is a `.', `?', or `!' followed by the end of a line or two
+spaces, with any number of `)', `]', `'', or `"' characters allowed in
+between. A sentence also begins or ends wherever a paragraph begins or
+ends.
+
+ Neither `M-a' nor `M-e' moves past the newline or spaces beyond the
+sentence edge at which it is stopping.
+
+ `M-a' and `M-e' have a corresponding kill command, just like `C-a'
+and `C-e' have `C-k'. The command is `M-k' (`kill-sentence') which
+kills from point to the end of the sentence. With minus one as an
+argument it kills back to the beginning of the sentence. Larger
+arguments serve as repeat counts.
+
+ There is a special command, `C-x <DEL>' (`backward-kill-sentence'),
+for killing back to the beginning of a sentence, which is useful when
+you change your mind in the middle of composing text.
+
+ The variable `sentence-end' controls recognition of the end of a
+sentence. It is a regexp that matches the last few characters of a
+sentence, together with the whitespace following the sentence. Its
+normal value is:
+
+ "[.?!][]\"')]*\\($\\|\t\\| \\)[ \t\n]*"
+
+This example is explained in the section on regexps. *Note Regexps::.
+
+\1f
+File: xemacs.info, Node: Paragraphs, Next: Pages, Prev: Sentences, Up: Text
+
+Paragraphs
+==========
+
+ The Emacs commands for manipulating paragraphs are also `Meta-' keys.
+
+`M-['
+ Move back to previous paragraph beginning
+ (`backward-paragraph').
+
+`M-]'
+ Move forward to next paragraph end (`forward-paragraph').
+
+`M-h'
+ Put point and mark around this or next paragraph
+ (`mark-paragraph').
+
+ `Meta-[' moves to the beginning of the current or previous paragraph,
+while `Meta-]' moves to the end of the current or next paragraph.
+Blank lines and text formatter command lines separate paragraphs and are
+not part of any paragraph. An indented line starts a new paragraph.
+
+ In major modes for programs (as opposed to Text mode), paragraphs
+begin and end only at blank lines. As a result, the paragraph commands
+continue to be useful even though there are no paragraphs per se.
+
+ When there is a fill prefix, paragraphs are delimited by all lines
+which don't start with the fill prefix. *Note Filling::.
+
+ To operate on a paragraph, you can use the command `Meta-h'
+(`mark-paragraph') to set the region around it. This command puts
+point at the beginning and mark at the end of the paragraph point was
+in. If point is between paragraphs (in a run of blank lines or at a
+boundary), the paragraph following point is surrounded by point and
+mark. If there are blank lines preceding the first line of the
+paragraph, one of the blank lines is included in the region. Thus, for
+example, `M-h C-w' kills the paragraph around or after point.
+
+ The precise definition of a paragraph boundary is controlled by the
+variables `paragraph-separate' and `paragraph-start'. The value of
+`paragraph-start' is a regexp that matches any line that either starts
+or separates paragraphs. The value of `paragraph-separate' is another
+regexp that matches only lines that separate paragraphs without being
+part of any paragraph. Lines that start a new paragraph and are
+contained in it must match both regexps. For example, normally
+`paragraph-start' is `"^[ \t\n\f]"' and `paragraph-separate' is `"^[
+\t\f]*$"'.
+
+ Normally it is desirable for page boundaries to separate paragraphs.
+The default values of these variables recognize the usual separator for
+pages.
+
+\1f
File: xemacs.info, Node: Pages, Next: Filling, Prev: Paragraphs, Up: Text
Pages
There are editing commands to operate on them.
* Grinding:: Adjusting indentation to show the nesting.
* Matching:: Insertion of a close-delimiter flashes matching open.
-* Comments:: Inserting, illing and aligning comments.
+* Comments:: Inserting, filling and aligning comments.
* Balanced Editing:: Inserting two matching parentheses at once, etc.
* Lisp Completion:: Completion on symbol names in Lisp code.
* Documentation:: Getting documentation of functions you plan to call.
* Lisp Indent:: Specifying how each Lisp function should be indented.
* C Indent:: Choosing an indentation style for C code.
-\1f
-File: xemacs.info, Node: Basic Indent, Next: Multi-line Indent, Prev: Grinding, Up: Grinding
-
-Basic Program Indentation Commands
-----------------------------------
-
-`<TAB>'
- Adjust indentation of current line.
-
-`<LFD>'
- Equivalent to <RET> followed by <TAB> (`newline-and-indent').
-
- The basic indentation command is <TAB>, which gives the current line
-the correct indentation as determined from the previous lines. The
-function that <TAB> runs depends on the major mode; it is
-`lisp-indent-line' in Lisp mode, `c-indent-line' in C mode, etc. These
-functions understand different syntaxes for different languages, but
-they all do about the same thing. <TAB> in any programming language
-major mode inserts or deletes whitespace at the beginning of the
-current line, independent of where point is in the line. If point is
-inside the whitespace at the beginning of the line, <TAB> leaves it at
-the end of that whitespace; otherwise, <TAB> leaves point fixed with
-respect to the characters around it.
-
- Use `C-q <TAB>' to insert a tab at point.
-
- When entering a large amount of new code, use <LFD>
-(`newline-and-indent'), which is equivalent to a <RET> followed by a
-<TAB>. <LFD> creates a blank line, then gives it the appropriate
-indentation.
-
- <TAB> indents the second and following lines of the body of a
-parenthetical grouping each under the preceding one; therefore, if you
-alter one line's indentation to be nonstandard, the lines below tend to
-follow it. This is the right behavior in cases where the standard
-result of <TAB> does not look good.
-
- Remember that Emacs assumes that an open-parenthesis, open-brace, or
-other opening delimiter at the left margin (including the indentation
-routines) is the start of a function. You should therefore never have
-an opening delimiter in column zero that is not the beginning of a
-function, not even inside a string. This restriction is vital for
-making the indentation commands fast. *Note Defuns::, for more
-information on this behavior.
-
-\1f
-File: xemacs.info, Node: Multi-line Indent, Next: Lisp Indent, Prev: Basic Indent, Up: Grinding
-
-Indenting Several Lines
------------------------
-
- Several commands are available to re-indent several lines of code
-which have been altered or moved to a different level in a list
-structure.
-
-`C-M-q'
- Re-indent all the lines within one list (`indent-sexp').
-
-`C-u <TAB>'
- Shift an entire list rigidly sideways so that its first line is
- properly indented.
-
-`C-M-\'
- Re-indent all lines in the region (`indent-region').
-
- To re-indent the contents of a single list, position point before the
-beginning of it and type `C-M-q'. This key is bound to `indent-sexp' in
-Lisp mode, `indent-c-exp' in C mode, and bound to other suitable
-functions in other modes. The indentation of the line the sexp starts
-on is not changed; therefore, only the relative indentation within the
-list, and not its position, is changed. To correct the position as
-well, type a <TAB> before `C-M-q'.
-
- If the relative indentation within a list is correct but the
-indentation of its beginning is not, go to the line on which the list
-begins and type `C-u <TAB>'. When you give <TAB> a numeric argument,
-it moves all the lines in the group, starting on the current line,
-sideways the same amount that the current line moves. The command does
-not move lines that start inside strings, or C preprocessor lines when
-in C mode.
-
- Another way to specify a range to be re-indented is with point and
-mark. The command `C-M-\' (`indent-region') applies <TAB> to every
-line whose first character is between point and mark.
-
-\1f
-File: xemacs.info, Node: Lisp Indent, Next: C Indent, Prev: Multi-line Indent, Up: Grinding
-
-Customizing Lisp Indentation
-----------------------------
-
- The indentation pattern for a Lisp expression can depend on the
-function called by the expression. For each Lisp function, you can
-choose among several predefined patterns of indentation, or define an
-arbitrary one with a Lisp program.
-
- The standard pattern of indentation is as follows: the second line
-of the expression is indented under the first argument, if that is on
-the same line as the beginning of the expression; otherwise, the second
-line is indented underneath the function name. Each following line is
-indented under the previous line whose nesting depth is the same.
-
- If the variable `lisp-indent-offset' is non-`nil', it overrides the
-usual indentation pattern for the second line of an expression, so that
-such lines are always indented `lisp-indent-offset' more columns than
-the containing list.
-
- Certain functions override the standard pattern. Functions whose
-names start with `def' always indent the second line by
-`lisp-body-indention' extra columns beyond the open-parenthesis
-starting the expression.
-
- Individual functions can override the standard pattern in various
-ways, according to the `lisp-indent-function' property of the function
-name. (Note: `lisp-indent-function' was formerly called
-`lisp-indent-hook'). There are four possibilities for this property:
-
-`nil'
- This is the same as no property; the standard indentation pattern
- is used.
-
-`defun'
- The pattern used for function names that start with `def' is used
- for this function also.
-
-a number, NUMBER
- The first NUMBER arguments of the function are "distinguished"
- arguments; the rest are considered the "body" of the expression.
- A line in the expression is indented according to whether the
- first argument on it is distinguished or not. If the argument is
- part of the body, the line is indented `lisp-body-indent' more
- columns than the open-parenthesis starting the containing
- expression. If the argument is distinguished and is either the
- first or second argument, it is indented twice that many extra
- columns. If the argument is distinguished and not the first or
- second argument, the standard pattern is followed for that line.
-
-a symbol, SYMBOL
- SYMBOL should be a function name; that function is called to
- calculate the indentation of a line within this expression. The
- function receives two arguments:
- STATE
- The value returned by `parse-partial-sexp' (a Lisp primitive
- for indentation and nesting computation) when it parses up to
- the beginning of this line.
-
- POS
- The position at which the line being indented begins.
-
- It should return either a number, which is the number of columns of
- indentation for that line, or a list whose first element is such a
- number. The difference between returning a number and returning a
- list is that a number says that all following lines at the same
- nesting level should be indented just like this one; a list says
- that following lines might call for different indentations. This
- makes a difference when the indentation is computed by `C-M-q'; if
- the value is a number, `C-M-q' need not recalculate indentation
- for the following lines until the end of the list.
-
-\1f
-File: xemacs.info, Node: C Indent, Prev: Lisp Indent, Up: Grinding
-
-Customizing C Indentation
--------------------------
-
- Two variables control which commands perform C indentation and when.
-
- If `c-auto-newline' is non-`nil', newlines are inserted both before
-and after braces that you insert and after colons and semicolons.
-Correct C indentation is done on all the lines that are made this way.
-
- If `c-tab-always-indent' is non-`nil', the <TAB> command in C mode
-does indentation only if point is at the left margin or within the
-line's indentation. If there is non-whitespace to the left of point,
-<TAB> just inserts a tab character in the buffer. Normally, this
-variable is `nil', and <TAB> always reindents the current line.
-
- C does not have anything analogous to particular function names for
-which special forms of indentation are desirable. However, it has a
-different need for customization facilities: many different styles of C
-indentation are in common use.
-
- There are six variables you can set to control the style that Emacs C
-mode will use.
-
-`c-indent-level'
- Indentation of C statements within surrounding block. The
- surrounding block's indentation is the indentation of the line on
- which the open-brace appears.
-
-`c-continued-statement-offset'
- Extra indentation given to a substatement, such as the then-clause
- of an `if' or body of a `while'.
-
-`c-brace-offset'
- Extra indentation for lines that start with an open brace.
-
-`c-brace-imaginary-offset'
- An open brace following other text is treated as if it were this
- far to the right of the start of its line.
-
-`c-argdecl-indent'
- Indentation level of declarations of C function arguments.
-
-`c-label-offset'
- Extra indentation for a line that is a label, case, or default.
-
- The variable `c-indent-level' controls the indentation for C
-statements with respect to the surrounding block. In the example:
-
- {
- foo ();
-
-the difference in indentation between the lines is `c-indent-level'.
-Its standard value is 2.
-
- If the open-brace beginning the compound statement is not at the
-beginning of its line, the `c-indent-level' is added to the indentation
-of the line, not the column of the open-brace. For example,
-
- if (losing) {
- do_this ();
-
-One popular indentation style is that which results from setting
-`c-indent-level' to 8 and putting open-braces at the end of a line in
-this way. Another popular style prefers to put the open-brace on a
-separate line.
-
- In fact, the value of the variable `c-brace-imaginary-offset' is
-also added to the indentation of such a statement. Normally this
-variable is zero. Think of this variable as the imaginary position of
-the open brace, relative to the first non-blank character on the line.
-By setting the variable to 4 and `c-indent-level' to 0, you can get
-this style:
-
- if (x == y) {
- do_it ();
- }
-
- When `c-indent-level' is zero, the statements inside most braces
-line up exactly under the open brace. An exception are braces in column
-zero, like those surrounding a function's body. The statements inside
-those braces are not placed at column zero. Instead, `c-brace-offset'
-and `c-continued-statement-offset' (see below) are added to produce a
-typical offset between brace levels, and the statements are indented
-that far.
-
- `c-continued-statement-offset' controls the extra indentation for a
-line that starts within a statement (but not within parentheses or
-brackets). These lines are usually statements inside other statements,
-like the then-clauses of `if' statements and the bodies of `while'
-statements. The `c-continued-statement-offset' parameter determines
-the difference in indentation between the two lines in:
-
- if (x == y)
- do_it ();
-
-The default value for `c-continued-statement-offset' is 2. Some
-popular indentation styles correspond to a value of zero for
-`c-continued-statement-offset'.
-
- `c-brace-offset' is the extra indentation given to a line that
-starts with an open-brace. Its standard value is zero; compare:
-
- if (x == y)
- {
-
-with:
-
- if (x == y)
- do_it ();
-
-If you set `c-brace-offset' to 4, the first example becomes:
-
- if (x == y)
- {
-
- `c-argdecl-indent' controls the indentation of declarations of the
-arguments of a C function. It is absolute: argument declarations
-receive exactly `c-argdecl-indent' spaces. The standard value is 5 and
-results in code like this:
-
- char *
- index (string, char)
- char *string;
- int char;
-
- `c-label-offset' is the extra indentation given to a line that
-contains a label, a case statement, or a `default:' statement. Its
-standard value is -2 and results in code like this:
-
- switch (c)
- {
- case 'x':
-
-If `c-label-offset' were zero, the same code would be indented as:
-
- switch (c)
- {
- case 'x':
-
-This example assumes that the other variables above also have their
-default values.
-
- Using the indentation style produced by the default settings of the
-variables just discussed and putting open braces on separate lines
-produces clear and readable files. For an example, look at any of the C
-source files of XEmacs.
-
-\1f
-File: xemacs.info, Node: Matching, Next: Comments, Prev: Grinding, Up: Programs
-
-Automatic Display of Matching Parentheses
-=========================================
-
- The Emacs parenthesis-matching feature shows you automatically how
-parentheses match in the text. Whenever a self-inserting character that
-is a closing delimiter is typed, the cursor moves momentarily to the
-location of the matching opening delimiter, provided that is visible on
-the screen. If it is not on the screen, some text starting with that
-opening delimiter is displayed in the echo area. Either way, you see
-the grouping you are closing off.
-
- In Lisp, automatic matching applies only to parentheses. In C, it
-also applies to braces and brackets. Emacs knows which characters to
-regard as matching delimiters based on the syntax table set by the major
-mode. *Note Syntax::.
-
- If the opening delimiter and closing delimiter are mismatched--as in
-`[x)'--the echo area displays a warning message. The correct matches
-are specified in the syntax table.
-
- Two variables control parenthesis matching displays.
-`blink-matching-paren' turns the feature on or off. The default is `t'
-(match display is on); `nil' turns it off.
-`blink-matching-paren-distance' specifies how many characters back
-Emacs searches to find a matching opening delimiter. If the match is
-not found in the specified region, scanning stops, and nothing is
-displayed. This prevents wasting lots of time scanning when there is no
-match. The default is 4000.
-
-\1f
-File: xemacs.info, Node: Comments, Next: Balanced Editing, Prev: Matching, Up: Programs
-
-Manipulating Comments
-=====================
-
- The comment commands insert, kill and align comments.
-
-`M-;'
- Insert or align comment (`indent-for-comment').
-
-`C-x ;'
- Set comment column (`set-comment-column').
-
-`C-u - C-x ;'
- Kill comment on current line (`kill-comment').
-
-`M-<LFD>'
- Like <RET> followed by inserting and aligning a comment
- (`indent-new-comment-line').
-
- The command that creates a comment is `Meta-;'
-(`indent-for-comment'). If there is no comment already on the line, a
-new comment is created and aligned at a specific column called the
-"comment column". Emacs creates the comment by inserting the string at
-the value of `comment-start'; see below. Point is left after that
-string. If the text of the line extends past the comment column,
-indentation is done to a suitable boundary (usually, at least one space
-is inserted). If the major mode has specified a string to terminate
-comments, that string is inserted after point, to keep the syntax valid.
-
- You can also use `Meta-;' to align an existing comment. If a line
-already contains the string that starts comments, `M-;' just moves
-point after it and re-indents it to the conventional place. Exception:
-comments starting in column 0 are not moved.
-
- Some major modes have special rules for indenting certain kinds of
-comments in certain contexts. For example, in Lisp code, comments which
-start with two semicolons are indented as if they were lines of code,
-instead of at the comment column. Comments which start with three
-semicolons are supposed to start at the left margin. Emacs understands
-these conventions by indenting a double-semicolon comment using <TAB>
-and by not changing the indentation of a triple-semicolon comment at
-all.
-
- ;; This function is just an example.
- ;;; Here either two or three semicolons are appropriate.
- (defun foo (x)
- ;;; And now, the first part of the function:
- ;; The following line adds one.
- (1+ x)) ; This line adds one.
-
- In C code, a comment preceded on its line by nothing but whitespace
-is indented like a line of code.
-
- Even when an existing comment is properly aligned, `M-;' is still
-useful for moving directly to the start of the comment.
-
- `C-u - C-x ;' (`kill-comment') kills the comment on the current
-line, if there is one. The indentation before the start of the comment
-is killed as well. If there does not appear to be a comment in the
-line, nothing happens. To reinsert the comment on another line, move
-to the end of that line, type first `C-y', and then `M-;' to realign
-the comment. Note that `C-u - C-x ;' is not a distinct key; it is `C-x
-;' (`set-comment-column') with a negative argument. That command is
-programmed to call `kill-comment' when called with a negative argument.
-However, `kill-comment' is a valid command which you could bind
-directly to a key if you wanted to.
-
-Multiple Lines of Comments
---------------------------
-
- If you are typing a comment and want to continue it on another line,
-use the command `Meta-<LFD>' (`indent-new-comment-line'), which
-terminates the comment you are typing, creates a new blank line
-afterward, and begins a new comment indented under the old one. If
-Auto Fill mode is on and you go past the fill column while typing, the
-comment is continued in just this fashion. If point is not at the end
-of the line when you type `M-<LFD>', the text on the rest of the line
-becomes part of the new comment line.
-
-Options Controlling Comments
-----------------------------
-
- The comment column is stored in the variable `comment-column'. You
-can explicitly set it to a number. Alternatively, the command `C-x ;'
-(`set-comment-column') sets the comment column to the column point is
-at. `C-u C-x ;' sets the comment column to match the last comment
-before point in the buffer, and then calls `Meta-;' to align the
-current line's comment under the previous one. Note that `C-u - C-x ;'
-runs the function `kill-comment' as described above.
-
- `comment-column' is a per-buffer variable; altering the variable
-affects only the current buffer. You can also change the default value.
-*Note Locals::. Many major modes initialize this variable for the
-current buffer.
-
- The comment commands recognize comments based on the regular
-expression that is the value of the variable `comment-start-skip'.
-This regexp should not match the null string. It may match more than
-the comment starting delimiter in the strictest sense of the word; for
-example, in C mode the value of the variable is `"/\\*+ *"', which
-matches extra stars and spaces after the `/*' itself. (Note that `\\'
-is needed in Lisp syntax to include a `\' in the string, which is needed
-to deny the first star its special meaning in regexp syntax. *Note
-Regexps::.)
-
- When a comment command makes a new comment, it inserts the value of
-`comment-start' to begin it. The value of `comment-end' is inserted
-after point and will follow the text you will insert into the comment.
-In C mode, `comment-start' has the value `"/* "' and `comment-end' has
-the value `" */"'.
-
- `comment-multi-line' controls how `M-<LFD>'
-(`indent-new-comment-line') behaves when used inside a comment. If
-`comment-multi-line' is `nil', as it normally is, then `M-<LFD>'
-terminates the comment on the starting line and starts a new comment on
-the new following line. If `comment-multi-line' is not `nil', then
-`M-<LFD>' sets up the new following line as part of the same comment
-that was found on the starting line. This is done by not inserting a
-terminator on the old line and not inserting a starter on the new line.
-In languages where multi-line comments are legal, the value you choose
-for this variable is a matter of taste.
-
- The variable `comment-indent-hook' should contain a function that is
-called to compute the indentation for a newly inserted comment or for
-aligning an existing comment. Major modes set this variable
-differently. The function is called with no arguments, but with point
-at the beginning of the comment, or at the end of a line if a new
-comment is to be inserted. The function should return the column in
-which the comment ought to start. For example, in Lisp mode, the
-indent hook function bases its decision on the number of semicolons
-that begin an existing comment and on the code in the preceding lines.
-
-\1f
-File: xemacs.info, Node: Balanced Editing, Next: Lisp Completion, Prev: Comments, Up: Programs
-
-Editing Without Unbalanced Parentheses
-======================================
-
-`M-('
- Put parentheses around next sexp(s) (`insert-parentheses').
-
-`M-)'
- Move past next close parenthesis and re-indent
- (`move-over-close-and-reindent').
-
- The commands `M-(' (`insert-parentheses') and `M-)'
-(`move-over-close-and-reindent') are designed to facilitate a style of
-editing which keeps parentheses balanced at all times. `M-(' inserts a
-pair of parentheses, either together as in `()', or, if given an
-argument, around the next several sexps, and leaves point after the open
-parenthesis. Instead of typing `( F O O )', you can type `M-( F O O',
-which has the same effect except for leaving the cursor before the
-close parenthesis. You can then type `M-)', which moves past the close
-parenthesis, deletes any indentation preceding it (in this example
-there is none), and indents with <LFD> after it.
-
-\1f
-File: xemacs.info, Node: Lisp Completion, Next: Documentation, Prev: Balanced Editing, Up: Programs
-
-Completion for Lisp Symbols
-===========================
-
- Completion usually happens in the minibuffer. An exception is
-completion for Lisp symbol names, which is available in all buffers.
-
- The command `M-<TAB>' (`lisp-complete-symbol') takes the partial
-Lisp symbol before point to be an abbreviation, and compares it against
-all non-trivial Lisp symbols currently known to Emacs. Any additional
-characters that they all have in common are inserted at point.
-Non-trivial symbols are those that have function definitions, values, or
-properties.
-
- If there is an open-parenthesis immediately before the beginning of
-the partial symbol, only symbols with function definitions are
-considered as completions.
-
- If the partial name in the buffer has more than one possible
-completion and they have no additional characters in common, a list of
-all possible completions is displayed in another window.
-
-\1f
-File: xemacs.info, Node: Documentation, Next: Change Log, Prev: Lisp Completion, Up: Programs
-
-Documentation Commands
-======================
-
- As you edit Lisp code to be run in Emacs, you can use the commands
-`C-h f' (`describe-function') and `C-h v' (`describe-variable') to
-print documentation of functions and variables you want to call. These
-commands use the minibuffer to read the name of a function or variable
-to document, and display the documentation in a window.
-
- For extra convenience, these commands provide default arguments
-based on the code in the neighborhood of point. `C-h f' sets the
-default to the function called in the innermost list containing point.
-`C-h v' uses the symbol name around or adjacent to point as its default.
-
- The `M-x manual-entry' command gives you access to documentation on
-Unix commands, system calls, and libraries. The command reads a topic
-as an argument, and displays the Unix manual page for that topic.
-`manual-entry' always searches all 8 sections of the manual and
-concatenates all the entries it finds. For example, the topic
-`termcap' finds the description of the termcap library from section 3,
-followed by the description of the termcap data base from section 5.
-
projects / chise / xemacs-chise.git- / blobdiff