Ada: Exceptions

Ada: Exceptions

How to deal with exceptions in Ada

In Ada, exceptions are a mechanism for handling exceptional situations that occur during program execution. They are designed to provide a structured way to deal with errors and other unexpected conditions, ensuring that the program can continue running in a controlled manner.

Exception Declaration

An exception is declared using the exception keyword, followed by the exception name. The exception name can be any user-defined identifier.

Code snippet

exception MyException;

Raising an Exception

An exception is raised using the raise keyword, followed by the exception name. The raise statement can appear anywhere in the program code where an exceptional condition is detected.

Code snippet

raise MyException;

Handling an Exception

Exceptions are handled using exception handlers, which are defined using the exception keyword followed by the exception name and a sequence of statements. Exception handlers can appear in any block scope, including subprograms, packages, and the main program.

Code snippet

when MyException =>
    Put_Line("MyException occurred!");

In this example, the exception handler for MyException will execute the Put_Line statement when the exception is raised.

Predefined Exceptions

Ada provides several predefined exceptions that represent common error conditions. These predefined exceptions are declared in the package Standard.

Code snippet

package Standard is
   pragma Elaborate;
   -- ...
   type Exception;
   exception Constraint_Error;
   exception Program_Error;
   exception Num_Error;
   exception Divide_By_Zero;
   -- ...
end Standard;

The predefined exceptions can be used to handle specific types of errors, such as constraint violations, arithmetic errors, and program errors.

Advantages of Exceptions

Exceptions offer several advantages for handling exceptional situations:

  • Structured Error Handling: Exceptions provide a structured way to handle errors, making the code more readable and maintainable.

  • Localized Error Management: Exceptions allow for localized error handling, preventing errors from propagating through the entire program.

  • Graceful Degradation: Exceptions enable graceful degradation, allowing the program to recover from errors and continue running in a limited capacity.

Disadvantages of Exceptions

Exceptions also have some potential disadvantages:

  • Performance Overhead: Raising and handling exceptions can introduce some performance overhead, especially in tight loops.

  • Code Complexity: Overuse of exceptions can make the code more complex and difficult to understand.

When to Use Exceptions

Exceptions should be used sparingly, primarily for handling exceptional situations that are rare and unexpected. They should not be used for normal program flow or to control data flow.

In general, exceptions are a valuable tool for handling exceptional situations in Ada programs. They provide a structured and controlled way to deal with errors, ensuring that the program can continue running in a stable and predictable manner.


In the Ada programming language, a pragma is a compiler directive that provides additional information to the compiler, influencing the translation or execution of the program. Pragmas are used to control various aspects of the compilation process, such as optimization, code generation, and resource management. They can also be used to provide implementation-specific directives.

Types of Pragmas

Ada pragmas can be broadly categorized into two main types:

  1. Language-defined pragmas: These are pragmas defined by the Ada standard and are supported by all Ada compilers. They provide a consistent and standardized way to control the behavior of the compiler. Examples include pragmas for optimization, listing control, and interfacing with other languages.

  2. Implementation-defined pragmas: These are pragmas defined by specific Ada compiler implementations and may vary between compilers. They provide additional functionality or control over compiler-specific features. Examples include pragmas for memory management, code generation, and debugging support.

Syntax of Pragmas

Pragmas follow a specific syntax:

Code snippet

pragma PragmaName(ParameterList);
  • PragmaName is the name of the pragma, typically an identifier.

  • ParameterList is an optional list of parameters that provide additional information to the pragma. The specific parameters depend on the pragma being used.

Examples of Pragmas

Here are some examples of commonly used pragmas in Ada:

  • pragma Optimize: Controls the optimization level of the generated code.

  • pragma Suppress: Suppresses compiler warnings or messages.

  • pragma Interface: Specifies the C interface for Ada types.

  • pragma Task_Priority: Sets the priority of Ada tasks.

  • pragma Elaborate: Controls the elaboration of Ada packages.

  • pragma Import: Imports C or assembly code into an Ada program.

Benefits of Pragmas

Pragmas offer several benefits for Ada programming:

  • Fine-grained Control: They allow for fine-grained control over the compilation and execution of Ada programs.

  • Optimization and Efficiency: They can be used to optimize code performance, memory usage, and resource management.

  • Implementation-specific Features: They provide access to implementation-specific features and capabilities.

  • Interfacing with Other Languages: They facilitate interfacing with C and assembly code.


Pragmas are an essential feature of the Ada programming language, providing a powerful mechanism for controlling the behavior of the compiler and customizing the execution of Ada programs. They play a crucial role in optimizing code performance, managing resources, and interfacing with other languages, making Ada a versatile and efficient programming language.

Avoid Exceptions

Avoiding exceptions and errors in Ada programming requires a combination of careful coding practices, thorough testing, and proactive error handling strategies. Here are some key principles that good Ada programmers follow to minimize errors and maintain program stability:

  1. Thorough Understanding of Ada Syntax and Semantics: A deep understanding of Ada syntax and semantics is crucial for writing correct and error-free code. This includes proper use of data types, operators, control structures, and exception handling mechanisms.

  2. Rigorous Input Validation: Input validation is essential to prevent errors caused by invalid or unexpected user inputs. This involves checking for input type, range, and format to ensure that the data is consistent and compatible with the program's expectations.

  3. Careful Handling of Arrays and Pointers: Arrays and pointers can be potential sources of errors if not handled carefully. Ensure proper index bounds checking for arrays and avoid dangling pointers or memory leaks.

  4. Use of Static Analysis Tools: Utilize static analysis tools to identify potential errors and code defects early in the development process. These tools can detect syntax errors, type mismatches, undefined variables, and other potential problems.

  5. Thorough Unit Testing: Employ comprehensive unit testing to isolate and identify errors in individual program units. Unit tests should cover a wide range of scenarios, including boundary conditions, error cases, and exceptional situations.

  6. Integration Testing and System Testing: Conduct rigorous integration testing to ensure that different program modules interact correctly and system testing to validate the overall functionality and behavior of the application in real-world scenarios.

  7. Effective Exception Handling: Implement exception handling mechanisms to gracefully handle unexpected situations and prevent program crashes. Use predefined exceptions and custom exceptions when appropriate, and ensure that exception handlers are designed to recover from errors or provide meaningful error messages.

  8. Code Reviews and Pair Programming: Engage in code reviews and pair programming practices to identify potential errors and improve code quality. Peer review and collaborative coding can catch errors that may have been overlooked by individual programmers.

  9. Documentation and Code Comments: Maintain clear and up-to-date documentation for the code, including comments and explanations of complex logic or non-obvious code sections. This documentation aids in understanding the code's intent and facilitates future maintenance.

  10. Continuous Learning and Improvement: Stay updated with the latest Ada language features, best practices, and error-handling techniques. Continuous learning ensures that programmers are equipped with the latest knowledge and tools to prevent errors.

By following these principles and adopting a rigorous approach to coding, testing, and error handling, Ada programmers can significantly reduce the occurrence of exceptions and errors, resulting in more stable, reliable, and maintainable applications.


Yes, Ada has built-in support for assertions and preconditions, which are powerful tools for proactive programming and preventing errors. Assertions are used to verify program assumptions and invariants, while preconditions ensure that functions and procedures are called with valid inputs.


Assertions are statements that express conditions that the programmer believes to be true at a specific point in the program. They are used to check the validity of program state and assumptions, and they can help to detect errors early in the program execution.

Code snippet

assert X >= 0;

In this example, the assertion checks that the value of the variable X is non-negative. If the assertion fails, an exception will be raised, indicating that the program state is inconsistent with the programmer's expectations.


Preconditions are conditions that must be met before a function or procedure is called. They are specified in the function or procedure specification and are checked before the function or procedure body is executed.

Code snippet

procedure MyFunction(X : Integer);
    assert X >= 0; -- Precondition
    -- ...

In this example, the precondition for the MyFunction procedure is that the value of the parameter X must be non-negative. If the caller passes an invalid value for X, an exception will be raised, preventing the function from executing with incorrect input.

Benefits of Assertions and Preconditions

Assertions and preconditions offer several benefits for proactive programming in Ada:

  • Error Detection: They help to detect errors early in the program execution, preventing them from propagating and causing unexpected behavior.

  • Program Correctness: They contribute to program correctness by verifying program assumptions and ensuring that functions and procedures are called with valid inputs.

  • Self-Documenting Code: They make the code more self-documenting by explicitly stating the programmer's expectations and invariants.

  • Improved Maintainability: They improve the maintainability of the code by making it easier to understand and debug.

Using Assertions and Preconditions Effectively

To use assertions and preconditions effectively, consider the following guidelines:

  • Place Assertions Strategically: Place assertions at key points in the code where assumptions are made or invariants are expected to hold.

  • Use Preconditions for Function Contracts: Utilize preconditions to specify the requirements for function and procedure calls, promoting clear communication between caller and callee.

  • Balance Assertions with Performance: Consider the potential performance impact of assertions, especially in critical or performance-sensitive sections of the code.

  • Use Assertions in Development and Testing: Leverage assertions during development and testing to identify errors and refine program behavior.

  • Remove Assertions for Production: Generally, remove assertions from production code to minimize overhead and avoid unnecessary exceptions.

By incorporating assertions and preconditions into Ada programming practices, developers can enhance the reliability, correctness, and maintainability of their applications.

Exception Statement

The exception statement in Ada is a structured way to handle unexpected events or errors that occur during program execution. It allows programmers to define specific actions to be taken when certain exceptions are raised.

Syntax: Code snippet

   -- Statements that may raise exceptions
   when Exception_Name =>
      -- Exception handler code
   when others =>
      -- Default exception handler code
end try;


  1. try block: The try block contains the statements that may raise exceptions. When an exception occurs, the normal flow of execution is interrupted, and control is transferred to the except block.

  2. except block: The except block contains one or more exception handlers. Each exception handler is identified by a when clause that specifies the type of exception it handles. The code within the exception handler is executed when the corresponding exception is raised.

  3. others clause: The others clause is an optional catch-all handler that executes if no other exception handler matches the raised exception. This is useful for handling unexpected or unknown exceptions.

Example: Code snippet

with Ada.Text_IO;

procedure Main is
   Input : String (1..20);
   Number : Integer;
   Put ("Enter a number: ");
   Get_Line (Input, Length);

      Number := Integer'Value (Input);
      when Constraint_Error =>
         Put_Line ("Invalid input: Number out of range.");
      when others =>
         Put_Line ("Invalid input: Unknown error.");
   end try;

   Put_Line ("Converted number: ", Number);
end Main;


  1. This program prompts the user to enter a number and then attempts to convert the input string to an integer using the Integer'Value function.

  2. The try block encloses the conversion operation.

  3. The except block defines two exception handlers:

    a. Constraint_Error handler: Handles the Constraint_Error exception, which occurs if the input string is not a valid integer representation.

    b. others handler: Handles any other unanticipated exceptions.

  4. The Converted number: message is printed only if the conversion is successful.

Disclaim: I have ask Rix for these questions but I have not like the answers I get so I also ask Bard. Sorry Rix you need to learn more about Ada.