-This is ../info/xemacs.info, produced by makeinfo version 3.12s from
+This is ../info/xemacs.info, produced by makeinfo version 4.0b 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: Pages, Next: Filling, Prev: Paragraphs, Up: Text
-
-Pages
-=====
-
- Files are often thought of as divided into "pages" by the "formfeed"
-character (ASCII Control-L, octal code 014). For example, if a file is
-printed on a line printer, each "page" of the file starts on a new page
-of paper. Emacs treats a page-separator character just like any other
-character. It can be inserted with `C-q C-l' or deleted with <DEL>.
-You are free to paginate your file or not. However, since pages are
-often meaningful divisions of the file, commands are provided to move
-over them and operate on them.
-
-`C-x ['
- Move point to previous page boundary (`backward-page').
-
-`C-x ]'
- Move point to next page boundary (`forward-page').
-
-`C-x C-p'
- Put point and mark around this page (or another page)
- (`mark-page').
-
-`C-x l'
- Count the lines in this page (`count-lines-page').
-
- The `C-x [' (`backward-page') command moves point to immediately
-after the previous page delimiter. If point is already right after a
-page delimiter, the command skips that one and stops at the previous
-one. A numeric argument serves as a repeat count. The `C-x ]'
-(`forward-page') command moves forward past the next page delimiter.
-
- The `C-x C-p' command (`mark-page') puts point at the beginning of
-the current page and the mark at the end. The page delimiter at the end
-is included (the mark follows it). The page delimiter at the front is
-excluded (point follows it). You can follow this command by `C-w' to
-kill a page you want to move elsewhere. If you insert the page after a
-page delimiter, at a place where `C-x ]' or `C-x [' would take you, the
-page will be properly delimited before and after once again.
-
- A numeric argument to `C-x C-p' is used to specify which page to go
-to, relative to the current one. Zero means the current page. One
-means the next page, and -1 means the previous one.
-
- The `C-x l' command (`count-lines-page') can help you decide where
-to break a page in two. It prints the total number of lines in the
-current page in the echo area, then divides the lines into those
-preceding the current line and those following it, for example
-
- Page has 96 (72+25) lines
-
-Notice that the sum is off by one; this is correct if point is not at
-the beginning of a line.
-
- The variable `page-delimiter' should have as its value a regexp that
-matches the beginning of a line that separates pages. This defines
-where pages begin. The normal value of this variable is `"^\f"', which
-matches a formfeed character at the beginning of a line.
+File: xemacs.info, Node: Specify Coding, Prev: Recognize Coding, Up: Mule
+
+Specifying a Coding System
+==========================
+
+ In cases where XEmacs does not automatically choose the right coding
+system, you can use these commands to specify one:
+
+`C-x <RET> f CODING <RET>'
+ Use coding system CODING for the visited file in the current
+ buffer.
+
+`C-x <RET> c CODING <RET>'
+ Specify coding system CODING for the immediately following command.
+
+`C-x <RET> k CODING <RET>'
+ Use coding system CODING for keyboard input.
+
+`C-x <RET> t CODING <RET>'
+ Use coding system CODING for terminal output.
+
+`C-x <RET> p CODING <RET>'
+ Use coding system CODING for subprocess input and output in the
+ current buffer.
+
+ The command `C-x RET f' (`set-buffer-file-coding-system') specifies
+the file coding system for the current buffer--in other words, which
+coding system to use when saving or rereading the visited file. You
+specify which coding system using the minibuffer. Since this command
+applies to a file you have already visited, it affects only the way the
+file is saved.
+
+ Another way to specify the coding system for a file is when you visit
+the file. First use the command `C-x <RET> c'
+(`universal-coding-system-argument'); this command uses the minibuffer
+to read a coding system name. After you exit the minibuffer, the
+specified coding system is used for _the immediately following command_.
+
+ So if the immediately following command is `C-x C-f', for example,
+it reads the file using that coding system (and records the coding
+system for when the file is saved). Or if the immediately following
+command is `C-x C-w', it writes the file using that coding system.
+Other file commands affected by a specified coding system include `C-x
+C-i' and `C-x C-v', as well as the other-window variants of `C-x C-f'.
+
+ In addition, if you run some file input commands with the precedent
+`C-u', you can specify coding system to read from minibuffer. So if
+the immediately following command is `C-x C-f', for example, it reads
+the file using that coding system (and records the coding system for
+when the file is saved). Other file commands affected by a specified
+coding system include `C-x C-i' and `C-x C-v', as well as the
+other-window variants of `C-x C-f'.
+
+ The variable `default-buffer-file-coding-system' specifies the
+choice of coding system to use when you create a new file. It applies
+when you find a new file, and when you create a buffer and then save it
+in a file. Selecting a language environment typically sets this
+variable to a good choice of default coding system for that language
+environment.
+
+ The command `C-x <RET> t' (`set-terminal-coding-system') specifies
+the coding system for terminal output. If you specify a character code
+for terminal output, all characters output to the terminal are
+translated into that coding system.
+
+ This feature is useful for certain character-only terminals built to
+support specific languages or character sets--for example, European
+terminals that support one of the ISO Latin character sets.
+
+ By default, output to the terminal is not translated at all.
+
+ The command `C-x <RET> k' (`set-keyboard-coding-system') specifies
+the coding system for keyboard input. Character-code translation of
+keyboard input is useful for terminals with keys that send non-ASCII
+graphic characters--for example, some terminals designed for ISO
+Latin-1 or subsets of it.
+
+ By default, keyboard input is not translated at all.
+
+ There is a similarity between using a coding system translation for
+keyboard input, and using an input method: both define sequences of
+keyboard input that translate into single characters. However, input
+methods are designed to be convenient for interactive use by humans, and
+the sequences that are translated are typically sequences of ASCII
+printing characters. Coding systems typically translate sequences of
+non-graphic characters.
+
+ The command `C-x <RET> p' (`set-buffer-process-coding-system')
+specifies the coding system for input and output to a subprocess. This
+command applies to the current buffer; normally, each subprocess has its
+own buffer, and thus you can use this command to specify translation to
+and from a particular subprocess by giving the command in the
+corresponding buffer.
+
+ By default, process input and output are not translated at all.
+
+ The variable `file-name-coding-system' specifies a coding system to
+use for encoding file names. If you set the variable to a coding
+system name (as a Lisp symbol or a string), XEmacs encodes file names
+using that coding system for all file operations. This makes it
+possible to use non-Latin-1 characters in file names--or, at least,
+those non-Latin-1 characters which the specified coding system can
+encode. By default, this variable is `nil', which implies that you
+cannot use non-Latin-1 characters in file names.
\1f
-File: xemacs.info, Node: Filling, Next: Case, Prev: Pages, Up: Text
-
-Filling Text
-============
-
- If you use Auto Fill mode, Emacs "fills" text (breaks it up into
-lines that fit in a specified width) as you insert it. When you alter
-existing text it is often no longer be properly filled afterwards and
-you can use explicit commands for filling.
+File: xemacs.info, Node: Major Modes, Next: Indentation, Prev: Mule, Up: Top
+
+Major Modes
+***********
+
+ Emacs has many different "major modes", each of which customizes
+Emacs for editing text of a particular sort. The major modes are
+mutually exclusive; at any time, each buffer has one major mode. The
+mode line normally contains the name of the current major mode in
+parentheses. *Note Mode Line::.
+
+ The least specialized major mode is called "Fundamental mode". This
+mode has no mode-specific redefinitions or variable settings. Each
+Emacs command behaves in its most general manner, and each option is in
+its default state. For editing any specific type of text, such as Lisp
+code or English text, you should switch to the appropriate major mode,
+such as Lisp mode or Text mode.
+
+ Selecting a major mode changes the meanings of a few keys to become
+more specifically adapted to the language being edited. <TAB>, <DEL>,
+and <LFD> are changed frequently. In addition, commands which handle
+comments use the mode to determine how to delimit comments. Many major
+modes redefine the syntactical properties of characters appearing in
+the buffer. *Note Syntax::.
+
+ The major modes fall into three major groups. Lisp mode (which has
+several variants), C mode, and Muddle mode are for specific programming
+languages. Text mode, Nroff mode, TeX mode, and Outline mode are for
+editing English text. The remaining major modes are not intended for
+use on users' files; they are used in buffers created by Emacs for
+specific purposes and include Dired mode for buffers made by Dired
+(*note Dired::), Mail mode for buffers made by `C-x m' (*note Sending
+Mail::), and Shell mode for buffers used for communicating with an
+inferior shell process (*note Interactive Shell::).
+
+ Most programming language major modes specify that only blank lines
+separate paragraphs. This is so that the paragraph commands remain
+useful. *Note Paragraphs::. They also cause Auto Fill mode to use the
+definition of <TAB> to indent the new lines it creates. This is
+because most lines in a program are usually indented. *Note
+Indentation::.
* Menu:
-* Auto Fill:: Auto Fill mode breaks long lines automatically.
-* Fill Commands:: Commands to refill paragraphs and center lines.
-* Fill Prefix:: Filling when every line is indented or in a comment, etc.
+* Choosing Modes:: How major modes are specified or chosen.
\1f
-File: xemacs.info, Node: Auto Fill, Next: Fill Commands, Prev: Filling, Up: Filling
-
-Auto Fill Mode
---------------
-
- "Auto Fill" mode is a minor mode in which lines are broken
-automatically when they become too wide. Breaking happens only when
-you type a <SPC> or <RET>.
-
-`M-x auto-fill-mode'
- Enable or disable Auto Fill mode.
-
-`<SPC>'
-`<RET>'
- In Auto Fill mode, break lines when appropriate.
-
- `M-x auto-fill-mode' turns Auto Fill mode on if it was off, or off
-if it was on. With a positive numeric argument the command always turns
-Auto Fill mode on, and with a negative argument it always turns it off.
-The presence of the word `Fill' in the mode line, inside the
-parentheses, indicates that Auto Fill mode is in effect. Auto Fill mode
-is a minor mode; you can turn it on or off for each buffer individually.
-*Note Minor Modes::.
-
- In Auto Fill mode, lines are broken automatically at spaces when
-they get longer than desired. Line breaking and rearrangement takes
-place only when you type <SPC> or <RET>. To insert a space or newline
-without permitting line-breaking, type `C-q <SPC>' or `C-q <LFD>'
-(recall that a newline is really a linefeed). `C-o' inserts a newline
-without line breaking.
-
- Auto Fill mode works well with Lisp mode: when it makes a new line in
-Lisp mode, it indents that line with <TAB>. If a line ending in a Lisp
-comment gets too long, the text of the comment is split into two
-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::).
-
- Auto Fill mode does not refill entire paragraphs. It can break
-lines but cannot merge lines. Editing in the middle of a paragraph can
-result in a paragraph that is not correctly filled. The easiest way to
-make the paragraph properly filled again is using an explicit fill
-commands.
+File: xemacs.info, Node: Choosing Modes, Prev: Major Modes, Up: Major Modes
- Many users like Auto Fill mode and want to use it in all text files.
-The section on init files explains how you can arrange this permanently
-for yourself. *Note Init File::.
+Choosing Major Modes
+====================
-\1f
-File: xemacs.info, Node: Fill Commands, Next: Fill Prefix, Prev: Auto Fill, Up: Filling
+ You can select a major mode explicitly for the current buffer, but
+most of the time Emacs determines which mode to use based on the file
+name or some text in the file.
-Explicit Fill Commands
-----------------------
+ Use a `M-x' command to explicitly select a new major mode. Add
+`-mode' to the name of a major mode to get the name of a command to
+select that mode. For example, to enter Lisp mode, execute `M-x
+lisp-mode'.
-`M-q'
- Fill current paragraph (`fill-paragraph').
+ When you visit a file, Emacs usually chooses the right major mode
+based on the file's name. For example, files whose names end in `.c'
+are edited in C mode. The variable `auto-mode-alist' controls the
+correspondence between file names and major mode. Its value is a list
+in which each element has the form:
-`M-g'
- Fill each paragraph in the region (`fill-region').
+ (REGEXP . MODE-FUNCTION)
-`C-x f'
- Set the fill column (`set-fill-column').
+For example, one element normally found in the list has the form
+`("\\.c$" . c-mode)'. It is responsible for selecting C mode for files
+whose names end in `.c'. (Note that `\\' is needed in Lisp syntax to
+include a `\' in the string, which is needed to suppress the special
+meaning of `.' in regexps.) The only practical way to change this
+variable is with Lisp code.
-`M-x fill-region-as-paragraph'
- Fill the region, considering it as one paragraph.
+ You can specify which major mode should be used for editing a certain
+file by a special sort of text in the first non-blank line of the file.
+The mode name should appear in this line both preceded and followed by
+`-*-'. Other text may appear on the line as well. For example,
-`M-s'
- Center a line.
+ ;-*-Lisp-*-
- To refill a paragraph, use the command `Meta-q' (`fill-paragraph').
-It causes the paragraph containing point, or the one after point if
-point is between paragraphs, to be refilled. All line breaks are
-removed, and new ones are inserted where necessary. `M-q' can be
-undone with `C-_'. *Note Undo::.
+tells Emacs to use Lisp mode. Note how the semicolon is used to make
+Lisp treat this line as a comment. Such an explicit specification
+overrides any default mode based on the file name.
- To refill many paragraphs, use `M-g' (`fill-region'), which divides
-the region into paragraphs and fills each of them.
+ Another format of mode specification is:
- `Meta-q' and `Meta-g' use the same criteria as `Meta-h' for finding
-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.
+ -*-Mode: MODENAME;-*-
- A numeric argument to `M-g' or `M-q' causes it to "justify" the text
-as well as filling it. Extra spaces are inserted to make the right
-margin line up exactly at the fill column. To remove the extra spaces,
-use `M-q' or `M-g' with no argument.
+which allows other things besides the major mode name to be specified.
+However, Emacs does not look for anything except the mode name.
- The variable `auto-fill-inhibit-regexp' takes as a value a regexp to
-match lines that should not be auto-filled.
+ The major mode can also be specified in a local variables list.
+*Note File Variables::.
- The command `Meta-s' (`center-line') centers the current line within
-the current fill column. With an argument, it centers several lines
-individually and moves past them.
+ When you visit a file that does not specify a major mode to use, or
+when you create a new buffer with `C-x b', Emacs uses the major mode
+specified by the variable `default-major-mode'. Normally this value is
+the symbol `fundamental-mode', which specifies Fundamental mode. If
+`default-major-mode' is `nil', the major mode is taken from the
+previously selected buffer.
- The maximum line width for filling is in the variable `fill-column'.
-Altering the value of `fill-column' makes it local to the current
-buffer; until then, the default value--initially 70--is in effect.
-*Note Locals::.
+\1f
+File: xemacs.info, Node: Indentation, Next: Text, Prev: Major Modes, Up: Top
- The easiest way to set `fill-column' is to use the command `C-x f'
-(`set-fill-column'). With no argument, it sets `fill-column' to the
-current horizontal position of point. With a numeric argument, it uses
-that number as the new fill column.
+Indentation
+***********
-\1f
-File: xemacs.info, Node: Fill Prefix, Prev: Fill Commands, Up: Filling
-
-The Fill Prefix
----------------
-
- To fill a paragraph in which each line starts with a special marker
-(which might be a few spaces, giving an indented paragraph), use the
-"fill prefix" feature. The fill prefix is a string which is not
-included in filling. Emacs expects every line to start with a fill
-prefix.
-
-`C-x .'
- Set the fill prefix (`set-fill-prefix').
-
-`M-q'
- Fill a paragraph using current fill prefix (`fill-paragraph').
-
-`M-x fill-individual-paragraphs'
- Fill the region, considering each change of indentation as
- starting a new paragraph.
-
- To specify a fill prefix, move to a line that starts with the desired
-prefix, put point at the end of the prefix, and give the command
-`C-x .' (`set-fill-prefix'). That's a period after the `C-x'. To turn
-off the fill prefix, specify an empty prefix: type `C-x .' with point
-at the beginning of a line.
-
- When a fill prefix is in effect, the fill commands remove the fill
-prefix from each line before filling and insert it on each line after
-filling. Auto Fill mode also inserts the fill prefix inserted on new
-lines it creates. Lines that do not start with the fill prefix are
-considered to start paragraphs, both in `M-q' and the paragraph
-commands; this is just right if you are using paragraphs with hanging
-indentation (every line indented except the first one). Lines which are
-blank or indented once the prefix is removed also separate or start
-paragraphs; this is what you want if you are writing multi-paragraph
-comments with a comment delimiter on each line.
-
- The fill prefix is stored in the variable `fill-prefix'. Its value
-is a string, or `nil' when there is no fill prefix. This is a
-per-buffer variable; altering the variable affects only the current
-buffer, but there is a default value which you can change as well.
-*Note Locals::.
-
- Another way to use fill prefixes is through `M-x
-fill-individual-paragraphs'. This function divides the region into
-groups of consecutive lines with the same amount and kind of
-indentation and fills each group as a paragraph, using its indentation
-as a fill prefix.
+`<TAB>'
+ Indent current line "appropriately" in a mode-dependent fashion.
-\1f
-File: xemacs.info, Node: Case, Prev: Filling, Up: Text
+`<LFD>'
+ Perform <RET> followed by <TAB> (`newline-and-indent').
-Case Conversion Commands
-========================
+`M-^'
+ Merge two lines (`delete-indentation'). This would cancel out the
+ effect of <LFD>.
- Emacs has commands for converting either a single word or any
-arbitrary range of text to upper case or to lower case.
+`C-M-o'
+ Split line at point; text on the line after point becomes a new
+ line indented to the same column that it now starts in
+ (`split-line').
-`M-l'
- Convert following word to lower case (`downcase-word').
+`M-m'
+ Move (forward or back) to the first non-blank character on the
+ current line (`back-to-indentation').
-`M-u'
- Convert following word to upper case (`upcase-word').
+`C-M-\'
+ Indent several lines to same column (`indent-region').
+
+`C-x <TAB>'
+ Shift block of lines rigidly right or left (`indent-rigidly').
-`M-c'
- Capitalize the following word (`capitalize-word').
+`M-i'
+ Indent from point to the next prespecified tab stop column
+ (`tab-to-tab-stop').
-`C-x C-l'
- Convert region to lower case (`downcase-region').
+`M-x indent-relative'
+ Indent from point to under an indentation point in the previous
+ line.
-`C-x C-u'
- Convert region to upper case (`upcase-region').
+ Most programming languages have some indentation convention. For
+Lisp code, lines are indented according to their nesting in
+parentheses. The same general idea is used for C code, though details
+differ.
- The word conversion commands are used most frequently. `Meta-l'
-(`downcase-word') converts the word after point to lower case, moving
-past it. Thus, repeating `Meta-l' converts successive words. `Meta-u'
-(`upcase-word') converts to all capitals instead, while `Meta-c'
-(`capitalize-word') puts the first letter of the word into upper case
-and the rest into lower case. The word conversion commands convert
-several words at once if given an argument. They are especially
-convenient for converting a large amount of text from all upper case to
-mixed case: you can move through the text using `M-l', `M-u', or `M-c'
-on each word as appropriate, occasionally using `M-f' instead to skip a
-word.
+ Use the <TAB> command to indent a line whatever the language. Each
+major mode defines this command to perform indentation appropriate for
+the particular language. In Lisp mode, <TAB> aligns a line according
+to its depth in parentheses. No matter where in the line you are when
+you type <TAB>, it aligns the line as a whole. In C mode, <TAB>
+implements a subtle and sophisticated indentation style that knows
+about many aspects of C syntax.
- When given a negative argument, the word case conversion commands
-apply to the appropriate number of words before point, but do not move
-point. This is convenient when you have just typed a word in the wrong
-case: you can give the case conversion command and continue typing.
+ In Text mode, <TAB> runs the command `tab-to-tab-stop', which
+indents to the next tab stop column. You can set the tab stops with
+`M-x edit-tab-stops'.
- If a word case conversion command is given in the middle of a word,
-it applies only to the part of the word which follows point. This is
-just like what `Meta-d' (`kill-word') does. With a negative argument,
-case conversion applies only to the part of the word before point.
+* Menu:
- The other case conversion commands are `C-x C-u' (`upcase-region')
-and `C-x C-l' (`downcase-region'), which convert everything between
-point and mark to the specified case. Point and mark do not move.
+* Indentation Commands:: Various commands and techniques for indentation.
+* Tab Stops:: You can set arbitrary "tab stops" and then
+ indent to the next tab stop when you want to.
+* Just Spaces:: You can request indentation using just spaces.
\1f
-File: xemacs.info, Node: Programs, Next: Running, Prev: Text, Up: Top
+File: xemacs.info, Node: Indentation Commands, Next: Tab Stops, Prev: Indentation, Up: Indentation
+
+Indentation Commands and Techniques
+===================================
+
+ If you just want to insert a tab character in the buffer, you can
+type `C-q <TAB>'.
+
+ To move over the indentation on a line, type `Meta-m'
+(`back-to-indentation'). This command, given anywhere on a line,
+positions point at the first non-blank character on the line.
+
+ To insert an indented line before the current line, type `C-a C-o
+<TAB>'. To make an indented line after the current line, use `C-e
+<LFD>'.
+
+ `C-M-o' (`split-line') moves the text from point to the end of the
+line vertically down, so that the current line becomes two lines.
+`C-M-o' first moves point forward over any spaces and tabs. Then it
+inserts after point a newline and enough indentation to reach the same
+column point is on. Point remains before the inserted newline; in this
+regard, `C-M-o' resembles `C-o'.
+
+ To join two lines cleanly, use the `Meta-^' (`delete-indentation')
+command to delete the indentation at the front of the current line, and
+the line boundary as well. Empty spaces are replaced by a single
+space, or by no space if at the beginning of a line, before a close
+parenthesis, or after an open parenthesis. To delete just the
+indentation of a line, go to the beginning of the line and use `Meta-\'
+(`delete-horizontal-space'), which deletes all spaces and tabs around
+the cursor.
+
+ There are also commands for changing the indentation of several
+lines at once. `Control-Meta-\' (`indent-region') gives each line which
+begins in the region the "usual" indentation by invoking <TAB> at the
+beginning of the line. A numeric argument specifies the column to
+indent to. Each line is shifted left or right so that its first
+non-blank character appears in that column. `C-x <TAB>'
+(`indent-rigidly') moves all the lines in the region right by its
+argument (left, for negative arguments). The whole group of lines moves
+rigidly sideways, which is how the command gets its name.
+
+ `M-x indent-relative' indents at point based on the previous line
+(actually, the last non-empty line.) It inserts whitespace at point,
+moving point, until it is underneath an indentation point in the
+previous line. An indentation point is the end of a sequence of
+whitespace or the end of the line. If point is farther right than any
+indentation point in the previous line, the whitespace before point is
+deleted and the first indentation point then applicable is used. If no
+indentation point is applicable even then, `tab-to-tab-stop' is run
+(see next section).
+
+ `indent-relative' is the definition of <TAB> in Indented Text mode.
+*Note Text::.
-Editing Programs
-****************
+\1f
+File: xemacs.info, Node: Tab Stops, Next: Just Spaces, Prev: Indentation Commands, Up: Indentation
+
+Tab Stops
+=========
+
+ For typing in tables, you can use Text mode's definition of <TAB>,
+`tab-to-tab-stop'. This command inserts indentation before point,
+enough to reach the next tab stop column. Even if you are not in Text
+mode, this function is associated with `M-i' anyway.
+
+ You can arbitrarily set the tab stops used by `M-i'. They are
+stored as a list of column-numbers in increasing order in the variable
+`tab-stop-list'.
+
+ The convenient way to set the tab stops is using `M-x
+edit-tab-stops', which creates and selects a buffer containing a
+description of the tab stop settings. You can edit this buffer to
+specify different tab stops, and then type `C-c C-c' to make those new
+tab stops take effect. In the tab stop buffer, `C-c C-c' runs the
+function `edit-tab-stops-note-changes' rather than the default
+`save-buffer'. `edit-tab-stops' records which buffer was current when
+you invoked it, and stores the tab stops in that buffer. Normally all
+buffers share the same tab stops and changing them in one buffer
+affects all. If you make `tab-stop-list' local in one buffer
+`edit-tab-stops' in that buffer edits only the local settings.
+
+ Below is the text representing ordinary tab stops every eight
+columns:
+
+ : : : : : :
+ 0 1 2 3 4
+ 0123456789012345678901234567890123456789012345678
+ To install changes, type C-c C-c
+
+ The first line contains a colon at each tab stop. The remaining
+lines help you see where the colons are and tell you what to do.
+
+ Note that the tab stops that control `tab-to-tab-stop' have nothing
+to do with displaying tab characters in the buffer. *Note Display
+Vars::, for more information on that.
- Emacs has many commands designed to understand the syntax of
-programming languages such as Lisp and C. These commands can:
+\1f
+File: xemacs.info, Node: Just Spaces, Prev: Tab Stops, Up: Indentation
- * Move over or kill balanced expressions or "sexps" (*note Lists::).
+Tabs vs. Spaces
+===============
- * Move over or mark top-level balanced expressions ("defuns", in
- Lisp; functions, in C).
+ Emacs normally uses both tabs and spaces to indent lines. If you
+prefer, all indentation can be made from spaces only. To request this,
+set `indent-tabs-mode' to `nil'. This is a per-buffer variable;
+altering the variable affects only the current buffer, but there is a
+default value which you can change as well. *Note Locals::.
- * Show how parentheses balance (*note Matching::).
+ There are also commands to convert tabs to spaces or vice versa,
+always preserving the columns of all non-blank text. `M-x tabify'
+scans the region for sequences of spaces, and converts sequences of at
+least three spaces to tabs if that is possible without changing
+indentation. `M-x untabify' changes all tabs in the region to
+corresponding numbers of spaces.
- * Insert, kill, or align comments (*note Comments::).
+\1f
+File: xemacs.info, Node: Text, Next: Programs, Prev: Indentation, Up: Top
+
+Commands for Human Languages
+****************************
+
+ The term "text" has two widespread meanings in our area of the
+computer field. One is data that is a sequence of characters. In this
+sense of the word any file that you edit with Emacs is text. The other
+meaning is more restrictive: a sequence of characters in a human
+language for humans to read (possibly after processing by a text
+formatter), as opposed to a program or commands for a program.
+
+ Human languages have syntactic and stylistic conventions that editor
+commands should support or use to advantage: conventions involving
+words, sentences, paragraphs, and capital letters. This chapter
+describes Emacs commands for all these things. There are also commands
+for "filling", or rearranging paragraphs into lines of approximately
+equal length. The commands for moving over and killing words,
+sentences, and paragraphs, while intended primarily for editing text,
+are also often useful for editing programs.
+
+ Emacs has several major modes for editing human language text. If a
+file contains plain text, use Text mode, which customizes Emacs in
+small ways for the syntactic conventions of text. For text which
+contains embedded commands for text formatters, Emacs has other major
+modes, each for a particular text formatter. Thus, for input to TeX,
+you can use TeX mode; for input to nroff, Nroff mode.
- * Follow the usual indentation conventions of the language (*note
- Grinding::).
+* Menu:
- 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
-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.
+* Text Mode:: The major modes for editing text files.
+* Nroff Mode:: The major mode for editing input to the formatter nroff.
+* TeX Mode:: The major modes for editing input to the formatter TeX.
+* Outline Mode:: The major mode for editing outlines.
+* Words:: Moving over and killing words.
+* Sentences:: Moving over and killing sentences.
+* Paragraphs:: Moving over paragraphs.
+* Pages:: Moving over pages.
+* Filling:: Filling or justifying text
+* Case:: Changing the case of text
- The selective display feature is useful for looking at the overall
-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.
+\1f
+File: xemacs.info, Node: Text Mode, Next: Words, Prev: Text, Up: Text
+
+Text Mode
+=========
+
+ You should use Text mode--rather than Fundamental or Lisp mode--to
+edit files of text in a human language. Invoke `M-x text-mode' to
+enter Text mode. In Text mode, <TAB> runs the function
+`tab-to-tab-stop', which allows you to use arbitrary tab stops set with
+`M-x edit-tab-stops' (*note Tab Stops::). Features concerned with
+comments in programs are turned off unless they are explicitly invoked.
+The syntax table is changed so that periods are not considered part of a
+word, while apostrophes, backspaces and underlines are.
+
+ A similar variant mode is Indented Text mode, intended for editing
+text in which most lines are indented. This mode defines <TAB> to run
+`indent-relative' (*note Indentation::), and makes Auto Fill indent the
+lines it creates. As a result, a line made by Auto Filling, or by
+<LFD>, is normally indented just like the previous line. Use `M-x
+indented-text-mode' to select this mode.
+
+ Entering Text mode or Indented Text mode calls the value of the
+variable `text-mode-hook' with no arguments, if that value exists and
+is not `nil'. This value is also called when modes related to Text
+mode are entered; this includes Nroff mode, TeX mode, Outline mode, and
+Mail mode. Your hook can look at the value of `major-mode' to see
+which of these modes is actually being entered.
+
+ Two modes similar to Text mode are of use for editing text that is to
+be passed through a text formatter before achieving its final readable
+form.
* Menu:
-* Program Modes:: Major modes for editing programs.
-* Lists:: Expressions with balanced parentheses.
- There are editing commands to operate on them.
-* Defuns:: Each program is made up of separate functions.
- 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.
-* 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.
-* Change Log:: Maintaining a change history for your program.
-* Tags:: Go direct to any function in your program in one
- command. Tags remembers which file it is in.
-* Fortran:: Fortran mode and its special features.
-* Asm Mode:: Asm mode and its special features.
+* Nroff Mode:: The major mode for editing input to the formatter nroff.
+* TeX Mode:: The major modes for editing input to the formatter TeX.
-\1f
-File: xemacs.info, Node: Program Modes, Next: Lists, Prev: Programs, Up: Programs
-
-Major Modes for Programming Languages
-=====================================
-
- Emacs has several major modes for the programming languages Lisp,
-Scheme (a variant of Lisp), C, Fortran, and Muddle. Ideally, a major
-mode should be implemented for each programming language you might want
-to edit with Emacs; but often the mode for one language can serve for
-other syntactically similar languages. The language modes that exist
-are those that someone decided to take the trouble to write.
-
- There are several variants of Lisp mode, which differ in the way they
-interface to Lisp execution. *Note Lisp Modes::.
-
- Each of the programming language modes defines the <TAB> key to run
-an indentation function that knows the indentation conventions of that
-language and updates the current line's indentation accordingly. For
-example, in C mode <TAB> is bound to `c-indent-line'. <LFD> is
-normally defined to do <RET> followed by <TAB>; thus it, too, indents
-in a mode-specific fashion.
-
- In most programming languages, indentation is likely to vary from
-line to line. So the major modes for those languages rebind <DEL> to
-treat a tab as if it were the equivalent number of spaces (using the
-command `backward-delete-char-untabify'). This makes it possible to
-rub out indentation one column at a time without worrying whether it is
-made up of spaces or tabs. In these modes, use `C-b C-d' to delete a
-tab character before point.
-
- Programming language modes define paragraphs to be separated only by
-blank lines, so that the paragraph commands remain useful. Auto Fill
-mode, if enabled in a programming language major mode, indents the new
-lines which it creates.
-
- Turning on a major mode calls a user-supplied function called the
-"mode hook", which is the value of a Lisp variable. For example,
-turning on C mode calls the value of the variable `c-mode-hook' if that
-value exists and is non-`nil'. Mode hook variables for other
-programming language modes include `lisp-mode-hook',
-`emacs-lisp-mode-hook', `lisp-interaction-mode-hook',
-`scheme-mode-hook', and `muddle-mode-hook'. The mode hook function
-receives no arguments.
-\1f
-File: xemacs.info, Node: Lists, Next: Defuns, Prev: Program Modes, Up: Programs
+ Another similar mode is used for editing outlines. It allows you
+to view the text at various levels of detail. You can view either
+the outline headings alone or both headings and text; you can also
+hide some of the headings at lower levels from view to make the high
+level structure more visible.
-Lists and Sexps
-===============
- By convention, Emacs keys for dealing with balanced expressions are
-usually `Control-Meta-' characters. They tend to be analogous in
-function to their `Control-' and `Meta-' equivalents. These commands
-are usually thought of as pertaining to expressions in programming
-languages, but can be useful with any language in which some sort of
-parentheses exist (including English).
-
- The commands fall into two classes. Some commands deal only with
-"lists" (parenthetical groupings). They see nothing except
-parentheses, brackets, braces (depending on what must balance in the
-language you are working with), and escape characters that might be used
-to quote those.
-
- The other commands deal with expressions or "sexps". The word `sexp'
-is derived from "s-expression", the term for a symbolic expression in
-Lisp. In Emacs, the notion of `sexp' is not limited to Lisp. It
-refers to an expression in the language your program is written in.
-Each programming language has its own major mode, which customizes the
-syntax tables so that expressions in that language count as sexps.
-
- Sexps typically include symbols, numbers, and string constants, as
-well as anything contained in parentheses, brackets, or braces.
-
- In languages that use prefix and infix operators, such as C, it is
-not possible for all expressions to be sexps. For example, C mode does
-not recognize `foo + bar' as an sexp, even though it is a C expression;
-it recognizes `foo' as one sexp and `bar' as another, with the `+' as
-punctuation between them. This is a fundamental ambiguity: both `foo +
-bar' and `foo' are legitimate choices for the sexp to move over if
-point is at the `f'. Note that `(foo + bar)' is a sexp in C mode.
-
- Some languages have obscure forms of syntax for expressions that
-nobody has bothered to make Emacs understand properly.
-
-`C-M-f'
- Move forward over an sexp (`forward-sexp').
-
-`C-M-b'
- Move backward over an sexp (`backward-sexp').
-
-`C-M-k'
- Kill sexp forward (`kill-sexp').
-
-`C-M-u'
- Move up and backward in list structure (`backward-up-list').
-
-`C-M-d'
- Move down and forward in list structure (`down-list').
-
-`C-M-n'
- Move forward over a list (`forward-list').
-
-`C-M-p'
- Move backward over a list (`backward-list').
-
-`C-M-t'
- Transpose expressions (`transpose-sexps').
-
-`C-M-@'
- Put mark after following expression (`mark-sexp').
-
- To move forward over an sexp, use `C-M-f' (`forward-sexp'). If the
-first significant character after point is an opening delimiter (`(' in
-Lisp; `(', `[', or `{' in C), `C-M-f' moves past the matching closing
-delimiter. If the character begins a symbol, string, or number,
-`C-M-f' moves over that. If the character after point is a closing
-delimiter, `C-M-f' just moves past it. (This last is not really moving
-across an sexp; it is an exception which is included in the definition
-of `C-M-f' because it is as useful a behavior as anyone can think of
-for that situation.)
-
- The command `C-M-b' (`backward-sexp') moves backward over a sexp.
-The detailed rules are like those above for `C-M-f', but with
-directions reversed. If there are any prefix characters (single quote,
-back quote, and comma, in Lisp) preceding the sexp, `C-M-b' moves back
-over them as well.
-
- `C-M-f' or `C-M-b' with an argument repeats that operation the
-specified number of times; with a negative argument, it moves in the
-opposite direction.
-
- In languages such as C where the comment-terminator can be
-recognized, the sexp commands move across comments as if they were
-whitespace. In Lisp and other languages where comments run until the
-end of a line, it is very difficult to ignore comments when parsing
-backwards; therefore, in such languages the sexp commands treat the
-text of comments as if it were code.
-
- Killing an sexp at a time can be done with `C-M-k' (`kill-sexp').
-`C-M-k' kills the characters that `C-M-f' would move over.
-
- The "list commands", `C-M-n' (`forward-list') and `C-M-p'
-(`backward-list'), move over lists like the sexp commands but skip over
-any number of other kinds of sexps (symbols, strings, etc). In some
-situations, these commands are useful because they usually ignore
-comments, since the comments usually do not contain any lists.
-
- `C-M-n' and `C-M-p' stay at the same level in parentheses, when that
-is possible. To move up one (or N) levels, use `C-M-u'
-(`backward-up-list'). `C-M-u' moves backward up past one unmatched
-opening delimiter. A positive argument serves as a repeat count; a
-negative argument reverses direction of motion and also requests
-repetition, so it moves forward and up one or more levels.
-
- To move down in list structure, use `C-M-d' (`down-list'). In Lisp
-mode, where `(' is the only opening delimiter, this is nearly the same
-as searching for a `('. An argument specifies the number of levels of
-parentheses to go down.
-
- `C-M-t' (`transpose-sexps') drags the previous sexp across the next
-one. An argument serves as a repeat count, and a negative argument
-drags backwards (thus canceling out the effect of `C-M-t' with a
-positive argument). An argument of zero, rather than doing nothing,
-transposes the sexps ending after point and the mark.
-
- To make the region be the next sexp in the buffer, use `C-M-@'
-(`mark-sexp') which sets the mark at the same place that `C-M-f' would
-move to. `C-M-@' takes arguments like `C-M-f'. In particular, a
-negative argument is useful for putting the mark at the beginning of
-the previous sexp.
-
- The list and sexp commands' understanding of syntax is completely
-controlled by the syntax table. Any character can, for example, be
-declared to be an opening delimiter and act like an open parenthesis.
-*Note Syntax::.
+* Outline Mode:: The major mode for editing outlines.
\1f
-File: xemacs.info, Node: Defuns, Next: Grinding, Prev: Lists, Up: Programs
-
-Defuns
-======
-
- In Emacs, a parenthetical grouping at the top level in the buffer is
-called a "defun". The name derives from the fact that most top-level
-lists in Lisp are instances of the special form `defun', but Emacs
-calls any top-level parenthetical grouping counts a defun regardless of
-its contents or the programming language. For example, in C, the body
-of a function definition is a defun.
-
-`C-M-a'
- Move to beginning of current or preceding defun
- (`beginning-of-defun').
-
-`C-M-e'
- Move to end of current or following defun (`end-of-defun').
-
-`C-M-h'
- Put region around whole current or following defun (`mark-defun').
-
- The commands to move to the beginning and end of the current defun
-are `C-M-a' (`beginning-of-defun') and `C-M-e' (`end-of-defun').
-
- To operate on the current defun, use `C-M-h' (`mark-defun') which
-puts point at the beginning and the mark at the end of the current or
-next defun. This is the easiest way to prepare for moving the defun to
-a different place. In C mode, `C-M-h' runs the function
-`mark-c-function', which is almost the same as `mark-defun', but which
-backs up over the argument declarations, function name, and returned
-data type so that the entire C function is inside the region.
-
- To compile and evaluate the current defun, use `M-x compile-defun'.
-This function prints the results in the minibuffer. If you include an
-argument, it inserts the value in the current buffer after the defun.
-
- Emacs assumes that any open-parenthesis found in the leftmost column
-is the start of a defun. Therefore, never put an open-parenthesis at
-the left margin in a Lisp file unless it is the start of a top level
-list. Never put an open-brace or other opening delimiter at the
-beginning of a line of C code unless it starts the body of a function.
-The most likely problem case is when you want an opening delimiter at
-the start of a line inside a string. To avoid trouble, put an escape
-character (`\' in C and Emacs Lisp, `/' in some other Lisp dialects)
-before the opening delimiter. It will not affect the contents of the
-string.
-
- The original Emacs found defuns by moving upward a level of
-parentheses until there were no more levels to go up. This required
-scanning back to the beginning of the buffer for every function. To
-speed this up, Emacs was changed to assume that any `(' (or other
-character assigned the syntactic class of opening-delimiter) at the
-left margin is the start of a defun. This heuristic is nearly always
-right; however, it mandates the convention described above.
+File: xemacs.info, Node: Nroff Mode, Next: TeX Mode, Prev: Text Mode, Up: Text Mode
+
+Nroff Mode
+----------
+
+ Nroff mode is a mode like Text mode but modified to handle nroff
+commands present in the text. Invoke `M-x nroff-mode' to enter this
+mode. Nroff mode differs from Text mode in only a few ways. All nroff
+command lines are considered paragraph separators, so that filling never
+garbles the nroff commands. Pages are separated by `.bp' commands.
+Comments start with backslash-doublequote. There are also three special
+commands that are not available in Text mode:
+
+`M-n'
+ Move to the beginning of the next line that isn't an nroff command
+ (`forward-text-line'). An argument is a repeat count.
+
+`M-p'
+ Like `M-n' but move up (`backward-text-line').
+
+`M-?'
+ Prints in the echo area the number of text lines (lines that are
+ not nroff commands) in the region (`count-text-lines').
+
+ The other feature of Nroff mode is Electric Nroff newline mode.
+This is a minor mode that you can turn on or off with `M-x
+electric-nroff-mode' (*note Minor Modes::). When the mode is on and
+you use <RET> to end a line containing an nroff command that opens a
+kind of grouping, Emacs automatically inserts the matching nroff
+command to close that grouping on the following line. For example, if
+you are at the beginning of a line and type `.(b <RET>', the matching
+command `.)b' will be inserted on a new line following point.
+
+ Entering Nroff mode calls the value of the variable `text-mode-hook'
+with no arguments, if that value exists and is not `nil'; then it does
+the same with the variable `nroff-mode-hook'.
\1f
-File: xemacs.info, Node: Grinding, Next: Matching, Prev: Defuns, Up: Programs
+File: xemacs.info, Node: TeX Mode, Next: Outline Mode, Prev: Nroff Mode, Up: Text Mode
-Indentation for Programs
-========================
+TeX Mode
+--------
- The best way to keep a program properly indented ("ground") is to
-use Emacs to re-indent it as you change the program. Emacs has commands
-to indent properly either a single line, a specified number of lines, or
-all of the lines inside a single parenthetical grouping.
+ TeX is a powerful text formatter written by Donald Knuth; like GNU
+Emacs, it is free. LaTeX is a simplified input format for TeX,
+implemented by TeX macros. It is part of TeX.
+
+ Emacs has a special TeX mode for editing TeX input files. It
+provides facilities for checking the balance of delimiters and for
+invoking TeX on all or part of the file.
+
+ TeX mode has two variants, Plain TeX mode and LaTeX mode, which are
+two distinct major modes that differ only slightly. These modes are
+designed for editing the two different input formats. The command `M-x
+tex-mode' looks at the contents of a buffer to determine whether it
+appears to be LaTeX input or not; it then selects the appropriate mode.
+If it can't tell which is right (e.g., the buffer is empty), the
+variable `tex-default-mode' controls which mode is used.
+
+ The commands `M-x plain-tex-mode' and `M-x latex-mode' explicitly
+select one of the variants of TeX mode. Use these commands when `M-x
+tex-mode' does not guess right.
* Menu:
-* Basic Indent::
-* Multi-line Indent:: Commands to reindent many lines at once.
-* Lisp Indent:: Specifying how each Lisp function should be indented.
-* C Indent:: Choosing an indentation style for C code.
+* Editing: TeX Editing. Special commands for editing in TeX mode.
+* Printing: TeX Print. Commands for printing part of a file with TeX.
-\1f
-File: xemacs.info, Node: Basic Indent, Next: Multi-line Indent, Prev: Grinding, Up: Grinding
+ TeX for Unix systems can be obtained from the University of
+Washington for a distribution fee.
-Basic Program Indentation Commands
-----------------------------------
+ To order a full distribution, send $140.00 for a 1/2 inch 9-track
+tape, $165.00 for two 4-track 1/4 inch cartridge tapes (foreign sites
+$150.00, for 1/2 inch, $175.00 for 1/4 inch, to cover the extra
+postage) payable to the University of Washington to:
-`<TAB>'
- Adjust indentation of current line.
+ The Director
+ Northwest Computer Support Group, DW-10
+ University of Washington
+ Seattle, Washington 98195
-`<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.
+Purchase orders are acceptable, but there is an extra charge of $10.00
+to pay for processing charges. (The total cost comes to $150 for
+domestic sites, $175 for foreign sites).
-\1f
-File: xemacs.info, Node: Multi-line Indent, Next: Lisp Indent, Prev: Basic Indent, Up: Grinding
+ The normal distribution is a tar tape, blocked 20, 1600 bpi, on an
+industry standard 2400 foot half-inch reel. The physical format for
+the 1/4 inch streamer cartridges uses QIC-11, 8000 bpi, 4-track
+serpentine recording for the SUN. Also, SystemV tapes can be written
+in cpio format, blocked 5120 bytes, ASCII headers.
-Indenting Several Lines
------------------------
+\1f
+File: xemacs.info, Node: TeX Editing, Next: TeX Print, Prev: TeX Mode, Up: TeX Mode
- 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.
+TeX Editing Commands
+....................
-`C-M-q'
- Re-indent all the lines within one list (`indent-sexp').
+ Here are the special commands provided in TeX mode for editing the
+text of the file.
-`C-u <TAB>'
- Shift an entire list rigidly sideways so that its first line is
- properly indented.
+`"'
+ Insert, according to context, either ```' or `"' or `'''
+ (`TeX-insert-quote').
-`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.
+`<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: 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.
+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: C Indent, Prev: Lisp Indent, Up: Grinding
+File: xemacs.info, Node: Outline Mode, Prev: TeX Mode, Up: Text Mode
-Customizing C Indentation
--------------------------
+Outline Mode
+------------
- Two variables control which commands perform C indentation and when.
+ 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.
- 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.
+ 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'.
- 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.
+ 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).
- 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.
+ 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.
- There are six variables you can set to control the style that Emacs C
-mode will use.
+* Menu:
-`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.
+* 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.
-`c-continued-statement-offset'
- Extra indentation given to a substatement, such as the then-clause
- of an `if' or body of a `while'.
+\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.
-`c-brace-offset'
- Extra indentation for lines that start with an open brace.
+\1f
+File: xemacs.info, Node: Outline Motion, Next: Outline Visibility, Prev: Outline Format, Up: Outline Mode
-`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.
+Outline Motion Commands
+.......................
-`c-argdecl-indent'
- Indentation level of declarations of C function arguments.
+ Some special commands in Outline mode move backward and forward to
+heading lines.
-`c-label-offset'
- Extra indentation for a line that is a label, case, or default.
+`C-c C-n'
+ Move point to the next visible heading line
+ (`outline-next-visible-heading').
- The variable `c-indent-level' controls the indentation for C
-statements with respect to the surrounding block. In the example:
+`C-c C-p'
+ Move point to the previous visible heading line
+ (`outline-previous-visible-heading').
- {
- foo ();
+`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').
-the difference in indentation between the lines is `c-indent-level'.
-Its standard value is 2.
+`C-c C-b'
+ Move point to the previous visible heading line at the same level
+ (`outline-backward-same-level').
- 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,
+`C-c C-u'
+ Move point up to a lower-level (more inclusive) visible heading
+ line (`outline-up-heading').
- if (losing) {
- do_this ();
+ `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.
-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.
+ 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.
- 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:
+\1f
+File: xemacs.info, Node: Outline Visibility, Prev: Outline Motion, Up: Outline Mode
- if (x == y) {
- do_it ();
- }
+Outline Visibility Commands
+...........................
- 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.
+ 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.
- `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:
+`M-x hide-body'
+ Make all body lines in the buffer invisible.
- if (x == y)
- do_it ();
+`M-x show-all'
+ Make all lines in the buffer visible.
-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-c C-d'
+ Make everything under this heading invisible, not including this
+ heading itself (`hide-subtree').
- `c-brace-offset' is the extra indentation given to a line that
-starts with an open-brace. Its standard value is zero; compare:
+`C-c C-s'
+ Make everything under this heading visible, including body,
+ subheadings, and their bodies (`show-subtree').
- if (x == y)
- {
+`M-x hide-leaves'
+ Make the body of this heading line, and of all its subheadings,
+ invisible.
-with:
+`M-x show-branches'
+ Make all subheadings of this heading line, at all levels, visible.
- if (x == y)
- do_it ();
+`C-c C-i'
+ Make immediate subheadings (one level down) of this heading line
+ visible (`show-children').
-If you set `c-brace-offset' to 4, the first example becomes:
+`M-x hide-entry'
+ Make this heading line's body invisible.
- if (x == y)
- {
+`M-x show-entry'
+ Make this heading line's body visible.
- `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:
+ 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.
- char *
- index (string, char)
- char *string;
- int char;
+ 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.
- `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:
+ 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'.
- switch (c)
- {
- case 'x':
+ 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.
-If `c-label-offset' were zero, the same code would be indented as:
+ 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.
- switch (c)
- {
- case 'x':
+ 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.
-This example assumes that the other variables above also have their
-default values.
+\1f
+File: xemacs.info, Node: Words, Next: Sentences, Prev: Text Mode, Up: Text
- 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.
+Words
+=====
-\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.
+ 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: 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.
+File: xemacs.info, Node: Sentences, Next: Paragraphs, Prev: Words, Up: Text
- 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.
+Sentences
+=========
-\1f
-File: xemacs.info, Node: Balanced Editing, Next: Lisp Completion, Prev: Comments, Up: Programs
+ The Emacs commands for manipulating sentences and paragraphs are
+mostly on `Meta-' keys, and therefore are like the word-handling
+commands.
-Editing Without Unbalanced Parentheses
-======================================
+`M-a'
+ Move back to the beginning of the sentence (`backward-sentence').
-`M-('
- Put parentheses around next sexp(s) (`insert-parentheses').
+`M-e'
+ Move forward to the end of the sentence (`forward-sentence').
-`M-)'
- Move past next close parenthesis and re-indent
- (`move-over-close-and-reindent').
+`M-k'
+ Kill forward to the end of the sentence (`kill-sentence').
- 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.
+`C-x <DEL>'
+ Kill back to the beginning of the sentence
+ (`backward-kill-sentence').
-\1f
-File: xemacs.info, Node: Lisp Completion, Next: Documentation, Prev: Balanced Editing, Up: Programs
+ 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.
-Completion for Lisp Symbols
-===========================
+ `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.
- Completion usually happens in the minibuffer. An exception is
-completion for Lisp symbol names, which is available in all buffers.
+ 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 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.
+ 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:
- If there is an open-parenthesis immediately before the beginning of
-the partial symbol, only symbols with function definitions are
-considered as completions.
+ "[.?!][]\"')]*\\($\\|\t\\| \\)[ \t\n]*"
- 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.
+This example is explained in the section on regexps. *Note Regexps::.
\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.
+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.
projects / chise / xemacs-chise.git / blobdiff