Re: Processing array subsections, a newbie question.

[Colin Paul Gloster <Colin_Paul_Gloster@ACM.org>]

On Sat, 12 Jun 2010, Peter C. Chapin sent:
|------------------------------------------------------------------------------|
|"[..]                                                                         |
|                                                                              |
|I want to invoke this procedure repeatedly on a particular buffer such that   |
|each invocation picks up where the previous invocation left off. For example  |
|                                                                              |
|Ok        : Boolean := True;                                                  |
|Index_Fst : Natural := Buffer'First;                                          |
|Index_Lst : Natural;                                                          |
|...                                                                           |
|                                                                              |
|while Ok and Index_Fst <= Buffer'Last loop                                    |
|  Do_Something(Buffer, Index_Fst, Index_Lst, Ok);                             |
|  Index_Fst := Index_Lst + 1;                                                 |
|end loop;                                                                     |
|                                                                              |
|The problem with this code is that the assignment to Index_Fst inside the loop|
|might raise Constraint_Error if Index_Lst = Buffer'Last after Do_Something    |
|finishes. I can work around this problem but my solutions tend to be rather   |
|ungainly looking. Surely there must be an easy way to handle this.            |
|                                                                              |
|Peter"                                                                        |
|------------------------------------------------------------------------------|

You seemed to dislike the good idea of using different ranges for the
cursors and the array mentioned elsewhere in this thread.

So how about something like
...
Index_Lst : integer := Buffer'First-1; --Hmm, perhaps I have merely
                                       --moved your disliked extra 1.
...

while Ok and Index_Lst + 1 <= Buffer'Last loop
  Index_Fst := Index_Lst + 1;
  Do_Something(Buffer, Index_Fst, Index_Lst, Ok);
end loop;
?

It is a pity that I have introduced code cloning, but looping without
sticking to predominant forms can have this consequence in any
language I can think of (well, just the languages which have already
been defined, that is, excluding languages we can devise).

I really do not approve of the names Index_Fst and Index_Lst. How many
people reading this have still not noticed Index_Fst is not in this
version's condition? Be candid.

I wish Ada success on student satellites!

Regards,
Colin Paul