cppguts

If your project depends on some external C/C++ projects and you want to make some changes in external functions/methods and then copy/paste these changes automatically - this package may help you.

There are two tools:

1. editcpp used to edit source code;
2. dumpcpp used to print some information about C/C++ translation units

We will discuss editcpp as it is the objective tool.

editcpp doesn't work with templates.

Same tool aimed at editing python files is also available as pythonguts

Installation

cppguts is available at PyPI:

pip install cppguts

The idea behind editcpp tool

editcpp uses libclang to find function/method definition start/end lines in text file (.c, .h, .hpp, .cpp or whatever C/C++ extension). libclang parses each dest.cpp and src.cpp and everything that is included by #include preprocessor directives. Then editcpp tool selects all functions and methods defined in dest.cpp and src.cpp (it assumes that you know where old and new function/method definition resides) and tries to find matching functions/methods. After that editcpp copies function/method definition from src.cpp and pastes it to the dest.cpp while deleting old funcion/method definition.

To find common function editcpp checks:

• are they both definitions?
• are they both const?
• are they both static?
• are they both vitual?
• are they both functions?
• are they both methods?
• do they both have the same name?
• do they both have the same return type and arg types?
• do they both have the same semantic parent (classname)? (for methods only)

Notes

• you are free to pass any clang argument after editcpp otions but don't pass file without flag to clang (as we usually do when using clang)
• if you parse files that includes non standard headers then you probably need to pass -I<include_dir> flag to clang to include directories;
• if you parse C++ files then it may be necessary to pass -std=c++03 (or higher) flag to inform clang that the file is C++;
• if your new function/method definition uses external types then these types must be preliminary declared (not necessary to define them);

Remember that after editcpp finds common functions/methods it will simply copy selected text lines from one file to another

Example

original function/method definition file dest.h:

#include<iostream>// helper class that is used by the target class `Src`classSrcPrivate {
public:SrcPrivate(){};
voidadd(int v){
val += v;
}
voidsubstract(int v){
val -= v;
}
private:int val;
}// target classclassSrc {
// method defined inside the classvoidadd(SrcPrivate p, int v){
p.add(v);
}
// method defined outside the classvoidsubstract(SrcPrivate p, int v);
// we won't tuch this methodvoiduntouched_print(int v){
std::cout << "The value is:\t" << v << std::endl;
}
}voidSrc::substract(SrcPrivate p, int v){
p.substract(v);
}
// simple functionvoidfoo(int &v){
v--;
}
namespacens {
// function in namespacevoidbar(int &v){
v++;
}
}

new function/method definition file src.h:

classSrcPrivate; // declare helper type// target classclassSrc {
// NEW method definition inside classvoidadd(SrcPrivate p, int v){
p.add(v) + 10;
}
// NEW method definition ouside classvoidsubstract(SrcPrivate p, int v);
}voidSrc::substract(SrcPrivate p, int v){
p.substract(v) - 10;
}
// NEW simple function definition voidfoo(int &v){
v -= 10;
}
// NEW function definition in namespacenamespacens {
voidbar(int &v){
v += 10;
}
}

Run:

editcpp --src-file=src.h --dest-file=dest.h --oldfile-keep -std=c++03

The -std=c++03 tells the clang to parse the files as C++. Also you may need to use any other clang flags like -I to include directories that are required by the files.

--oldfile-keep (default) is used to keep the original file (it will be renamed by adding _OLD_N suffix). Otherwise use --oldfile-delete to delete the original file.

Another option is to run the test (though the test deletes all the generated files so you better take a look in /tests dir):

python -m unittest cppguts.tests.test_cppguts