Re: Interesting article on ARG work

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

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:pa4ip3$1ton$1@gioia.aioe.org...
> On 05/04/2018 00:30, Randy Brukardt wrote:
>
>> There is a much more general proposal for Ada 2020 called "ghost code" - 
>> a
>> silly name for code and declarations intended only to be used by 
>> assertions.
>> (The idea being that if it is marked and enforced as such, it can be 
>> removed
>> when the Assertion_Policy is Ignore.)
>>
>> Using that (which may or may not make it into Ada 2020 -- we haven't yet
>> discussed it at a meeting), one could use a ghost function for this 
>> purpose:
>>
>>        function My_Assertion (...) return Boolean is
>>            (if Condition then raise Assertion_Error with Message else 
>> True)
>>            with Ghost;
>>
>>       pragma Assert (My_Assertion (...));
>>
>> (Note: The "..." here is any objects that Condition needs to be 
>> evaluated.)
>
> Assertion code is quite useless from my point of view, but what about 
> debugging code? It is quite tedious to comment it in and out all the time 
> (and with/use clauses required for it).

My assumption has always been that Ghost code could be used for that as 
well, but since it's more of an idea than a proposal, it's hard to say 
anything definitive.

If you used Janus/Ada, you'd have a built-in solution for that (sadly, 
incompatible with Ada 2020): the @ conditional compilation marker. It is 
interpreted as either "--" or " " depending on a compilation flag, so it can 
easily add or remove anything. We originally invented it to deal with 
debugging/assertion code in the Janus/Ada compiler; probably about 25% of 
the code in Janus/Ada is marked that way. Since it is lexical, it can 
comment out anything, including declarations, pragmas, and with clauses.

In programs intended to be portable, I just use static Boolean flags for 
debugging code. Any compiler with decent dead code elimination (which would 
be about all of them) will get rid of most/all of the code that way. But 
that doesn't work on pragmas, context clauses, or declarations, so it isn't 
quite as through as @. (With Janus/Ada, which does dead subprogram 
elimination during binding, including for tagged type primitives, the 
difference isn't that substantial unless large data declarations are 
involved.)

               Randy.