Re: Normalizing array indices

["Randy Brukardt" <randy@rrsoftware.com>]

<Stefan.Lucks@uni-weimar.de> wrote in message 
news:Pine.LNX.4.64.1110282013540.21821@medsec1.medien.uni-weimar.de...
> Hi all, does anyone know a way to change the array indices of a subprogram
> parameter to start with a default index? This question occurred to me when
> I happened to discover a subtle bug in a sort procedure I had implemented.
>
>  generic
>    type Element_Type is private;
>    type Sort_Array_Type is array (Positive range <>) of Element_Type;
>    with function "<" (Left, Right: Element_Type) return Boolean is <>;
>  procedure Sort(A: in out Sort_Array_Type);
>
> I had a reasonable amount of black box tests and Sort passed all of them.
>
> Some time later, I added a test with A'range being
>   Positive'Last -2 .. Positive'Last
> and boooom -- got a Constraint_Error. As it turned out, there was a
> Positive index variable which could take the value A'Last+1 -- which is
> perfectly OK except when A'Last = Positive'Last.

This is pretty typical. We've often talked about the need in Ada for 
one-sided array subtypes, but we don't have any first class ones at this 
point.

I probably would constrain the parameter to have a lower bound of 1. Using 
Ada 2012:

generic
   type Element_Type is private;
   type Sort_Array_Type is array (Positive range <>) of Element_Type;
   with function "<" (Left, Right: Element_Type) return Boolean is <>;
procedure Sort(A: in out Sort_Array_Type)
   with Pre => A'First 1;

You could do something similar with a subtype using a dynamic predicate (but 
not in a generic specification).

In Ada 2005 and earlier, I'd simply make it part of the spec with some 
English wording, and then start the code with
    if A'First /= 1 then raise Program_Error; end if;
(You could also use pragma Assert if you don't mind the possibility that 
someone turned it off.)

Then, if you had any calls that don't have the right bounds (which is likely 
to be rare), I'd use a sliding trick similar to the one Adam showed. (But 
I'd probably try hard to figure out how to avoid passing the slice in the 
first place.)

Of course, it's better to make the routine work for all possible bounds. And 
if you do that, you certainly need to add that to the testing burden (it's 
commonly forgotten and probably is one of the most common Ada bugs).

                                           Randy.