Avoiding constraint checks w/ 'Base

[Anonymous Coward <anonymous@coward.org>]

In article <1134065313.469475.267400@g47g2000cwa.googlegroups.com>, 
Matthew Heaney wrote:
> 
> 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.

I like the idea of avoiding constraint checks - especially when I know
the result will be in range.  Even if I can't be sure that the sum of
the two operands is in range, it would be an advantage to be able to
handle the situation without throwing an exception.

So I have some questions.  In your example, based on what you've said
the ARM guarantees about minimal T'Base ranges, why would the
initialization for O2 go unchecked, knowing that it could just as well
go out of bounds?  Is the 'Base attribute also code for "trust me, I
know what I'm doing?"

I think it's unfortunate that the 'Base does not necessarily use the
full object size, so we are still forced to declare a new type, like
"T_Safe" in this example:

  package Base_Experiment is

     type T is range 1..42;

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

  end Base_Experiment;

  package body Base_Experiment is

     function "+" (L, R : T) return T is

        type T_Safe is range T'First..2 * T'Last;

        --The following use of 'Base mitigates constraint checking?
        --
        Sum : constant T_Safe'Base := T_Safe(L) + T_Safe(R);

        Return_Data : T := T'Last;

     begin

	--Do our own check if we are uncertain about the resulting
	--range.

        if Sum > T_Safe'Base(T'Last) then

           --[Take some corrective action here]--

           --The usual crash everything without a clue:
           --
           --raise Constraint_Error;

           --Give the user a reasonable chance to correct:
           --
           --raise Our_Custom_Exception;

           --Probably the best answer in most cases:
           --
           --Log_Error("Base_Experiment."+" out of bounds!");

           null;

        else

           Return_Data := T(Sum);

        end if;

        return Return_Data;
     end "+";
  end Base_Experiment;