[Emacs-diffs] Changes to programs.texi

[Glenn Morris]

CVSROOT:        /sources/emacs
Module name:    emacs
Changes by:     Glenn Morris <gm>       07/09/06 04:48:09

Index: programs.texi
===================================================================
RCS file: programs.texi
diff -N programs.texi
--- /dev/null   1 Jan 1970 00:00:00 -0000
+++ programs.texi       6 Sep 2007 04:48:09 -0000       1.1
@@ -0,0 +1,1773 @@
address@hidden This is part of the Emacs manual.
address@hidden Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 1999, 
2000,
address@hidden   2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software 
Foundation, Inc.
address@hidden See file emacs.texi for copying conditions.
address@hidden Programs, Building, Text, Top
address@hidden Editing Programs
address@hidden Lisp editing
address@hidden C editing
address@hidden program editing
+
+  Emacs provides many features to facilitate editing programs.  Some
+of these features can
+
address@hidden @bullet
address@hidden
+Find or move over top-level definitions (@pxref{Defuns}).
address@hidden
+Apply the usual indentation conventions of the language
+(@pxref{Program Indent}).
address@hidden
+Balance parentheses (@pxref{Parentheses}).
address@hidden
+Insert, kill or align comments (@pxref{Comments}).
address@hidden
+Highlight program syntax (@pxref{Font Lock}).
address@hidden itemize
+
+  This chapter describes these features and many more.
+
address@hidden
+* Program Modes::       Major modes for editing programs.
+* Defuns::              Commands to operate on major top-level parts
+                          of a program.
+* Program Indent::      Adjusting indentation to show the nesting.
+* Parentheses::         Commands that operate on parentheses.
+* Comments::           Inserting, killing, and aligning comments.
+* Documentation::       Getting documentation of functions you plan to call.
+* Hideshow::            Displaying blocks selectively.
+* Symbol Completion::   Completion on symbol names of your program or language.
+* Glasses::             Making identifiersLikeThis more readable.
+* Misc for Programs::   Other Emacs features useful for editing programs.
+* C Modes::             Special commands of C, C++, Objective-C,
+                          Java, and Pike modes.
+* Asm Mode::            Asm mode and its special features.
address@hidden
+* Fortran::             Fortran mode and its special features.
address@hidden ifnottex
address@hidden menu
+
address@hidden Program Modes
address@hidden Major Modes for Programming Languages
address@hidden modes for programming languages
+
+  Emacs has specialized major modes for various programming languages.
address@hidden Modes}.  A programming language major mode typically
+specifies the syntax of expressions, the customary rules for
+indentation, how to do syntax highlighting for the language, and how
+to find the beginning of a function definition.  It often customizes
+or provides facilities for compiling and debugging programs as well.
+
+  Ideally, Emacs should provide a major mode for each programming
+language that you might want to edit; if it doesn't have a mode for
+your favorite language, you can contribute one.  But often the mode
+for one language can serve for other syntactically similar languages.
+The major mode for language @var{l} is called @address@hidden,
+and you can select it by typing @kbd{M-x @var{l}-mode @key{RET}}.
address@hidden Modes}.
+
address@hidden Perl mode
address@hidden Icon mode
address@hidden Makefile mode
address@hidden Tcl mode
address@hidden CPerl mode
address@hidden DSSSL mode
address@hidden Octave mode
address@hidden Metafont mode
address@hidden Modula2 mode
address@hidden Prolog mode
address@hidden Python mode
address@hidden Simula mode
address@hidden VHDL mode
address@hidden M4 mode
address@hidden Shell-script mode
address@hidden Delphi mode
address@hidden PostScript mode
address@hidden Conf mode
address@hidden DNS mode
+  The existing programming language major modes include Lisp, Scheme (a
+variant of Lisp) and the Scheme-based DSSSL expression language, Ada,
+ASM, AWK, C, C++, Delphi (Object Pascal), Fortran (free format and fixed
+format), Icon, IDL (CORBA), IDLWAVE, Java, Metafont (@TeX{}'s
+companion for font creation), Modula2, Objective-C, Octave, Pascal,
+Perl, Pike, PostScript, Prolog, Python, Simula, Tcl, and VHDL.  An
+alternative mode for Perl is called CPerl mode.  Modes are available for
+the scripting languages of the common GNU and Unix shells, VMS DCL, and
+MS-DOS/MS-Windows @samp{BAT} files.  There are also major modes for
+editing makefiles, DNS master files, and various sorts of configuration
+files.
+
address@hidden DEL @r{(programming modes)}
address@hidden c-electric-backspace
+  In most programming languages, indentation should vary from line to
+line to illustrate the structure of the program.  So the major modes
+for programming languages arrange for @key{TAB} to update the
+indentation of the current line.  They also rebind @key{DEL} to treat
+a tab as if it were the equivalent number of spaces; this lets you
+delete one column of indentation without worrying whether the
+whitespace consists of spaces or tabs.  Use @kbd{C-b C-d} to delete a
+tab character before point, in these modes.
+
+  Separate manuals are available for the modes for Ada (@pxref{Top, , Ada
+Mode, ada-mode, Ada Mode}), C/C++/Objective C/Java/Corba IDL/Pike/AWK
+(@pxref{Top, , CC Mode, ccmode, CC Mode}) and the IDLWAVE modes
+(@pxref{Top, , IDLWAVE, idlwave, IDLWAVE User Manual}).  For Fortran
+mode, see
address@hidden
address@hidden,,, emacs-xtra, Specialized Emacs Features}.
address@hidden iftex
address@hidden
address@hidden
address@hidden ifnottex
+
+
address@hidden mode hook
address@hidden c-mode-hook
address@hidden lisp-mode-hook
address@hidden emacs-lisp-mode-hook
address@hidden lisp-interaction-mode-hook
address@hidden scheme-mode-hook
+  Turning on a major mode runs a normal hook called the @dfn{mode
+hook}, which is the value of a Lisp variable.  Each major mode has a
+mode hook, and the hook's name is always made from the mode command's
+name by adding @samp{-hook}.  For example, turning on C mode runs the
+hook @code{c-mode-hook}, while turning on Lisp mode runs the hook
address@hidden  The purpose of the mode hook is to give you a
+place to set up customizations for that major mode.  @xref{Hooks}.
+
address@hidden Defuns
address@hidden Top-Level Definitions, or Defuns
+
+  In Emacs, a major definition at the top level in the buffer,
+something like a function, is called a @dfn{defun}.  The name comes
+from Lisp, but in Emacs we use it for all languages.
+
address@hidden
+* Left Margin Paren::   An open-paren or similar opening delimiter
+                          starts a defun if it is at the left margin.
+* Moving by Defuns::    Commands to move over or mark a major definition.
+* Imenu::               Making buffer indexes as menus.
+* Which Function::      Which Function mode shows which function you are in.
address@hidden menu
+
address@hidden Left Margin Paren
address@hidden Left Margin Convention
+
address@hidden open-parenthesis in leftmost column
address@hidden ( in leftmost column
+  Emacs assumes by default that any opening delimiter found at the
+left margin is the start of a top-level definition, or defun.
+Therefore, @strong{don't put an opening delimiter at the left margin
+unless it should have that significance}.  For instance, never put an
+open-parenthesis at the left margin in a Lisp file unless it is the
+start of a top-level list.  
+
+  If you don't follow this convention, not only will you have trouble
+when you explicitly use the commands for motion by defuns; other
+features that use them will also give you trouble.  This includes
+the indentation commands (@pxref{Program Indent}) and Font Lock
+mode (@pxref{Font Lock}).
+
+  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 (@samp{\}, in C and Emacs Lisp, @samp{/} in some
+other Lisp dialects) before the opening delimiter.  This will not
+affect the contents of the string, but will prevent that opening
+delimiter from starting a defun.  Here's an example:
+
address@hidden
+  (insert "Foo:
+\(bar)
+")
address@hidden example
+
+  To help you catch violations of this convention, Font Lock mode
+highlights confusing opening delimiters (those that ought to be
+quoted) in bold red.
+
+If you need to override this convention, you can so by setting this
+user option:
+
address@hidden open-paren-in-column-0-is-defun-start
+If this user option is set to @code{t} (the default), opening
+parentheses or braces at column zero always start defuns.  When it's
address@hidden, defuns are found by searching for parens or braces at the
+outermost level.
address@hidden defvar
+
+  Usually, you shouldn't need to set
address@hidden to @code{nil}.  However,
+if your buffer contains parentheses or braces in column zero which
+don't start defuns and this confuses Emacs, it sometimes helps to set
+the option to @code{nil}.  Be aware, though, that this will make
+scrolling and display in large buffers quite sluggish, and that
+parentheses and braces must be correctly matched throughout the buffer
+for it to work properly.
+
+  In the earliest days, the original Emacs found defuns by moving
+upward a level of parentheses or braces until there were no more
+levels to go up.  This always required scanning all the way back to
+the beginning of the buffer, even for a small function.  To speed up
+the operation, we changed Emacs to assume that any opening delimiter
+at the left margin is the start of a defun.  This heuristic is nearly
+always right, and avoids the need to scan back to the beginning of the
+buffer.  However, now that modern computers are so powerful, this
+scanning is rarely slow enough to annoy, so we've provided a way to
+disable the heuristic.
+
address@hidden Moving by Defuns
address@hidden Moving by Defuns
address@hidden defuns
+
+  These commands move point or set up the region based on top-level
+major definitions, also called @dfn{defuns}.
+
address@hidden @kbd
address@hidden C-M-a
+Move to beginning of current or preceding defun
+(@code{beginning-of-defun}).
address@hidden C-M-e
+Move to end of current or following defun (@code{end-of-defun}).
address@hidden C-M-h
+Put region around whole current or following defun (@code{mark-defun}).
address@hidden table
+
address@hidden move to beginning or end of function
address@hidden function, move to beginning or end
address@hidden C-M-a
address@hidden C-M-e
address@hidden C-M-h
address@hidden beginning-of-defun
address@hidden end-of-defun
address@hidden mark-defun
+  The commands to move to the beginning and end of the current defun
+are @kbd{C-M-a} (@code{beginning-of-defun}) and @kbd{C-M-e}
+(@code{end-of-defun}).  If you repeat one of these commands, or use a
+positive numeric argument, each repetition moves to the next defun in
+the direction of motion.
+
+  @kbd{C-M-a} with a negative argument @address@hidden moves forward
address@hidden times to the next beginning of a defun.  This is not exactly
+the same place that @kbd{C-M-e} with argument @var{n} would move to;
+the end of this defun is not usually exactly the same place as the
+beginning of the following defun.  (Whitespace, comments, and perhaps
+declarations can separate them.)  Likewise, @kbd{C-M-e} with a
+negative argument moves back to an end of a defun, which is not quite
+the same as @kbd{C-M-a} with a positive argument.
+
address@hidden C-M-h @r{(C mode)}
address@hidden c-mark-function
+  To operate on the current defun, use @kbd{C-M-h} (@code{mark-defun})
+which puts point at the beginning and mark at the end of the current
+defun.  This is the easiest way to get ready to kill the defun in
+order to move it to a different place in the file.  If you use the
+command while point is between defuns, it uses the following defun.
+Successive uses of @kbd{C-M-h}, or using it in Transient Mark mode
+when the mark is active, extends the end of the region to include one
+more defun each time.
+
+  In C mode, @kbd{C-M-h} runs the function @code{c-mark-function},
+which is almost the same as @code{mark-defun}; the difference is that
+it backs up over the argument declarations, function name and returned
+data type so that the entire C function is inside the region.  This is
+an example of how major modes adjust the standard key bindings so that
+they do their standard jobs in a way better fitting a particular
+language.  Other major modes may replace any or all of these key
+bindings for that purpose.
+
address@hidden Imenu
address@hidden Imenu
address@hidden index of buffer definitions
address@hidden buffer definitions index
address@hidden tags
+
+  The Imenu facility offers a way to find the major definitions in
+a file by name.  It is also useful in text formatter major modes,
+where it treats each chapter, section, etc., as a definition.
+(@xref{Tags}, for a more powerful feature that handles multiple files
+together.)
+
address@hidden imenu
+  If you type @kbd{M-x imenu}, it reads the name of a definition using
+the minibuffer, then moves point to that definition.  You can use
+completion to specify the name; the command always displays the whole
+list of valid names.
+
address@hidden imenu-add-menubar-index
+  Alternatively, you can bind the command @code{imenu} to a mouse
+click.  Then it displays mouse menus for you to select a definition
+name.  You can also add the buffer's index to the menu bar by calling
address@hidden  If you want to have this menu bar
+item available for all buffers in a certain major mode, you can do
+this by adding @code{imenu-add-menubar-index} to its mode hook.  But
+if you have done that, you will have to wait a little while each time
+you visit a file in that mode, while Emacs finds all the definitions
+in that buffer.
+
address@hidden imenu-auto-rescan
+  When you change the contents of a buffer, if you add or delete
+definitions, you can update the buffer's index based on the
+new contents by invoking the @samp{*Rescan*} item in the menu.
+Rescanning happens automatically if you set @code{imenu-auto-rescan} to
+a address@hidden value.  There is no need to rescan because of small
+changes in the text.
+
address@hidden imenu-sort-function
+  You can customize the way the menus are sorted by setting the
+variable @code{imenu-sort-function}.  By default, names are ordered as
+they occur in the buffer; if you want alphabetic sorting, use the
+symbol @code{imenu--sort-by-name} as the value.  You can also
+define your own comparison function by writing Lisp code.
+
+  Imenu provides the information to guide Which Function mode
address@hidden
+(@pxref{Which Function}).
address@hidden ifnottex
address@hidden
+(see below).
address@hidden iftex
+The Speedbar can also use it (@pxref{Speedbar}).
+
address@hidden Which Function
address@hidden Which Function Mode
address@hidden current function name in mode line
+
+  Which Function mode is a minor mode that displays the current
+function name in the mode line, updating it as you move around in a
+buffer.
+
address@hidden which-function-mode
address@hidden which-func-modes
+  To either enable or disable Which Function mode, use the command
address@hidden which-function-mode}.  This command is global; it applies to
+all buffers, both existing ones and those yet to be created.  However,
+it takes effect only in certain major modes, those listed in the value
+of @code{which-func-modes}.  If the value is @code{t}, then Which
+Function mode applies to all major modes that know how to support
+it---in other words, all the major modes that support Imenu.
+
address@hidden Program Indent
address@hidden Indentation for Programs
address@hidden indentation for programs
+
+  The best way to keep a program properly indented is to use Emacs to
+reindent it as you change it.  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.
+
address@hidden
+* Basic Indent::       Indenting a single line.
+* Multi-line Indent::   Commands to reindent many lines at once.
+* Lisp Indent::                Specifying how each Lisp function should be 
indented.
+* C Indent::           Extra features for indenting C and related modes.
+* Custom C Indent::    Controlling indentation style for C and related modes.
address@hidden menu
+
address@hidden pretty-printer
+  Emacs also provides a Lisp pretty-printer in the library @code{pp}.
+This program reformats a Lisp object with indentation chosen to look nice.
+
address@hidden Basic Indent
address@hidden Basic Program Indentation Commands
+
+  The basic indentation commands indent a single line according to the
+usual conventions of the language you are editing.
+
address@hidden 1000
address@hidden @kbd
address@hidden @key{TAB}
+Adjust indentation of current line.
address@hidden C-j
+Insert a newline, then adjust indentation of following line
+(@code{newline-and-indent}).
address@hidden table
+
address@hidden TAB @r{(programming modes)}
address@hidden c-indent-command
address@hidden indent-line-function
address@hidden indent-for-tab-command
+  The basic indentation command is @key{TAB}, which gives the current line
+the correct indentation as determined from the previous lines.  The
+function that @key{TAB} runs depends on the major mode; it is
address@hidden
+in Lisp mode, @code{c-indent-command} in C mode, etc.  These functions
+understand the syntax and conventions of different languages, but they all do
+conceptually the same job: @key{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 was inside the
+whitespace at the beginning of the line, @key{TAB} puts it at the end of
+that whitespace; otherwise, @key{TAB} keeps point fixed with respect to
+the characters around it.
+
+  Use @kbd{C-q @key{TAB}} to insert a tab character at point.
+
address@hidden C-j
address@hidden newline-and-indent
+  When entering lines of new code, use @kbd{C-j}
+(@code{newline-and-indent}), which inserts a newline and then adjusts
+indentation after it.  (It also deletes any trailing whitespace which
+remains before the new newline.)  Thus, @kbd{C-j} at the end of a line
+creates a blank line with appropriate indentation.  In programming
+language modes, it is equivalent to @key{RET} @key{TAB}.
+
+  @key{TAB} indents a line that starts within a parenthetical grouping
+under the preceding line within the grouping, or the text after the
+parenthesis.  Therefore, if you manually give one of these lines a
+nonstandard indentation, the lines below will tend to follow it.  This
+behavior is convenient in cases where you have overridden the standard
+result of @key{TAB} because you find it unaesthetic for a particular
+line.
+
+  In some modes, an open-parenthesis, open-brace or other opening
+delimiter at the left margin is assumed by Emacs (including the
+indentation routines) to be the start of a function.  This speeds up
+indentation commands.  If you will be editing text which contains
+opening delimiters in column zero that aren't the beginning of a
+functions, even inside strings or comments, you must set
address@hidden  @xref{Left Margin
+Paren}, for more information on this.
+
+  Normally, lines are indented with tabs and spaces.  If you want Emacs
+to use spaces only, set @code{indent-tabs-mode} (@pxref{Just Spaces}).
+
address@hidden Multi-line Indent
address@hidden Indenting Several Lines
+
+  When you wish to reindent several lines of code which have been
+altered or moved to a different level in the parenthesis structure,
+you have several commands available.
+
address@hidden @kbd
address@hidden C-M-q
+Reindent all the lines within one parenthetical grouping 
(@code{indent-pp-sexp}).
address@hidden C-M-\
+Reindent all lines in the region (@code{indent-region}).
address@hidden C-u @key{TAB}
+Shift an entire parenthetical grouping rigidly sideways so that its
+first line is properly indented.
address@hidden M-x indent-code-rigidly
+Shift all the lines in the region rigidly sideways, but do not alter
+lines that start inside comments and strings.
address@hidden table
+
address@hidden C-M-q
address@hidden indent-pp-sexp
+  You can reindent the contents of a single parenthetical grouping by
+positioning point before the beginning of it and typing @kbd{C-M-q}
+(@code{indent-pp-sexp} in Lisp mode, @code{c-indent-exp} in C mode; also
+bound to other suitable commands in other modes).  The indentation of
+the line where the grouping starts is not changed; therefore this
+changes only the relative indentation within the grouping, not its
+overall indentation.  To correct that as well, type @key{TAB} first.
+
+  Another way to specify the range to be reindented is with the
+region.  The command @kbd{C-M-\} (@code{indent-region}) applies
address@hidden to every line whose first character is between point and
+mark.
+
address@hidden C-u TAB
+  If you like the relative indentation within a grouping, but not the
+indentation of its first line, you can type @kbd{C-u @key{TAB}} to
+reindent the whole grouping as a rigid unit.  (This works in Lisp
+modes and C and related modes.)  @key{TAB} with a numeric argument
+reindents the current line as usual, then reindents by the same amount
+all the lines in the parenthetical grouping starting on the current
+line.  It is clever, though, and does not alter lines that start
+inside strings.  Neither does it alter C preprocessor lines when in C
+mode, but it does reindent any continuation lines that may be attached
+to them.
+
address@hidden indent-code-rigidly
+  You can also perform this operation on the region, using the command
address@hidden indent-code-rigidly}.  It rigidly shifts all the lines in the
+region sideways, like @code{indent-rigidly} does (@pxref{Indentation
+Commands}).  It doesn't alter the indentation of lines that start
+inside a string, unless the region also starts inside that string.
+The prefix arg specifies the number of columns to indent.
+
address@hidden Lisp Indent
address@hidden Customizing Lisp Indentation
address@hidden 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.
+
address@hidden lisp-indent-offset
+  If the variable @code{lisp-indent-offset} is address@hidden, it overrides
+the usual indentation pattern for the second line of an expression, so that
+such lines are always indented @code{lisp-indent-offset} more columns than
+the containing list.
+
address@hidden lisp-body-indent
+  Certain functions override the standard pattern.  Functions whose
+names start with @code{def} treat the second lines as the start of
+a @dfn{body}, by indenting the second line @code{lisp-body-indent}
+additional columns beyond the open-parenthesis that starts the
+expression.
+
address@hidden @code{lisp-indent-function} property
+  You can override the standard pattern in various ways for individual
+functions, according to the @code{lisp-indent-function} property of
+the function name.  Normally you would use this for macro definitions
+and specify it using the @code{declare} construct (@pxref{Defining
+Macros,,, elisp, the Emacs Lisp Reference Manual}).
+
address@hidden C Indent
address@hidden Commands for C Indentation
+
+  Here are special features for indentation in C mode and related modes:
+
address@hidden @code
address@hidden C-c C-q
address@hidden C-c C-q @r{(C mode)}
address@hidden c-indent-defun
+Reindent the current top-level function definition or aggregate type
+declaration (@code{c-indent-defun}).
+
address@hidden C-M-q
address@hidden C-M-q @r{(C mode)}
address@hidden c-indent-exp
+Reindent each line in the balanced expression that follows point
+(@code{c-indent-exp}).  A prefix argument inhibits warning messages
+about invalid syntax.
+
address@hidden @key{TAB}
address@hidden c-indent-command
+Reindent the current line, and/or in some cases insert a tab character
+(@code{c-indent-command}).
+
address@hidden c-tab-always-indent
+If @code{c-tab-always-indent} is @code{t}, this command always reindents
+the current line and does nothing else.  This is the default.
+
+If that variable is @code{nil}, this command reindents the current line
+only if point is at the left margin or in the line's indentation;
+otherwise, it inserts a tab (or the equivalent number of spaces,
+if @code{indent-tabs-mode} is @code{nil}).
+
+Any other value (not @code{nil} or @code{t}) means always reindent the
+line, and also insert a tab if within a comment or a string.
address@hidden table
+
+  To reindent the whole current buffer, type @kbd{C-x h C-M-\}.  This
+first selects the whole buffer as the region, then reindents that
+region.
+
+  To reindent the current block, use @kbd{C-M-u C-M-q}.  This moves
+to the front of the block and then reindents it all.
+
address@hidden Custom C Indent
address@hidden Customizing C Indentation
address@hidden style (for indentation)
+
+  C mode and related modes use a flexible mechanism for customizing
+indentation.  C mode indents a source line in two steps: first it
+classifies the line syntactically according to its contents and
+context; second, it determines the indentation offset associated by
+your selected @dfn{style} with the syntactic construct and adds this
+onto the indentation of the @dfn{anchor statement}.
+
address@hidden @kbd
address@hidden C-c . @key{RET} @var{style} @key{RET}
+Select a predefined style @var{style} (@code{c-set-style}).
address@hidden table
+
+  A @dfn{style} is a named collection of customizations that can be
+used in C mode and the related modes.  @ref{Styles,,, ccmode, The CC
+Mode Manual}, for a complete description.  Emacs comes with several
+predefined styles, including @code{gnu}, @code{k&r}, @code{bsd},
address@hidden, @code{linux}, @code{python}, @code{java},
address@hidden, @code{ellemtel}, and @code{awk}.  Some of these
+styles are primarily intended for one language, but any of them can be
+used with any of the languages supported by these modes.  To find out
+what a style looks like, select it and reindent some code, e.g., by
+typing @key{C-M-q} at the start of a function definition.
+
address@hidden C-c . @r{(C mode)}
address@hidden c-set-style
+  To choose a style for the current buffer, use the command @address@hidden
+.}}.  Specify a style name as an argument (case is not significant).
+This command affects the current buffer only, and it affects only
+future invocations of the indentation commands; it does not reindent
+the code already in the buffer.  To reindent the whole buffer in the
+new style, you can type @kbd{C-x h C-M-\}.
+
address@hidden c-default-style
+  You can also set the variable @code{c-default-style} to specify the
+default style for various major modes.  Its value should be either the
+style's name (a string) or an alist, in which each element specifies
+one major mode and which indentation style to use for it.  For
+example,
+
address@hidden
+(setq c-default-style
+      '((java-mode . "java") (awk-mode . "awk") (other . "gnu")))
address@hidden example
+
address@hidden
+specifies explicit choices for Java and AWK modes, and the default
address@hidden style for the other C-like modes.  (These settings are
+actually the defaults.)  This variable takes effect when you select
+one of the C-like major modes; thus, if you specify a new default
+style for Java mode, you can make it take effect in an existing Java
+mode buffer by typing @kbd{M-x java-mode} there.
+
+  The @code{gnu} style specifies the formatting recommended by the GNU
+Project for C; it is the default, so as to encourage use of our
+recommended style.
+
+  @xref{Indentation Engine Basics,,, ccmode, the CC Mode Manual}, and
address@hidden Indentation,,, ccmode, the CC Mode Manual}, for more
+information on customizing indentation for C and related modes,
+including how to override parts of an existing style and how to define
+your own styles.
+
address@hidden Parentheses
address@hidden Commands for Editing with Parentheses
+
address@hidden check-parens
address@hidden unbalanced parentheses and quotes
+  This section describes the commands and features that take advantage
+of the parenthesis structure in a program, or help you keep it
+balanced.
+
+  When talking about these facilities, the term ``parenthesis'' also
+includes braces, brackets, or whatever delimiters are defined to match
+in pairs.  The major mode controls which delimiters are significant,
+through the syntax table (@pxref{Syntax}).  In Lisp, only parentheses
+count; in C, these commands apply to braces and brackets too.
+
+  You can use @kbd{M-x check-parens} to find any unbalanced
+parentheses and unbalanced string quotes in the buffer.
+
address@hidden
+* Expressions::         Expressions with balanced parentheses.
+* Moving by Parens::    Commands for moving up, down and across
+                          in the structure of parentheses.
+* Matching::           Insertion of a close-delimiter flashes matching open.
address@hidden menu
+
address@hidden Expressions
address@hidden Expressions with Balanced Parentheses
+
address@hidden sexp
address@hidden expression
address@hidden balanced expression
+  These commands deal with balanced expressions, also called
address@hidden@footnote{The word ``sexp'' is used to refer to an
+expression in Lisp.}.
+
address@hidden @kbd
address@hidden C-M-f
+Move forward over a balanced expression (@code{forward-sexp}).
address@hidden C-M-b
+Move backward over a balanced expression (@code{backward-sexp}).
address@hidden C-M-k
+Kill balanced expression forward (@code{kill-sexp}).
address@hidden C-M-t
+Transpose expressions (@code{transpose-sexps}).
address@hidden C-M-@@
address@hidden address@hidden
+Put mark after following expression (@code{mark-sexp}).
address@hidden table
+
+  Each programming language major mode customizes the definition of
+balanced expressions to suit that language.  Balanced expressions
+typically include symbols, numbers, and string constants, as well as
+any pair of matching delimiters and their contents.  Some languages
+have obscure forms of expression syntax that nobody has bothered to
+implement in Emacs.
+
address@hidden Control-Meta
+  By convention, the keys for these commands are all Control-Meta
+characters.  They usually act on expressions just as the corresponding
+Meta characters act on words.  For instance, the command @kbd{C-M-b}
+moves backward over a balanced expression, just as @kbd{M-b} moves
+back over a word.
+
address@hidden C-M-f
address@hidden C-M-b
address@hidden forward-sexp
address@hidden backward-sexp
+  To move forward over a balanced expression, use @kbd{C-M-f}
+(@code{forward-sexp}).  If the first significant character after point
+is an opening delimiter (@samp{(} in Lisp; @samp{(}, @samp{[} or
address@hidden@{} in C), @kbd{C-M-f} moves past the matching closing
+delimiter.  If the character begins a symbol, string, or number,
address@hidden moves over that.
+
+  The command @kbd{C-M-b} (@code{backward-sexp}) moves backward over a
+balanced expression.  The detailed rules are like those above for
address@hidden, but with directions reversed.  If there are prefix
+characters (single-quote, backquote and comma, in Lisp) preceding the
+expression, @kbd{C-M-b} moves back over them as well.  The balanced
+expression commands move across comments as if they were whitespace,
+in most modes.
+
+  @kbd{C-M-f} or @kbd{C-M-b} with an argument repeats that operation the
+specified number of times; with a negative argument, it moves in the
+opposite direction.
+
address@hidden killing expressions
address@hidden C-M-k
address@hidden kill-sexp
+  Killing a whole balanced expression can be done with @kbd{C-M-k}
+(@code{kill-sexp}).  @kbd{C-M-k} kills the characters that @kbd{C-M-f}
+would move over.
+
address@hidden transposition of expressions
address@hidden C-M-t
address@hidden transpose-sexps
+  A somewhat random-sounding command which is nevertheless handy is
address@hidden (@code{transpose-sexps}), which drags the previous
+balanced expression across the next one.  An argument serves as a
+repeat count, moving the previous expression over that many following
+ones.  A negative argument drags the previous balanced expression
+backwards across those before it (thus canceling out the effect of
address@hidden with a positive argument).  An argument of zero, rather
+than doing nothing, transposes the balanced expressions ending at or
+after point and the mark.
+
address@hidden C-M-@@
address@hidden address@hidden
address@hidden mark-sexp
+  To set the region around the next balanced expression in the buffer,
+use @kbd{C-M-@@} (@code{mark-sexp}), which sets mark at the same place
+that @kbd{C-M-f} would move to.  @kbd{C-M-@@} takes arguments like
address@hidden  In particular, a negative argument is useful for putting
+the mark at the beginning of the previous balanced expression.  The
+alias @address@hidden is equivalent to @kbd{C-M-@@}.  When you
+repeat this command, or use it in Transient Mark mode when the mark is
+active, it extends the end of the region by one sexp each time.
+
+  In languages that use infix operators, such as C, it is not possible
+to recognize all balanced expressions as such because there can be
+multiple possibilities at a given position.  For example, C mode does
+not treat @samp{foo + bar} as a single expression, even though it
address@hidden one C expression; instead, it recognizes @samp{foo} as one
+expression and @samp{bar} as another, with the @samp{+} as punctuation
+between them.  Both @samp{foo + bar} and @samp{foo} are legitimate
+choices for ``the expression following point'' when point is at the
address@hidden, so the expression commands must perforce choose one or the
+other to operate on.  Note that @samp{(foo + bar)} is recognized as a
+single expression in C mode, because of the parentheses.
+
address@hidden Moving by Parens
address@hidden Moving in the Parenthesis Structure
+
address@hidden parenthetical groupings
address@hidden parentheses, moving across
address@hidden matching parenthesis and braces, moving to
address@hidden braces, moving across
address@hidden list commands
+  The Emacs commands for handling parenthetical groupings see nothing
+except parentheses (or whatever characters must balance in the
+language you are working with), and the escape characters that might
+be used to quote those.  They are mainly intended for editing
+programs, but can be useful for editing any text that has parentheses.
+They are sometimes called ``list'' commands because in Lisp these
+groupings are lists.
+
address@hidden @kbd
address@hidden C-M-n
+Move forward over a parenthetical group (@code{forward-list}).
address@hidden C-M-p
+Move backward over a parenthetical group (@code{backward-list}).
address@hidden C-M-u
+Move up in parenthesis structure (@code{backward-up-list}).
address@hidden C-M-d
+Move down in parenthesis structure (@code{down-list}).
address@hidden table
+
address@hidden C-M-n
address@hidden C-M-p
address@hidden forward-list
address@hidden backward-list
+  The ``list'' commands @kbd{C-M-n} (@code{forward-list}) and
address@hidden (@code{backward-list}) move over one (or @var{n})
+parenthetical groupings, skipping blithely over any amount of text
+that doesn't include meaningful parentheses (symbols, strings, etc.).
+
address@hidden C-M-u
address@hidden backward-up-list
+  @kbd{C-M-n} and @kbd{C-M-p} try to stay at the same level in the
+parenthesis structure.  To move @emph{up} one (or @var{n}) levels, use
address@hidden (@code{backward-up-list}).  @kbd{C-M-u} moves backward up
+past one unmatched opening delimiter.  A positive argument serves as a
+repeat count; a negative argument reverses the direction of motion, so
+that the command moves forward and up one or more levels.
+
address@hidden C-M-d
address@hidden down-list
+  To move @emph{down} in the parenthesis structure, use @kbd{C-M-d}
+(@code{down-list}).  In Lisp mode, where @samp{(} is the only opening
+delimiter, this is nearly the same as searching for a @samp{(}.  An
+argument specifies the number of levels to go down.
+
address@hidden Matching
address@hidden Automatic Display Of Matching Parentheses
address@hidden matching parentheses
address@hidden parentheses, displaying matches
+
+  The Emacs parenthesis-matching feature is designed to show
+automatically how parentheses (and other matching delimiters) match in
+the text.  Whenever you type a self-inserting character that is a
+closing delimiter, the cursor moves momentarily to the location of the
+matching opening delimiter, provided that is on the screen.  If it is
+not on the screen, Emacs displays some of the text near it in the echo
+area.  Either way, you can tell which grouping you are closing off.
+
+  If the opening delimiter and closing delimiter are mismatched---such
+as in @samp{[x)}---a warning message is displayed in the echo area.
+
address@hidden blink-matching-paren
address@hidden blink-matching-paren-distance
address@hidden blink-matching-delay
+  Three variables control parenthesis match display:
+
+  @code{blink-matching-paren} turns the feature on or off: @code{nil}
+disables it, but the default is @code{t} to enable match display.
+
+  @code{blink-matching-delay} says how many seconds to leave the
+cursor on the matching opening delimiter, before bringing it back to
+the real location of point; the default is 1, but on some systems it
+is useful to specify a fraction of a second.
+
+  @code{blink-matching-paren-distance} specifies how many characters
+back to search to find the matching opening delimiter.  If the match
+is not found in that distance, scanning stops, and nothing is displayed.
+This is to prevent the scan for the matching delimiter from wasting
+lots of time when there is no match.  The default is 25600.
+
address@hidden Show Paren mode
address@hidden highlighting matching parentheses
address@hidden show-paren-mode
+  Show Paren mode provides a more powerful kind of automatic matching.
+Whenever point is after a closing delimiter, that delimiter and its
+matching opening delimiter are both highlighted; otherwise, if point
+is before an opening delimiter, the matching closing delimiter is
+highlighted.  (There is no need to highlight the opening delimiter in
+that case, because the cursor appears on top of that character.)  Use
+the command @kbd{M-x show-paren-mode} to enable or disable this mode.
+
+  Show Paren mode uses the faces @code{show-paren-match} and
address@hidden to highlight parentheses; you can customize
+them to control how highlighting looks.  @xref{Face Customization}.
+
address@hidden Comments
address@hidden Manipulating Comments
address@hidden comments
+
+  Because comments are such an important part of programming, Emacs
+provides special commands for editing and inserting comments.  It can
+also do spell checking on comments with Flyspell Prog mode
+(@pxref{Spelling}).
+
address@hidden
+* Comment Commands::    Inserting, killing, and aligning comments.
+* Multi-Line Comments:: Commands for adding and editing multi-line comments.
+* Options for Comments::Customizing the comment features.
address@hidden menu
+
address@hidden Comment Commands
address@hidden Comment Commands
address@hidden indentation for comments
address@hidden alignment for comments
+
+  The comment commands in this table insert, kill and align comments.
+They are described in this section and following sections.
+
address@hidden @asis
address@hidden @kbd{M-;}
+Insert or realign comment on current line; alternatively, comment or
+uncomment the region (@code{comment-dwim}).
address@hidden @kbd{C-u M-;}
+Kill comment on current line (@code{comment-kill}).
address@hidden @kbd{C-x ;}
+Set comment column (@code{comment-set-column}).
address@hidden @kbd{C-M-j}
address@hidden @kbd{M-j}
+Like @key{RET} followed by inserting and aligning a comment
+(@code{comment-indent-new-line}).  @xref{Multi-Line Comments}.
address@hidden @kbd{M-x comment-region}
address@hidden @kbd{C-c C-c} (in C-like modes)
+Add or remove comment delimiters on all the lines in the region.
address@hidden table
+
address@hidden M-;
address@hidden comment-dwim
+  The command to create or align a comment is @kbd{M-;}
+(@code{comment-dwim}).  The word ``dwim'' is an acronym for ``Do What
+I Mean''; it indicates that this command can be used for many
+different jobs relating to comments, depending on the situation where
+you use it.
+
+  If there is no comment already on the line, @kbd{M-;} inserts a new
+comment, aligned at a specific column called the @dfn{comment column}.
+The new comment begins with the string Emacs thinks comments should
+start with (the value of @code{comment-start}; see below).  Point is
+after that string, so you can insert the text of the comment right
+away.  If the major mode has specified a string to terminate comments,
address@hidden;} inserts that after point, to keep the syntax valid.
+
+  If the text of the line extends past the comment column, this
+command aligns the comment start string to a suitable boundary
+(usually, at least one space is inserted).
+
+  You can also use @kbd{M-;} to align an existing comment.  If a line
+already contains the comment-start string, @kbd{M-;} realigns it to
+the conventional alignment and moves point after it.  (Exception:
+comments starting in column 0 are not moved.)  Even when an existing
+comment is properly aligned, @kbd{M-;} is still useful for moving
+directly to the start of the text inside the comment.
+
address@hidden comment-kill
address@hidden C-u M-;
+  @kbd{C-u M-;} kills any comment on the current line, along with the
+whitespace before it.  To reinsert the comment on another line, move
+to the end of that line, do @kbd{C-y}, and then do @kbd{M-;} to
+realign it.
+
+  Note that @kbd{C-u M-;} is not a distinct key; it is @kbd{M-;}
+(@code{comment-dwim}) with a prefix argument.  That command is
+programmed so that when it receives a prefix argument it calls
address@hidden  However, @code{comment-kill} is a valid command
+in its own right, and you can bind it directly to a key if you wish.
+
+  @kbd{M-;} does two other jobs when used with an active region in
+Transient Mark mode (@pxref{Transient Mark}).  Then it either adds or
+removes comment delimiters on each line of the region.  (If every line
+is a comment, it removes comment delimiters from each; otherwise, it
+adds comment delimiters to each.)  If you are not using Transient Mark
+mode, then you should use the commands @code{comment-region} and
address@hidden to do these jobs (@pxref{Multi-Line Comments}),
+or else enable Transient Mark mode momentarily (@pxref{Momentary Mark}).
+A prefix argument used in these circumstances specifies how many
+comment delimiters to add or how many to delete.
+
+  Some major modes have special rules for aligning 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 and are often used
+for sectioning purposes.  Emacs understands
+these conventions by indenting a double-semicolon comment using @key{TAB},
+and by not changing the indentation of a triple-semicolon comment at all.
+
address@hidden
+;; 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.
address@hidden example
+
+  For C-like modes, you can configure the exact effect of @kbd{M-;}
+more flexibly than for most buffers by setting the variables
address@hidden and
address@hidden  For example, on a line
+ending in a closing brace, @kbd{M-;} puts the comment one space after
+the brace rather than at @code{comment-column}.  For full details see
address@hidden Commands,,, ccmode, The CC Mode Manual}. 
+
address@hidden Multi-Line Comments
address@hidden Multiple Lines of Comments
+
address@hidden C-M-j
address@hidden M-j
address@hidden blank lines in programs
address@hidden comment-indent-new-line
+
+  If you are typing a comment and wish to continue it on another line,
+you can use the command @kbd{C-M-j} or @kbd{M-j}
+(@code{comment-indent-new-line}).  If @code{comment-multi-line}
+(@pxref{Options for Comments}) is address@hidden, it moves to a new
+line within the comment.  Otherwise it closes the comment and starts a
+new comment on a new line.  When Auto Fill mode is on, going past the
+fill column while typing a comment causes the comment to be continued
+in just this fashion.
+
address@hidden C-c C-c (C mode)
address@hidden comment-region
+  To turn existing lines into comment lines, use the @kbd{M-x
+comment-region} command (or type @kbd{C-c C-c} in C-like modes).  It
+adds comment delimiters to the lines that start in the region, thus
+commenting them out.  With a negative argument, it does the
+opposite---it deletes comment delimiters from the lines in the region.
+
+  With a positive argument, @code{comment-region} duplicates the last
+character of the comment start sequence it adds; the argument
+specifies how many copies of the character to insert.  Thus, in Lisp
+mode, @kbd{C-u 2 M-x comment-region} adds @samp{;;} to each line.
+Duplicating the comment delimiter is a way of calling attention to the
+comment.  It can also affect how the comment is aligned or indented.
+In Lisp, for proper indentation, you should use an argument of two or
+three, if between defuns; if within a defun, it must be three.
+
+  You can configure C Mode such that when you type a @samp{/} at the
+start of a line in a multi-line block comment, this closes the
+comment.  Enable the @code{comment-close-slash} clean-up for this.
address@hidden,,, ccmode, The CC Mode Manual}.
+
address@hidden Options for Comments
address@hidden Options Controlling Comments
+
address@hidden comment-column
address@hidden C-x ;
address@hidden comment-set-column
+  The @dfn{comment column}, the column at which Emacs tries to place
+comments, is stored in the variable @code{comment-column}.  You can
+set it to a number explicitly.  Alternatively, the command @kbd{C-x ;}
+(@code{comment-set-column}) sets the comment column to the column
+point is at.  @kbd{C-u C-x ;} sets the comment column to match the
+last comment before point in the buffer, and then does a @kbd{M-;} to
+align the current line's comment under the previous one.
+
+  The variable @code{comment-column} is per-buffer: setting the variable
+in the normal fashion affects only the current buffer, but there is a
+default value which you can change with @code{setq-default}.
address@hidden  Many major modes initialize this variable for the
+current buffer.
+
address@hidden comment-start-skip
+  The comment commands recognize comments based on the regular
+expression that is the value of the variable @code{comment-start-skip}.
+Make sure this regexp does 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
address@hidden This stops M-q from breaking the line inside that @code.
address@hidden@w{"/\\*+ *\\|//+ *"}}, which matches extra stars and spaces
+after the @samp{/*} itself, and accepts C++ style comments also.
+(Note that @samp{\\} is needed in Lisp syntax to include a @samp{\} in
+the string, which is needed to deny the first star its special meaning
+in regexp syntax.  @xref{Regexp Backslash}.)
+
address@hidden comment-start
address@hidden comment-end
+  When a comment command makes a new comment, it inserts the value of
address@hidden to begin it.  The value of @code{comment-end} is
+inserted after point, so that it will follow the text that you will
+insert into the comment.  When @code{comment-end} is non-empty, it
+should start with a space.  For example, in C mode,
address@hidden has the value @address@hidden"/* "}} and
address@hidden has the value @address@hidden" */"}}.
+
address@hidden comment-padding
+  The variable @code{comment-padding} specifies how many spaces
address@hidden should insert on each line between the comment
+delimiter and the line's original text.  The default is 1, to insert
+one space.  @code{nil} means 0.  Alternatively, @code{comment-padding}
+can hold the actual string to insert.
+
address@hidden comment-multi-line
+  The variable @code{comment-multi-line} controls how @kbd{C-M-j}
+(@code{indent-new-comment-line}) behaves when used inside a comment.
+Specifically, when @code{comment-multi-line} is @code{nil}, the
+command inserts a comment terminator, begins a new line, and finally
+inserts a comment starter.  Otherwise it does not insert the
+terminator and starter, so it effectively continues the current
+comment across multiple lines.  In languages that allow multi-line
+comments, the choice of value for this variable is a matter of taste.
+The default for this variable depends on the major mode.
+
address@hidden comment-indent-function
+  The variable @code{comment-indent-function} should contain a function
+that will be called to compute the alignment for a newly inserted
+comment or for aligning an existing comment.  It is set differently by
+various major modes.  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.  It should return the column in which the
+comment ought to start.  For example, in Lisp mode, the indent hook
+function bases its decision on how many semicolons begin an existing
+comment, and on the code in the preceding lines.
+
address@hidden Documentation
address@hidden Documentation Lookup
+
+  Emacs provides several features you can use to look up the
+documentation of functions, variables and commands that you plan to
+use in your program.
+
address@hidden
+* Info Lookup::         Looking up library functions and commands
+                          in Info files.
+* Man Page::            Looking up man pages of library functions and commands.
+* Lisp Doc::            Looking up Emacs Lisp functions, etc.
address@hidden menu
+
address@hidden Info Lookup
address@hidden Info Documentation Lookup
+
address@hidden info-lookup-symbol
address@hidden info-lookup-file
address@hidden C-h S
+  For many major modes, that apply to languages that have
+documentation in Info, you can use @kbd{C-h S}
+(@code{info-lookup-symbol}) to view the Info documentation for a
+symbol used in the program.  You specify the symbol with the
+minibuffer; the default is the symbol appearing in the buffer at
+point.  For example, in C mode this looks for the symbol in the C
+Library Manual.  The command only works if the appropriate manual's
+Info files are installed.
+
+  The major mode determines where to look for documentation for the
+symbol---which Info files to look in, and which indices to search.
+You can also use @kbd{M-x info-lookup-file} to look for documentation
+for a file name.
+
+  If you use @kbd{C-h S} in a major mode that does not support it,
+it asks you to specify the ``symbol help mode.''  You should enter
+a command such as @code{c-mode} that would select a major
+mode which @kbd{C-h S} does support.
+
address@hidden Man Page
address@hidden Man Page Lookup
+
address@hidden manual page
+  On Unix, the main form of on-line documentation was the @dfn{manual
+page} or @dfn{man page}.  In the GNU operating system, we aim to
+replace man pages with better-organized manuals that you can browse
+with Info (@pxref{Misc Help}).  This process is not finished, so it is
+still useful to read manual pages.
+
address@hidden manual-entry
+  You can read the man page for an operating system command, library
+function, or system call, with the @kbd{M-x man} command.  It
+runs the @code{man} program to format the man page; if the system
+permits, it runs @code{man} asynchronously, so that you can keep on
+editing while the page is being formatted.  (On MS-DOS and MS-Windows
+3, you cannot edit while Emacs waits for @code{man} to finish.)  The
+result goes in a buffer named @samp{*Man @var{topic}*}.  These buffers
+use a special major mode, Man mode, that facilitates scrolling and
+jumping to other manual pages.  For details, type @kbd{C-h m} while in
+a man page buffer.
+
address@hidden sections of manual pages
+  Each man page belongs to one of ten or more @dfn{sections}, each
+named by a digit or by a digit and a letter.  Sometimes there are
+multiple man pages with the same name in different sections.  To read
+a man page from a specific section, type
address@hidden@var{topic}(@var{section})} or @address@hidden @var{topic}}
+when @kbd{M-x manual-entry} prompts for the topic.  For example, to
+read the man page for the C library function @code{chmod} (as opposed
+to a command of the same name), type @kbd{M-x manual-entry @key{RET}
+chmod(2) @key{RET}}.  (@code{chmod} is a system call, so it is in
+section @samp{2}.)
+
address@hidden Man-switches
+  If you do not specify a section, the results depend on how the
address@hidden program works on your system.  Some of them display only
+the first man page they find.  Others display all man pages that have
+the specified name, so you can move between them with the @kbd{M-n}
+and @kbd{M-p} address@hidden some systems, the @code{man} program
+accepts a @samp{-a} command-line option which tells it to display all
+the man pages for the specified topic.  If you want this behavior, you
+can add this option to the value of the variable @code{Man-switches}.}.
+The mode line shows how many manual pages are present in the Man buffer.
+
address@hidden Man-fontify-manpage-flag
+  By default, Emacs highlights the text in man pages.  For a long man
+page, highlighting can take substantial time.  You can turn off
+highlighting of man pages by setting the variable
address@hidden to @code{nil}.
+
address@hidden Man-fontify-manpage
+  If you insert the text of a man page into an Emacs buffer in some
+other fashion, you can use the command @kbd{M-x Man-fontify-manpage} to
+perform the same conversions that @kbd{M-x manual-entry} does.
+
address@hidden woman
address@hidden manual pages, on MS-DOS/MS-Windows
+  An alternative way of reading manual pages is the @kbd{M-x woman}
address@hidden name of the command, @code{woman}, is an acronym
+for ``w/o (without) man,'' since it doesn't use the @code{man}
+program.}.  Unlike @kbd{M-x man}, it does not run any external
+programs to format and display the man pages; instead it does the job
+in Emacs Lisp, so it works on systems such as MS-Windows, where the
address@hidden program (and other programs it uses) are not generally
+available.
+
+  @kbd{M-x woman} prompts for a name of a manual page, and provides
+completion based on the list of manual pages that are installed on
+your machine; the list of available manual pages is computed
+automatically the first time you invoke @code{woman}.  The word at
+point in the current buffer is used to suggest the default for the
+name the manual page.
+
+  With a numeric argument, @kbd{M-x woman} recomputes the list of the
+manual pages used for completion.  This is useful if you add or delete
+manual pages.
+
+  If you type a name of a manual page and @kbd{M-x woman} finds that
+several manual pages by the same name exist in different sections, it
+pops up a window with possible candidates asking you to choose one of
+them.
+
+  For more information about setting up and using @kbd{M-x woman}, see
address@hidden, WoMan, Browse UN*X Manual Pages WithOut Man, woman, The WoMan
+Manual}.
+
address@hidden Lisp Doc
address@hidden Emacs Lisp Documentation Lookup
+
+  As you edit Lisp code to be run in Emacs, you can use the commands
address@hidden f} (@code{describe-function}) and @kbd{C-h v}
+(@code{describe-variable}) to view documentation of functions and
+variables that you want to use.  These commands use the minibuffer to
+read the name of a function or variable to document, and display the
+documentation in a window.  Their default arguments are based on the
+code in the neighborhood of point.  For @kbd{C-h f}, the default is
+the function called in the innermost list containing point.  @kbd{C-h
+v} uses the symbol name around or adjacent to point as its default.
+
address@hidden Eldoc mode
address@hidden eldoc-mode
+  A more automatic but less powerful method is Eldoc mode.  This minor
+mode constantly displays in the echo area the argument list for the
+function being called at point.  (In other words, it finds the
+function call that point is contained in, and displays the argument
+list of that function.)  If point is over a documented variable, it
+shows the first line of the variable's docstring.  Eldoc mode applies
+in Emacs Lisp and Lisp Interaction modes, and perhaps a few others
+that provide special support for looking up doc strings.  Use the
+command @kbd{M-x eldoc-mode} to enable or disable this feature.
+
address@hidden Hideshow
address@hidden Hideshow minor mode
+
address@hidden hs-minor-mode
+  Hideshow minor mode provides selective display of portions of a
+program, known as @dfn{blocks}.  You can use @kbd{M-x hs-minor-mode}
+to enable or disable this mode, or add @code{hs-minor-mode} to the
+mode hook for certain major modes in order to enable it automatically
+for those modes.
+
+  Just what constitutes a block depends on the major mode.  In C mode
+or C++ mode, they are delimited by braces, while in Lisp mode and
+similar modes they are delimited by parentheses.  Multi-line comments
+also count as blocks.
+
address@hidden hs-hide-all
address@hidden hs-hide-block
address@hidden hs-show-all
address@hidden hs-show-block
address@hidden hs-show-region
address@hidden hs-hide-level
address@hidden hs-minor-mode
address@hidden C-c @@ C-h
address@hidden C-c @@ C-s
address@hidden C-c @@ C-M-h
address@hidden C-c @@ C-M-s
address@hidden C-c @@ C-r
address@hidden C-c @@ C-l
address@hidden S-Mouse-2
address@hidden @kbd
address@hidden C-c @@ C-h
+Hide the current block (@code{hs-hide-block}).
address@hidden C-c @@ C-s
+Show the current block (@code{hs-show-block}).
address@hidden C-c @@ C-c
+Either hide or show the current block (@code{hs-toggle-hiding}).
address@hidden S-Mouse-2
+Either hide or show the block you click on (@code{hs-mouse-toggle-hiding}).
address@hidden C-c @@ C-M-h
+Hide all top-level blocks (@code{hs-hide-all}).
address@hidden C-c @@ C-M-s
+Show everything in the buffer (@code{hs-show-all}).
address@hidden C-c @@ C-l
+Hide all blocks @var{n} levels below this block
+(@code{hs-hide-level}).
address@hidden table
+
address@hidden hs-hide-comments-when-hiding-all
address@hidden hs-isearch-open
address@hidden hs-special-modes-alist
+  These variables exist for customizing Hideshow mode.
+
address@hidden @code
address@hidden hs-hide-comments-when-hiding-all
address@hidden says that @kbd{hs-hide-all} should hide comments too.
+
address@hidden hs-isearch-open
+Specifies what kind of hidden blocks incremental search should make
+visible.  The value should be one of these four symbols:
+
address@hidden @code
address@hidden code
+Open only code blocks.
address@hidden comment
+Open only comments.
address@hidden t
+Open both code blocks and comments.
address@hidden nil
+Open neither code blocks nor comments.
address@hidden table
+
address@hidden hs-special-modes-alist
+A list of elements, each specifying how to initialize Hideshow
+variables for one major mode.  See the variable's documentation string
+for more information.
address@hidden table
+
address@hidden Symbol Completion
address@hidden Completion for Symbol Names
address@hidden completion (symbol names)
+
+  In Emacs, completion is something you normally do in the minibuffer.
+But one kind of completion is available in all buffers: completion for
+symbol names.
+
address@hidden M-TAB
+  The character @address@hidden runs a command to complete the
+partial symbol before point against the set of meaningful symbol
+names.  This command inserts at point any additional characters that
+it can determine from the partial name.
+
+  If your window manager defines @address@hidden to switch windows,
+you can type @address@hidden @key{TAB}} or @kbd{C-M-i} instead.
+However, most window managers let you customize these shortcuts, and
+we recommend that you change any that get in the way of use of Emacs.
+
+  If the partial name in the buffer has multiple possible completions
+that differ in the very next character, so that it is impossible to
+complete even one more character, @address@hidden displays a list of
+all possible completions in another window.
+
address@hidden tags-based completion
address@hidden Info index completion
address@hidden complete-symbol
+  In most programming language major modes, @address@hidden runs the
+command @code{complete-symbol}, which provides two kinds of completion.
+Normally it does completion based on a tags table (@pxref{Tags}); with a
+numeric argument (regardless of the value), it does completion based on
+the names listed in the Info file indexes for your language.  Thus, to
+complete the name of a symbol defined in your own program, use
address@hidden@key{TAB}} with no argument; to complete the name of a standard
+library function, use @kbd{C-u address@hidden  Of course, Info-based
+completion works only if there is an Info file for the standard library
+functions of your language, and only if it is installed at your site.
+
address@hidden Lisp symbol completion
address@hidden completion (Lisp symbols)
address@hidden lisp-complete-symbol
+  In Emacs-Lisp mode, the name space for completion normally consists of
+nontrivial symbols present in Emacs---those that have function
+definitions, values or properties.  However, if there is an
+open-parenthesis immediately before the beginning of the partial symbol,
+only symbols with function definitions are considered as completions.
+The command which implements this is @code{lisp-complete-symbol}.
+
+  In Text mode and related modes, @address@hidden completes words
+based on the spell-checker's dictionary.  @xref{Spelling}.
+
address@hidden Glasses
address@hidden Glasses minor mode
address@hidden Glasses mode
address@hidden identifiers, making long ones readable
address@hidden StudlyCaps, making them readable
address@hidden glasses-mode
+
+  Glasses minor mode makes @samp{unreadableIdentifiersLikeThis}
+readable by altering the way they display.  It knows two different
+ways to do this: by displaying underscores between a lower-case letter
+and the following capital letter, and by emboldening the capital
+letters.  It does not alter the buffer text, only the way they
+display, so you can use it even on read-only buffers.  You can use the
+command @kbd{M-x glasses-mode} to enable or disable the mode in the
+current buffer; you can also add @code{glasses-mode} to the mode hook
+of the programming language major modes in which you normally want
+to use Glasses mode.
+
address@hidden Misc for Programs
address@hidden Other Features Useful for Editing Programs
+
+  A number of Emacs commands that aren't designed specifically for
+editing programs are useful for that nonetheless.
+
+  The Emacs commands that operate on words, sentences and paragraphs
+are useful for editing code.  Most symbols names contain words
+(@pxref{Words}); sentences can be found in strings and comments
+(@pxref{Sentences}).  Paragraphs in the strict sense can be found in
+program code (in long comments), but the paragraph commands are useful
+in other places too, because programming language major modes define
+paragraphs to begin and end at blank lines (@pxref{Paragraphs}).
+Judicious use of blank lines to make the program clearer will also
+provide useful chunks of text for the paragraph commands to work on.
+Auto Fill mode, if enabled in a programming language major mode,
+indents the new lines which it creates.
+
+  The selective display feature is useful for looking at the overall
+structure of a function (@pxref{Selective Display}).  This feature
+hides the lines that are indented more than a specified amount.
+Programming modes often support Outline minor mode (@pxref{Outline
+Mode}).  The Foldout package provides folding-editor features
+(@pxref{Foldout}).
+
+  The ``automatic typing'' features may be useful for writing programs.
address@hidden,,Autotyping, autotype, Autotyping}.
+
address@hidden C Modes
address@hidden C and Related Modes
address@hidden C mode
address@hidden Java mode
address@hidden Pike mode
address@hidden IDL mode
address@hidden CORBA IDL mode
address@hidden Objective C mode
address@hidden C++ mode
address@hidden AWK mode
address@hidden mode, Java
address@hidden mode, C
address@hidden mode, C++
address@hidden mode, Objective C
address@hidden mode, CORBA IDL
address@hidden mode, Pike
address@hidden mode, AWK
+
+  This section gives a brief description of the special features
+available in C, C++, Objective-C, Java, CORBA IDL, Pike and AWK modes.
+(These are called ``C mode and related modes.'')  @xref{Top, , CC Mode,
+ccmode, CC Mode}, for a more extensive description of these modes
+and their special features.
+
address@hidden
+* Motion in C::                 Commands to move by C statements, etc.
+* Electric C::                  Colon and other chars can automatically 
reindent.
+* Hungry Delete::               A more powerful DEL command.
+* Other C Commands::            Filling comments, viewing expansion of macros,
+                                and other neat features.
address@hidden menu
+
address@hidden Motion in C
address@hidden C Mode Motion Commands
+
+  This section describes commands for moving point, in C mode and
+related modes.
+
address@hidden @code
address@hidden M-x c-beginning-of-defun
address@hidden M-x c-end-of-defun
address@hidden c-beginning-of-defun
address@hidden c-end-of-defun
+Move point to the beginning or end of the current function or
+top-level definition.  These are found by searching for the least
+enclosing braces.  (By contrast, @code{beginning-of-defun} and
address@hidden search for braces in column zero.)  If you are
+editing code where the opening brace of a function isn't placed in
+column zero, you may wish to bind @code{C-M-a} and @code{C-M-e} to
+these commands.  @xref{Moving by Defuns}.
+
address@hidden C-c C-u
address@hidden C-c C-u @r{(C mode)}
address@hidden c-up-conditional
+Move point back to the containing preprocessor conditional, leaving the
+mark behind.  A prefix argument acts as a repeat count.  With a negative
+argument, move point forward to the end of the containing
+preprocessor conditional.
+
address@hidden is equivalent to @samp{#else} followed by @samp{#if}, so
+the function will stop at a @samp{#elif} when going backward, but not
+when going forward.
+
address@hidden C-c C-p
address@hidden C-c C-p @r{(C mode)}
address@hidden c-backward-conditional
+Move point back over a preprocessor conditional, leaving the mark
+behind.  A prefix argument acts as a repeat count.  With a negative
+argument, move forward.
+
address@hidden C-c C-n
address@hidden C-c C-n @r{(C mode)}
address@hidden c-forward-conditional
+Move point forward across a preprocessor conditional, leaving the mark
+behind.  A prefix argument acts as a repeat count.  With a negative
+argument, move backward.
+
address@hidden M-a
address@hidden M-a (C mode)
address@hidden c-beginning-of-statement
+Move point to the beginning of the innermost C statement
+(@code{c-beginning-of-statement}).  If point is already at the beginning
+of a statement, move to the beginning of the preceding statement.  With
+prefix argument @var{n}, move back @var{n} @minus{} 1 statements.
+
+In comments or in strings which span more than one line, this command
+moves by sentences instead of statements.
+
address@hidden M-e
address@hidden M-e (C mode)
address@hidden c-end-of-statement
+Move point to the end of the innermost C statement or sentence; like
address@hidden except that it moves in the other direction
+(@code{c-end-of-statement}).
address@hidden table
+
address@hidden Electric C
address@hidden Electric C Characters
+
+  In C mode and related modes, certain printing characters are
address@hidden addition to inserting themselves, they also
+reindent the current line, and optionally also insert newlines.  The
+``electric'' characters are @address@hidden, @address@hidden, @kbd{:}, @kbd{#},
address@hidden;}, @kbd{,}, @kbd{<}, @kbd{>}, @kbd{/}, @kbd{*}, @kbd{(}, and
address@hidden)}.
+
+  You might find electric indentation inconvenient if you are editing
+chaotically indented code.  If you are new to CC Mode, you might find
+it disconcerting.  You can toggle electric action with the command
address@hidden C-l}; when it is enabled, @samp{/l} appears in the mode line
+after the mode name:
+
address@hidden @kbd
address@hidden C-c C-l
address@hidden C-c C-l @r{(C mode)}
address@hidden c-toggle-electric-state
+Toggle electric action (@code{c-toggle-electric-state}).  With a
+prefix argument, this command enables electric action if the argument
+is positive, disables it if it is negative.
address@hidden table
+
+  Electric characters insert newlines only when, in addition to the
+electric state, the @dfn{auto-newline} feature is enabled (indicated
+by @samp{/la} in the mode line after the mode name).  You can turn
+this feature on or off with the command @kbd{C-c C-a}:
+
address@hidden @kbd
address@hidden C-c C-a
address@hidden C-c C-a @r{(C mode)}
address@hidden c-toggle-auto-newline
+Toggle the auto-newline feature (@code{c-toggle-auto-newline}).  With a
+prefix argument, this command turns the auto-newline feature on if the
+argument is positive, and off if it is negative.
address@hidden table
+
+  Usually the CC Mode style configures the exact circumstances in
+which Emacs inserts auto-newlines.  You can also configure this
+directly.  @xref{Custom Auto-newlines,,, ccmode, The CC Mode Manual}.
+
address@hidden Hungry Delete
address@hidden Hungry Delete Feature in C
address@hidden hungry deletion (C Mode)
+
+  If you want to delete an entire block of whitespace at point, you
+can use @dfn{hungry deletion}.  This deletes all the contiguous
+whitespace either before point or after point in a single operation.
address@hidden here includes tabs and newlines, but not comments or
+preprocessor commands.
+
address@hidden @kbd
address@hidden C-c address@hidden
address@hidden C-c @key{DEL}
address@hidden c-hungry-delete-backwards
address@hidden C-c address@hidden (C Mode)
address@hidden C-c @key{DEL} (C Mode)
address@hidden the entire block of whitespace
+preceding point.
+
address@hidden C-c C-d
address@hidden C-c address@hidden
address@hidden C-c @key{DELETE}
address@hidden c-hungry-delete-forward
address@hidden C-c C-d (C Mode)
address@hidden C-c address@hidden (C Mode)
address@hidden C-c @key{DELETE} (C Mode)
address@hidden the entire block of whitespace
+following point.
address@hidden table
+
+  As an alternative to the above commands, you can enable @dfn{hungry
+delete mode}.  When this feature is enabled (indicated by @samp{/h} in
+the mode line after the mode name), a single @key{DEL} deletes all
+preceding whitespace, not just one space, and a single @kbd{C-c C-d}
+(but @emph{not} plain @key{DELETE}) deletes all following whitespace.
+
address@hidden @kbd
address@hidden M-x c-toggle-hungry-state
address@hidden c-toggle-hungry-state
+Toggle the hungry-delete feature
+(@code{c-toggle-hungry-state})@footnote{This command had the binding
address@hidden C-d} in earlier versions of Emacs.  @kbd{C-c C-d} is now
+bound to @code{c-hungry-delete-forward}.}.  With a prefix argument,
+this command turns the hungry-delete feature on if the argument is
+positive, and off if it is negative.
address@hidden table
+
address@hidden c-hungry-delete-key
+   The variable @code{c-hungry-delete-key} controls whether the
+hungry-delete feature is enabled.
+
address@hidden Other C Commands
address@hidden Other Commands for C Mode
+
address@hidden @kbd
address@hidden C-c C-w
address@hidden M-x c-subword-mode
address@hidden c-subword-mode
+Enable (or disable) @dfn{subword mode}.  In subword mode, Emacs's word
+commands recognize upper case letters in
address@hidden as word boundaries.  This is indicated by
+the flag @samp{/w} on the mode line after the mode name
+(e.g. @samp{C/law}).  You can even use @kbd{M-x c-subword-mode} in
+non-CC Mode buffers.
+
+In the GNU project, we recommend using underscores to separate words
+within an identifier in C or C++, rather than using case distinctions.
+
address@hidden M-x c-context-line-break
address@hidden c-context-line-break
+This command inserts a line break and indents the new line in a manner
+appropriate to the context.  In normal code, it does the work of
address@hidden (@code{newline-and-indent}), in a C preprocessor line it
+additionally inserts a @samp{\} at the line break, and within comments
+it's like @kbd{M-j} (@code{c-indent-new-comment-line}).
+
address@hidden isn't bound to a key by default, but it
+needs a binding to be useful.  The following code will bind it to
address@hidden  We use @code{c-initialization-hook} here to make sure
+the keymap is loaded before we try to change it.
+
address@hidden
+(defun my-bind-clb ()
+  (define-key c-mode-base-map "\C-j" 'c-context-line-break))
+(add-hook 'c-initialization-hook 'my-bind-clb)
address@hidden smallexample
+
address@hidden C-M-h
+Put mark at the end of a function definition, and put point at the
+beginning (@code{c-mark-function}).
+
address@hidden M-q
address@hidden M-q @r{(C mode)}
address@hidden c-fill-paragraph
+Fill a paragraph, handling C and C++ comments (@code{c-fill-paragraph}).
+If any part of the current line is a comment or within a comment, this
+command fills the comment or the paragraph of it that point is in,
+preserving the comment indentation and comment delimiters.
+
address@hidden C-c C-e
address@hidden macro expansion in C
address@hidden expansion of C macros
address@hidden c-macro-expand
address@hidden C-c C-e @r{(C mode)}
+Run the C preprocessor on the text in the region, and show the result,
+which includes the expansion of all the macro calls
+(@code{c-macro-expand}).  The buffer text before the region is also
+included in preprocessing, for the sake of macros defined there, but the
+output from this part isn't shown.
+
+When you are debugging C code that uses macros, sometimes it is hard to
+figure out precisely how the macros expand.  With this command, you
+don't have to figure it out; you can see the expansions.
+
address@hidden C-c C-\
address@hidden c-backslash-region
address@hidden C-c C-\ @r{(C mode)}
+Insert or align @samp{\} characters at the ends of the lines of the
+region (@code{c-backslash-region}).  This is useful after writing or
+editing a C macro definition.
+
+If a line already ends in @samp{\}, this command adjusts the amount of
+whitespace before it.  Otherwise, it inserts a new @samp{\}.  However,
+the last line in the region is treated specially; no @samp{\} is
+inserted on that line, and any @samp{\} there is deleted.
+
address@hidden M-x cpp-highlight-buffer
address@hidden preprocessor highlighting
address@hidden cpp-highlight-buffer
+Highlight parts of the text according to its preprocessor conditionals.
+This command displays another buffer named @samp{*CPP Edit*}, which
+serves as a graphic menu for selecting how to display particular kinds
+of conditionals and their contents.  After changing various settings,
+click on @samp{[A]pply these settings} (or go to that buffer and type
address@hidden) to rehighlight the C mode buffer accordingly.
+
address@hidden C-c C-s
address@hidden c-show-syntactic-information
address@hidden C-c C-s @r{(C mode)}
+Display the syntactic information about the current source line
+(@code{c-show-syntactic-information}).  This information directs how
+the line is indented.
+
address@hidden M-x cwarn-mode
address@hidden M-x global-cwarn-mode
address@hidden cwarn-mode
address@hidden global-cwarn-mode
address@hidden global-cwarn-mode
address@hidden CWarn mode
address@hidden suspicious constructions in C, C++
+CWarn minor mode highlights certain suspicious C and C++ constructions:
+
address@hidden @bullet{}
address@hidden
+Assignments inside expressions.
address@hidden
+Semicolon following immediately after @samp{if}, @samp{for}, and @samp{while}
+(except after a @samp{do @dots{} while} statement);
address@hidden
+C++ functions with reference parameters.
address@hidden itemize
+
address@hidden
+You can enable the mode for one buffer with the command @kbd{M-x
+cwarn-mode}, or for all suitable buffers with the command @kbd{M-x
+global-cwarn-mode} or by customizing the variable
address@hidden  You must also enable Font Lock mode to make
+it work.
+
address@hidden M-x hide-ifdef-mode
address@hidden hide-ifdef-mode
address@hidden Hide-ifdef mode
+Hide-ifdef minor mode hides selected code within @samp{#if} and
address@hidden preprocessor blocks.  See the documentation string of
address@hidden for more information.
+
address@hidden M-x ff-find-related-file
address@hidden related files
address@hidden ff-find-related-file
address@hidden ff-related-file-alist
+Find a file ``related'' in a special way to the file visited by the
+current buffer.  Typically this will be the header file corresponding
+to a C/C++ source file, or vice versa.  The variable
address@hidden specifies how to compute related file
+names.
address@hidden table
+
address@hidden Asm Mode
address@hidden Asm Mode
+
address@hidden Asm mode
address@hidden assembler mode
+Asm mode is a major mode for editing files of assembler code.  It
+defines these commands:
+
address@hidden @kbd
address@hidden @key{TAB}
address@hidden
address@hidden C-j
+Insert a newline and then indent using @code{tab-to-tab-stop}.
address@hidden :
+Insert a colon and then remove the indentation from before the label
+preceding colon.  Then do @code{tab-to-tab-stop}.
address@hidden ;
+Insert or align a comment.
address@hidden table
+
+  The variable @code{asm-comment-char} specifies which character
+starts comments in assembler syntax.
+
address@hidden
address@hidden fortran-xtra.texi
address@hidden ifnottex
+
address@hidden
+   arch-tag: c7ee7409-40a4-45c7-bfb7-ae7f2c74d0c0
address@hidden ignore