Re: String literals and wide_string literals - how?

[Robert A Duff <bobduff@shell01.TheWorld.com>]

"Jeffrey R. Carter" <jrcarter@acm.org> writes:

> Robert A Duff wrote:
>>     type Bit is ('0', '1');
>>     type Bit_String is array (Positive range <>) of Bit;
>>     pragma Pack(Bit_String);
>>     X: constant Bit_String := "01011110";
>> Bit is a character type, and Bit_String is a string type.
>> X can fit in 8 bits, by the way.
>
> for Bit'Size use 1;

Bit'Size is 1 by default, so I suppose:

    pragma Assert(Bit'Size = 1);

would be a better way to express this, in case you care.

> for Bit_String'Component_Size use Bit'Size;
>
> subtype Byte_String is Bit_String (1 .. 8);
>
> Y : constant Byte_String := "00001111";
> pragma Assert (Y'Size = Y'Length);

Y'Size might well be 32 on some implementations.
But that's OK -- Byte_String'Size should be 8.

> type Byte is mod 2 ** 8;
> for Byte'Size use 8;
>
> function To_Byte is new Ada.Unchecked_Conversion
>    (Source => Byte_String, Target => Byte);
>
> Z : constant Byte := To_Byte (Y);
>
> What is Z and 1?

0 or 1, depending on the implementation.

I'm not sure what your point is, here.  Unchecked_Conversion depends on
implementation choices (in this case, based on endianness), and is
therefore implementation defined.  So?

Types Bit and Bit_String above have well-defined portable semantics.
Patient: "Doc, It hurts when I Unchecked_Convert."
Doctor: "So don't do that."  ;-)

- Bob