Bounds of Slice's return value

Bounds of Slice's return value

[Matthew Woodcraft]

Ada.Strings.Unbounded.Slice returns a Standard.String.

Am I guaranteed anything about the bounds of this string?

In particular, if I run the following program, should I always get '1',
or is an implementation allowed to choose a different value?


with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Ada.Text_IO; use Ada.Text_IO;

procedure Slice_Return_Value is
   U : Unbounded_String := To_Unbounded_String ("hello");
   S : String := Slice (U, 2, 3);
begin
   Put_Line (Integer'Image (S'first));
end Slice_Return_Value;

-M-

Re: Bounds of Slice's return value

[Jeffrey Carter]

Matthew Woodcraft wrote:
> 
> Ada.Strings.Unbounded.Slice returns a Standard.String.
> 
> Am I guaranteed anything about the bounds of this string?

As you noticed, the ARM is silent about this. The ARG is working towards
(if they haven't already completed) an AI stating that the bounds should
be the same as the indices passed to Slice, to correspond with the
bounds of a slice of a String. GNAT noticeably does not do this in the
most recent public version (3.13p), though I believe this has been
changed in more recent (as yet non-public) versions.

See program Strm_Sub, distributed as part of the PragmAda Reusable
Components, for an example of using Slice portably even when the lower
bound returned is one.

-- 
Jeff Carter
"I blow my nose on you."
Monty Python & the Holy Grail

Re: Bounds of Slice's return value

[Matthew Woodcraft]

Jeffrey Carter <jrcarter@acm.org> writes:

> Matthew Woodcraft wrote:
> > 
> > Ada.Strings.Unbounded.Slice returns a Standard.String.
> > 
> > Am I guaranteed anything about the bounds of this string?
> 
> As you noticed, the ARM is silent about this. The ARG is working towards
> (if they haven't already completed) an AI stating that the bounds should
> be the same as the indices passed to Slice, to correspond with the
> bounds of a slice of a String.

Thanks. I'm glad they're nailing it down; it seems to be a needless
source of hard-to-spot errors, otherwise.


> GNAT noticeably does not do this in the most recent public version
> (3.13p), though I believe this has been changed in more recent (as yet
> non-public) versions.

Indeed, I came across this because one of my unit tests failed when I
tried compiling with cvs gcc.

-M-

Re: Bounds of Slice's return value

[Robert A Duff]

Matthew Woodcraft <mattheww@chiark.greenend.org.uk> writes:

> Thanks. I'm glad they're nailing it down; it seems to be a needless
> source of hard-to-spot errors, otherwise.

The fact that Ada allows strings to start at other than 1, depending on
where they came from, is a "needless source of hard-to-spot errors" even
in cases where it *is* nailed down.  Sigh.

- Bob

Re: Bounds of Slice's return value

[Matthew Woodcraft]

Robert A Duff <bobduff@shell01.TheWorld.com> writes:

> Matthew Woodcraft <mattheww@chiark.greenend.org.uk> writes:
> > Thanks. I'm glad they're nailing it down; it seems to be a needless
> > source of hard-to-spot errors, otherwise.

> The fact that Ada allows strings to start at other than 1, depending
> on where they came from, is a "needless source of hard-to-spot errors"
> even in cases where it *is* nailed down. Sigh.

I agree it's an unpleasant source of errors. But it's only needless if
there's a fix available.

Perhaps saying that strings are just arrays of characters isn't such a
good idea? Or do you think arrays with differing lower bounds are the
trouble?

-M-

Re: Bounds of Slice's return value

[Matthew Heaney]

"Matthew Woodcraft" <mattheww@chiark.greenend.org.uk> wrote in message
news:87bsfrcksf.fsf@chiark.greenend.org.uk...
> In particular, if I run the following program, should I always get '1',
> or is an implementation allowed to choose a different value?
>
> procedure Slice_Return_Value is
>    U : Unbounded_String := To_Unbounded_String ("hello");
>    S : String := Slice (U, 2, 3);
> begin
>    Put_Line (Integer'Image (S'first));
> end Slice_Return_Value;

You can fix this to specify the index constraint you desire, using a subtype
constraint:

declare
   F : constant Positive := 2;
   L : constant Positive := 3;
   S : constant String (1 .. L - F + 1) := Slice (U, F, L);
begin

or

declare
   F : constant Positive := 2;
   L : constant Positive := 3;
   S : constant String (F .. L) := Slice (U, F, L);
begin

Of course, this declares a constrained string object (no dope vector is
generated), so this is not strictly comparable to your original example.
You could fix that by using an explicit subtype:

declare
   F : constant Positive := 2;
   L : constant Positive := 3;
   subtype T is String (1 .. L - F + 1);
   S : constant String := T(Slice (U, F, L));
begin

or

declare
   F : constant Positive := 2;
   L : constant Positive := 3;
   subtype T is String (F .. L);
   S : constant String := T(Slice (U, F, L));
begin