Martin Dowie wrote:
> James Giles wrote:
...
>> In most Ada implementations, as for most other languages, all
>> the bit patterns in the representation of an INTEGER data type
>> are valid integer values.
>
> That's not entirely true, the standard states Integer must include the
> range �2**15+1 .. +2**15�1 - thus (usually) leaving -2**15 as a
> possible 'default uninitialized' value.

Well I allowed for that possibility.  I made no absolute
assertion.  I said "most Ada implementations".  In fact,
most language definitions *allow* implementations
to implement integers with a lot of flexibility.  Most
actual implementations use all the bit patterns their
underlying hardware allows and *don't* use any of
them for NOI (Not An Integer).  And, let's not forget
character data types (does your actual implementation
have a value that means NOC - Not A Character?).
What about booleans?  Ada also has fixed point types,
enumerations, records, etc.  Does your actual implementation
catch uses of undefined variables for all those?  Indeed,
does it even use NANs from the floating point hardware to
detect uninitialized REALs?

It's true: nearly all languages permit implementations
to internally represent data with additional memory
for the purpose of detecting and reporting uses of
undefined variables (and for other reasons - like the
value of a variable that was defined, but the expression
involved an unhandled exception).  In formal semantics,
the idea is called a lifted domain.  Applying it in software
is expensive at run-time.

Now, I've always liked the idea of using the anomalous
value in two's complement integers (sign bit set, all others
clear) as NOI.  I don't think it's a likely implementation
strategy unless it was treated that way in hardware.

-- 
J. Giles

"I conclude that there are two ways of constructing a software
design: One way is to make it so simple that there are obviously
no deficiencies and the other way is to make it so complicated
that there are no obvious deficiencies."   --  C. A. R. Hoare