www.delorie.com/gnu/docs/gcc/gnat_ug_toc.html

search

	Buy the book!

Untitled Document

Table of Contents

About This Guide

What This Guide Contains
What You Should Know before Reading This Guide
Related Information
Conventions

1. Getting Started with GNAT

1.1 Running GNAT
1.2 Running a Simple Ada Program
1.3 Running a Program with Multiple Units
1.4 Using the gnatmake Utility
1.5 Introduction to Glide and GVD

1.5.1 Building a New Program with Glide
1.5.2 Simple Debugging with GVD
1.5.3 Other Glide Features

2. The GNAT Compilation Model

2.1 Source Representation
2.2 Foreign Language Representation

2.2.1 Latin-1
2.2.2 Other 8-Bit Codes
2.2.3 Wide Character Encodings

2.3 File Naming Rules
2.4 Using Other File Names
2.5 Alternative File Naming Schemes
2.6 Generating Object Files
2.7 Source Dependencies
2.8 The Ada Library Information Files
2.9 Binding an Ada Program
2.10 Mixed Language Programming

2.10.1 Interfacing to C
2.10.2 Calling Conventions

2.11 Building Mixed Ada & C++ Programs

2.11.1 Interfacing to C++
2.11.2 Linking a Mixed C++ & Ada Program
2.11.3 A Simple Example
2.11.4 Adapting the Run Time to a New C++ Compiler

2.12 Comparison between GNAT and C/C++ Compilation Models
2.13 Comparison between GNAT and Conventional Ada Library Models

3. Compiling Using gcc

3.1 Compiling Programs
3.2 Switches for gcc

3.2.1 Output and Error Message Control
3.2.2 Debugging and Assertion Control
3.2.3 Validity Checking
3.2.4 Style Checking
3.2.5 Run-Time Checks
3.2.6 Stack Overflow Checking
3.2.7 Run-Time Control
3.2.8 Using gcc for Syntax Checking
3.2.9 Using gcc for Semantic Checking
3.2.10 Compiling Ada 83 Programs
3.2.11 Character Set Control
3.2.12 File Naming Control
3.2.13 Subprogram Inlining Control
3.2.14 Auxiliary Output Control
3.2.15 Debugging Control
3.2.16 Units to Sources Mapping Files

3.3 Search Paths and the Run-Time Library (RTL)
3.4 Order of Compilation Issues
3.5 Examples

4. Binding Using gnatbind

4.1 Running gnatbind
4.2 Generating the Binder Program in C
4.3 Consistency-Checking Modes
4.4 Binder Error Message Control
4.5 Elaboration Control
4.6 Output Control
4.7 Binding with Non-Ada Main Programs
4.8 Binding Programs with No Main Subprogram
4.9 Summary of Binder Switches
4.10 Command-Line Access
4.11 Search Paths for gnatbind
4.12 Examples of gnatbind Usage

5. Linking Using gnatlink

5.1 Running gnatlink
5.2 Switches for gnatlink
5.3 Setting Stack Size from gnatlink
5.4 Setting Heap Size from gnatlink

6. The GNAT Make Program gnatmake

6.1 Running gnatmake
6.2 Switches for gnatmake
6.3 Mode Switches for gnatmake
6.4 Notes on the Command Line
6.5 How gnatmake Works
6.6 Examples of gnatmake Usage

7. Renaming Files Using gnatchop

7.1 Handling Files with Multiple Units
7.2 Operating gnatchop in Compilation Mode
7.3 Command Line for gnatchop
7.4 Switches for gnatchop
7.5 Examples of gnatchop Usage

8. Configuration Pragmas

8.1 Handling of Configuration Pragmas
8.2 The Configuration Pragmas Files

9. Handling Arbitrary File Naming Conventions Using gnatname

9.1 Arbitrary File Naming Conventions
9.2 Running gnatname
9.3 Switches for gnatname
9.4 Examples of gnatname Usage

10. GNAT Project Manager

10.1 Introduction

10.1.1 Project Files

10.2 Examples of Project Files

10.2.1 Common Sources with Different Switches and Different Output Directories

Source Files
Specifying the Object Directory
Specifying the Exec Directory
Project File Packages
Specifying Switch Settings
Main Subprograms
Source File Naming Conventions
Source Language(s)

10.2.2 Using External Variables
10.2.3 Importing Other Projects
10.2.4 Extending a Project

10.3 Project File Syntax

10.3.1 Basic Syntax
10.3.2 Packages
10.3.3 Expressions
10.3.4 String Types
10.3.5 Variables
10.3.6 Attributes
10.3.7 Associative Array Attributes
10.3.8 case Constructions

10.4 Objects and Sources in Project Files

10.4.1 Object Directory
10.4.2 Exec Directory
10.4.3 Source Directories
10.4.4 Source File Names

10.5 Importing Projects
10.6 Project Extension
10.7 External References in Project Files
10.8 Packages in Project Files
10.9 Variables from Imported Projects
10.10 Naming Schemes
10.11 Library Projects
10.12 Switches Related to Project Files
10.13 Tools Supporting Project Files

10.13.1 gnatmake and Project Files

10.13.1.1 Switches and Project Files
10.13.1.2 Project Files and Main Subprograms

10.13.2 The GNAT Driver and Project Files
10.13.3 Glide and Project Files

10.14 An Extended Example
10.15 Project File Complete Syntax

11. Elaboration Order Handling in GNAT

11.1 Elaboration Code in Ada 95
11.2 Checking the Elaboration Order in Ada 95
11.3 Controlling the Elaboration Order in Ada 95
11.4 Controlling Elaboration in GNAT - Internal Calls
11.5 Controlling Elaboration in GNAT - External Calls
11.6 Default Behavior in GNAT - Ensuring Safety
11.7 Elaboration Issues for Library Tasks
11.8 Mixing Elaboration Models
11.9 What to Do If the Default Elaboration Behavior Fails
11.10 Elaboration for Access-to-Subprogram Values
11.11 Summary of Procedures for Elaboration Control
11.12 Other Elaboration Order Considerations

12. The Cross-Referencing Tools gnatxref and gnatfind

12.1 gnatxref Switches
12.2 gnatfind Switches
12.3 Project Files for gnatxref and gnatfind
12.4 Regular Expressions in gnatfind and gnatxref
12.5 Examples of gnatxref Usage

12.5.1 General Usage
12.5.2 Using gnatxref with vi

12.6 Examples of gnatfind Usage

13. File Name Krunching Using gnatkr

13.1 About gnatkr
13.2 Using gnatkr
13.3 Krunching Method
13.4 Examples of gnatkr Usage

14. Preprocessing Using gnatprep

14.1 Using gnatprep
14.2 Switches for gnatprep
14.3 Form of Definitions File
14.4 Form of Input Text for gnatprep
14.5 Switches for gnatlbr
14.6 Example of gnatlbr Usage

15. The GNAT Library Browser gnatls

15.1 Running gnatls
15.2 Switches for gnatls
15.3 Example of gnatls Usage

16. GNAT and Libraries

16.1 Creating an Ada Library
16.2 Installing an Ada Library
16.3 Using an Ada Library
16.4 Creating an Ada Library to be Used in a Non-Ada Context

16.4.1 Creating the Library
16.4.2 Using the Library
16.4.3 The Finalization Phase
16.4.4 Restrictions in Libraries

16.5 Rebuilding the GNAT Run-Time Library

17. Using the GNU make Utility

17.1 Using gnatmake in a Makefile
17.2 Automatically Creating a List of Directories
17.3 Generating the Command Line Switches
17.4 Overcoming Command Line Length Limits

18. Finding Memory Problems with gnatmem

18.1 Running gnatmem (GDB Mode)
18.2 Running gnatmem (GMEM Mode)
18.3 Switches for gnatmem
18.4 Example of gnatmem Usage
18.5 GDB and GMEM Modes
18.6 Implementation Note

18.6.1 gnatmem Using GDB Mode
18.6.2 gnatmem Using GMEM Mode

19. Finding Memory Problems with GNAT Debug Pool
20. Creating Sample Bodies Using gnatstub

20.1 Running gnatstub
20.2 Switches for gnatstub

21. Reducing the Size of Ada Executables with gnatelim

21.1 About gnatelim
21.2 Eliminate Pragma
21.3 Tree Files
21.4 Preparing Tree and Bind Files for gnatelim
21.5 Running gnatelim
21.6 Correcting the List of Eliminate Pragmas
21.7 Making Your Executables Smaller
21.8 Summary of the gnatelim Usage Cycle

22. Other Utility Programs

22.1 Using Other Utility Programs with GNAT
22.2 The gnatpsta Utility Program
22.3 The External Symbol Naming Scheme of GNAT
22.4 Ada Mode for Glide

22.4.1 General Features:
22.4.2 Ada Mode Features That Help Understanding Code:
22.4.3 Glide Support for Writing Ada Code:

22.5 Converting Ada Files to html with gnathtml
22.6 Installing gnathtml

23. Running and Debugging Ada Programs

23.1 The GNAT Debugger GDB
23.2 Running GDB
23.3 Introduction to GDB Commands
23.4 Using Ada Expressions
23.5 Calling User-Defined Subprograms
23.6 Using the Next Command in a Function
23.7 Breaking on Ada Exceptions
23.8 Ada Tasks
23.9 Debugging Generic Units
23.10 GNAT Abnormal Termination or Failure to Terminate
23.11 Naming Conventions for GNAT Source Files
23.12 Getting Internal Debugging Information
23.13 Stack Traceback

23.13.1 Non-Symbolic Traceback

23.13.1.1 Tracebacks From an Unhandled Exception
23.13.1.2 Tracebacks From Exception Occurrences
23.13.1.3 Tracebacks From Anywhere in a Program

23.13.2 Symbolic Traceback

23.13.2.1 Tracebacks From Exception Occurrences
23.13.2.2 Tracebacks From Anywhere in a Program

24. Inline Assembler

24.1 Basic Assembler Syntax
24.2 A Simple Example of Inline Assembler
24.3 Output Variables in Inline Assembler
24.4 Input Variables in Inline Assembler
24.5 Inlining Inline Assembler Code
24.6 Other Asm Functionality

24.6.1 The Clobber Parameter
24.6.2 The Volatile Parameter

24.7 A Complete Example

24.7.1 Check_CPU Procedure
24.7.2 Intel_CPU Package Specification
24.7.3 Intel_CPU Package Body

25. Performance Considerations

25.1 Controlling Run-Time Checks
25.2 Optimization Levels
25.3 Debugging Optimized Code
25.4 Inlining of Subprograms

GNU Free Documentation License

ADDENDUM: How to use this License for your documents

Index