Pre-processing to inject log statements with minor visibility in source code

Question

I'm working with extensive logging for years now. My question is not about logging versus debugging but an argument which comes again and again.

It is simply ugly to have excessive log statements disturbing the reader looking for function flow.

There is no value to see the log statements. Only by reviewing the recorded logs they are needed.

Even pre-processor usage will not help enough.

My idea is to put it into comments where all editors help to reduce the visibility (e.g. light gray).

Today I'm working on an Ada/gnat project but this isn't important. Here a simple example

<code>
...
i := i + 1;   [email protected]@
...

<mapping file>
[email protected]@
if logging_enabled then 
  put_line("i: " & Integer'image(i));
end if;
[email protected]@
...

By going through pre-processing the code should be inline modified to give the mapped block within the same line to the compiler (no line feeds). The line count of the file will not increase.

It is not clear to me if this could be done without affecting incremental compilation (time stamps issues). Only the compile step sees the patched file. Later and for the repository (git) this shouldn't be notified.

Any comments which trouble I have to expect? Is there a similar example available to see how the compilation can be manipulated this way.

thanks Wolfgang R.

Answer 1

If you are using GPS, you could try using the plugin gps_utils.highlighter

from ps_utils.highligher import *
Regexp_Highlighter(
   regexp='if logging_enabled.*end if',
   style=OverlayStyle(
      foreground='gray'
   )
)

You will likely have to play a bit with things to get it right, but that should allow you to simply highlight (or as the case may be the opposite) specific parts of the code

Answer 2

I think I've got it. I need a second build directory.

The primary doesn't have any logging code. The second directory is supervised by a controller process. If it gets a signal (e.g. updated executable) from the primary it copies over the touched sources and patches in the logging statements.

The controller process finally starts the incremental build in the secondary.

This way both worlds are fairly separated. Doubling the compilations won't matter I guess.