-@item M-(
-Put parentheses around next sexp(s) (@code{insert-parentheses}).
-@item M-)
-Move past next close parenthesis and reindent
-(@code{move-past-close-and-reindent}).
-@end table
-
-@kindex M-(
-@kindex M-)
-@findex insert-parentheses
-@findex move-past-close-and-reindent
- The commands @kbd{M-(} (@code{insert-parentheses}) and @kbd{M-)}
-(@code{move-past-close-and-reindent}) are designed to facilitate a style
-of editing which keeps parentheses balanced at all times. @kbd{M-(}
-inserts a pair of parentheses, either together as in @samp{()}, or, if
-given an argument, around the next several sexps. It leaves point after
-the open parenthesis. The command @kbd{M-)} moves past the close
-parenthesis, deleting any indentation preceding it, and indenting with
-@kbd{C-j} after it.
-
- For example, instead of typing @kbd{( F O O )}, you can type @kbd{M-(
-F O O}, which has the same effect except for leaving the cursor before
-the close parenthesis.
-
-@vindex parens-require-spaces
- @kbd{M-(} may insert a space before the open parenthesis, depending on
-the syntax class of the preceding character. Set
-@code{parens-require-spaces} to @code{nil} value if you wish to inhibit
-this.
-
-@node Symbol Completion
-@section Completion for Symbol Names
-@cindex completion (symbol names)
-
- Usually completion happens in the minibuffer. But one kind of completion
-is available in all buffers: completion for symbol names.
-
-@kindex M-TAB
- The character @kbd{M-@key{TAB}} runs a command to complete the partial
-symbol before point against the set of meaningful symbol names. Any
-additional characters determined by the partial name are inserted at
-point.
-
- 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.
-
-@cindex completion using tags
-@cindex tags completion
-@cindex Info index completion
-@findex complete-symbol
- In most programming language major modes, @kbd{M-@key{TAB}} 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
-@kbd{M-@key{TAB}} with no argument; to complete the name of a standard
-library function, use @kbd{C-u M-@key{TAB}}. 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.
-
-@cindex Lisp symbol completion
-@cindex completion in Lisp
-@findex 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, @kbd{M-@key{TAB}} completes words
-based on the spell-checker's dictionary. @xref{Spelling}.
-
-@node Which Function
-@section Which Function Mode
-
- Which Function mode is a minor mode that displays the current function
-name in the mode line, as you move around in a buffer.
-
-@findex which-function-mode
-@vindex which-func-modes
- To enable (or disable) Which Function mode, use the command @kbd{M-x
-which-function-mode}. This command is global; it applies to all
-buffers, both existing ones and those yet to be created. However, this
-only affects 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---which are
-the major modes that support Imenu.)
-
-@node Documentation
-@section Documentation Commands
-
- As you edit Lisp code to be run in Emacs, the commands @kbd{C-h f}
-(@code{describe-function}) and @kbd{C-h v} (@code{describe-variable}) can
-be used to print documentation of functions and variables that 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. @kbd{C-h f} sets the default to 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.
-
-@cindex Eldoc mode
-@findex eldoc-mode
- For Emacs Lisp code, you can also use 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.)
-Eldoc mode applies in Emacs Lisp and Lisp Interaction modes only. Use
-the command @kbd{M-x eldoc-mode} to enable or disable this feature.
-
-@findex info-lookup-symbol
-@findex info-lookup-file
-@kindex C-h C-i
- For C, Lisp, and other languages, you can use @kbd{C-h C-i}
-(@code{info-lookup-symbol}) to view the Info documentation for a symbol.
-You specify the symbol with the minibuffer; by default, it uses the
-symbol that appears in the buffer at point. The major mode determines
-where to look for documentation for the symbol---which Info files and
-which indices. You can also use @kbd{M-x info-lookup-file} to look for
-documentation for a file name.
-
-@findex manual-entry
- You can read the ``man page'' for an operating system command, library
-function, or system call, with the @kbd{M-x manual-entry} command. It
-runs the @code{man} program to format the man page, and runs it
-asynchronously if your system permits, so that you can keep on editing
-while the page is being formatted. (MS-DOS and MS-Windows 3 do not
-permit asynchronous subprocesses, so on these systems you cannot edit
-while Emacs waits for @code{man} to exit.) The result goes in a buffer
-named @samp{*Man @var{topic}*}. These buffers use a special major mode,
-Man mode, that facilitates scrolling and examining other manual pages.
-For details, type @kbd{C-h m} while in a man page buffer.
-
-@vindex Man-fontify-manpage-flag
- For a long man page, setting the faces properly can take substantial
-time. By default, Emacs uses faces in man pages if Emacs can display
-different fonts or colors. You can turn off use of faces in man pages
-by setting the variable @code{Man-fontify-manpage-flag} to @code{nil}.
-
-@findex 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.
-
- Eventually the GNU project hopes to replace most man pages with
-better-organized manuals that you can browse with Info. @xref{Misc
-Help}. Since this process is only partially completed, it is still
-useful to read manual pages.
-
-@node Change Log
-@section Change Logs
-
-@cindex change log
-@kindex C-x 4 a
-@findex add-change-log-entry-other-window
- The Emacs command @kbd{C-x 4 a} adds a new entry to the change log
-file for the file you are editing
-(@code{add-change-log-entry-other-window}).
-
- A change log file contains a chronological record of when and why you
-have changed a program, consisting of a sequence of entries describing
-individual changes. Normally it is kept in a file called
-@file{ChangeLog} in the same directory as the file you are editing, or
-one of its parent directories. A single @file{ChangeLog} file can
-record changes for all the files in its directory and all its
-subdirectories.
-
- A change log entry starts with a header line that contains your name,
-your email address (taken from the variable @code{user-mail-address}),
-and the current date and time. Aside from these header lines, every
-line in the change log starts with a space or a tab. The bulk of the
-entry consists of @dfn{items}, each of which starts with a line starting
-with whitespace and a star. Here are two entries, both dated in May
-1993, each with two items:
-
-@iftex
-@medbreak
-@end iftex
-@smallexample
-1993-05-25 Richard Stallman <rms@@gnu.org>
-
- * man.el: Rename symbols `man-*' to `Man-*'.
- (manual-entry): Make prompt string clearer.
-
- * simple.el (blink-matching-paren-distance):
- Change default to 12,000.
-
-1993-05-24 Richard Stallman <rms@@gnu.org>
-
- * vc.el (minor-mode-map-alist): Don't use it if it's void.
- (vc-cancel-version): Doc fix.
-@end smallexample
-
-@noindent
-(Previous Emacs versions used a different format for the date.)
-
- One entry can describe several changes; each change should have its
-own item. Normally there should be a blank line between items. When
-items are related (parts of the same change, in different places), group
-them by leaving no blank line between them. The second entry above
-contains two items grouped in this way.
-
- @kbd{C-x 4 a} visits the change log file and creates a new entry
-unless the most recent entry is for today's date and your name. It also
-creates a new item for the current file. For many languages, it can
-even guess the name of the function or other object that was changed.
-
-@cindex Change Log mode
-@findex change-log-mode
- The change log file is visited in Change Log mode. In this major
-mode, each bunch of grouped items counts as one paragraph, and each
-entry is considered a page. This facilitates editing the entries.
-@kbd{C-j} and auto-fill indent each new line like the previous line;
-this is convenient for entering the contents of an entry.
-
- Version control systems are another way to keep track of changes in your
-program and keep a change log. @xref{Log Buffer}.
-
-@node Tags
-@section Tags Tables
-@cindex tags table
-
- A @dfn{tags table} is a description of how a multi-file program is
-broken up into files. It lists the names of the component files and the
-names and positions of the functions (or other named subunits) in each
-file. Grouping the related files makes it possible to search or replace
-through all the files with one command. Recording the function names
-and positions makes possible the @kbd{M-.} command which finds the
-definition of a function by looking up which of the files it is in.
-
- Tags tables are stored in files called @dfn{tags table files}. The
-conventional name for a tags table file is @file{TAGS}.
-
- Each entry in the tags table records the name of one tag, the name of the
-file that the tag is defined in (implicitly), and the position in that file
-of the tag's definition.
-
- Just what names from the described files are recorded in the tags table
-depends on the programming language of the described file. They
-normally include all functions and subroutines, and may also include
-global variables, data types, and anything else convenient. Each name
-recorded is called a @dfn{tag}.
-
-@menu
-* Tag Syntax:: Tag syntax for various types of code and text files.
-* Create Tags Table:: Creating a tags table with @code{etags}.
-* Etags Regexps:: Create arbitrary tags using regular expressions.
-* Select Tags Table:: How to visit a tags table.
-* Find Tag:: Commands to find the definition of a specific tag.
-* Tags Search:: Using a tags table for searching and replacing.
-* List Tags:: Listing and finding tags defined in a file.
-@end menu
-
-@node Tag Syntax
-@subsection Source File Tag Syntax
-
- Here is how tag syntax is defined for the most popular languages:
-
-@itemize @bullet
-@item
-In C code, any C function or typedef is a tag, and so are definitions of
-@code{struct}, @code{union} and @code{enum}. You can tag function
-declarations and external variables in addition to function definitions
-by giving the @samp{--declarations} option to @code{etags}.
-@code{#define} macro definitions and @code{enum} constants are also
-tags, unless you specify @samp{--no-defines} when making the tags table.
-Similarly, global variables are tags, unless you specify
-@samp{--no-globals}. Use of @samp{--no-globals} and @samp{--no-defines}
-can make the tags table file much smaller.
-
-@item
-In C++ code, in addition to all the tag constructs of C code, member
-functions are also recognized, and optionally member variables if you
-use the @samp{--members} option. Tags for variables and functions in
-classes are named @samp{@var{class}::@var{variable}} and
-@samp{@var{class}::@var{function}}. @code{operator} functions tags are
-named, for example @samp{operator+}.
-
-@item
-In Java code, tags include all the constructs recognized in C++, plus
-the @code{interface}, @code{extends} and @code{implements} constructs.
-Tags for variables and functions in classes are named
-@samp{@var{class}.@var{variable}} and @samp{@var{class}.@var{function}}.
-
-@item
-In La@TeX{} text, the argument of any of the commands @code{\chapter},
-@code{\section}, @code{\subsection}, @code{\subsubsection},
-@code{\eqno}, @code{\label}, @code{\ref}, @code{\cite}, @code{\bibitem},
-@code{\part}, @code{\appendix}, @code{\entry}, or @code{\index}, is a
-tag.@refill
-
-Other commands can make tags as well, if you specify them in the
-environment variable @code{TEXTAGS} before invoking @code{etags}. The
-value of this environment variable should be a colon-separated list of
-command names. For example,
-
-@example
-TEXTAGS="def:newcommand:newenvironment"
-export TEXTAGS
-@end example
-
-@noindent
-specifies (using Bourne shell syntax) that the commands @samp{\def},
-@samp{\newcommand} and @samp{\newenvironment} also define tags.
-
-@item
-In Lisp code, any function defined with @code{defun}, any variable
-defined with @code{defvar} or @code{defconst}, and in general the first
-argument of any expression that starts with @samp{(def} in column zero, is
-a tag.
-
-@item
-In Scheme code, tags include anything defined with @code{def} or with a
-construct whose name starts with @samp{def}. They also include variables
-set with @code{set!} at top level in the file.
-@end itemize
-
- Several other languages are also supported:
-
-@itemize @bullet
-
-@item
-In Ada code, functions, procedures, packages, tasks, and types are
-tags. Use the @samp{--packages-only} option to create tags for packages
-only.
-
-@item
-In assembler code, labels appearing at the beginning of a line,
-followed by a colon, are tags.
-
-@item
-In Bison or Yacc input files, each rule defines as a tag the nonterminal
-it constructs. The portions of the file that contain C code are parsed
-as C code.
-
-@item
-In Cobol code, tags are paragraph names; that is, any word starting in
-column 8 and followed by a period.
-
-@item
-In Erlang code, the tags are the functions, records, and macros defined
-in the file.
-
-@item
-In Fortran code, functions, subroutines and blockdata are tags.
-
-@item
-In Objective C code, tags include Objective C definitions for classes,
-class categories, methods, and protocols.
-
-@item
-In Pascal code, the tags are the functions and procedures defined in
-the file.
-
-@item
-In Perl code, the tags are the procedures defined by the @code{sub},
-@code{my} and @code{local} keywords. Use @samp{--globals} if you want
-to tag global variables.
-
-@item
-In Postscript code, the tags are the functions.
-
-@item
-In Prolog code, a tag name appears at the left margin.
-
-@item
-In Python code, @code{def} or @code{class} at the beginning of a line
-generate a tag.
-@end itemize
-
- You can also generate tags based on regexp matching (@pxref{Using
-Regexps}) to handle other formats and languages.
-
-@node Create Tags Table
-@subsection Creating Tags Tables
-@cindex @code{etags} program
-
- The @code{etags} program is used to create a tags table file. It knows
-the syntax of several languages, as described in
-@iftex
-the previous section.
-@end iftex
-@ifinfo
-@ref{Tag Syntax}.
-@end ifinfo
-Here is how to run @code{etags}:
-
-@example
-etags @var{inputfiles}@dots{}
-@end example
-
-@noindent
-The @code{etags} program reads the specified files, and writes a tags
-table named @file{TAGS} in the current working directory. You can
-intermix compressed and plain text source file names. @code{etags}
-knows about the most common compression formats, and does the right
-thing. So you can compress all your source files and have @code{etags}
-look for compressed versions of its file name arguments, if it does not
-find uncompressed versions. Under MS-DOS, @code{etags} also looks for
-file names like @samp{mycode.cgz} if it is given @samp{mycode.c} on the
-command line and @samp{mycode.c} does not exist.
-
- @code{etags} recognizes the language used in an input file based on
-its file name and contents. You can specify the language with the
-@samp{--language=@var{name}} option, described below.
-
- If the tags table data become outdated due to changes in the files
-described in the table, the way to update the tags table is the same way it
-was made in the first place. It is not necessary to do this often.
-
- If the tags table fails to record a tag, or records it for the wrong
-file, then Emacs cannot possibly find its definition. However, if the
-position recorded in the tags table becomes a little bit wrong (due to
-some editing in the file that the tag definition is in), the only
-consequence is a slight delay in finding the tag. Even if the stored
-position is very wrong, Emacs will still find the tag, but it must
-search the entire file for it.
-
- So you should update a tags table when you define new tags that you want
-to have listed, or when you move tag definitions from one file to another,
-or when changes become substantial. Normally there is no need to update
-the tags table after each edit, or even every day.
-
- One tags table can effectively include another. Specify the included
-tags file name with the @samp{--include=@var{file}} option when creating
-the file that is to include it. The latter file then acts as if it
-contained all the files specified in the included file, as well as the
-files it directly contains.
-
- If you specify the source files with relative file names when you run
-@code{etags}, the tags file will contain file names relative to the
-directory where the tags file was initially written. This way, you can
-move an entire directory tree containing both the tags file and the
-source files, and the tags file will still refer correctly to the source
-files.
-
- If you specify absolute file names as arguments to @code{etags}, then
-the tags file will contain absolute file names. This way, the tags file
-will still refer to the same files even if you move it, as long as the
-source files remain in the same place. Absolute file names start with
-@samp{/}, or with @samp{@var{device}:/} on MS-DOS and MS-Windows.
-
- When you want to make a tags table from a great number of files, you
-may have problems listing them on the command line, because some systems
-have a limit on its length. The simplest way to circumvent this limit
-is to tell @code{etags} to read the file names from its standard input,
-by typing a dash in place of the file names, like this:
-
-@smallexample
-find . -name "*.[chCH]" -print | etags -
-@end smallexample
-
- Use the option @samp{--language=@var{name}} to specify the language
-explicitly. You can intermix these options with file names; each one
-applies to the file names that follow it. Specify
-@samp{--language=auto} to tell @code{etags} to resume guessing the
-language from the file names and file contents. Specify
-@samp{--language=none} to turn off language-specific processing
-entirely; then @code{etags} recognizes tags by regexp matching alone
-(@pxref{Etags Regexps}).
-
- @samp{etags --help} prints the list of the languages @code{etags}
-knows, and the file name rules for guessing the language. It also prints
-a list of all the available @code{etags} options, together with a short
-explanation.
-
-@node Etags Regexps
-@subsection Etags Regexps
-
- The @samp{--regex} option provides a general way of recognizing tags
-based on regexp matching. You can freely intermix it with file names.
-Each @samp{--regex} option adds to the preceding ones, and applies only
-to the following files. The syntax is:
-
-@smallexample
---regex=/@var{tagregexp}[/@var{nameregexp}]/
-@end smallexample
-
-@noindent
-where @var{tagregexp} is used to match the lines to tag. It is always
-anchored, that is, it behaves as if preceded by @samp{^}. If you want
-to account for indentation, just match any initial number of blanks by
-beginning your regular expression with @samp{[ \t]*}. In the regular
-expressions, @samp{\} quotes the next character, and @samp{\t} stands
-for the tab character. Note that @code{etags} does not handle the other
-C escape sequences for special characters.
-
-@cindex interval operator (in regexps)
- The syntax of regular expressions in @code{etags} is the same as in
-Emacs, augmented with the @dfn{interval operator}, which works as in
-@code{grep} and @code{ed}. The syntax of an interval operator is
-@samp{\@{@var{m},@var{n}\@}}, and its meaning is to match the preceding
-expression at least @var{m} times and up to @var{n} times.
-
- You should not match more characters with @var{tagregexp} than that
-needed to recognize what you want to tag. If the match is such that
-more characters than needed are unavoidably matched by @var{tagregexp}
-(as will usually be the case), you should add a @var{nameregexp}, to
-pick out just the tag. This will enable Emacs to find tags more
-accurately and to do completion on tag names more reliably. You can
-find some examples below.
-
- The option @samp{--ignore-case-regex} (or @samp{-c}) is like
-@samp{--regex}, except that the regular expression provided will be
-matched without regard to case, which is appropriate for various
-programming languages.
-
- The @samp{-R} option deletes all the regexps defined with
-@samp{--regex} options. It applies to the file names following it, as
-you can see from the following example:
-
-@smallexample
-etags --regex=/@var{reg1}/ voo.doo --regex=/@var{reg2}/ \
- bar.ber -R --lang=lisp los.er
-@end smallexample
-
-@noindent
-Here @code{etags} chooses the parsing language for @file{voo.doo} and
-@file{bar.ber} according to their contents. @code{etags} also uses
-@var{reg1} to recognize additional tags in @file{voo.doo}, and both
-@var{reg1} and @var{reg2} to recognize additional tags in
-@file{bar.ber}. @code{etags} uses the Lisp tags rules, and no regexp
-matching, to recognize tags in @file{los.er}.
-
- A regular expression can be bound to a given language, by prepending
-it with @samp{@{lang@}}. When you do this, @code{etags} will use the
-regular expression only for files of that language. @samp{etags --help}
-prints the list of languages recognised by @code{etags}. The following
-example tags the @code{DEFVAR} macros in the Emacs source files.
-@code{etags} applies this regular expression to C files only:
-
-@smallexample
---regex='@{c@}/[ \t]*DEFVAR_[A-Z_ \t(]+"\([^"]+\)"/'
-@end smallexample
-
-@noindent
-This feature is particularly useful when storing a list of regular
-expressions in a file. The following option syntax instructs
-@code{etags} to read two files of regular expressions. The regular
-expressions contained in the second file are matched without regard to
-case.
-
-@smallexample
---regex=@@first-file --ignore-case-regex=@@second-file
-@end smallexample
-
-@noindent
-A regex file contains one regular expressions per line. Empty lines,
-and lines beginning with space or tab are ignored. When the first
-character in a line is @samp{@@}, @code{etags} assumes that the rest of
-the line is the name of a file of regular expressions. This means that
-such files can be nested. All the other lines are taken to be regular
-expressions. For example, one can create a file called
-@samp{emacs.tags} with the following contents (the first line in the
-file is a comment):
-
-@smallexample
- -- This is for GNU Emacs source files
-@{c@}/[ \t]*DEFVAR_[A-Z_ \t(]+"\([^"]+\)"/\1/
-@end smallexample
-
-@noindent
-and then use it like this:
-
-@smallexample
-etags --regex=@@emacs.tags *.[ch] */*.[ch]
-@end smallexample
-
- Here are some more examples. The regexps are quoted to protect them
-from shell interpretation.
-
-@itemize @bullet
-
-@item
-Tag Octave files:
-
-@smallexample
-etags --language=none \
- --regex='/[ \t]*function.*=[ \t]*\([^ \t]*\)[ \t]*(/\1/' \
- --regex='/###key \(.*\)/\1/' \
- --regex='/[ \t]*global[ \t].*/' \
- *.m
-@end smallexample
-
-@noindent
-Note that tags are not generated for scripts so that you have to add a
-line by yourself of the form `###key <script-name>' if you want to jump
-to it.