Ada Programming/Aspects

When entities like variables or subprograms are declared, certain properties thereof normally are left to the compiler to specify (like the size or the address of a variable, the calling convention of a subprogram). Properties which may be queried are called Attributes; those which may be specified are called Aspects. Some aspects correspond with attributes which then have the same name. Aspects and attributes are defined in the Ada Reference Manual, pragmas in.

Description
Aspects are certain properties of an entity that may be specified, depending on the kind of entity, by an aspect specification as part of its declaration or by a separate attribute definition clause or pragma declaration. Aspect_Specification ::= Aspect_Name [ => Aspect_Definition] {, Aspect_Name [ => Aspect_Definition] } ;

Attribute_Definition_Clause ::= entity_name'attribute_designator expression; | entity_name'attribute_designator  name;

Name (Parameter_List);

If an aspect is not specified, it depends on the aspect itself whether its value is left to the compiler or prescribed in the Ada RM.

The specification of a  valued aspect may omit the aspect definition, which then has the value.

Examples of such properties are the size of a type, i.e. the number of bits a stand-alone object of that type will use; or that a subprogram will not return from its call: aspect. This latter one is an example of an aspect that has a  value.

List of language defined aspects
If not marked otherwise, an aspect is specified by an Aspect_Specification.

An aspect marked Ada 2012 is an Ada 2012 language functionality not available in previous Ada generations.

An aspect marked Ada 2022 is an Ada 2022 language functionality not available in previous Ada generations.

Aspects not so marked, were previously defined via pragmas or attribute definition clauses. This is still possible, but deprecated.

A – D

 * Aggregate (Ada 2022; Aspect_Specification)
 * Address (Attribute_Definition_Clause, Aspect_Specification)
 * Alignment (Attribute_Definition_Clause)
 * (Pragma)
 * Allows_Exit (Ada 2022; Aspect_Specification)
 * Bit_Order (Attribute_Definition_Clause)
 * Coding (Enumeration_Representation_Clause)
 * Component_Size (Attribute_Definition_Clause)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2012)
 * Default_Initial_Condition (Ada 2022; Aspect_Specification)
 * (Ada 2012)
 * (Ada 2012; Pragma)
 * (Ada 2012)
 * Dispatching (Ada 2022; Aspect_Specification)
 * (Ada 2012)
 * (Ada 2012; Aspect_Specification, Pragma)
 * (Ada 2012)
 * (Ada 2012)
 * Dispatching (Ada 2022; Aspect_Specification)
 * (Ada 2012)
 * (Ada 2012; Aspect_Specification, Pragma)
 * (Ada 2012)

E – O

 * (Pragma)
 * (Ada 2012)
 * (Attribute_Definition_Clause)
 * Full_Access_Only (Ada 2022; Aspect_Specification)
 * Global (Ada 2022; Aspect_Specification)
 * Global'Class (Ada 2022; Aspect_Specification)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2012)
 * (Attribute_Definition_Clause)
 * (Ada 2012; Attribute_Definition_Clause)
 * Integer_Literal (Ada 2022; Aspect_Specification)
 * (Ada 2012)
 * Iterator_View (Ada 2022; Aspect_Specification)
 * Layout (Record_Representation_Clause)
 * Machine_Radix (Attribute_Definition_Clause)
 * Max_Entry_Queue_Length (Ada 2022; Aspect_Specification)
 * No_Controlled_Parts (Ada 2022; Aspect_Specification)
 * Nonblocking (Ada 2022; Aspect_Specification)
 * (Attribute_Definition_Clause)
 * (Ada 2012; Attribute_Definition_Clause)
 * Machine_Radix (Attribute_Definition_Clause)
 * Max_Entry_Queue_Length (Ada 2022; Aspect_Specification)
 * No_Controlled_Parts (Ada 2022; Aspect_Specification)
 * Nonblocking (Ada 2022; Aspect_Specification)
 * (Attribute_Definition_Clause)
 * (Ada 2012; Attribute_Definition_Clause)
 * (Attribute_Definition_Clause)
 * (Ada 2012; Attribute_Definition_Clause)

P – Z

 * Parallel_Calls (Ada 2022; Aspect_Specification)
 * Parallel_Iterator (Ada 2022; Aspect_Specification)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2012)
 * (Pragma)
 * Preelaborable_Initialization (Ada 2022; Aspect_Specification)
 * (Pragma)
 * Put_Image (Ada 2022; Aspect_Specification)
 * (Attribute_Definition_Clause)
 * (Ada 2012; Attribute_Definition_Clause)
 * Real_Literal (Ada 2022; Aspect_Specification)
 * (Ada 2022; Aspect_Specification)
 * (Pragma)
 * (Pragma)
 * (Pragma)
 * Size (Attribute_Definition_Clause)
 * (Attribute_Definition_Clause)
 * Stable_Properties (Ada 2022; Aspect_Specification)
 * Stable_Properties'Class (Ada 2022; Aspect_Specification)
 * Static (Ada 2022; Aspect_Specification)
 * (Ada 2012)
 * (Attribute_Definition_Clause)
 * (Attribute_Definition_Clause)
 * (Attribute_Definition_Clause)
 * String_Literal (Ada 2022; Aspect_Specification)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2012)
 * (Ada 2022; Aspect_Specification)
 * Use_Formal (Ada 2022; Aspect_Specification)
 * (Ada 2012)
 * (Attribute_Definition_Clause)
 * (Ada 2012; Attribute_Definition_Clause)
 * Yield (Ada 2022; Aspect_Specification)
 * (Attribute_Definition_Clause)
 * (Ada 2012; Attribute_Definition_Clause)
 * Yield (Ada 2022; Aspect_Specification)
 * Yield (Ada 2022; Aspect_Specification)

List of implementation defined aspects
The following pragmas are not available in all Ada compilers, only in those that had implemented them.

Currently, there are only listed the implementation-defined pragmas of a few compilers. You can help Wikibooks adding specific aspects of other compilers:


 * GNAT : Implementation defined aspect of the GNAT compiler from AdaCore and FSF.


 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)
 * (GNAT)

Wikibook

 * Ada Programming
 * Ada Programming/Attributes
 * Ada Programming/Keywords
 * Ada Programming/Pragmas

Ada 2022

 * 13.1.1: Aspect Specifications
 * K.1: Language-Defined Aspects
 * J.15: Aspect-related Pragmas