3 files changed, 1450 insertions, 0 deletions

diff --git a/info/dir b/info/dir
index 1215a9398af..73d037ee5cc 100644
--- a/info/dir
+++ b/info/dir
@@ -33,6 +33,7 @@ File: dir	Node: Top	This is the top of the INFO tree
 * Ada mode: (ada-mode). The GNU Emacs mode editing Ada.
 * IDLWAVE: (idlwave).   Major mode and shell for IDL and WAVE/CL files.
 * EUDC: (eudc).         Emacs Unified Directory Client.
+* Ebrowse: (ebrowse)    A C++ class browser for Emacs.
 
 Editors
 * Autotype: (autotype). Convenient features for text that you enter frequently
diff --git a/man/ChangeLog b/man/ChangeLog
index 85314c43557..f2b5ae2b7c8 100644
--- a/man/ChangeLog
+++ b/man/ChangeLog
@@ -1,3 +1,10 @@
+2000-05-11  Gerd Moellmann  <gerd@gnu.org>
+
+        * Makefile.in (INFO_TARGETS): Add info/ebrowse.
+        (../info/ebrowse, ebrowse.dvi): New targets.
+
+        * ebrowse.texi: New file.
+
 2000-05-09  Eli Zaretskii  <eliz@is.elta.co.il>
 
         * programs.texi (Documentation): Document woman.el features.
diff --git a/man/ebrowse.texi b/man/ebrowse.texi
new file mode 100644
index 00000000000..cfafef5c044
--- /dev/null
+++ b/man/ebrowse.texi
@@ -0,0 +1,1442 @@
+\input texinfo   @c -*-texinfo-*-
+
+@comment TODO
+@comment 1. Class *Globals*
+@comment 2. Hinweis auf customize
+
+@comment %**start of header
+@setfilename ../info/ebrowse
+@settitle A Class Browser for C++
+@setchapternewpage odd
+@comment %**end of header
+
+@ifinfo
+@direntry 
+* Ebrowse::   A C++ class browser for Emacs.
+@end direntry
+
+This file documents Ebrowse, a C++ class browser for GNU Emacs.
+
+Copyright @copyright{} 1992--1999, 2000 Free Software Foundation, Inc.
+
+Permission is granted to make and distribute verbatim copies of
+this manual provided the copyright notice and this permission notice
+are preserved on all copies.
+
+@ignore
+Permission is granted to process this file through Tex and print the
+results, provided the printed document carries copying permission
+notice identical to this one except for the removal of this paragraph
+(this paragraph not being relevant to the printed manual).
+
+@end ignore
+Permission is granted to copy and distribute modified versions of this
+manual under the conditions for verbatim copying, provided also that the
+sections entitled ``The GNU Manifesto'', ``Distribution'' and ``GNU
+General Public License'' are included exactly as in the original, and
+provided that the entire resulting derived work is distributed under the
+terms of a permission notice identical to this one.
+
+Permission is granted to copy and distribute translations of this manual
+into another language, under the above conditions for modified versions,
+except that the sections entitled ``The GNU Manifesto'',
+``Distribution'' and ``GNU General Public License'' may be included in a
+translation approved by the Free Software Foundation instead of in the
+original English.
+@end ifinfo
+
+@titlepage
+@sp 10
+@center @titlefont{A C++ Browser for GNU Emacs}
+@vskip 0pt plus 1filll
+Copyright @copyright{} 1992--1999, 2000 Free Software Foundation, Inc.
+
+Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+Permission is granted to copy and distribute modified versions of this
+manual under the conditions for verbatim copying, provided also that the
+sections entitled ``Distribution'' and ``General Public License'' are
+included exactly as in the original, and provided that the entire
+resulting derived work is distributed under the terms of a permission
+notice identical to this one.
+
+Permission is granted to copy and distribute translations of this manual
+into another language, under the above conditions for modified versions,
+except that the sections entitled ``Distribution'' and ``General Public
+License'' may be included in a translation approved by the author
+instead of in the original English.
+@end titlepage
+
+
+
+@node Top, Overview, (dir), (dir)
+
+You can browse C++ class hierarchies from within Emacs by using
+Ebrowse.
+
+@menu
+* Overview::                    What is it and now does it work?
+* Generating browser files::    How to process C++ source files
+* Loading a Tree::              How to start browsing
+* Tree Buffers::                Traversing class hierarchies
+* Member Buffers::              Looking at member information
+* Tags-like Functions::         Finding members from source files
+* Concept Index::               An entry for each concept defined
+@end menu
+
+
+
+
+@node Overview, Generating browser files, Top, Top
+@chapter Introduction
+@cindex tree buffer
+@cindex member buffer
+@cindex major modes
+@cindex parser
+@cindex @samp{*Globals*}
+
+When working in software projects using C++, I frequently missed
+software support for two things:
+
+@itemize @bullet
+@item
+When you get a new class library, or you have to work on source code you
+haven't written yourself (or written sufficiently long ago), you need a
+tool letting you navigate through class hierarchies and investigate
+features of the software.  Without such a tool you often end up grep'ing
+through dozens or even hundreds of files.
+
+@item
+Once you are productive, it would be nice to have a tool that knows your
+sources and can help you while you are editing source code.  Imagine to
+be able to jump to the definition of an identifier while you are
+editing, or something that can complete long identifier names because it
+knows what identifiers are defined in your program@dots{}.
+@end itemize
+
+The design of Ebrowse reflects these two needs.
+
+How does it work? 
+
+A fast parser written in C is used to process C++ source files.
+The parser generates a data base containing information about classes,
+members, global functions, defines, types etc. found in the sources.
+
+The second part of Ebrowse is a Lisp program.  This program reads
+the data base generated by the parser.  It displays its contents in
+various forms and allows you to perform operations on it, or do
+something with the help of the knowledge contained in the data base.
+
+@dfn{Navigational} use of Ebrowse is centered around two
+types of buffers which define their own major modes:
+
+@dfn{Tree buffers} are used to view class hierarchies in tree form.
+They allow you to quickly find classes, find or view class declarations,
+perform operations like query replace on sets of your source files, and
+finally tree buffers are used to produce the second buffer form---member
+buffers.
+
+Members are displayed in @dfn{member buffers}.  Ebrowse
+distinguishes between six different types of members; each type is
+displayed as a member list of its own:
+
+@itemize @bullet
+@item
+Instance member variables,
+
+@item
+Instance member functions,
+
+@item
+Static member variables,
+
+@item
+Static member functions,
+
+@item
+Friends/Defines,  The list of defines is contained in the friends
+list of the pseudo-class @samp{*Globals*}.
+
+@item
+Types (@code{enum}s, and @code{typedef}s defined with class
+scope).@refill
+@end itemize
+
+You can switch member buffers from one list to another, or to another
+class.  You can include inherited members in the display, you can set
+filters that remove categories of members from the display, and most
+importantly you can find or view member declarations and definitions
+with a keystroke.
+
+These two buffer types and the commands they provide support the
+navigational use of the browser.  The second form resembles Emacs' Tags
+package for C and other procedural languages.  Ebrowse's commands of
+this type are not confined to special buffers; they are most often used
+while you are editing your source code.
+
+To list just a subset of what you can use the Tags part of Ebrowse for:
+
+@itemize @bullet
+@item
+Jump to the definition or declaration of an identifier in your source
+code, with an electric position stack that let's you easily navigate
+back and forth.
+
+@item
+Complete identifiers in your source with a completion list containing
+identifiers from your source code only.
+
+@item
+Perform search and query replace operations over some or all of your
+source files.
+
+@item
+Show all identifiers matching a regular expression---and jump to one of
+them, if you like.
+@end itemize
+
+
+
+
+@node Generating browser files, Loading a Tree, Overview, Top
+@comment node-name,  next,  previous,  up
+@chapter Processing Source Files
+@cindex command line
+@cindex options
+@cindex switches
+@cindex parser switches
+
+Before you can start browsing a class hierarchy, you must run the parser
+@file{ebrowse} on your source files in order to generate a Lisp data
+base describing your program.
+
+The operation of @file{ebrowse} can be tailored with command line
+options.  Under normal circumstances it suffices to let the parser use
+its default settings.  If you want to do that, call it with a command
+line like:
+
+@example
+ebrowse *.h *.cc
+@end example
+
+@noindent
+or, if your shell doesn't allow all file names to be specified on
+the command line,
+
+@example
+ebrowse --files=@var{file}
+@end example
+
+@noindent
+where @var{file} contains the names of the files to be parsed, one
+per line.
+
+When invoked with option @samp{--help}, @file{ebrowse} prints a list of
+available command line options.@refill
+
+@menu
+* Input files::         Specifying which files to parse
+* Output file::         Changing the output file name
+* Structs and unions::  Omitting @code{struct}s and @code{union}s
+* Matching::            Setting regular expression lengths
+* Verbosity::           Getting feedback for lengthy operations
+@end menu
+
+
+
+
+@comment name,     next,        prev,                     up
+@node Input files, Output file, Generating browser files, Generating browser files
+@section Specifying Input Files
+@cindex input files
+@cindex response files
+@cindex @samp{--files}
+@cindex @samp{--search-path}
+@cindex standard input
+@cindex header files
+@cindex friend functions
+
+@table @samp
+@item file
+Each file name on the command line tells @file{ebrowse} to parse
+that file.
+
+@item --files=@var{file}
+This command line switch specifies that @var{file} contains a list of
+file names to parse.  Each line in @var{file} must contain one file
+name.  More than one option of this kind is allowed.  You might, for
+instance, want to use one file for header files, and another for source
+files.
+
+@item standard input
+When @file{ebrowse} finds no file names on the command line, and no
+@samp{--file} option is specified, it reads file names from standard
+input.  This is sometimes convenient when @file{ebrowse} is used as part
+of a command pipe.
+
+@item --search-path=@var{paths}
+This option let's you specify search paths for your input files.
+@var{paths} is a list of directory names, separated from each other by a
+either a colon or a semicolon, depending on the operating system.
+@end table
+
+It is generally a good idea to specify input files so that header files
+are parsed before source files.  This facilitates the parser's work of
+properly identifying friend functions of a class.
+
+
+
+@comment name,     next,               prev,        up
+@node Output file, Structs and unions, Input files, Generating browser files
+@section Changing the Output File Name
+@cindex output file name
+@cindex @samp{BROWSE}
+@cindex appending output
+@cindex @samp{--output-file}
+@cindex @samp{--append}
+
+@table @samp
+@item --output-file=@var{file}
+This option instructs @file{ebrowse} to generate a Lisp data base with
+name @var{file}.  By default, the data base is named @file{BROWSE}, and
+is written in the directory in which @file{ebrowse} is invoked.
+
+If you regularly use data base names different from the default, you
+might want to add this to your init file
+
+@lisp
+(add-to-list 'auto-mode-alist '(@var{NAME} . ebrowse-tree-mode))
+@end lisp
+
+@noindent 
+where @var{NAME} is the Lisp data base name you are using.
+
+@item --append
+By default, each run of @file{ebrowse} erases the old contents of the
+output file when writing to it.  You can instruct @file{ebrowse} to
+append its output to an existing file with this command line option.
+@end table
+
+
+
+
+@comment name,            next,     prev,        up
+@node Structs and unions, Matching, Output file, Generating browser files
+@section Structs and Unions
+@cindex structs
+@cindex unions
+@cindex @samp{--no-structs-or-unions}
+
+@table @samp
+@item --no-structs-or-unions
+This switch suppresses all classes in the data base declared as
+@code{struct} or @code{union} in the output.
+
+This is mainly thought for the case that you are converting an existing
+C program to C++, and do not want to see the old C structs in a class
+tree.
+@end table
+
+
+
+
+@comment name,  next,      prev,               up
+@node Matching, Verbosity, Structs and unions, Generating browser files
+@section Regular Expressions
+@cindex regular expressions
+@cindex minimum regexp length
+@cindex maximum regexp length
+@cindex @samp{--min-regexp-length}
+@cindex @samp{--max-regexp-length}
+@cindex @samp{--no-regexps}
+
+The parser @file{ebrowse} normally writes strings to its output file
+that help the Lisp part of Ebrowse to find functions, variables etc. in
+their source files.
+
+You can instruct @file{ebrowse} to omit these strings by calling it
+with the command line switch @samp{--no-regexps}.
+
+When you do this, the Lisp part of Ebrowse tries to guess, from member
+or class names, suitable regular expressions to locate that class or
+member in source files.  This works fine in most cases, but the
+automatic generation of regular expressions can be too weak if unusual
+coding styles are used.
+
+@table @samp
+@item --no-regexps
+This option turns regular expression recording off.
+
+@item --min-regexp-length=@var{n}
+The number @var{n} following this option specifies the minimum length of
+the regular expressions recorded to match class and member declarations
+and definitions.  The default value is set at compilation time of
+@file{ebrowse}.
+
+The smaller the minimum length the higher the probability that
+Ebrowse will find a wrong match.  The larger the value, the
+larger the output file and therefore the memory consumption once the
+file is read from Emacs.
+
+@item --max-regexp-length=@var{n}
+The number following this option specifies the maximum length of the
+regular expressions used to match class and member declarations and
+definitions.  The default value is set at compilation time of
+@file{ebrowse}.
+
+The larger the maximum length the higher the probability that the
+browser will find a correct match, but the larger the value the larger
+the output file and therefore the memory consumption once the data is
+read.  As a second effect, the larger the regular expression the higher
+the probability that it will no longer match after editing the file.
+@end table
+
+
+
+
+@node Verbosity, , Matching, Generating browser files
+@comment  node-name,  next,  previous,  up
+@section Verbose Mode
+@cindex verbose
+@cindex @samp{--verbose}
+@cindex @samp{--very-verbose}
+
+@table @samp
+@item --verbose
+When this option is specified on the command line, @file{ebrowse} prints
+a period for each file parsed, and it displays a @samp{+} for each
+class written to the output file.
+
+@item --very-verbose
+This option makes @file{ebrowse} print out the names of the files and
+the names of the classes seen.
+@end table
+
+
+
+
+@node Loading a Tree, Tree Buffers, Generating browser files, Top
+@comment  node-name,  next,  previous,  up
+@chapter Starting to Browse
+@cindex loading
+@cindex browsing
+
+You start browsing a class hierarchy parsed by @file{ebrowse} by just
+finding the @file{BROWSE} file with @kbd{C-x C-f}.
+
+An example of a tree buffer display is shown below.
+
+@example
+|  Collection
+|    IndexedCollection
+|      Array
+|        FixedArray
+|    Set
+|    Dictionary
+@end example
+
+When you run Emacs under X, you will notice that that certain areas in
+the tree buffer are highlighted when you move the mouse over them.  This
+highlight marks mouse-sensitive regions in the buffer.  Please notice
+the help strings in the echo area when the mouse moves over a sensitive
+region.
+
+A click with @kbd{mouse-3} on a mouse-sensitive region opens a context
+menu.  In addition to this, each buffer also has a buffer-specific menu
+that is opened with a click with @kbd{mouse-3} somewhere in the buffer
+where no highlight is displayed.
+
+
+
+@comment ****************************************************************
+@comment ***
+@comment ***                 TREE BUFFERS
+@comment ***
+@comment ****************************************************************
+
+@node Tree Buffers, Member Buffers, Loading a Tree, Top
+@comment  node-name,  next,  previous,  up
+@chapter Tree Buffers
+@cindex tree buffers
+@cindex tree
+@cindex tree buffer mode
+@cindex class trees
+
+Class trees are displayed in @dfn{tree buffers} which install their own
+major mode.  Most Emacs keys work in tree buffers in the usual way,
+e.g., you can move around in the buffer with the usual @kbd{C-f},
+@kbd{C-v} etc., or you can search with @kbd{C-s}.
+
+Tree-specific commands are bound to simple keystrokes, similar to
+@code{Gnus}.  You can take a look at the key bindings by entering
+@kbd{?} which calls @code{M-x describe-mode} in both tree and member
+buffers.
+
+@menu
+* Source Display::              Viewing and finding a class declaration
+* Member Display::              Showing members, switching to member buffers
+* Go to Class::                 Finding a class
+* Quitting::                    Discarding and burying the tree buffer
+* File Name Display::           Showing file names in the tree
+* Expanding and Collapsing::    Expanding and collapsing branches
+* Tree Indentation::            Changing the tree indentation
+* Killing Classes::             Removing class from the tree
+* Saving a Tree::               Saving a modified tree
+* Statistics::                  Displaying class tree statistics
+* Marking Classes::             Marking and unmarking classes
+@end menu
+
+
+
+@node Source Display, Member Display, Tree Buffers, Tree Buffers
+@comment  node-name,  next,  previous,  up
+@section Viewing and Finding Class Declarations
+@cindex viewing, class
+@cindex finding, class
+@cindex class declaration
+
+You can view or find a class declaration when the cursor is on a class
+name.
+
+@table @kbd
+@item SPC
+This command views the class declaration if the database
+contains informations about it.  If you don't parse the entire source
+you are working on, some classes will only be known to exist but the
+location of their declarations and definitions will not be known.@refill
+
+@item RET
+Works like @kbd{SPC}, except that it finds the class
+declaration rather than viewing it, so that it is ready for
+editing.@refill
+@end table
+
+The same functionality is available from the menu opened with
+@kbd{mouse-3} on the class name.
+
+
+
+
+@node Member Display, Go to Class, Source Display, Tree Buffers
+@comment  node-name,  next,  previous,  up
+@section Displaying Members
+@cindex @samp{*Members*}
+@cindex @samp{*Globals*}
+@cindex freezing
+@cindex member lists
+
+Ebrowse distinguishes six different kinds of members, each of
+which is displayed as a separate @dfn{member list}: instance variables,
+instance functions, static variables, static functions, friend
+functions, and types.
+
+Each of these lists can be displayed in a member buffer with a command
+starting with @kbd{L} when the cursor is on a class name.  By default,
+there is only one member buffer named @dfn{*Members*} that is reused
+each time you display a member list---this has proven to be more
+practical than to clutter up the buffer list with dozens of member
+buffers.
+
+If you want to display more than one member list at a time you can
+@dfn{freeze} its member buffer. Freezing a member buffer prevents it
+from being overwritten the next time you display a member list. You can
+toggle this buffer status at any time.
+
+Every member list display command in the tree buffer can be used with a
+prefix argument (@kbd{C-u}).  Without a prefix argument, the command will
+pop to a member buffer displaying the member list.  With prefix argument,
+the member buffer will additionally be @dfn{frozen}.
+
+@table @kbd
+@item L v
+This command displays the list of instance member variables.
+
+@item L V
+Display the list of static variables.
+
+@item L d
+Display the list of friend functions.  This list is used for defines if
+you are viewing the class @samp{*Globals*} which is a place holder for
+global symbols.
+
+@item L f
+Display the list of member functions.
+
+@item L F
+Display the list of static member functions.
+
+@item L t
+Display a list of types.
+@end table
+
+These lists are also available from the class' context menu invoked with
+@kbd{mouse-3} on the class name.
+
+
+
+
+@node Go to Class, Quitting, Member Display, Tree Buffers
+@comment  node-name,  next,  previous,  up
+@section Finding a Class
+@cindex locate class
+@cindex expanding branches
+
+@table @kbd
+@item /
+This command reads a class name from the minibuffer with completion and
+positions the cursor on the class in the class tree.
+
+If the branch of the class tree containing the class searched for is
+currently collapsed, the class itself and all its base classes are
+recursively made visible.  (See also @xref{Expanding and
+Collapsing}.)@refill
+
+This function is also available from the tree buffer's context menu.
+
+@item n
+Repeat the last search done with @kbd{/}.  Each tree buffer has its own
+local copy of the regular expression last searched in it.
+@end table
+
+
+
+
+@node Quitting, File Name Display, Go to Class, Tree Buffers
+@comment  node-name,  next,  previous,  up
+@section Burying a Tree Buffer
+@cindex burying buffer, tree
+
+@table @kbd
+@item q
+Is a synonym for @kbd{M-x bury-buffer}.
+@end table
+
+
+
+
+@node File Name Display, Expanding and Collapsing, Quitting, Tree Buffers
+@comment  node-name,  next,  previous,  up
+@section Displaying File Names
+@cindex file name display
+
+@table @kbd
+@item T f
+This command toggles the display of file names in a tree buffer.  If
+file name display is switched on, the names of the files containing the
+class declaration are shown to the right of the class names.  If the
+file is not known, the string @samp{unknown} is displayed.
+
+This command is also provided in the tree buffer's context menu.
+
+@item s
+Display file names for the current line, or for the number of lines
+given by a prefix argument. 
+@end table
+
+Here is an example of a tree buffer with file names displayed.
+
+@example
+|  Collection           (unknown)
+|    IndexedCollection  (indexedcltn.h)
+|      Array            (array.h)
+|        FixedArray     (fixedarray.h)
+|    Set                (set.h)
+|    Dictionary         (dict.h)
+@end example
+
+
+
+
+@node Expanding and Collapsing, Tree Indentation, File Name Display, Tree Buffers
+@comment  node-name,  next,  previous,  up
+@section Expanding and Collapsing a Tree
+@cindex expand
+@cindex collapse
+@cindex branches
+
+You can expand and collapse parts of a tree to reduce the complexity of
+large class hierarchies.  Expanding or collapsing branches of a tree has
+no impact on the functionality of other commands, like @kbd{/}.  (See
+also @xref{Go to Class}.)@refill
+
+Collapsed branches are indicated with an ellipsis following the class
+name like in the example below.
+
+@example
+|  Collection
+|    IndexedCollection...
+|    Set
+|    Dictionary
+@end example
+
+@table @kbd
+@item -
+This command collapses the branch of the tree starting at the class the
+cursor is on. 
+
+@item +
+This command expands the branch of the tree starting at the class the
+cursor is on. Both commands for collapsing and expanding branches are
+also available from the class' object menu.
+
+@item *
+This command expands all collapsed branches in the tree.
+@end table
+
+
+
+
+@node Tree Indentation, Killing Classes, Expanding and Collapsing, Tree Buffers
+@comment  node-name,  next,  previous,  up
+@section Changing the Tree Indentation
+@cindex tree indentation
+@cindex indentation
+
+@table @kbd
+@item T w
+This command reads a new indentation width from the minibuffer and
+redisplays the tree buffer with the new indentation. It is also
+available from the tree buffer's context menu.
+@end table
+
+
+
+
+@node Killing Classes, Saving a Tree, Tree Indentation, Tree Buffers
+@comment  node-name,  next,  previous,  up
+@section Removing Classes from the Tree
+@cindex killing classes
+
+@table @kbd
+@item C-k
+This command removes the class the cursor is on and all its derived
+classes from the tree.  The user is asked for confirmation before the
+deletion is actually performed.
+@end table
+
+
+
+
+@node Saving a Tree, Statistics, Killing Classes, Tree Buffers
+@comment  node-name,  next,  previous,  up
+@comment node-name, next, previous, up
+@section Saving a Tree
+@cindex saving tree
+
+@table @kbd
+@item C-x C-s
+This command writes a class tree to the file it was read from.  This is
+useful after classes have been deleted from a tree.
+
+@item  C-x C-w
+Writes the tree to a file whose name is read from the minibuffer.
+@end table
+
+
+
+
+@node     Statistics, Marking Classes, Saving a Tree, Tree Buffers
+@comment  node-name,  next,        previous, up
+@cindex statistics
+
+@table @kbd
+@item x
+Display statistics for the tree, like number of classes in it, number of
+member functions, etc.  This command can also be found in the buffer's
+context menu.
+@end table
+
+
+
+
+@node     Marking Classes, , Statistics, Tree Buffers
+@comment  node-name,       next,       previous,      up
+@cindex marking classes
+
+Classes can be marked for operations similar to the standard Emacs
+commands @kbd{M-x tags-search} and @kbd{M-x tags-query-replace} (see
+also @xref{Tags-like Functions}.)@refill
+
+@table @kbd
+@item M t
+Toggle the mark of the line point is in or for as many lines as given by
+a prefix command.  This command can also be found in the class' context
+menu. 
+
+@item M a
+Unmark all classes.  With prefix argument @kbd{C-u}, mark all classes in
+the tree. Since this command operates on the whole buffer, it can also be
+found in the buffer's object menu.
+@end table
+
+Marked classes are displayed with an @code{>} in column one of the tree
+display, like in the following example
+
+@example
+|> Collection
+|    IndexedCollection...
+|>   Set
+|    Dictionary
+@end example
+
+
+
+
+@c ****************************************************************
+@c ***
+@c ***                 MEMBER BUFFERS
+@c ***
+@c ****************************************************************
+
+@node Member Buffers, Tags-like Functions, Tree Buffers, Top
+@comment  node-name,       next,       previous,      up
+@chapter Member Buffers
+@cindex member buffer
+@cindex members
+@cindex member buffer mode
+
+@dfn{Member buffers} are used to operate on lists of members of a class.
+Ebrowse distinguishes six kinds of lists:
+
+@itemize @bullet
+@item
+Instance variables (normal member variables),
+@item
+Instance functions (normal member functions),
+@item
+Static variables,
+@item
+Static member functions,
+@item
+Friend functions,
+@item
+Types (@code{enum}s and @code{typedef}s defined with class scope.
+Nested classes will be shown in the class tree like normal classes.
+@end itemize
+
+Like tree buffers, member buffers install their own major mode.  Also
+like in tree buffers, menus are provided for certain areas in the
+buffer: members, classes, and the buffer itself.
+
+@menu
+* Switching Member Lists::      Choosing which members to display
+* Finding/Viewing::             Modifying source code
+* Inherited Members::           Display of Inherited Members
+* Searching Members::           Finding members in member buffer
+* Switching to Tree::           Going back to the tree buffer
+* Filters::                     Selective member display
+* Attributes::                  Display of @code{virtual} etc.
+* Long and Short Display::      Comprehensive and verbose display
+* Regexp Display::              Showing matching regular expressions
+* Switching Classes::           Displaying another class
+* Killing/Burying::             Getting rid of the member buffer
+* Column Width::                Display style
+* Redisplay::                   Redrawing the member list
+* Getting Help::                How to get help for key bindings
+@end menu
+
+
+
+
+@node Switching Member Lists, Finding/Viewing, Member Buffers, Member Buffers
+@comment  node-name,       next,       previous,      up
+@section Switching Member Lists
+@cindex member lists
+@cindex static members
+@cindex friends
+@cindex types
+@cindex defines
+
+@table @kbd
+@item L n
+This command switches the member buffer display to the next member list.
+
+@item L p
+This command switches the member buffer display to the previous member
+list.
+
+@item L f
+Switch to the list of member functions.
+
+@item L F
+Switch to the list of static member functions.
+
+@item L v
+Switch to the list of member variables.
+
+@item L V
+Switch to the list of static member variables.
+
+@item L d
+Switch to the list of friends or defines.
+
+@item L t
+Switch to the list of types.x
+@end table
+
+Both commands cycle through the member list.
+
+Most of the commands are also available from the member buffer's 
+context menu.
+
+
+
+
+@node Finding/Viewing, Inherited Members, Switching Member Lists, Member Buffers
+@comment  node-name,       next,       previous,      up
+@section Finding and Viewing Member Source
+@cindex finding members
+@cindex viewing members
+@cindex member definitions
+@cindex member declarations
+@cindex definitions
+@cindex declarations
+
+@table @kbd
+@item RET
+This command finds the definition of the member the cursor is on.
+Finding involves roughly the same as the standard Emacs tags facility
+does---loading the file and searching for a regular expression matching
+the member.
+
+@item f
+This command finds the declaration of the member the cursor is on.
+
+@item SPC
+This is the same command as @kbd{RET}, but views the member definition
+instead of finding the member's source file.
+
+@item v
+This is the same command as @kbd{f}, but views the member's declaration
+instead of finding the file the declaration is in.
+@end table
+
+You can install a hook function to perform actions after a member or
+class declaration or definition has been found, or when it is not found.
+
+All the commands described above can also be found in the context menu
+displayed when clicking @kbd{mouse-2} on a member name.
+
+
+
+
+@node Inherited Members, Searching Members, Finding/Viewing, Member Buffers
+@comment  node-name,       next,       previous,      up
+@section Display of Inherited Members
+@cindex superclasses
+@cindex base classes
+@cindex inherited members
+
+@table @kbd
+@item D b
+This command toggles the display of inherited members in the member
+buffer. This is also in the buffer's context menu.
+@end table
+
+
+
+
+@node Searching Members, Switching to Tree, Inherited Members, Member Buffers
+@comment  node-name,       next,       previous,      up
+@section Searching Members
+@cindex searching members
+
+@table @kbd
+@item G v
+Position the cursor on a member whose name is read from the minibuffer;
+only members shown in the current member buffer appear in the completion
+list.
+
+@item G m
+Like the above command, but all members for the current class appear in
+the completion list. If necessary, the current member list is switched
+to the one containing the member.
+
+With a prefix argument (@kbd{C-u}), all members in the class tree,
+i.e., all members the browser knows about appear in the completion
+list. The member display will be switched to the class and member list
+containing the member.
+
+@item G n
+Repeat the last member search.
+@end table
+
+Look into the buffer's context menu for a convenient way to do this with
+a mouse.
+
+
+
+@node Switching to Tree, Filters, Searching Members, Member Buffers
+@comment  node-name,       next,       previous,      up
+@section Switching to Tree Buffer
+@cindex tree buffer
+@cindex buffer switching
+@cindex switching buffers
+
+@table @kbd
+@item TAB
+Pop up the tree buffer to which the member buffer belongs.
+
+@item t
+Do the same as @kbd{TAB} but also position the cursor on the class
+displayed in the member buffer.
+@end table
+
+
+
+
+@node Filters, Attributes, Switching to Tree, Member Buffers
+@comment  node-name,       next,       previous,      up
+@section Filters
+@cindex filters
+@cindex @code{public}
+@cindex @code{protected}
+@cindex @code{private}
+@cindex @code{virtual}
+@cindex @code{inline}
+@cindex @code{const}
+@cindex pure virtual members
+
+@table @kbd
+@item F a u 
+This command toggles the display of @code{public} members.  The
+@samp{a} stands for `access'.
+
+@item F a o
+This command toggles the display of @code{protected} members.
+
+@item F a i
+This command toggles the display of @code{private} members.
+
+@item F v
+This command toggles the display of @code{virtual} members.
+
+@item F i
+This command toggles the display of @code{inline} members.
+
+@item F c
+This command toggles the display of @code{const} members.
+
+@item F p
+This command toggles the display of pure virtual members.
+
+@item F r
+This command removes all filters.
+@end table
+
+These commands are also found in the buffer's context menu.
+
+
+
+
+@node Attributes, Long and Short Display, Filters, Member Buffers
+@comment  node-name,       next,       previous,      up
+@section Displaying Member Attributes
+@cindex attributes
+@cindex member attributes
+@cindex @code{virtual}
+@cindex @code{extern "C"}
+@cindex @code{mutable}
+@cindex @code{explicit}
+@cindex @code{template}
+@cindex @code{inline}
+@cindex @code{const}
+@cindex pure virtual
+
+@table @kbd
+@item D a
+Toggle the display of member attributes (default is on).
+
+The nine member attributes Ebrowse knows about are are displayed
+as a list a single-characters flags enclosed in angle brackets in front
+the of the member's name.  A @samp{-} at a given position means that
+the attribute is false.  The list of attributes from left to right is
+
+@table @samp
+@item T
+The member is a template.
+
+@item C
+The member is declared @code{extern "C"}.
+
+@item v
+Means the member is declared @code{virtual}.
+
+@item i
+The member is declared @code{inline}.
+
+@item c
+The member is @code{const}.
+
+@item 0
+The member is a pure virtual function.
+
+@item m
+The member is declared @code{mutable}.
+
+@item e
+The member is declared @code{explicit}.
+
+@item t
+The member is a function with a throw list.
+@end table
+@end table
+
+This command is also in the buffer's context menu.
+
+
+
+@node Long and Short Display, Regexp Display, Attributes, Member Buffers
+@comment  node-name,       next,       previous,      up
+@section Long and Short Member Display
+@cindex display form
+@cindex long display
+@cindex short display
+@cindex @samp{--no-regexps}
+
+@table @kbd
+@item D l
+This command toggles the member buffer between short and long display
+form.  The short display form displays member names, only:
+
+@example
+| isEmpty        contains       hasMember      create
+| storeSize      hash           isEqual        restoreGuts
+| saveGuts
+@end example
+
+The long display shows one member per line with member name and regular
+expressions matching the member (if known):
+
+@example
+| isEmpty               Bool isEmpty () const...
+| hash                  unsigned hash () const...
+| isEqual               int isEqual (...
+@end example
+
+Regular expressions will only be displayed when the Lisp database has
+not been produced with the @file{ebrowse} option @samp{--no-regexps}.
+@end table
+
+
+
+
+@node Regexp Display, Switching Classes, Long and Short Display, Member Buffers
+@comment  node-name,       next,       previous,      up
+@section Display of Regular Expressions
+@cindex regular expression display
+
+@table @kbd
+@item D r
+This command toggles the long display form from displaying the regular
+expressions matching the member declarations to those expressions
+matching member definitions.
+@end table
+
+Regular expressions will only be displayed when the Lisp database has
+not been produced with the @file{ebrowse} option @samp{--no-regexps}.
+
+
+
+
+@node Switching Classes, Killing/Burying, Regexp Display, Member Buffers
+@comment  node-name,       next,       previous,      up
+@section Displaying Another Class
+@cindex base classes
+@cindex derived classes
+@cindex superclasses
+@cindex subclasses
+@cindex class display
+
+@table @kbd
+@item C c
+This command lets you switch the member buffer to another class.  It
+reads the name of the new class from the minibuffer with completion.
+
+@item C b
+This is the same command as @kbd{C c} but restricts the classes shown in
+the completion list to immediate base classes, only.  If only one base
+class exists, this one is immediately shown in the minibuffer.
+
+@item C d
+Same as @kbd{C b}, but for derived classes.
+
+@item C p
+Switch to the previous class in the class hierarchy on the same level as
+the class currently displayed.
+
+@item C n
+Switch to the next sibling of the class in the class tree.
+@end table
+
+
+
+
+@node Killing/Burying, Column Width, Switching Classes, Member Buffers
+@comment  node-name,       next,       previous,      up
+@section Burying a Member Buffer
+@cindex burying member buffers
+
+@table @kbd
+@item q
+This command is a synonym for @kbd{M-x bury-buffer}.
+@end table
+
+
+
+
+@node Column Width, Redisplay, Killing/Burying, Member Buffers
+@comment  node-name,       next,       previous,      up
+@section Setting the Column Width
+@cindex column width
+@cindex member indentation
+@cindex indentation, member
+
+@table @kbd
+@item D w
+This command sets the column width depending on the display form used
+(long or short display).
+@end table
+
+
+
+
+@node Redisplay, Getting Help, Column Width, Member Buffers
+@comment  node-name,       next,       previous,      up
+@section Forced Redisplay
+@cindex redisplay
+
+@table @kbd
+@item C-l
+This command forces a redisplay of the member buffer.  If the width
+of the window displaying the member buffer is changed this command
+redraws the member list with the appropriate column widths and number of
+columns. 
+@end table
+
+
+
+
+@node Getting Help, , Redisplay, Member Buffers
+@comment  node-name,  next,  previous,  up
+@cindex help
+
+@table @kbd
+@item ?
+This key is bound to @code{describe-mode}.
+@end table
+
+
+
+
+@comment **************************************************************
+@comment ***                TAGS LIKE FUNCTIONS
+@comment **************************************************************
+
+@node Tags-like Functions, Concept Index, Member Buffers, Top
+@comment  node-name,       next,       previous,      up
+@chapter Tags-like Functions
+
+Ebrowse provides tags functions similar to those of the standard
+Emacs Tags facility, but better suited to the needs of C++ programmers.
+
+@menu
+* Finding and Viewing:: Going to a member declaration/definition
+* Position Stack::      Moving to previous locations
+* Search & Replace::    Searching and replacing over class tree files
+* Members in Files::    Listing all members in a given file
+* Apropos::             Listing members matching a regular expression
+* Symbol Completion::   Completing names while editing
+* Member Buffer Display:: Quickly display a member buffer for some
+                        identifier
+@end menu
+
+
+
+@node Finding and Viewing, Position Stack, Tags-like Functions, Tags-like Functions
+@comment  node-name,       next,       previous,      up
+@section Finding and Viewing Members
+@cindex finding member
+@cindex viewing member
+@cindex tags
+@cindex member definition
+@cindex member declaration
+
+@table @kbd
+@item C-c b f
+Find the definition of the member around point.  If you invoke this
+function with a prefix argument, the declaration is searched.
+
+If more than one class contains a member with the given name you can
+select the class with completion.  If there is a scope declaration in
+front of the member name, this class name is used as initial input for
+the completion.
+
+@item C-c b F
+Fin the declaration of the member around point.
+
+@item C-c b v
+View the definition of the member around point.
+
+@item C-c b V
+View the declaration of the member around point.
+
+@item C-c b 4 f
+Find a member's definition in another window.
+
+@item C-c b 4 F
+Find a member's declaration in another window.
+
+@item C-c b 4 v
+View a member's definition in another window.
+
+@item C-c b 4 V
+View a member's declaration in another window.
+
+@item C-c b 5 f
+Find a member's definition in another frame.
+
+@item C-c b 5 F
+Find a member's declaration in another frame.
+
+@item C-c b 5 v
+View a member's definition in another frame.
+
+@item C-c b 5 V
+View a member's declaration in another frame.
+@end table
+
+
+
+@node Position Stack, Search & Replace, Finding and Viewing, Tags-like Functions
+@comment  node-name,       next,       previous,      up
+@section The Position Stack
+@cindex position stack
+
+When jumping to a member declaration or definition with one of
+Ebrowse's commands, the position from where you performed the
+jump and the position where you jumped to are recorded in a
+@dfn{position stack}.  There are several ways in which you can quickly
+move to positions in the stack:@refill
+
+@table @kbd
+@item C-c b -
+This command sets point to the previous position in the position stack.
+Directly after you performed a jump, this will put you back to the
+position where you came from.
+
+The stack is not popped, i.e., you can always switch back and forth
+between positions in the stack.  To avoid letting the stack grow to
+infinite size there is a maximum number of positions defined.  When this
+number is reached, older positions are discarded when new positions are
+pushed on the stack.
+
+@item C-c b +
+This command moves forward in the position stack, setting point to
+the next position stored in the position stack.
+
+@item C-c b p
+Displays an electric buffer showing all positions saved in the stack. 
+You can select a position by pressing @kbd{SPC} in a line. You can
+view a position with @kbd{v}.
+@end table
+
+
+
+
+@node     Search & Replace, Members in Files, Position Stack, Tags-like Functions
+@comment  node-name,       next,       previous,      up
+@section Searching and Replacing
+@cindex searching
+@cindex replacing
+@cindex restart tags-operation
+
+Ebrowse allows you to perform operations on all or a subset of the files
+mentioned in a class tree.  When you invoke one of the following
+functions and more than one class tree is loaded, you must choose a
+class tree to use from an electric tree menu.  If the selected tree
+contains marked classes, the following commands operate on the files
+mentioned in the marked classes only.  Otherwise all files in the class
+tree are used.
+
+@table @kbd
+@item C-c b s
+This function performs a regular expression search in the chosen set of
+files.
+
+@item C-c b u
+This command performs a search for calls of a given member which is
+selected in the usual way with completion.
+
+@item C-c b %
+Perform a query replace over the set of files.
+
+@item C-c b ,
+All three operations above stop when finding a match. You can restart
+the operation with this command.
+
+@item C-c b n
+This restarts the last tags operation with the next file in the list. 
+@end table
+
+
+
+
+@node Members in Files, Apropos, Search & Replace, Tags-like Functions
+@comment  node-name,       next,       previous,      up
+@section Members in Files
+@cindex files
+@cindex members in file
+@cindex file, members
+
+The command @kbd{C-c b l}, lists all members in a given file.  The file
+name is read from the minibuffer with completion.
+
+
+
+
+@node Apropos, Symbol Completion, Members in Files, Tags-like Functions
+@comment  node-name,       next,       previous,      up
+@section Member Apropos 
+@cindex apropos
+@cindex members, matching regexp
+
+The command @kbd{C-c b a} can be used to display all members matching a
+given regular expression.  This command can be very useful if you
+remember only part of a member name, and not its beginning.
+
+A special buffer is popped up containing all identifiers matching the
+regular expression, and what kind of symbol it is (e.g., a member
+function, or a type).  You can then switch to this buffer, and use the
+command @kbd{C-c b f}, for example, to jump to a specific member.
+
+
+
+
+@node Symbol Completion, Member Buffer Display, Apropos, Tags-like Functions
+@comment  node-name,       next,       previous,      up
+@section Symbol Completion
+@cindex completion
+@cindex symbol completion
+
+The command @kbd{C-c b TAB} completes the symbol in front of point.
+
+
+
+
+@node Member Buffer Display,  , Symbol Completion, Tags-like Functions
+@section Quick Member Display
+@cindex member buffer
+
+You can quickly display a member buffer containing the member the cursor
+in on with the command @kbd{C-c b m}.
+
+
+@node Concept Index, , Tags-like Functions, Top
+@unnumbered Concept Index
+@printindex cp
+
+@contents
+@bye