Re: condition true or false? -> (-1 < sizeof("test"))

[Adam Beneschan <adam@irvine.com>]

On Monday, May 21, 2012 8:28:44 AM UTC-7, Nomen Nescio wrote:
> Forwarding this to guys who write code in real languages to see what they
> think of this. AFAIK you cannot get something like that past the compiler in
> Ada...and you would have to define a type or a subtype to even have an
> unsigned int unless you use a modular type IIRC.

The last part is pretty much correct.  If you do something like this in Ada:
 
   B := -1 < Some_Type'Size;

where B is a Boolean, it works like this: Some_Type'Size is a universal integer, and it can be converted to any integer type.  However, in a case like this where there's no variable or anything else that tells the language which type to use, the language has a preference for "root_integer", which is a signed integer type.  So the above would do what you expect (i.e. set B to True since 'Size can never be negative).  (The rule about preferring root_integer was added in Ada 95.  I don't know for sure whether the above is legal in Ada 83; I think this might have been an error.)

You could create a situation where -1 is treated as a modular type expression, so that the above would set B to False.  However, you really have to try.  For instance:

    type Word is mod 2**32;

    B := -1 < Word' (Some_Type'Size);

would cause Some_Type'Size to be interpreted as a Word, and then the - and < operators are treated as the ones that operate on Word.  Or:

    One : constant Word := 1;

    B := -One < Some_Type'Size;

But you do have to have some modular type involved to get False for B, and you have to either use the type name in the expression, use the name of an object of that type, or do something like

    B := Thing_Defining_Modular_Type."<" (-1, Some_Type'Size);

It won't happen implicitly.

                           -- Adam