annotate man/ada-mode.texi @ 31223:bceceed9ef87

Check <strings.h>; check `index' and `rindex' functions.

\input texinfo  @c -*-texinfo-*-
@setfilename ../info/ada-mode
@settitle Ada Mode
@dircategory Emacs
@direntry
* Ada mode: (ada-mode). The GNU Emacs mode for editing Ada.
@end direntry

@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 @ref{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 @ref{(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