gnatpro_toolsuite

Toolsuite

Comprehensive Ada Toolsuite

GPRbuild - Multi-Language Management

GPRbuild is an advanced software tool designed to help automate the construction of multi-language systems. It removes complexity from multi-language development by allowing developers to quickly and easily compile and link software written in a combination of languages including Ada, Assembler, C, C++, and Fortran. Easily extendable by users to cover new toolchains and languages it is primarily aimed at projects of all sizes organized into subsystems and libraries and is particularly well-suited for compiled languages.

Multi-Language Management Made Easy

Designed to work with any version of AdaCore’s GNAT Pro development environment GPRbuild features a built in knowledge base that understands the characteristics of compilers across a wide variety of languages. Rather than having to maintain complex rules for building each components of a system, developers simply specify sources location and compiler options. GPRbuild automatically manages their integration into a complete system.

Previously developers needed to manually link components of multi-language applications, which relied on in-depth knowledge of each compiler involved as well as how they interact with each other. This process had to be repeated if new versions of compilers were used as there was no simple way of collecting and sharing integration data. GPRbuild’s inherent knowledge base covers most commonly used toolchains and languages but also allows developers to add their own information to standardise native and cross-platform configuration.

To browse online documentation, please click here.

GPRbuild manages a three step build process

Compilation:

Each compilation unit of every subsystem is examined in turn, checked for consistency and compiled or recompiled when necessary by the appropriate compiler. The recompilation decision is based on dependency information usually automatically captured by a former compilation.

Post-compilation (binding):

Compiled units of a given language are passed to a language specific post-compilation tool where it exists. It is also during this phase that objects are grouped into static or dynamic libraries as specified.

Linking:

All units or libraries from all subsystems are passed to a linker tool specific to the set of toolchains used together.

GPRbuild takes as its main input a project file defining the build characteristics of the system under construction such as: which sources to use, where to find them, where to store the objects produced by the compiler and which options the various tools should be invoked with.

While GPRbuild is generic in the sense that it provides equivalent build features for all supported languages, it also allows the addition of new languages and new toolchains and provides a means of configuring aspects including:

  • Language characteristics (such as source naming conventions)
  • Toolchain characteristics (such as compiler invocation)
  • Subsystem characteristics (such as compiler default options)
  • Source file characteristics (such as file specific compilation options)

Knowledge Center

Developer Gems    

Live Docs

  • GPRbuild User’s Guide »

    This is the main documentation for GPRbuild, a generic build tool designed for the construction of large multi-language systems organized into subsystems and libraries.

Development Log

Press Releases

In the Press

Events