Curso de Ada - Pragmas

Descripción

Los pragmas son sentencias especiales que controlan el comportamiento del compilador, es decir son directivas de compilador∞. Tienen esta forma estándar:

pragma∞ Nombre (Lista_de_argumentos);

La Lista_de_argumentos es opcional, no todos los pragmas necesitan argumentos.

Ejemplo

Imaginemos que deseamos hacer que una llamada a un subprograma∞ se convierta en una expansión del código en el código objeto generado. Esto se suele hacer con subprogramas que son muy cortos, en los que se tarda más en realizar las operaciones necesarias en código máquina para llamar a la subrutina, que en realizar el código de la subrutina en sí. Para conseguir esta expansión del código se utiliza el pragma Inline∞.

function∞ A_Pesetas (Euros : T_Euros) return∞ T_Pesetas is∞ begin∞ return∞ Euros * 166.386; end∞ A_Pesetas; pragma∞ Inline (A_Pesetas);

Siempre que se llame a A_Pesetas (Precio_en_Euros), el resultado en el código objeto sería equivalente a escribir Precio_en_Euros * 166.386 en lugar de la llamada.

Lista de pragmas definidos por el lenguaje

A continuación se presenta una tabla con los pragmas de Ada, sus argumentos, un enlace a la sección del Manual de referencia de Ada∞ donde se define y una nota entre las que podemos encontrar:

Ada 2005 Este es un nuevo pragma que aparecerá en el estándar de Ada 2005∞. Obsoleto Este es un pragma que se considera obsoleto pero se mantiene por compatibilidad. No es aconsejable usarlo en código nuevo.

A - H

Pragmas de Ada (A - H)|| Pragma || Argumentos || Enlace al ARM || Notas ||
|| All_Calls_Remote∞ || [(library_unit_name)] || E.2.3∞ ||
|| Assert∞ || ([Check =>] boolean_expression[, [Message =>] string_expression]) || 11.4.2∞ || (Ada 2005) ||
|| Assertion_Policy∞ || (policy_identifier) || 11.4.2∞ || (Ada 2005) ||
|| Asynchronous∞ || (local_name) || E.4.1∞ ||
|| Atomic∞ || (local_name) || C.6∞ ||
|| Atomic_Components∞ || (array_local_name) || C.6∞ ||
|| Attach_Handler∞ || (handler_name, expression) || C.3.1∞ ||
|| Controlled∞ || (first_subtype_local_name) || 13.11.3∞ ||
|| Convention∞ || ([Convention =>] convention_identifier, [Entity =>] local_name) || B.1∞ ||
|| Detect_Blocking∞ || || H.5∞ || (Ada 2005) ||
|| Discard_Names∞ || [([On => ] local_name)] || C.5∞ ||
|| Elaborate∞ || (library_unit_name{, library_unit_name}) || 10.2.1∞ ||
|| Elaborate_All∞ || (library_unit_name{, library_unit_name}) || 10.2.1∞ ||
|| Elaborate_Body∞ || [(library_unit_name)] || 10.2.1∞ ||
|| Export∞ || ([Convention =>] convention_identifier, [Entity =>] local_name [, [External_Name =>] string_expression] [, [Link_Name =>] string_expression]) || B.1∞ ||

I - O

Pragmas de Ada (I - O)|| Pragma || Argumentos || Enlace al ARM || Notas ||
|| Import∞ || ([Convention =>] convention_identifier, [Entity =>] local_name [, [External_Name =>] string_expression] [, [Link_Name =>] string_expression]) || B.1∞ ||
|| Detect_Blocking∞ || || || (Ada 2005) ||
|| Inline∞ || (name {, name}) || 6.3.2∞ ||
|| Inspection_Point∞ || [(object_name {, object_name})] || H.3.2∞ ||
|| Interface∞ || || || (Obsoleto) ||
|| Interrupt_Handler∞ || (handler_name) || C.3.1∞ ||
|| Interrupt_Priority∞ || [(expression)] || D.1∞ ||
|| Linker_Options∞ || (string_expression) || B.1∞ ||
|| List∞ || (identifier) || 2.8∞ ||
|| Locking_Policy∞ || (policy_identifier) || D.3∞ ||
|| Memory_Size∞ || || || (Obsoleto) ||
|| No_Return∞ || (procedure_local_name{, procedure_local_name}) || 6.5.1∞ || (Ada 2005) ||
|| Normalize_Scalars∞ || || H.1∞ ||
|| Optimize∞ || (identifier) || 2.8∞ ||

P - R

Pragmas de Ada (P - R)|| Pragma || Argumentos || Enlace al ARM || Notas ||
|| Pack∞ || (first_subtype_local_name) || 13.2∞ ||
|| Page∞ || || 2.8∞ ||
|| Partition_Elaboration_Policy∞ || (policy_identifier) || H.6∞ || (Ada 2005) ||
|| Preelaborable_Initialization∞ || (direct_name) || 10.2.1∞ || (Ada 2005) ||
|| Preelaborate∞ || [(library_unit_name)] || 10.2.1∞ ||
|| Priority∞ || (expression) || D.1∞ ||
|| Priority_Specific_Dispatching∞ || (policy_identifier, first_priority_expression, last_priority_expression) || D.2.2∞ || (Ada 2005) ||
|| Profile∞ || (profile_identifier {, profile_pragma_argument_association}) || D.13∞ || (Ada 2005) Véase Perfil de Ravenscar∞ en Wikipedia. ||
|| Pure∞ || [(library_unit_name)] || 10.2.1∞ ||
|| Queuing_Policy∞ || (policy_identifier) || D.4∞ ||
|| Remote_Call_Interface∞ || [(library_unit_name)] || E.2.3∞ ||
|| Remote_Types∞ || [(library_unit_name)] || E.2.2∞ ||
|| Relative_Deadline∞ || (relative_deadline_expression) || D.2.6∞ || (Ada 2005) ||
|| Restrictions∞ || (restriction{, restriction}) || 13.12∞ ||
|| Reviewable∞ || || H.3.1∞ ||

S - Z

Pragmas de Ada (S - Z)|| Pragma || Argumentos || Enlace al ARM || Notas ||
|| Shared∞ || || || (Obsoleto) ||
|| Shared_Passive∞ || [(library_unit_name)] || E.2.1∞ ||
|| Storage_Size∞ || (expression) || 13.3∞ ||
|| Storage_Unit∞ || || || (Obsoleto) ||
|| Suppress∞ || (identifier [, [On =>] name]) || 11.5∞ ||
|| System_Name∞ || || || (Obsoleto) ||
|| Task_Dispatching_Policy∞ || (policy_identifier ) || D.2.2∞ ||
|| Unchecked_Union∞ || (first_subtype_local_name) || B.3.3∞ || (Ada 2005) ||
|| Unsuppress∞ || (identifier) || 11.5∞ || (Ada 2005) ||
|| Volatile∞ || (local_name) || C.6∞ ||
|| Volatile_Components∞ || (array_local_name) || C.6∞ ||

Lista de pragmas definidos por la implementación

La siguiente lista de pragmas no están disponibles en cualquier compilador, sólo en aquellos que han decidido implementarlos:

GNAT Éste es un pragma definido por la implementación∞ del compilador GNAT∞.

A - C

• Abort_Defer∞ (GNAT)
• Ada_83∞ (GNAT)
• Ada_95∞ (GNAT)
• Ada_05∞ (GNAT)
• Annotate∞ (GNAT)
• Ast_Entry∞ (GNAT)
• C_Pass_By_Copy∞ (GNAT)
• Comment∞ (GNAT)
• Common_Object∞ (GNAT)
• Compile_Time_Warning∞ (GNAT)
• Complex_Representation∞ (GNAT)
• Component_Alignment∞ (GNAT)
• Convention_Identifier∞ (GNAT)
• CPP_Class∞ (GNAT)
• CPP_Constructor∞ (GNAT)
• CPP_Virtual∞ (GNAT)
• CPP_Vtable∞ (GNAT)

D - H

• Debug∞ (GNAT)
• Elaboration_Checks∞ (GNAT)
• Eliminate∞ (GNAT)
• Export_Exception∞ (GNAT)
• Export_Function∞ (GNAT)
• Export_Object∞ (GNAT)
• Export_Procedure∞ (GNAT)
• Export_Value∞ (GNAT)
• Export_Valued_Procedure∞ (GNAT)
• Extend_System∞ (GNAT)
• External∞ (GNAT)
• External_Name_Casing∞ (GNAT)
• Finalize_Storage_Only∞ (GNAT)
• Float_Representation∞ (GNAT)

I - L

• Ident∞ (GNAT)
• Import_Exception∞ (GNAT)
• Import_Function∞ (GNAT)
• Import_Object∞ (GNAT)
• Import_Procedure∞ (GNAT)
• Import_Valued_Procedure∞ (GNAT)
• Initialize_Scalars∞ (GNAT)
• Inline_Always∞ (GNAT)
• Inline_Generic∞ (GNAT)
• Interface_Name∞ (GNAT)
• Interrupt_State∞ (GNAT)
• Keep_Names∞ (GNAT)
• License∞ (GNAT)
• Link_With∞ (GNAT)
• Linker_Alias∞ (GNAT)
• Linker_Section∞ (GNAT)
• Long_Float∞ (GNAT: OpenVMS)

M - S

• Machine_Attribute∞ (GNAT)
• Main_Storage∞ (GNAT)
• Obsolescent∞ (GNAT)
• Passive∞ (GNAT)
• Polling∞ (GNAT)
• Profile_Warnings∞ (GNAT)
• Propagate_Exceptions∞ (GNAT)
• Psect_Object∞ (GNAT)
• Pure_Function∞ (GNAT)
• Restriction_Warnings∞ (GNAT)
• Source_File_Name∞ (GNAT)
• Source_File_Name_Project∞ (GNAT)
• Source_Reference∞ (GNAT)
• Stream_Convert∞ (GNAT)
• Style_Checks∞ (GNAT)
• Subtitle∞ (GNAT)
• Suppress_All∞ (GNAT)
• Suppress_Exception_Locations∞ (GNAT)
• Suppress_Initialization∞ (GNAT)

T - Z

• Task_Info∞ (GNAT)
• Task_Name∞ (GNAT)
• Task_Storage∞ (GNAT)
• Thread_Body∞ (GNAT)
• Time_Slice∞ (GNAT)
• Title∞ (GNAT)
• Unimplemented_Unit∞ (GNAT)
• Universal_Data∞ (GNAT)
• Unreferenced∞ (GNAT)
• Unreserve_All_Interrupts∞ (GNAT)
• Use_VADS_Size∞ (GNAT)
• Validity_Checks∞ (GNAT)
• Warnings∞ (GNAT)
• Weak_External∞ (GNAT)

Manual de referencia de Ada

Ada 95

• 2.8 Pragmas∞
• Annex L: (informative) Language-Defined Pragmas∞

Ada 2005

• 2.8 Pragmas∞
• Annex L (informative) Language-Defined Pragmas∞