Re: Dynamic Variant Record Creation

[Warren <ve3wwg@gmail.com>]

Jeffrey R. Carter expounded in news:hnov3m$t4o$1@tornado.tornevall.net:

> Warren wrote:
>> 
>> The other way for me to solve this is simply provide
>> a discrimanant that only identifies the few variants. But 
>> to keep to 32-bits, I'd have to find a way to specify the
>> discriminant as 3-bits, which I don't think is possible.
> 
> Looking at what you have, it looks like a design problem to me. You
> have a whole bunch of enumeration values, but you don't have a bunch
> of variants. I'd probably have an enumeration type with 3 values that
> serves as the discriminant. Then have 3 enumeration types, one for
> each variant, that gives the specific information that you're now
> trying to use for the discriminant as well. 

I looked at this closely last night and ended up agreeing
with you (design problem). So I changed it along the 
lines that you suggested:

type Token_Type(Aux : Aux_Kind := No_Aux) is    
    record
        Token :             Token_Kind := No_Token;
        case Aux is
            when SID_Aux =>
                SID :       String_ID;
            when FID_Aux =>
                FID :       Func_ID;
            when No_Aux =>
                null;
        end case;
    end record;

I was also able to get the representation I wanted (yeah):

for Token_Type use
    record
        Aux     at 0    range 0..2;
        Token   at 0    range 3..15;
        SID     at 0    range 16..31;
        FID     at 0    range 16..31;
    end record;

This design allows me to flexible in the auxiliary
information provided. For example, each "token line"
ends with a linefeed token (LEX_LF). However, each
statement has an optional "inline" comment like:

01000 LET OPEN_FLAG = FALSE    $ Mark file as not-opened.

Using the discriminant Aux allowed me to use a SID 
(Aux = SID_Aux) or not ( Aux = No_Aux ) as required:

T := ( Aux => SID_Aux, Token => LEX_LF, SID => ID );

  or

T := ( Aux = No_Aux, Token => LEX_LF );

As you pointed out, when designed this way, I always 
know the static representation required, even though 
the Token member may be variable.

I knew that we'd eventually converge on a solution. 
Thanks everyone.

Warren