Is there a tool that enables me to insert one line of code into all functions and methods in a C++-source file?

Question

It should turn this

int Yada (int yada)
{
   return yada;
}

into this

int Yada (int yada)
{
   SOME_HEIDEGGER_QUOTE;
   return yada;
}

but for all (or at least a big bunch of) syntactically legal C/C++ - function and method constructs.

Maybe you've heard of some Perl library that will allow me to perform these kinds of operations in a view lines of code.

My goal is to add a tracer to an old, but big C++ project in order to be able to debug it without a debugger.

Answer 1

I use this regex,

"(?<=[\\s:~])(\\w+)\\s*\\([\\w\\s,<>\\[\\].=&':/*]*?\\)\\s*(const)?\\s*{"

to locate the functions and add extra lines of code.

With that regex I also get the function name (group 1) and the arguments (group 2).
Note: you must filter out names like, "while", "do", "for", "switch".

Answer 2

There is no such tool that I am aware of. In order to recognise the correct insertion point, the tool would have to include a complete C++ parser - regular expressions are not enough to accomplish this.

But as there are a number of FOSS C++ parsers out there, such a tool could certainly be written - a sort of intelligent sed for C++ code. The biggest problem would probably be designing the specification language for the insert/update/delete operation - regexes are obviously not the answer, though they should certainly be included in the language somehow.

People are always asking here for ideas for projects - how about this for one?

Answer 3

Try Aspect C++ (www.aspectc.org). You can define an Aspect that will pick up every method execution.

In fact, the quickstart has pretty much exactly what you are after defined as an example: http://www.aspectc.org/fileadmin/documentation/ac-quickref.pdf

Answer 4

If you build using GCC and the -pg flag, GCC will automatically issue a call to the mcount() function at the start of every function. In this function you can then inspect the return address to figure out where you were called from. This approach is used by the linux kernel function tracer (CONFIG_FUNCTION_TRACER). Note that this function should be written in assembler, and be careful to preserve all registers!

Also, note that this should be passed only in the build phase, not link, or GCC will add in the profiling libraries that normally implement mcount.

Answer 5

I would suggest using the gcc flag "-finstrument-functions". Basically, it automatically calls a specific function ("__cyg_profile_func_enter") upon entry to each function, and another function is called ("__cyg_profile_func_exit") upon exit of the function. Each function is passed a pointer to the function being entered/exited, and the function which called that one.

You can turn instrumenting off on a per-function or per-file basis... see the docs for details.

The feature goes back at least as far as version 3.0.4 (from February 2002).

This is intended to support profiling, but it does not appear to have side effects like -pg does (which compiles code suitable for profiling).

This could work quite well for your problem (tracing execution of a large program), but, unfortunately, it isn't as general purpose as it would have been if you could specify a macro. On the plus side, you don't need to worry about remembering to add your new code into the beginning of all new functions that are written.

Answer 6

This can be easily done with a program transformation system.

The DMS Software Reengineering Toolkit is a general purpose program transformation system, and can be used with many languages (C#, COBOL, Java, EcmaScript, Fortran, ..) as well as specifically with C++.

DMS parses source code (using full langauge front end, in this case for C++), builds Abstract Syntax Trees, and allows you to apply source-to-source patterns to transform your code from one C# program into another with whatever properties you wish. THe transformation rule to accomplish exactly the task you specified would be:

domain CSharp.

insert_trace():function->function
  "\visibility \returntype \fnname(int \parametername)
   { \body  } "
       ->
  "\visibility \returntype \fnname(int \parametername)
   { Heidigger(\CppString\(\methodname\),
               \CppString\(\parametername\),
               \parametername);
      \body } "

The quote marks (") are not C++ quote marks; rather, they are "domain quotes", and indicate that the content inside the quote marks is C++ syntax (because we said, "domain CSharp"). The \foo notations are meta syntax.

This rule matches the AST representing the function, and rewrites that AST into the traced form. The resulting AST is then prettyprinted back into source form, which you can compile. You probably need other rules to handle other combinations of arguments; in fact, you'd probably generalize the argument processing to produce (where practical) a string value for each scalar argument.

It should be clear you can do a lot more than just logging with this, and a lot more than just aspect-oriented programming, since you can express arbitrary transformations and not just before-after actions.