Re: 'Base

["Matthew Heaney" <mheaney@on2.com>]

ada_student@yahoo.com wrote:
> What information does this attribute provide that cannot be specified
> using other Ada attributes?
>
> Why use an expression style to return a type? Is this because of
> the presence of parameterized types(i.e. generics) in Ada?


T'Base refers to the "base range" of the type, which defines the range
in which intermediate calculations are performed.

The standard states that the range of T'Base:

(1) includes the value 0
(2) is symmetric about zero, with possibly an extra negative value
(3) includes all of the values in the subtype T

So for example, if T is:

  type T is 1 .. 42;

then T'Base is

  type T'Base is -42 .. 42;

Note that built-in operators go through the base type, and T's "+" op
for example is implicitly declared as:

  function "+" (L, R : T'Base) return T'Base;

There are no constraint checks on T'Base, so for example:

declare
  O1 : T := T'(1) + T'(2);
  O2 : T'Base := T'(1) + T'(2)
begin

then in the first assignment to O1, there is a constraint check to
ensure that the result of 1 + 2 is in the range of T, but in the second
assignment to O2, there is no check.

T'Base is useful for generics, when you need to able to recover the
base range of the type, in order to declare a object with value 0; for
example, if this is an accumulator.

It's helpful to know something about the base range of the type, so
that you have a guarantee that you don't get any overflow during
intermediate calculations.  For example, given type T above then

procedure Op (O1, O2 : T) is
  Sum : T'Base := O1 + O2;
begin

This is a problem, since if the sum of O1 and O2 is large (that is,
greater than T'Base'Last), then you'll get overflow.  Knowing that
you're going to be adding two values together means you should declare
the type this way:

  T_Last : constant := 42;
  type T_Base is 0 .. 2 * T_Last;
  subtype T is T_Base range 1 .. T_Last;

That way you know that (sub)type T's range is 1 .. 42, but you also
have a guarantee that T'Base'Last >= 84, and hence the sum of two
values of type T cannot overflow.

Note that a declaration of the form:

  type T is range ...

actually declares a subtype, named T, of some anonymous base type.  We
can refer to the range of this base type as T'Base.

Note also that an enumeration type is its own base type, so given this
type:

  type ET is (A, B, C);

then the range of ET is the same as the range of ET'Base.  If you need
some extra literals in your "base" type, then you have to declare them
manually, not unlike what we did above:

  type ET_Base is (ET_Base_First, A, B, C, ET_Base_Last);
  subtype ET is ET_Base range A .. C;

Now you can say ET'Next (ET'Last) and you'll get a meaningful answer.
This is necessary when you do something like:

declare
  E : ET'Base := ET'First;
begin
  while E <= ET'Last then
     ... -- do something
     E := ET'Next (E);
  end loop;
end;


I might have some of the details wrong, but that's the general idea.

-Matt