Subversion Repositories openrisc

\input texinfo   @c -*-texinfo-*-

@c %**start of header

@c oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

@c                                                                            o

@c                            GNAT DOCUMENTATION                              o

@c                                                                            o

@c                             G N A T _ U G N                                o

@c                                                                            o

@c           Copyright (C) 1992-2012, Free Software Foundation, Inc.          o

@c                                                                            o

@c oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

@setfilename gnat_ugn.info

@copying

Copyright @copyright{} 1995-2009 Free Software Foundation,

Inc.

Permission is granted to copy, distribute and/or modify this document

under the terms of the GNU Free Documentation License, Version 1.3 or

any later version published by the Free Software Foundation; with no

Invariant Sections, with no Front-Cover Texts and with no Back-Cover

Texts.  A copy of the license is included in the section entitled

``GNU Free Documentation License''.

@end copying

@c oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

@c

@c                           GNAT_UGN Style Guide

@c

@c  1. Always put a @noindent on the line before the first paragraph

@c     after any of these commands:

@c

@c          @chapter

@c          @section

@c          @subsection

@c          @subsubsection

@c          @subsubsubsection

@c

@c          @end smallexample

@c          @end itemize

@c          @end enumerate

@c

@c  2. DO NOT use @example. Use @smallexample instead.

@c     a) DO NOT use highlighting commands (@b{}, @i{}) inside an @smallexample

@c        context.  These can interfere with the readability of the texi

@c        source file.  Instead, use one of the following annotated

@c        @smallexample commands, and preprocess the texi file with the

@c        ada2texi tool (which generates appropriate highlighting):

@c        @smallexample @c ada

@c        @smallexample @c adanocomment

@c        @smallexample @c projectfile

@c     b) The "@c ada" markup will result in boldface for reserved words

@c        and italics for comments

@c     c) The "@c adanocomment" markup will result only in boldface for

@c        reserved words (comments are left alone)

@c     d) The "@c projectfile" markup is like "@c ada" except that the set

@c        of reserved words include the new reserved words for project files

@c

@c  3. Each @chapter, @section, @subsection, @subsubsection, etc.

@c     command must be preceded by two empty lines

@c

@c  4. The @item command should be on a line of its own if it is in an

@c     @itemize or @enumerate command.

@c

@c  5. When talking about ALI files use "ALI" (all uppercase), not "Ali"

@c     or "ali".

@c

@c  6. DO NOT put trailing spaces at the end of a line.  Such spaces will

@c     cause the document build to fail.

@c

@c  7. DO NOT use @cartouche for examples that are longer than around 10 lines.

@c     This command inhibits page breaks, so long examples in a @cartouche can

@c     lead to large, ugly patches of empty space on a page.

@c

@c  NOTE: This file should be submitted to xgnatugn with either the vms flag

@c        or the unw flag set.  The unw flag covers topics for both Unix and

@c        Windows.

@c

@c oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

@set NOW January 2007

@c This flag is used where the text refers to conditions that exist when the

@c text was entered into the document but which may change over time.

@c Update the setting for the flag, and (if necessary) the text surrounding,

@c the references to the flag, on future doc revisions:

@c search for @value{NOW}.

@set FSFEDITION

@set EDITION GNAT

@set DEFAULTLANGUAGEVERSION Ada 2005

@set NONDEFAULTLANGUAGEVERSION Ada 95

@ifset unw

@set PLATFORM

@end ifset

@ifset vms

@set PLATFORM OpenVMS

@end ifset

@c @ovar(ARG)

@c ----------

@c The ARG is an optional argument.  To be used for macro arguments in

@c their documentation (@defmac).

@macro ovar{varname}

@r{[}@var{\varname\}@r{]}@c

@end macro

@c Status as of November 2009:

@c Unfortunately texi2pdf and texi2html treat the trailing "@c"

@c differently, and faulty output is produced by one or the other

@c depending on whether the "@c" is present or absent.

@c As a result, the @ovar macro is not used, and all invocations

@c of the @ovar macro have been expanded inline.

@settitle @value{EDITION} User's Guide @value{PLATFORM}

@dircategory GNU Ada tools

@direntry

* @value{EDITION} User's Guide: (gnat_ugn). @value{PLATFORM}

@end direntry

@include gcc-common.texi

@setchapternewpage odd

@syncodeindex fn cp

@c %**end of header

@titlepage

@title @value{EDITION} User's Guide

@ifset vms

@sp 1

@flushright

@titlefont{@i{@value{PLATFORM}}}

@end flushright

@end ifset

@sp 2

@subtitle GNAT, The GNU Ada Compiler

@versionsubtitle

@author AdaCore

@page

@vskip 0pt plus 1filll

@insertcopying

@end titlepage

@ifnottex

@node Top, About This Guide, (dir), (dir)

@top @value{EDITION} User's Guide

@noindent

@value{EDITION} User's Guide @value{PLATFORM}

@noindent

GNAT, The GNU Ada Compiler@*

GCC version @value{version-GCC}@*

@noindent

AdaCore@*

@menu

* About This Guide::

* Getting Started with GNAT::

* The GNAT Compilation Model::

* Compiling Using gcc::

* Binding Using gnatbind::

* Linking Using gnatlink::

* The GNAT Make Program gnatmake::

* Improving Performance::

* Renaming Files Using gnatchop::

* Configuration Pragmas::

* Handling Arbitrary File Naming Conventions Using gnatname::

* GNAT Project Manager::

* Tools Supporting Project Files::

* The Cross-Referencing Tools gnatxref and gnatfind::

* The GNAT Pretty-Printer gnatpp::

* The GNAT Metric Tool gnatmetric::

* File Name Krunching Using gnatkr::

* Preprocessing Using gnatprep::

* The GNAT Library Browser gnatls::

* Cleaning Up Using gnatclean::

@ifclear vms

* GNAT and Libraries::

* Using the GNU make Utility::

@end ifclear

* Memory Management Issues::

* Stack Related Facilities::

* Verifying Properties Using gnatcheck::

* Creating Sample Bodies Using gnatstub::

* Creating Unit Tests Using gnattest::

* Generating Ada Bindings for C and C++ headers::

* Other Utility Programs::

* Running and Debugging Ada Programs::

@ifclear vms

* Code Coverage and Profiling::

@end ifclear

@ifset vms

* Compatibility with HP Ada::

@end ifset

* Platform-Specific Information for the Run-Time Libraries::

* Example of Binder Output File::

* Elaboration Order Handling in GNAT::

* Conditional Compilation::

* Inline Assembler::

* Compatibility and Porting Guide::

@ifset unw

* Microsoft Windows Topics::

@end ifset

* GNU Free Documentation License::

* Index::

 --- The Detailed Node Listing ---

About This Guide

* What This Guide Contains::

* What You Should Know before Reading This Guide::

* Related Information::

* Conventions::

Getting Started with GNAT

* Running GNAT::

* Running a Simple Ada Program::

* Running a Program with Multiple Units::

* Using the gnatmake Utility::

@ifset vms

* Editing with Emacs::

@end ifset

@ifclear vms

* Introduction to GPS::

@end ifclear

The GNAT Compilation Model

* Source Representation::

* Foreign Language Representation::

* File Naming Rules::

* Using Other File Names::

* Alternative File Naming Schemes::

* Generating Object Files::

* Source Dependencies::

* The Ada Library Information Files::

* Binding an Ada Program::

* Mixed Language Programming::

@ifclear vms

* Building Mixed Ada & C++ Programs::

* Comparison between GNAT and C/C++ Compilation Models::

@end ifclear

* Comparison between GNAT and Conventional Ada Library Models::

@ifset vms

* Placement of temporary files::

@end ifset

Foreign Language Representation

* Latin-1::

* Other 8-Bit Codes::

* Wide Character Encodings::

Compiling Ada Programs With gcc

* Compiling Programs::

* Switches for gcc::

* Search Paths and the Run-Time Library (RTL)::

* Order of Compilation Issues::

* Examples::

Switches for gcc

* Output and Error Message Control::

* Warning Message Control::

* Debugging and Assertion Control::

* Validity Checking::

* Style Checking::

* Run-Time Checks::

* Using gcc for Syntax Checking::

* Using gcc for Semantic Checking::

* Compiling Different Versions of Ada::

* Character Set Control::

* File Naming Control::

* Subprogram Inlining Control::

* Auxiliary Output Control::

* Debugging Control::

* Exception Handling Control::

* Units to Sources Mapping Files::

* Integrated Preprocessing::

@ifset vms

* Return Codes::

@end ifset

Binding Ada Programs With gnatbind

* Running gnatbind::

* Switches for gnatbind::

* Command-Line Access::

* Search Paths for gnatbind::

* Examples of gnatbind Usage::

Switches for gnatbind

* Consistency-Checking Modes::

* Binder Error Message Control::

* Elaboration Control::

* Output Control::

* Binding with Non-Ada Main Programs::

* Binding Programs with No Main Subprogram::

Linking Using gnatlink

* Running gnatlink::

* Switches for gnatlink::

The GNAT Make Program gnatmake

* Running gnatmake::

* Switches for gnatmake::

* Mode Switches for gnatmake::

* Notes on the Command Line::

* How gnatmake Works::

* Examples of gnatmake Usage::

Improving Performance

* Performance Considerations::

* Text_IO Suggestions::

* Reducing Size of Ada Executables with gnatelim::

* Reducing Size of Executables with unused subprogram/data elimination::

Performance Considerations

* Controlling Run-Time Checks::

* Use of Restrictions::

* Optimization Levels::

* Debugging Optimized Code::

* Inlining of Subprograms::

* Vectorization of loops::

* Other Optimization Switches::

* Optimization and Strict Aliasing::

@ifset vms

* Coverage Analysis::

@end ifset

Reducing Size of Ada Executables with gnatelim

* About gnatelim::

* Running gnatelim::

* Processing Precompiled Libraries::

* Correcting the List of Eliminate Pragmas::

* Making Your Executables Smaller::

* Summary of the gnatelim Usage Cycle::

Reducing Size of Executables with unused subprogram/data elimination

* About unused subprogram/data elimination::

* Compilation options::

Renaming Files Using gnatchop

* Handling Files with Multiple Units::

* Operating gnatchop in Compilation Mode::

* Command Line for gnatchop::

* Switches for gnatchop::

* Examples of gnatchop Usage::

Configuration Pragmas

* Handling of Configuration Pragmas::

* The Configuration Pragmas Files::

Handling Arbitrary File Naming Conventions Using gnatname

* Arbitrary File Naming Conventions::

* Running gnatname::

* Switches for gnatname::

* Examples of gnatname Usage::

The Cross-Referencing Tools gnatxref and gnatfind

* Switches for gnatxref::

* Switches for gnatfind::

* Project Files for gnatxref and gnatfind::

* Regular Expressions in gnatfind and gnatxref::

* Examples of gnatxref Usage::

* Examples of gnatfind Usage::

The GNAT Pretty-Printer gnatpp

* Switches for gnatpp::

* Formatting Rules::

The GNAT Metrics Tool gnatmetric

* Switches for gnatmetric::

File Name Krunching Using gnatkr

* About gnatkr::

* Using gnatkr::

* Krunching Method::

* Examples of gnatkr Usage::

Preprocessing Using gnatprep

* Preprocessing Symbols::

* Using gnatprep::

* Switches for gnatprep::

* Form of Definitions File::

* Form of Input Text for gnatprep::

The GNAT Library Browser gnatls

* Running gnatls::

* Switches for gnatls::

* Examples of gnatls Usage::

Cleaning Up Using gnatclean

* Running gnatclean::

* Switches for gnatclean::

@c * Examples of gnatclean Usage::

@ifclear vms

GNAT and Libraries

* Introduction to Libraries in GNAT::

* General Ada Libraries::

* Stand-alone Ada Libraries::

* Rebuilding the GNAT Run-Time Library::

Using the GNU make Utility

* Using gnatmake in a Makefile::

* Automatically Creating a List of Directories::

* Generating the Command Line Switches::

* Overcoming Command Line Length Limits::

@end ifclear

Memory Management Issues

* Some Useful Memory Pools::

* The GNAT Debug Pool Facility::

@ifclear vms

* The gnatmem Tool::

@end ifclear

Stack Related Facilities

* Stack Overflow Checking::

* Static Stack Usage Analysis::

* Dynamic Stack Usage Analysis::

Some Useful Memory Pools

The GNAT Debug Pool Facility

@ifclear vms

The gnatmem Tool

* Running gnatmem::

* Switches for gnatmem::

* Example of gnatmem Usage::

@end ifclear

Verifying Properties Using gnatcheck

Sample Bodies Using gnatstub

* Running gnatstub::

* Switches for gnatstub::

Creating Unit Tests Using gnattest

* Running gnattest::

* Switches for gnattest::

* Project Attributes for gnattest::

* Simple Example::

* Setting Up and Tearing Down the Testing Environment::

* Regenerating Tests::

* Default Test Behavior::

* Testing Primitive Operations of Tagged Types::

* Testing Inheritance::

* Tagged Types Substitutability Testing::

* Testing with Contracts::

* Additional Tests::

* Current Limitations::

Other Utility Programs

* Using Other Utility Programs with GNAT::

* The External Symbol Naming Scheme of GNAT::

* Converting Ada Files to html with gnathtml::

@ifclear vms

Code Coverage and Profiling

* Code Coverage of Ada Programs using gcov::

* Profiling an Ada Program using gprof::

@end ifclear

Running and Debugging Ada Programs

* The GNAT Debugger GDB::

* Running GDB::

* Introduction to GDB Commands::

* Using Ada Expressions::

* Calling User-Defined Subprograms::

* Using the Next Command in a Function::

* Ada Exceptions::

* Ada Tasks::

* Debugging Generic Units::

* Remote Debugging using gdbserver::

* GNAT Abnormal Termination or Failure to Terminate::

* Naming Conventions for GNAT Source Files::

* Getting Internal Debugging Information::

* Stack Traceback::

@ifset vms

* LSE::

@end ifset

@ifset vms

Compatibility with HP Ada

* Ada Language Compatibility::

* Differences in the Definition of Package System::

* Language-Related Features::

* The Package STANDARD::

* The Package SYSTEM::

* Tasking and Task-Related Features::

* Pragmas and Pragma-Related Features::

* Library of Predefined Units::

* Bindings::

* Main Program Definition::

* Implementation-Defined Attributes::

* Compiler and Run-Time Interfacing::

* Program Compilation and Library Management::

* Input-Output::

* Implementation Limits::

* Tools and Utilities::

Language-Related Features

* Integer Types and Representations::

* Floating-Point Types and Representations::

* Pragmas Float_Representation and Long_Float::

* Fixed-Point Types and Representations::

* Record and Array Component Alignment::

* Address Clauses::

* Other Representation Clauses::

Tasking and Task-Related Features

* Implementation of Tasks in HP Ada for OpenVMS Alpha Systems::

* Assigning Task IDs::

* Task IDs and Delays::

* Task-Related Pragmas::

* Scheduling and Task Priority::

* The Task Stack::

* External Interrupts::

Pragmas and Pragma-Related Features

* Restrictions on the Pragma INLINE::

* Restrictions on the Pragma INTERFACE::

* Restrictions on the Pragma SYSTEM_NAME::

Library of Predefined Units

* Changes to DECLIB::

Bindings

* Shared Libraries and Options Files::

* Interfaces to C::

@end ifset

Platform-Specific Information for the Run-Time Libraries

* Summary of Run-Time Configurations::

* Specifying a Run-Time Library::

* Choosing the Scheduling Policy::

* Solaris-Specific Considerations::

* Linux-Specific Considerations::

* AIX-Specific Considerations::

* Irix-Specific Considerations::

* RTX-Specific Considerations::

* HP-UX-Specific Considerations::

Example of Binder Output File

Elaboration Order Handling in GNAT

* Elaboration Code::

* Checking the Elaboration Order::

* Controlling the Elaboration Order::

* Controlling Elaboration in GNAT - Internal Calls::

* Controlling Elaboration in GNAT - External Calls::

* Default Behavior in GNAT - Ensuring Safety::

* Treatment of Pragma Elaborate::

* Elaboration Issues for Library Tasks::

* Mixing Elaboration Models::

* What to Do If the Default Elaboration Behavior Fails::

* Elaboration for Access-to-Subprogram Values::

* Summary of Procedures for Elaboration Control::

* Other Elaboration Order Considerations::

Conditional Compilation

* Use of Boolean Constants::

* Debugging - A Special Case::

* Conditionalizing Declarations::

* Use of Alternative Implementations::

* Preprocessing::

Inline Assembler

* Basic Assembler Syntax::

* A Simple Example of Inline Assembler::

* Output Variables in Inline Assembler::

* Input Variables in Inline Assembler::

* Inlining Inline Assembler Code::

* Other Asm Functionality::

Compatibility and Porting Guide

* Compatibility with Ada 83::

* Compatibility between Ada 95 and Ada 2005::

* Implementation-dependent characteristics::

@ifclear vms

@c This brief section is only in the non-VMS version

@c The complete chapter on HP Ada issues is in the VMS version

* Compatibility with HP Ada 83::

@end ifclear

* Compatibility with Other Ada Systems::

* Representation Clauses::

@ifset vms

* Transitioning to 64-Bit GNAT for OpenVMS::

@end ifset

@ifset unw

Microsoft Windows Topics

* Using GNAT on Windows::

* CONSOLE and WINDOWS subsystems::

* Temporary Files::

* Mixed-Language Programming on Windows::

* Windows Calling Conventions::

* Introduction to Dynamic Link Libraries (DLLs)::

* Using DLLs with GNAT::

* Building DLLs with GNAT::

* GNAT and Windows Resources::

* Debugging a DLL::

* Setting Stack Size from gnatlink::

* Setting Heap Size from gnatlink::

@end ifset

* Index::

@end menu

@end ifnottex

@node About This Guide

@unnumbered About This Guide

@noindent

@ifset vms

This guide describes the use of @value{EDITION},

a compiler and software development toolset for the full Ada

programming language, implemented on OpenVMS for HP's Alpha and

Integrity server (I64) platforms.

@end ifset

@ifclear vms

This guide describes the use of @value{EDITION},

a compiler and software development

toolset for the full Ada programming language.

@end ifclear

It documents the features of the compiler and tools, and explains

how to use them to build Ada applications.

@value{EDITION} implements Ada 95 and Ada 2005, and it may also be invoked in

Ada 83 compatibility mode.

By default, @value{EDITION} assumes @value{DEFAULTLANGUAGEVERSION},

but you can override with a compiler switch

(@pxref{Compiling Different Versions of Ada})

to explicitly specify the language version.

Throughout this manual, references to ``Ada'' without a year suffix

apply to both the Ada 95 and Ada 2005 versions of the language.

@ifclear FSFEDITION

For ease of exposition, ``@value{EDITION}'' will be referred to simply as

``GNAT'' in the remainder of this document.

@end ifclear

@menu

* What This Guide Contains::

* What You Should Know before Reading This Guide::

* Related Information::

* Conventions::

@end menu

@node What This Guide Contains

@unnumberedsec What This Guide Contains

@noindent

This guide contains the following chapters:

@itemize @bullet

@item

@ref{Getting Started with GNAT}, describes how to get started compiling

and running Ada programs with the GNAT Ada programming environment.

@item

@ref{The GNAT Compilation Model}, describes the compilation model used

by GNAT.

@item

@ref{Compiling Using gcc}, describes how to compile

Ada programs with @command{gcc}, the Ada compiler.

@item

@ref{Binding Using gnatbind}, describes how to

perform binding of Ada programs with @code{gnatbind}, the GNAT binding

utility.

@item

@ref{Linking Using gnatlink},

describes @command{gnatlink}, a

program that provides for linking using the GNAT run-time library to

construct a program. @command{gnatlink} can also incorporate foreign language

object units into the executable.

@item

@ref{The GNAT Make Program gnatmake}, describes @command{gnatmake}, a

utility that automatically determines the set of sources

needed by an Ada compilation unit, and executes the necessary compilations

binding and link.

@item

@ref{Improving Performance}, shows various techniques for making your

Ada program run faster or take less space.

It discusses the effect of the compiler's optimization switch and

also describes the @command{gnatelim} tool and unused subprogram/data

elimination.

@item

@ref{Renaming Files Using gnatchop}, describes

@code{gnatchop}, a utility that allows you to preprocess a file that

contains Ada source code, and split it into one or more new files, one

for each compilation unit.

@item

@ref{Configuration Pragmas}, describes the configuration pragmas

handled by GNAT.

@item

@ref{Handling Arbitrary File Naming Conventions Using gnatname},

shows how to override the default GNAT file naming conventions,

either for an individual unit or globally.

@item

@ref{GNAT Project Manager}, describes how to use project files

to organize large projects.

@item

@ref{The Cross-Referencing Tools gnatxref and gnatfind}, discusses

@code{gnatxref} and @code{gnatfind}, two tools that provide an easy

way to navigate through sources.

@item

@ref{The GNAT Pretty-Printer gnatpp}, shows how to produce a reformatted

version of an Ada source file with control over casing, indentation,

comment placement, and other elements of program presentation style.

@item

@ref{The GNAT Metric Tool gnatmetric}, shows how to compute various

metrics for an Ada source file, such as the number of types and subprograms,

and assorted complexity measures.

@item

@ref{File Name Krunching Using gnatkr}, describes the @code{gnatkr}

file name krunching utility, used to handle shortened

file names on operating systems with a limit on the length of names.

@item

@ref{Preprocessing Using gnatprep}, describes @code{gnatprep}, a

preprocessor utility that allows a single source file to be used to

generate multiple or parameterized source files by means of macro

substitution.

@item

@ref{The GNAT Library Browser gnatls}, describes @code{gnatls}, a

utility that displays information about compiled units, including dependences

on the corresponding sources files, and consistency of compilations.

@item

@ref{Cleaning Up Using gnatclean}, describes @code{gnatclean}, a utility

to delete files that are produced by the compiler, binder and linker.

@ifclear vms

@item

@ref{GNAT and Libraries}, describes the process of creating and using

Libraries with GNAT. It also describes how to recompile the GNAT run-time

library.

@item

@ref{Using the GNU make Utility}, describes some techniques for using

the GNAT toolset in Makefiles.

@end ifclear

@item

@ref{Memory Management Issues}, describes some useful predefined storage pools

and in particular the GNAT Debug Pool facility, which helps detect incorrect

memory references.

@ifclear vms

It also describes @command{gnatmem}, a utility that monitors dynamic

allocation and deallocation and helps detect ``memory leaks''.

@end ifclear

@item

@ref{Stack Related Facilities}, describes some useful tools associated with

stack checking and analysis.

@item

@ref{Verifying Properties Using gnatcheck}, discusses @code{gnatcheck},

a utility that checks Ada code against a set of rules.

@item

@ref{Creating Sample Bodies Using gnatstub}, discusses @code{gnatstub},

a utility that generates empty but compilable bodies for library units.

@item

@ref{Creating Unit Tests Using gnattest}, discusses @code{gnattest},

a utility that generates unit testing templates for library units.

@item

@ref{Generating Ada Bindings for C and C++ headers}, describes how to

generate automatically Ada bindings from C and C++ headers.

@item

@ref{Other Utility Programs}, discusses several other GNAT utilities,

including @code{gnathtml}.

@ifclear vms

@item

@ref{Code Coverage and Profiling}, describes how to perform a structural

coverage and profile the execution of Ada programs.

@end ifclear

@item

@ref{Running and Debugging Ada Programs}, describes how to run and debug

Ada programs.

@ifset vms

@item

@ref{Compatibility with HP Ada}, details the compatibility of GNAT with

HP Ada 83 @footnote{``HP Ada'' refers to the legacy product originally

developed by Digital Equipment Corporation and currently supported by HP.}

for OpenVMS Alpha. This product was formerly known as DEC Ada,

@cindex DEC Ada

and for

historical compatibility reasons, the relevant libraries still use the

DEC prefix.

@end ifset

@item

@ref{Platform-Specific Information for the Run-Time Libraries},

describes the various run-time

libraries supported by GNAT on various platforms and explains how to

choose a particular library.

@item

@ref{Example of Binder Output File}, shows the source code for the binder

output file for a sample program.

@item

@ref{Elaboration Order Handling in GNAT}, describes how GNAT helps

you deal with elaboration order issues.

@item

@ref{Conditional Compilation}, describes how to model conditional compilation,

both with Ada in general and with GNAT facilities in particular.

@item

@ref{Inline Assembler}, shows how to use the inline assembly facility

in an Ada program.

@item

@ref{Compatibility and Porting Guide}, contains sections on compatibility

of GNAT with other Ada development environments (including Ada 83 systems),

to assist in porting code from those environments.

@ifset unw

@item

@ref{Microsoft Windows Topics}, presents information relevant to the

Microsoft Windows platform.

@end ifset

@end itemize

@c *************************************************

@node What You Should Know before Reading This Guide

@c *************************************************

@unnumberedsec What You Should Know before Reading This Guide

@cindex Ada 95 Language Reference Manual

@cindex Ada 2005 Language Reference Manual

@noindent

This guide assumes a basic familiarity with the Ada 95 language, as

described in the International Standard ANSI/ISO/IEC-8652:1995, January

1995.

It does not require knowledge of the new features introduced by Ada 2005,

(officially known as ISO/IEC 8652:1995 with Technical Corrigendum 1

and Amendment 1).

Both reference manuals are included in the GNAT documentation

package.

@node Related Information

@unnumberedsec Related Information

@noindent

For further information about related tools, refer to the following

documents:

@itemize @bullet

@item

@xref{Top, GNAT Reference Manual, About This Guide, gnat_rm, GNAT

Reference Manual}, which contains all reference material for the GNAT

implementation of Ada.

@ifset unw

@item

@cite{Using the GNAT Programming Studio}, which describes the GPS

Integrated Development Environment.

@item

@cite{GNAT Programming Studio Tutorial}, which introduces the

main GPS features through examples.