-This is Info file ../info/xemacs.info, produced by Makeinfo version
-1.68 from the input file xemacs/xemacs.texi.
+This is ../info/xemacs.info, produced by makeinfo version 4.0 from
+xemacs/xemacs.texi.
INFO-DIR-SECTION XEmacs Editor
START-INFO-DIR-ENTRY
translation approved by the author instead of in the original English.
\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
comment lines. Optionally, new comment delimiters are inserted at the
end of the first line and the beginning of the second, so that each line
is a separate comment. The variable `comment-multi-line' controls the
-choice (*note Comments::.).
+choice (*note Comments::).
Auto Fill mode does not refill entire paragraphs. It can break
lines but cannot merge lines. Editing in the middle of a paragraph can
the region into paragraphs and fills each of them.
`Meta-q' and `Meta-g' use the same criteria as `Meta-h' for finding
-paragraph boundaries (*note Paragraphs::.). For more control, you can
+paragraph boundaries (*note Paragraphs::). For more control, you can
use `M-x fill-region-as-paragraph', which refills everything between
point and mark. This command recognizes only blank lines as paragraph
separators.
Emacs has many commands designed to understand the syntax of
programming languages such as Lisp and C. These commands can:
- * Move over or kill balanced expressions or "sexps" (*note Lists::.).
+ * Move over or kill balanced expressions or "sexps" (*note Lists::).
* Move over or mark top-level balanced expressions ("defuns", in
Lisp; functions, in C).
- * Show how parentheses balance (*note Matching::.).
+ * Show how parentheses balance (*note Matching::).
- * Insert, kill, or align comments (*note Comments::.).
+ * Insert, kill, or align comments (*note Comments::).
* Follow the usual indentation conventions of the language (*note
- Grinding::.).
+ Grinding::).
The commands available for words, sentences, and paragraphs are
useful in editing code even though their canonical application is for
editing human language text. Most symbols contain words (*note
-Words::.); sentences can be found in strings and comments (*note
-Sentences::.). Paragraphs per se are not present in code, but the
+Words::); sentences can be found in strings and comments (*note
+Sentences::). Paragraphs per se are not present in code, but the
paragraph commands are useful anyway, because Lisp mode and C mode
-define paragraphs to begin and end at blank lines (*note
-Paragraphs::.). Judicious use of blank lines to make the program
-clearer also provides interesting chunks of text for the paragraph
-commands to work on.
+define paragraphs to begin and end at blank lines (*note Paragraphs::).
+Judicious use of blank lines to make the program clearer also provides
+interesting chunks of text for the paragraph commands to work on.
The selective display feature is useful for looking at the overall
-structure of a function (*note Selective Display::.). This feature
+structure of a function (*note Selective Display::). This feature
causes only the lines that are indented less than a specified amount to
appear on the screen.
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