Re: Variable sizes for record fields

[Kilgallen@eisner.decus.org.nospam (Larry Kilgallen)]

In article <NV2f7.16792$ZM2.1470093@newsread2.prod.itd.earthlink.net>, David Brown <s-complangada@davidb.org> writes:
> Larry Kilgallen <Kilgallen@eisner.decus.org.nospam> wrote:
> 
>>> I have recently encountered a concrete example of the need for something
>>> like this.  The application is storing variable sized data fields in fixed
>>> length records (say disk sectors).  The block is defined as a large string.
>>> The beginning of the block contains lengths for each of the variable sized
>>> fields.  The data items start at the end of the record and work their way
>>> backward.
>> 
>> This sounds to me like the beginning of the record definition is the
>> discriminant values and the end of the record is the text fields.
>> The one trick, to achieve a fixed size, is to have an extra discriminant
>> to define the size of the "middle".  This is based on my experience with
>> Ada83.  Perhaps Ada95 lets you do more "math" with discriminant values
>> to avoid the need for an extra discriminant.
> 
> To make this work, I would need several things.  First of all, my
> discriminants would have to be an array of values whose size is based on
> another discriminant.

An Ada record type always has a fixed number of discriminants (often zero).

> Second, I need to represent things (like the size of the middle) without
> taking up any space.  They need to be computed and that's it.  The sizes of
> each of the other text strings needs to be based on the array of
> discriminant sizes.

Check into the Ada95 angle.

> Third, I need to be able to change the structure in-place.  It is
> complicated code, and I don't think that the compiler would understand all
> of the cases involved, even if you could arbitrarily assign to
> discriminants like this.

	POINTER_TO_NEW_RECORD := new MY_RECORD_TYPE (
		SIZE_1 => 42,
		SIZE 2 => 42,
		SIZE_3 => 42,
		SIZE_REST => 42 );

> I wasn't even able to make a simple record containing a discriminant and a
> string of that length and come up with a way to make the particular
> discriminant a constant and not take up any storage.

That is just the point.  Ada requires that the discriminants of the record
can be recognized at run time.  There is no way to do that without taking
up space.