CODEWITHSUNDEEP
c++cregexaoptrace
secr
secr

Reputation: 2893

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

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.

Upvotes: 3

Views: 1482

Answers (6)

Ira Baxter
Ira Baxter

Reputation: 95400

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.

Upvotes: 0

markets
markets

Reputation: 9714

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.

Upvotes: 5

bdonlan
bdonlan

Reputation: 231373

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.

Upvotes: 5

Phil
Phil

Reputation: 174

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

Upvotes: 10

anon
anon

Reputation:

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?

Upvotes: 2

Nick Dandoulakis
Nick Dandoulakis

Reputation: 43140

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".

Upvotes: 1

Related Questions