Chapter 4 Upward Compatibility

Six new reserved words are introduced in Ada 95: abstract, aliased, protected, requeue, tagged, and until.

In Ada 95, the type Character has 256 positions. In Ada 83, it had 128 positions.

type Char_Kind is (Numeric, Alphabetic, Other);

Kind_Array: array (Character) of Char_Kind :=       -- (1)
               ('0' .. '9' => Numeric,
                'A' .. 'Z' | 'a' .. 'z' => Alphabetic,
                others => Other);

case Char is                                        -- (2)
   when Character'Val(0) .. Character'Val(63) => ...
   when Character'Val(64) .. Character'Val(127) => ...
end case;

I: Integer := Character'Pos(Character'Last);        -- (3)

In Ada 95, library unit packages are allowed to have a body only if required by language rules. This avoids a nasty and not so rare error.

package Optional_Body is
   Global_Variable: Integer;
end Optional_Body;

-----------------------------------------

with Integer_Function;
package body Optional_Body is
begin
   Global_Variable := Integer_Function;
end Optional_Body;

Ada 95 provides new syntax for a generic formal private type to indicate that the actual subtype is allowed to be indefinite. The old syntax is retained, but the meaning is changed to require definite actual parameters.

generic
   type Element_Type is private;
package Stack is ...

------------------------------------------------------

with Stack;
package String_Stack is new Stack(Element_Type => String);

generic
   type Element_Type is private;  -- !! (<>) in Ada 95
package Stack ...

In Ada 95, the exception Numeric_Error is declared in the package Standard as a renaming of Constraint_Error.

which is the currently recommended way of avoiding the confusion between Numeric_Error and Constraint_Error in Ada 83.

exception
   when Constraint_Error => Action_1;
   when Numeric_Error => Action_2;
end;

exception
   when Constraint_Error => Action_1;
   when others => Action_2;
end;

It is considered that other incompatibilities will be unlikely to occur in normal programs -- the Ada 83 semantics being known only to the most erudite of Ada programmers -- and so only a brief description seems appropriate in this document. In the following summary, they are grouped according to whether they result in a legal Ada 95 program but with different semantics; whether they would be detectable by an Ada 95 compiler and so on.

the chosen representation for a floating point type may have less precision in Ada 95 for hardware with a non-binary radix.

the chosen representation for a fixed point type may have less precision in Ada 95. This is related to the next item.

In Ada 83, the default value of Small was defined to be the largest power of two not exceeding S'Delta. In Ada 95, it is allowed to be a smaller power of two.

Rounding is defined in Ada 95 as away from zero if the real number is midway between two integers.

The order of evaluation of defaulted generic actuals is arbitrary in Ada 95.

Static expressions are always evaluated exactly in Ada 95. In Ada 83 this was only required in a static context.

These incompatibilities cause a legal Ada 83 program to be an illegal Ada 95 program and hence are detectable at compile time. They are considered to be unlikely in normal programs.

Bad pragmas illegal --

In Ada 95, a pragma with an error in its arguments makes the compilation illegal. In Ada 83, it was ignored.

In Ada 95, S'Base is not defined for a composite subtype S.

As a result of adding types Wide_Character and Wide_String to package Standard, Ada 95 character literals are always overloaded and Ada 95 string literals are always overloaded.

In Ada 95, range constraints on a type after its declaration and in occurrences in pragmas freeze the representation (are treated as forcing occurrences). In Ada 83 they were not treated as forcing occurrences.

In Ada 95, matching of subtypes is now performed statically instead of at runtime (as in Ada 83) in array conversions and generic instantiations.

In Ada 95 it is illegal to use the value of a deferred constant before it is set. In Ada 83 it was erroneous.

in Ada 95 such constraints are illegal; in Ada 83 they were ignord.

in Ada 95, it is illegal to raise an exception in a static expression; in Ada 83 it made the expression non-static.

In Ada 95, the overload resolution rules have been changed to simplify them. As a consequence certain pathological Ada 83 programs become illegal.

Ada 83 generic contract model violations have been overcome in Ada 95 by assuming the worst case in a generic body.

New identifiers in package System may introduce illegalities into a unit having a use clause for System.

In Ada 95, subtype File_Mode in packages Sequential_IO and Text_IO has an extra literal, Append_Mode.

New identifiers in package Ada.Text_IO may introduce illegalities into a unit having a use clause for Text_IO.

New identifiers in package Standard may clash with existing use-visible identifiers.

In Ada 95 it is illegal or raises Program_Error if a function with a result type with a task subcomponent returns a local variable. In Ada 83 it was erroneous to return a variable containing a local task.

In Ada 95, it is illegal to give a representation item for a derived type containing a task.

In Ada 95, character literals are visible everywhere. In Ada 83 they followed the usual rules of visibility.

The Ada 83 attributes for a real subtype S (such as S'Mantissa) have been replaced by Ada 95 attributes defined in the Numerics Annex.

Some pragmas (including Interface and Shared) have been removed from the language and Priority has been moved to the Real-Time Systems annex.

The names of new pragmas may clash with implementation-defined pragmas.

The names of new attributes may clash with implementation-defined attributes.

The names of new (language-defined) library units may clash with user-defined or implementation-defined library units.

In Ada 95, dependent compatibility checks are performed on object declaration. In Ada 83, they were performed on subtype declaration.

Ada 95 allows sliding in more situations than did Ada 83, so Constraint_Error might not be raised as in Ada 83.

In Ada 95, the lower bound of the result of catenation for a constrained array type is defined to be 'First of the index subtype. In Ada 83, the lower bound of the result was 'First of the left operand.

In Ada 95, raising Time_Error can be deferred until Split or Year is called, or might not be raised at all. In Ada 83, it is raised on "+" or "-".

In Ada 95, Get for real types accepts a wider range of formats which would raise Data_Error in Ada 83. Leading and trailing zeros and the radix point are not required.

This chapter has outlined the incompatibilities between Ada 83 and Ada 95. As we have seen, the small number that are likely to occur in practice are easily overcome. The remainder are unlikely to be encountered in normal programs but have been mentioned for completeness. For further details the reader should consult the comprehensive discussion in [Taylor 95] upon which this discussion has been based.