Re: Running a preprocessor from GPS?

["Randy Brukardt" <randy@rrsoftware.com>]

"EGarrulo" <egarrulo@gmail.com> wrote in message 
news:d3142cab-776d-4daa-8475-1dd4d46d8556@googlegroups.com...
> On Thursday, July 30, 2015 at 9:32:17 PM UTC+2, Randy Brukardt wrote:
...
>> And there couldn't be any useful runtime checking, either
>
> Why not?  Please explain me why this is acceptable:
>
>   -- This conversion will fail if Some_Integer is bigger than what
>   -- Constrained_Integer_Type can hold.
>   Some_Constrained_Integer := Constrained_Integer_Type (Some_Integer);
>
> whilst this is not:
>
>   -- This conversion will fail if Any doesn't contain an Integer.
>   Some_Integer := Integer (Any);
>
> I don't see any difference.  Both conversions can fail at runtime because 
> types
> don't match.

This is the same nonsense that Dmitry has been spouting. In the first 
instance, you have the *same* types with different constraints (ranges in 
this case). Ranges *might* be checked at rumtime, although Ada compilers 
spend an enormous amount of effort into checking them at compile-time (so 
there is no overhead).

The second case is a mapping of actual different types. That would require 
some sort of runtime type representation, which would imply a lot of 
overhead for elementary types (as the runtime type representation would be 
larger than the type itself in many cases). Additionally, elementary types 
are by-copy; that would prevent the techniques used for tagged types from 
working. Most likely, one would have to add a level of indirection into most 
objects. That sort of distributed overhead is typically frowned on in Ada.

Indeed, if the second case was allowed in Ada, it definitely would NOT 
represent different types. The check would be some sort of constraint check 
(similar to the tag check of tagged types). "Any" would represent any type, 
and thus would never fail type matching.

                               Randy.