--- /dev/null
+\input texinfo @c -*-texinfo-*-
+@setfilename ada-mode.info
+@settitle Ada Mode
+
+@ifinfo
+This file documents Ada mode.
+
+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 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 same conditions as for modified versions.
+@end ifinfo
+
+@titlepage
+@sp 10
+@title{Ada Mode}
+@sp 2
+@subtitle An Emacs major mode for programming Ada 95 with GNAT
+@subtitle July 1998 for Ada Mode Version 3.0
+@sp 2
+
+@comment This is for the copyright page.
+@page
+@vskip 0pt plus 1filll
+
+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 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 same conditions as for modified versions.
+
+@end titlepage
+
+@node Top, Overview, (dir), (dir)
+
+@menu
+* Overview::
+* Installation:: Installing the Ada mode on your system
+* Customization:: Setting up the Ada mode to your taste
+* Project files:: Describing the organization of your project
+* Syntax highlighting:: Using specific colors and fonts to highlight
+ the structure of your files
+* Moving Through Ada Code:: Moving easily through Ada sources
+* Identifier completion:: Finishing words automatically
+* Index Menu of Subprograms:: A menu of all the types and subprograms
+ defined in your application
+* File Browser:: Easy access to your files
+* Automatic Smart Indentation:: Indenting your code automatically as you type
+* Formatting Parameter Lists:: Formating subprograms parameter lists
+ automatically
+* Automatic Casing:: Adjusting the case of words automatically
+* Statement Templates:: Inserting code templates
+* Comment Handling:: Reformatting comments easily
+* Compiling Executing:: Working with your application within Emacs
+* Debugging:: Debugging your application
+* Using non-standard file names:: Configuring Emacs for special file names
+* Working Remotely:: Working on a different machine
+@end menu
+
+
+@c -----------------------------------------------------------------------
+@node Overview, Installation, Top, Top
+@chapter Overview
+@c -----------------------------------------------------------------------
+
+The Emacs mode for programming in Ada 95 with GNAT helps the user in
+understanding existing code and facilitates writing new code. It
+furthermore provides some utility functions for easier integration of
+standard Emacs features when programming in Ada.
+
+@section General features:
+
+@itemize @bullet
+@item full Integrated Development Environment :
+@itemize @bullet
+@item support of 'project files' for the configuration (directories,
+compilation options,...)
+@item compiling and stepping through error messages.
+@item running and debugging your applications within Emacs.
+@end itemize
+@item easy to use for beginners by pull-down menus,
+@item user configurable by many user-option variables.
+@end itemize
+
+@section Ada mode features that help understanding code:
+
+@itemize @bullet
+@item functions for easy and quick stepping through Ada code,
+@item getting cross reference information for identifiers (e.g. find the
+defining place by a keystroke),
+@item displaying an index menu of types and subprograms and move point to
+the chosen one,
+@item automatic color highlighting of the various entities in Ada code.
+@end itemize
+
+@section Emacs support for writing Ada code:
+
+@itemize @bullet
+@item switching between spec and body files with eventually
+auto-generation of body files,
+@item automatic formating of subprograms parameter lists.
+@item automatic smart indentation according to Ada syntax,
+@item automatic completion of identifiers,
+@item automatic casing of identifiers, keywords, and attributes,
+@item insertion of statement templates,
+@item filling comment paragraphs like filling normal text,
+@end itemize
+
+@c -----------------------------------------------------------------------
+@node Installation, Customization, Overview, Top
+@chapter Installation
+@c -----------------------------------------------------------------------
+
+If you got the Ada mode as a separate distribution, you should have a
+look at the @file{README} file. It explains the basic steps necessary
+for a good installation of the emacs Ada mode.
+
+Installing the Ada mode is basically just a matter of copying a few
+files into the Emacs library directories. Every time you open a file
+with a file extension of @file{.ads} or @file{.adb}, Emacs will
+automatically load and activate the Ada mode.
+
+See the section @xref{Using non-standard file names} if your files do
+not use these extensions and if you want Emacs to automatically start the
+Ada mode every time you edit an Ada file.
+
+See also the Emacs documentation @xref{(emacs)} for general usage
+variables that you might want to set.
+
+@c ---------------------------------------------------------------------
+@section Required files
+@c ---------------------------------------------------------------------
+
+This Ada mode works best with Emacs 20.3 or higher (the easy editing
+features for the project files won't work with any older version), but
+most of the commands should work with older versions too. Please try to
+install the most recent version of Emacs on your system before
+installing the Ada mode.
+
+Although part of the Ada mode is compiler independent, the most advanced
+features are specific to the Gnat compiler @url{http://www.gnat.com}.
+
+The following files are provided with the Ada mode distribution:
+
+@itemize @bullet
+
+@item @file{ada-mode.el}: The main file for the Ada mode.
+This is the only file which does not require Gnat. It contains the
+functions for indentation, formatting of parameter lists, stepping
+through code, comment handling and automatic casing. Emacs versions
+20.2 and higher already contain Ada mode version 2.27, which is an older
+version of this file and should be replaced. Loading @file{ada-mode.el}
+from the current distribution supersedes the standard installation.
+
+@item @file{ada-stmt.el}: Contains the statement templates feature.
+
+@item @file{ada-xref.el}: This file provides the main support for Gnat.
+This is where the functions for cross-references, completion of
+identifiers, support for project files and compilation of your
+application are defined.
+
+@item @file{ada-prj.el}: The functions to use for easy-edition of the
+project files. This file is the only one which really requires Emacs at
+least 20.2. It uses the new widget features from Emacs.
+
+@end itemize
+
+@c --------------------------------------------------------------------
+@node Customization, Project files, Installation, Top
+@chapter Customizing the Ada mode
+@c ---------------------------------------------------------------------
+
+The ada-mode is fully customizable. Everything, from the file names to
+the automatic indentation and the automatic casing can be adapted to
+your own needs.
+
+There are two different kinds of variables that control this
+customization, both are easy to modify.
+
+The first set of variables are standard Emacs variables. Of course, some
+are defined only for the Ada mode, whereas others have a more general
+meaning in Emacs. Please see the Emacs documentation for more
+information on the latest. In this documentation, we will detail all the
+variables that are specific to the Ada mode, and a few others. The names
+will be given, as in @code{ada-case-identifier}.
+
+Emacs provides an easy way to modify them, through a special mode called
+customization. To access this mode, select the menu
+@kbd{Ada->Customize}. This will open a new buffer with some fields that
+you can edit. For instance, you will get something like:
+@example
+Put below the compiler switches.
+comp_opt= _____________________________________
+@end example
+The first line gives a brief description of the variable. The second
+line is the name of the variable and the field where you can give a
+value for this variable. Simply type what you want in the field.
+
+When you are finished modifying the variables, you can simply click on
+the @b{Save for future sessions} button at the top of the buffer (click
+with the middle mouse button). This will save the values in your
+@file{.emacs} file, so that next time you start Emacs they will have the
+same values.
+
+To modify a specific variable, you can directly call the function
+@code{customize-variable} from Emacs (just type @key{M-x
+customize-variable RET} and then type the variable name.
+
+Some users might prefer to modify the variables directly in their
+configuration file, @file{.emacs}. This file is coded in Emacs lisp, and
+the syntax to set a variable is the following:
+@example
+(setq variable-name value)
+@end example
+
+The second set of variables for customization are set through the use of
+project files. These variables are specific to a given project, whereas
+the first set was more general. For more information, please
+@xref{Project files}.
+
+@c ---------------------------------------------------------------------
+@node Project files, Syntax highlighting, Customization, Top
+@chapter Project files
+@c ---------------------------------------------------------------------
+
+@c ---------------------------------------------------------------------
+@section General overview
+@c ---------------------------------------------------------------------
+
+Emacs provides a full Integrated Development Environment for GNAT and
+Ada programmers. That is to say, editing, compiling, executing and
+debugging can be performed within Emacs in a convenient and natural way.
+
+To take full advantage of this features, it is possible to create a file
+in the main directory of your application, with a '.adp' extension.
+This file contain all needed information dealing with the way your
+application is organized between directories, the commands to compile,
+run and debug it etc. Creating this file is not mandatory and convenient
+defaults are automatically provided for simple setups. It only becomes
+necessary when those above mentioned defaults need customizing.
+
+A simple way to edit this file is provided for Emacs 20.2 or newer, with
+the following functions, that you can access also through the Ada
+menu. It is also possible to edit the project file as a regular text
+file.
+
+Once in the buffer for editing the project file, you can save your
+modification using the '[OK]' button at the bottom of the buffer, or
+simply use the usual @kbd{C-x C-s} binding. To cancel your
+modifications, simply kill the buffer or click on the '[CANCEL]' button
+at the button.
+
+Each buffer using Ada mode will be associated with one project file when
+there is one available, so that Emacs can easily navigate through
+related source files for instance.
+
+The exact algorithm to determine which project file should be used is
+described in the next section, but you can force the project file you
+want to use by setting one or two variables in your @file{.emacs} file.
+
+@itemize @bullet
+@item To set up a default project file to use for any directory, anywhere
+on your system, set the variable @code{ada-prj-default-project-file} to
+the name of that file.
+@example
+ (set 'ada-prj-default-project-file "/dir1/dir2/file")
+@end example
+
+@item For a finer controlled, you can set a per-directory project file.
+This is done through the variable @code{ada-xref-default-prj-file}.
+@example
+ (set 'ada-xref-default-prj-file
+ '(("/dir1/dir2" . "/dir3/file1")
+ ("/dir4/dir5" . "/dir6/file2")))
+@end example
+Note: This has a higher priority than the first variable, so the first
+choice is to use this variable settings, and otherwise
+@code{ada-prj-default-project-file}.
+@end itemize
+
+
+@table @kbd
+@item C-c u ada-customize menu: Ada->Project->New/Edit
+Create or edit the project file for the current buffer.
+@item C-c c ada-change-prj
+Change the project file associated with the current Ada buffer.
+@item C-c d
+Change the default project file for the current directory. Every new
+file opened from this directory will be associated with that file by
+default.
+@item ada-set-default-project-file menu: Ada->Project->Set Default
+Set the default project file to use for *any* Ada file opened anywhere
+on your system. This sets this file only for the current Emacs session.
+@end table
+
+@c ---------------------------------------------------------------------
+@section Project file variables
+@c ---------------------------------------------------------------------
+
+The following variables can be defined in a project file. They all have
+a default value, so that small projects do not need to create a project
+file.
+
+Some variables below can be referenced in other variables, using a
+shell-like notation. For instance, if the variable @code{comp_cmd}
+contains a sequence like @code{$@{comp_opt@}}, the value of that variable
+will be substituted.
+
+Here is the list of variables:
+
+@table @code
+@item src_dir [default: "./"]
+This is a list of directories where the Ada mode will look for source
+files. These directories are used mainly in two cases, both as a switch
+for the compiler and for the cross-references.
+
+@item obj_dir [default: "./"]
+This is a list of directories where to look for object and library
+files. The library files are the .ali files generated by Gnat and that
+contain cross-reference informations.
+
+@item comp_opt [default: ""]
+Creates a variable which can be referred to subsequently by using the
+@code{$@{comp_opt@}} notation. This is intended to store the default
+switches given to `gnatmake' and `gcc'.
+
+@item bind_opt=SWITCHES [default: ""]
+Creates a variable which can be referred to subsequently by using the
+@code{$@{bind_opt@}} notation. This is intended to store the default
+switches given to `gnatbind'.
+
+@item link_opt=SWITCHES [default: ""]
+Creates a variable which can be referred to subsequently by using the
+@code{$@{link_opt@}} notation. This is intended to store the default
+switches given to `gnatlink'.
+
+@item main=EXECUTABLE [default: ""]
+Specifies the name of the executable for the application. This variable
+can be referred to in the following lines by using the @code{$@{main@}}
+notation.
+
+@item cross_prefix=PREFIX [default: ""]
+This variable should be set if you are working in a cross-compilation
+environment. This is the prefix used in front of the gnatmake commands.
+
+@item remote_machine=MACHINE [default: ""]
+This is the name of the machine to log into before issuing the
+compilation command. If this variable is empty, the command will be run
+on the local machine. This will not work on Windows NT machines, since
+the Ada mode will simply precede the compilation command with a 'rsh'
+command, unknown on Windows.
+
+@item comp_cmd=COMMAND [default: "$@{cross_prefix@}gcc -c -I$@{src_dir@} -g -gnatq"]
+Specifies the command used to compile a single file in the application.
+The name of the file will be added at the end of this command.
+
+@item make_cmd=COMMAND [default: "$@{cross_prefix@}gnatmake $@{main@} -aI$@{src_dir@} -aO$@{obj_dir@} -g -gnatq -cargs $@{comp_opt@} -bargs $@{bind_opt@} -largs $@{link_opt@}"]'
+Specifies the command used to recompile the whole application.
+
+@item run_cmd=COMMAND [default: "$@{main@}"]
+Specifies the command used to run the application.
+
+@item debug_cmd=COMMAND [default: "$@{cross_prefix@}gdb $@{main@}"]
+Specifies the command used to debug the application
+
+@end table
+
+@c ---------------------------------------------------------------------
+@section Detailed algorithm
+@c ---------------------------------------------------------------------
+
+This section gives more details on the project file setup and is only of
+interest for advanced users.
+
+Usually, an Ada file is part of a larger application, whose sources and
+objects can be spread over multiple directories. The first time emacs is
+asked to compile, run or debug an application, or when a cross reference
+function is used (goto declaration for instance), the following steps
+are taken:
+
+@itemize @bullet
+@item find the appropriate project file, open and parse it.
+All the fields read in the project file are then stored by emacs
+locally. Finding the project file requires a few steps:
+
+@itemize @minus
+@item if a file from the same directory was already associated with
+a project file, use the same one. This is the variable
+@code{ada-xref-default-prj-file} described above.
+@item if the variable @code{ada-prj-default-project-file} is set,
+use the project file specified in this variable.
+@item if there is a project file whose name is the same as the source file
+ except for the suffix, use this one.
+@item if there's only one project file in the source directory, use
+that one.
+@item if there are more than one project file in the source directory,
+ask the user.
+@item if there are no project files in the source directory use standard
+default values.
+@end itemize
+
+The first project file that is selected in a given directory becomes the
+default project file for this directory and is used implicitly for other
+sources unless specified otherwise by the user.
+
+@item look for the corresponding .ali file in the @code{obj_dir} defined
+in the project file. If this file can not be found, emacs proposes to
+compile the source using the @code{comp_cmd} defined in the project file
+in order to create the ali file.
+
+@item when cross referencing is requested, the .ali file is parsed to
+determine the file and line of the identifier definition. It is
+possible for the .ali file to be older than the source file, in which
+case it will be recompiled if the variable @code{ada-xref-create-ali} is
+set, otherwise the reference is searched in the obsolete ali file with
+possible inaccurate results.
+
+@item look for the file containing the declaration using the source
+path @code{src_dir} defined in the project file. Put the cursor at the
+correct position and display this new cursor.
+@end itemize
+
+@c -----------------------------------------------------------------------
+@node Syntax highlighting, Moving Through Ada Code, Project files, Top
+@chapter Syntax highlighting
+@c -----------------------------------------------------------------------
+
+The Ada mode is made to help you understand the structure of your source
+files. Some people like having colors or different fonts depending on
+the context: commands should be displayed differently than keywords,
+which should also be different from strings, ...
+
+Emacs is able to display in a different way the following syntactic
+entities:
+
+@itemize @bullet
+@item keywords
+@item commands
+@item strings
+@item gnatprep statements (preprocessor)
+@item types (under certain conditions)
+@item other words
+@end itemize
+
+This is not the default behavior for Emacs. You have to explicitly
+activate it. This requires that you add a new line in your @file{.emacs}
+file (if this file does not exist, just create it).
+
+@example
+ (global-font-lock-mode t)
+@end example
+
+But the default colors might not be the ones you like. Fortunately,
+there is a very easy way to change them. Just select the menu
+@kbd{Help->Customize->Specific Face...} and press @kbd{Return}. This
+will display a buffer will all the "faces" (the colors) that Emacs knows
+about. You can change any of them.
+
+
+@c -----------------------------------------------------------------------
+@node Moving Through Ada Code, Identifier completion, Syntax highlighting, Top
+@chapter Moving Through Ada Code
+@c -----------------------------------------------------------------------
+
+There are several easy to use commands to stroll through Ada code. All
+these functions are available through the Ada menu, and you can also use
+the following key bindings or the command names:
+
+@table @kbd
+@item M-C-e ada-next-procedure
+Move to the next function/procedure/task, which ever comes next.
+@item M-C-a ada-previous-procedure
+Move to previous function/procedure/task.
+@item ada-next-package
+Move to next package.
+@item ada-prev-package
+Move to previous package.
+@item C-c C-a ada-move-to-start
+Move to matching start of @code{end}. If point is at the end of a
+subprogram, this command jumps to the corresponding @code{begin} if the
+user option @code{ada-move-to-declaration} is @code{nil} (default), it
+jumps to the subprogram declaration otherwise.
+@item C-c C-e ada-move-to-end
+Move point to end of current block.
+@item C-c o ff-find-other-file
+Switch between corresponding spec and body file. If the cursor is on a
+subprogram, switch between declaration and body.
+@item C-c c-d
+Move from any reference to its declaration and switch between
+declaration and body (for procedures, tasks, private and incomplete
+types).
+@item C-c C-r ada-find-references
+runs the @file{gnatfind} command to search for all references to the
+entity pointed by the cursor. Use 'next-error' function, or C-x `, to
+visit each reference (as for compilation errors).
+@end table
+
+These functions use the information in the output of the Gnat Ada
+compiler. However, if your application was compiled with the
+@code{-gnatx} switch, these functions will not work, since no extra
+information is generated by GNAT. See GNAT documentation for further
+information.
+
+Emacs will try to run Gnat for you whenever the cross-reference
+informations are older than your source file (provided the
+@code{ada-xref-create-ali} variable is non nil). Gnat then produces a
+file with the same name as the current Ada file but with the extension
+changed to @code{.ali}. This files are normally used by the binder, but
+they will also contain additional cross-referencing information.
+
+@c -----------------------------------------------------------------------
+@node Identifier completion, Index Menu of Subprograms, Moving Through Ada Code, Top
+@chapter Identifier completion
+@c -----------------------------------------------------------------------
+
+@c -----------------------------------------------------------------------
+@section Overview
+@c -----------------------------------------------------------------------
+
+Emacs and the Ada mode provide two general ways for the completion of
+identifiers. This is an easy way to type faster: you just have to type
+the first few letters of an identifiers, and then loop through all the
+possible completions.
+
+The first method is general for Emacs. It will work both with Ada
+buffers, but also in C buffers, Java buffers, ... The idea is to parse
+all the opened buffers for possible completions.
+
+For instance, if the following words are present in any of the opened
+files: my_identifier, my_subprogam, then you will have this scenario:
+@example
+You type: my@key{M-/}
+Emacs will display: my_identifier
+If you press @key{M-/} once again, Emacs will replace my_identifier with
+my_subprogram.
+Pressing @key{M-/} once more will bring you back to my_identifier.
+@end example
+
+This is a very fast way to do completion, and the casing of words will
+also be respected.
+
+The second method is specific to Ada buffer, and even to users of the
+Gnat compiler. Emacs will search the cross-information found in the .ali
+files generated by Gnat for possible completions.
+
+The main advantage is that this completion is more accurate: only
+existing identifier will be suggested, you don't need to have a file
+opened that already contains this identifiers,...
+
+On the other hand, this completion is a little bit slower and requires
+that you have compiled your file at least once since you created that
+identifier.
+
+@c -----------------------------------------------------------------------
+@section Summary of commands
+@c -----------------------------------------------------------------------
+
+@table @kbd
+@item C-TAB ada-complete-identifier
+complete accurately current identifier using information in .ali file
+@item M-/
+complete identifier using buffer information (not ada specific)
+@end table
+
+@c -----------------------------------------------------------------------
+@node Index Menu of Subprograms, File Browser, Identifier completion, Top
+@chapter Index Menu of Subprograms
+@c -----------------------------------------------------------------------
+
+You can display a choice menu with all procedure/function/task
+declarations in the file and choose an item by mouse click to get to its
+declaration. This function is accessible through the 'Ada' menu when
+editing a Ada file, or simply through the following key binding :
+
+@table @kbd
+@item C-S-mouse-3
+display index menu
+@end table
+
+@c -----------------------------------------------------------------------
+@node File Browser, Automatic Smart Indentation, Index Menu of Subprograms, Top
+@chapter File Browser
+@c -----------------------------------------------------------------------
+
+Emacs provides a special mode, called @code{speedbar}. When this mode is
+activated, a new frame is displayed, with a file browser. The files from
+the current directory are displayed, and you can click on them as you
+would with any file browser. The following commands are then available.
+
+You can click on a directory name or file name to open it. The editor
+will automatically select the best possible mode for this file,
+including of course the ada-mode for files written in Ada
+
+If you click on the [+] symbol near a file name, all the symbols (types,
+variables and subprograms) defined in that file will be displayed, and
+you can directly click on them to open the right file at the right
+place.
+
+You can activate this mode by typing @key{M-x speedbar} in the editor.
+This will open a new frame. A better way might be to assicate the
+following key binding
+
+@example
+(global-set-key [f7] 'speedbar-get-focus)
+@end example
+
+Every time you press @key{f7}, the mouse will automatically move to the
+speedbar frame (which will be created if it does not exist).
+
+@c -----------------------------------------------------------------------
+@node Automatic Smart Indentation, Formatting Parameter Lists, File Browser, Top
+@chapter Automatic Smart Indentation
+@c -----------------------------------------------------------------------
+
+The Ada mode comes with a full set of rules for automatic indentation.
+You can of course configure the indentation as you want, by setting the
+value of a few variables.
+
+As always, the preferred way to modify variables is to use the
+@code{Ada->Customize} menu (don't forget to save your changes!). This
+will also show you some example of code where this variable is used, and
+hopefully make things clearer.
+
+The relevant variables are the following:
+
+@table @code
+@item ada-broken-indent (default value: 2)
+Number of columns to indent the continuation of a broken line
+
+@item ada-indent (default value: 3)
+Width of the default indentation
+
+@item ada-indent-record-rel-type (default value: 3)
+Indentation for 'record' relative to 'type' or 'use'
+
+@item ada-indent-return (default value: 0)
+Indentation for 'return' relative to 'function' (if ada-indent-return
+is greater than 0), or the open parenthesis (if ada-indent-return is
+negative or null). Note that in the second case, when there is no
+open parenthesis, the indentation is done relative to 'function' with
+the value of ada-broken-indent.
+
+@item ada-label-indent (default value: -4)
+Number of columns to indent a label
+
+@item ada-stmt-end-indent (default value: 0)
+Number of columns to indent a statement 'end' keyword on a separate line
+
+@item ada-when-indent (default value: 3)
+Indentation for 'when' relative to 'exception' or 'case'
+
+@item ada-indent-is-separate (default value: t)
+Non-nil means indent 'is separate' or 'is abstract' if on a single line
+
+@item ada-indent-to-open-paren (default value: t)
+Non-nil means indent according to the innermost open parenthesis
+
+@item ada-indent-after-return (default value: t)
+Non-nil means that the current line will also be re-indented before
+inserting a newline, when you press @kbd{Return}.
+
+@end table
+
+Most of the time, the indentation will be automatic, i.e when you will
+press @kbd{Return}, the cursor will move to the correct column on the
+next line.
+
+However, you might want or need sometimes to re-indent the current line
+or a set of lines. For this, you can simply go to that line, or select
+the lines, and then press @kbd{TAB}. This will automatically re-indent
+the lines.
+
+Another mode of indentation exists that helps you to set up your
+indentation scheme. If you press @kbd{C-c TAB}, the ada-mode will do the
+following:
+@itemize @bullet
+@item Reindent the current line, as @kbd{TAB} would do
+@item Temporarily move the cursor to a reference line, i.e the line that
+ was used to calculate the current indentation
+@item Display at the bottom of the window the name of the variable that
+ provided the offset for the indentation
+@end itemize
+
+The exact indentation of the current line is the same as the one for the
+reference line, plus an offset given by the variable.
+
+Once you know the name of the variable, you can either modify it through
+the usual @key{Ada->Customize} menu, or by typing @key{M-x
+customize-variable RET} in the Emacs window, and then give the name of
+the variable.
+
+@table @kbd
+@item TAB
+indent the current line or the current region.
+@item M-C-\
+indent lines in the current selected block.
+@item C-c TAB
+indent the current line and prints the name of the variable used for
+indentation.
+@end table
+
+
+
+@c -----------------------------------------------------------------------
+@node Formatting Parameter Lists, Automatic Casing, Automatic Smart Indentation, Top
+@chapter Formatting Parameter Lists
+@c -----------------------------------------------------------------------
+
+To help you correctly align fields in a subprogram parameter list, Emacs
+provides one function that will do most of the work for you. This
+function will align the declarations on the colon (':') separating
+argument names and argument types, plus align the 'in', 'out' and 'in
+out' keywords if required.
+
+@table @kbd
+@item C-c C-f ada-format-paramlist
+Format the parameter list.
+@end table
+
+@c -----------------------------------------------------------------------
+@node Automatic Casing, Statement Templates, Formatting Parameter Lists, Top
+@chapter Automatic Casing
+@c -----------------------------------------------------------------------
+
+Casing of identifiers, attributes and keywords is automatically
+performed while typing when the variable @code{ada-auto-case} is set.
+Every time you press a word separator, the previous word is
+automatically cased.
+
+You can customize the automatic casing differently for keywords,
+attributes and identifiers. The relevant variables are the following:
+@code{ada-case-keyword}, @code{ada-case-attribute} and
+@code{ada-case-identifier}.
+
+All these variables can have one of the following values:
+
+@table @kbd
+@item downcase-word
+The previous word will simply be in all lower cases. For instance
+@code{My_vARIable} is converted to @code{my_variable}.
+
+@item upcase-word
+The previous word will be fully converted to upper cases. For instance
+@code{My_vARIable} is converted to @code{MY_VARIABLE}.
+
+@item ada-capitalize-word
+All letters, except the first one of the word and every letter after the
+'_' character are lower cased. Other letters are upper cased. For
+instance @code{My_vARIable} is converted to @code{My_Variable}.
+
+@item ada-loose-case-word
+No letters is modified in the previous word, except the ones after the
+'_' character that are upper cased. For instance @code{My_vARIable} is
+converted to @code{My_VARIable}.
+@end table
+
+These functions, although they will work in most cases, will not be
+accurate sometimes. The Ada mode allows you to define some exceptions,
+that will always be cased the same way.
+
+The idea is to create a dictionary of exceptions, and store it in a
+file. This file should contain one identifier per line, with the casing
+you want to force. The default name for this file is
+@file{~/.emacs_case_exceptions}. You can of course change this name,
+through the variable @code{ada-case-exception-file}.
+
+Note that each line in this file must start with the key word whose
+casing you want to specify. The rest of the line can be used for
+comments (explaining for instance what an abbreviation means, as
+recommended in the Ada 95 Quality and Style, paragrpah 3.1.4). Thus, a
+good example for this file could be:
+
+@example
+DOD Department of Defense
+Text_IO
+GNAT The GNAT compiler from Ada Core Technologies
+@end example
+
+When working on project involving multiple programmers, we recommend
+that every member of the team sets this variable to the same value,
+which should point to a system-wide file that each of them can
+write. That way, you will ensure that the casing is consistent
+throughout your application(s).
+
+There are two ways to add new items to this file: you can simply edit it
+as you would edit any text file, and add or suppress entries in this
+file. Remember that you should put one entity per line. The other,
+easier way, is to position the cursor over the word you want to add, in
+an Ada buffer. This word should have the casing you want. Then simply
+select the menu @kbd{Ada->Edit->Create Case Exception}, or the key
+@kbd{C-c C-y}. The word will automatically be added to the current list
+of exceptions and to the file.
+
+It is sometimes useful to have multiple exception files around (for
+instance, one could be the standard Ada acronyms, the second some
+company specific exceptions, and the last one some project specific
+exceptions). If you set up the variable @code{ada-case-exception-file}
+as a list of files, each of them will be parsed and used in your emacs
+session.
+
+However, when you save a new exception through the menu, as described
+above, the new exception will be added to the first file in the list
+only. You can not automatically add an exception to one of the other
+files, although you can of course edit the files by hand at any time.
+
+Automatic casing can be performed on port or whole buffer using:
+@table @kbd
+@item C-c C-b
+Adjust case in the whole buffer.
+@item C-c C-y
+Create a new entry in the exception dictionary, with the word under
+the cursor
+@item C-c C-t
+Rereads the exception dictionary from the file
+@code{ada-case-exception-file}.
+@end table
+
+@c -----------------------------------------------------------------------
+@node Statement Templates, Comment Handling, Automatic Casing, Top
+@chapter Statement Templates
+@c -----------------------------------------------------------------------
+
+NOTE: This features are not available on VMS for Emacs 19.28. The
+functions used here do not exist on Emacs 19.28.
+
+Templates exist for most Ada statements. They can be inserted in the
+buffer using the following commands:
+
+@table @kbd
+@item C-c t b
+exception Block
+@item C-c t c
+case.
+@item C-c t d
+declare Block.
+@item C-c t e
+else.
+@item C-c t f
+for Loop.
+@item C-c t h
+Header.
+@item C-c t i
+if.
+@item C-c t k
+package Body.
+@item C-c t l
+loop.
+@item C-c t t
+task Body.
+@item C-c t w
+while Loop.
+@item C-c t u
+use.
+@item C-c t x
+exit.
+@item C-c t C-a
+array.
+@item C-c t C-e
+elsif.
+@item C-c t C-f
+function Spec.
+@item C-c t C-k
+package Spec.
+@item C-c t C-p
+procedure Spec.
+@item C-c t C-r
+record.
+@item C-c t C-s
+subtype.
+@item C-c t C-t
+task Spec.
+@item C-c t C-u
+with.
+@item C-c t C-v
+private.
+@item C-c t C-w
+when.
+@item C-c t C-x
+exception.
+@item C-c t C-y
+type.
+@end table
+
+@c -----------------------------------------------------------------------
+@node Comment Handling, Compiling Executing, Statement Templates, Top
+@chapter Comment Handling
+@c -----------------------------------------------------------------------
+
+By default, comment lines get indented like Ada code. There are a few
+additional functions to handle comments:
+
+
+@table @kbd
+@item M-;
+Start a comment in default column.
+@item M-j
+Continue comment on next line.
+@item C-c ; comment-region
+Comment the selected region (add -- at the beginning of lines).
+@item C-c :
+Uncomment the selected region
+@item M-q
+autofill the current comment.
+@end table
+
+@c -----------------------------------------------------------------------
+@node Compiling Executing, Debugging, Comment Handling, Top
+@chapter Compiling Executing
+@c -----------------------------------------------------------------------
+
+Ada mode provides a much complete environment for compiling, debugging
+and running an application within Emacs.
+
+All the commands used by Emacs to manipulate your application can be
+customized in the project file. Some default values are provided, but
+these will likely not be good enough for a big or even medium-sized
+project. See the section on the project file for an explanation on how
+to set up the commands to use.
+
+One of the variables you can set in your project file,
+@code{cross_prefix}, indicates whether you are using a cross-compilation
+environment, and if yes for which target. The default command used for
+compilation will add this @code{cross_prefix} in front of the name:
+@code{gcc} will become @code{cross_prefix}-@code{gcc}, @code{gnatmake}
+will become @code{cross_prefix}-@code{gnatmake}, ...
+
+This will also modify the way your application is run and debugged,
+although this is not implemented at the moment.
+
+Here are the commands for building and using an Ada application
+
+@itemize @bullet
+
+@item Compiling the current source
+This command is issued when issuing the @code{compile} command from the
+Ada menu. It compiles unconditionally the current source using the
+@code{comp_cmd} variable of the project file. Compilation options can be
+customized with the variable @code{comp_opt} of the project file.
+
+Emacs will display a new buffer that contains the result of the
+compilation. Each line associated with an error will become active: you
+can simply click on it with the middle button of the mouse, or move the
+cursor on it and press @kbd{Return}. Emacs will then display the
+relevant source file and put the cursor on the line and column the error
+was found at.
+
+You can also simply press the @kbd{C-x `} key and Emacs will jump to the
+first error. If you press that key again, it will move you to the second
+error, and so on.
+
+Some error messages might also include references to some files. These
+references are also clickable in the same way.
+
+
+@item (Re)building the whole application
+This command is issued when you select the @code{build} command from the
+Ada menu. It compiles all obsolete units of the current application
+using the @code{make_cmd} variable of the project file. Compilation
+options can be customized with the variable @code{comp_opt} of the
+project file, binder options with @code{bind_opt} and linker options
+with @code{link_opt}. The main unit of the application may be specified
+with @code{main}.
+
+The compilation buffer is also active in the same way it was for the above
+command.
+
+@item Running the application
+This command is issued when you select the @code{run} command from the
+Ada menu. It executes the current application in an emacs
+buffer. Arguments can be passed through before executing. The execution
+buffer allows for interactive input/output.
+
+This command is not yet available in a cross-compilation
+toolchain. Emacs would first need to log on the target before running
+the application. This will be implemented in a future release of Gnat.
+
+@end itemize
+
+@c ---------------------------------------------------------------------
+@node Debugging, Using non-standard file names, Compiling Executing, Top
+@chapter Debugging your application
+@c ---------------------------------------------------------------------
+
+You can set up in the project file a command to use to debug your
+application. Emacs is compatible with a lot of debuggers, and provide an
+easy interface to them.
+
+This selection will focus on the gdb debugger, and two of the graphical
+interfaces that exist for it.
+
+In all cases, the main window in Emacs will be split in two: in the
+upper buffer, the source code will appear, whereas the debugger
+input/output window is displayed at the bottom. You can enter the
+debugger commands as usual in the command window. Every time a new
+source file is selected by the debugger (for instance as a result of a
+@code{frame} command), the appropriate source file is displayed in the
+upper buffer.
+
+The source window is interactive: you can click on an identifier with the
+right mouse button, and print its value in the debugger window. You can
+also set a breakpoint simply by right-clicking on a line.
+
+You can easily use Emacs as the source window when you are using a
+graphical interface for the debugger. The interesting thing is that,
+whereas you still have the graphical nifties, you can also you the
+cross-references features that the ada-mode provides to look at the
+definition for the identifiers,...
+
+Here is how you can set up gdbtk and ddd for use with Emacs (These are
+the commands you should setup in the project file):
+
+@itemize @bullet
+@item gdbtk
+should be used with the switch --emacs_gdbtk. It provides a nice
+backtrace window, as well as a tasks window. You can click interactively
+on both of them, and Emacs will display the source file on the correct
+line.
+
+@item ddd (Data Display Debugger)
+should be used with the switches --tty and -fullname. Whenever you
+print a variable from Emacs, it will be displayed graphically in the
+data window.
+
+@end itemize
+
+
+@c ---------------------------------------------------------------------
+@node Using non-standard file names, Working Remotely, Debugging, Top
+@chapter Using non-standard file names
+@c ---------------------------------------------------------------------
+
+By default, Emacs is configured to use the GNAT style file names, where
+file names are the package names, and the extension for spec and bodies
+are respectively .ads and .adb.
+
+If you want to use other types of file names, you will need to modify
+your .emacs configuration file.
+
+Adding new possible extensions is easy. Since the ada-mode needs to know
+how to go from the body to the spec (and back), you always have to
+specify both. A function is provided with the ada-mode to add new
+extensions.
+
+For instance, if your files are called <unit>_s.ada and <unit>_b.ada
+respectively for spec and bodies, you need to add the following to your
+@file{.emacs} :
+
+@example
+(ada-add-extensions "_s.ada" "_b.ada")
+@end example
+
+Note that it is possible to redefine the extension, even if they already
+exist, as in:
+
+@example
+(ada-add-extensions ".ads" "_b.ada")
+(ada-add-extensions ".ads" ".body")
+@end example
+
+This simply means that whenever the ada-mode will look for the body for
+a file whose extension is @file{.ads}, it will take the first available
+file that ends with either @file{.adb} (standard), @file{_b.ada} or
+@file{.body}.
+
+If the filename is not the unit name, then things are a little more
+complicated. You then need to rewrite the function
+ada-make-filename-from-adaname (see the file @file{ada-mode.el} for an
+example).
+
+@c ---------------------------------------------------------------------
+@node Working Remotely, ,Using non-standard file names, Top
+@chapter Working Remotely
+@c ---------------------------------------------------------------------
+
+When you work on project that involve a lot of programmers, it is
+generally the case that you will edit the files on your own machine, but
+you want to compile, run and debug your application in another buffer.
+
+Fortunately, here too Emacs provides a very convenient way to do this.
+
+@c ---------------------------------------------------------------------
+@section Remote editing
+@c ---------------------------------------------------------------------
+
+First of all, the files do not need to be on your machine. Emacs can
+edit any remote file, by doing transparent FTP sessions between your
+machine and the remote machine that stores your files. This is a special
+Emacs mode, called @code{ange-ftp}. To use it, you just have to use a
+slightly different syntax when you open a file.
+
+@example
+For instance, if you want to open the file /work/foo.adb on the machine
+aleph.gnu.org, where you log in as qwe, you would simply do this:
+
+@key{C-x C-f} /qwe@@aleph.gnu.org:/work/foo.adb @key{Return}
+
+i.e put your name, the name of the machine and the name of the file.
+@end example
+
+The first time, Emacs will ask you for a password that it will remember
+until you close the current Emacs. Even if the ftp session times out,
+you won't need to reenter your password.
+
+Every time you save the file, Emacs will upload it to the remote machine
+transparently. No file is modified on the local machine.
+
+@c ---------------------------------------------------------------------
+@section Remote compiling
+@c ---------------------------------------------------------------------
+
+If the machine you want to compile on is not the one your Emacs is
+running on, you can set the variable @code{remote_machine} in the
+project file for your application.
+
+This will force Emacs to issue a rsh command for the compilation,
+instead of running it on the local machine. Unfortunately, this won't
+work on Windows workstations, since this protocol is not supported.
+
+@example
+If your @code{remote_machine} is aleph.gnu.org and the standard
+compilation command is @code{cd /work/ && gnatmake foo}, then Emacs will
+actually issue the command @code{rsh aleph.gnu.org 'cd /work/ &&
+gnatmake foo'}.
+@end example
+
+The advantage of using the @code{remote_machine} variable is that it is
+easier to change that machine without having to modify the compilation
+command.
+
+Note that if you need to set up some environment variables before the
+compilation, you need to insert a call to the appropriate initialization
+script in the compilation command, for instance:
+
+@example
+build_cmd= initialization_script ; cd /work/ && gnatmake foo
+@end example
+
+@c ---------------------------------------------------------------------
+@section Remote running and debugging
+@c ---------------------------------------------------------------------
+
+This feature is not completely implemented yet.
+
+However, most of the time, you will be able to run your application
+remotely simply by replacing it with a 'rsh' call on Unix.
+
+@example
+For instance, if your command was '$@{main@}', you could replace it with
+'rsh aleph.gnu.org $@{main@}'.
+@end example
+
+However, this would not fully work for instance on vxworks, where rsh
+is not supported.
+
+@contents
+@bye
projects / emacs.git / commitdiff