Re: Ada.Execution_Time

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

"Georg Bauhaus" <rm-host.bauhaus@maps.futureapps.de> wrote in message 
news:4d05e737$0$6980$9b4e6d93@newsspool4.arcor-online.net...
...
> <rant>
> Some found the explicit null statement to be unusual,
> bothersome, and confusing in the presence of a pragma.
> Thus it was dropped by the language designers.

The logic is that you need a "null;" statement when there is nothing in some 
list of statements. A pragma (or label) is not "nothing", so the requirement 
for "null;" is illogical in those cases.

> The little learning it took, the few words of explanation,
> explicitness of intent dropped in favor of a special case in Ada
> 2012 which lets one use a pragma in place of a null statement.

Yes. This is primarily an issue for a pragma Assert.

> (And re-introduce "null;" once rewriting / removing debug stuff
> / etc is taking place.)

True, but that is always the case when removing debug stuff. The change here 
has no real effect on that. Most of mine is some sort of logging:

       if Something then
            <Lot of code>
       else
            Log_Item ("Something is False");
       end if;

If I remove the logging, I have to add a "null;" or remove the "else".

The situation for a pragma in Ada 2012 is no different:

       if Something then
            <Lot of code>
       else
            pragma Assert (not Something_Else);
       end if;

And it seems less likely that you would change this than the first form, and 
neither seems that likely.

(Note that this was not a change I cared about much in either direction. The 
use of pragmas for executable things is bad language design IMHO, and in any 
I simply don't use them for that sort of purpose, because they are much too 
limited to be of much use in a complex system.)

> Let's hope we can buy support tools in the future to
> help us ensure the effects of language special casing can
> be bridled per project.

I'd suggest you stick with Ada 2005. Ada 2012 is all about easier ways to 
write Ada code: not just these tweaks, but also conditional expressions, 
expression functions, iterator syntax, indexing of containers, the reference 
aspect (giving automatic dereferencing) are all "syntax sugar". That is, 
they're all about making it easier to write (and in most cases, read) Ada 
code in a style that is closer to the problem rather than the solution. (One 
could also put all of the contract stuff into this category, as you can 
write preconditions, postconditions, invariants, and predicates using pragma 
Assert -- it's just a lot more reliable for the compiler to decide where 
they need to go.)

                                               Randy.