[Code Contribution] Improved C++ Import of macros

[jeremysalwen]

I've worked on a small piece of code to preprocess C++ files so that importing code with macros will work without pulling in all the types defined in #includes. It's not perfect, but I think it will work for almost all of the common use cases.

The basic idea is this: We extract the macros from the included files to substitute into our target file, but we ignore the contents of the included files themselves.

To do this, first we invoke

$ cpp -dM a.hpp -o a.hpp.macros

We then append a.hpp to a.hpp.macros, and manually remove all the #include directives. We run the preprocessor on this file, and and get a properly "preprocessed" file, which has all the macros substituted, but no extra data structures included.

Of course, this could fail if #include directives were used in funky ways, but for the standard use of just including header files, it will work perfectly.

I've written the function do do this preproprocessing. There are only 3 options which need to be exposed to the user: The C Preprocessor executable command (on most unix systems just "cpp"), the include search path options (which they can copy from the build system), and the working directory from which the preprocessor should be invoked (significant when #includes use relative paths). The nice thing is that this function fails gracefully. If anything goes wrong, it will just return the original filename you fed in, which the DoUML C++ parser can handle just as in previous versions (albeit without macros substituted).

Thanks for your work keeping DoUML alive and open source, it's very useful to me.

#include <qstringlist.h>
#include <qstring.h>
#include <qtextstream.h>
#include <qfileinfo.h>
#include <qdir.h>
#include <qprocess.h>

QString j_preprocess(const QString &cpp_exec, const QString & f,const QString& working_dir, const QStringList& include_args) {
    QString macrosfilenm(f+".included");
    QProcess process;
    process.setWorkingDirectory(working_dir);
    QStringList get_macros_args(include_args);
    get_macros_args << "-dM" << f << "-o" << macrosfilenm;
    process.start(cpp_exec, get_macros_args);
    if(!process.waitForFinished())  {
        return f;
    }

    QFile srcfile(f);
    if(!srcfile.open(QIODevice::ReadOnly)) {
        return f;
    }
    QFile macrosfile(macrosfilenm);
    if(!macrosfile.open(QIODevice::WriteOnly | QIODevice::Append|QIODevice::Text)) {
        return f;
    }

    QTextStream in(&srcfile);
    QTextStream out(&macrosfile);
    while(!in.atEnd()) {
        QString line = in.readLine();
        if(!line.startsWith("#include",false)) {
            out << line << "\n";
        }
    }

    srcfile.close();
    macrosfile.close();

    QString outpfilenm(f+".preprocessed");

    QStringList preprocess_args;
    preprocess_args << macrosfilenm << "-o" << outpfilenm;
    process.start(cpp_exec,preprocess_args);
    if(!process.waitForFinished())  {
        return f;
    }
    if(!QFileInfo(outpfilenm).exists()) {
        return f;
    }
    return outpfilenm;
}

[mobius3]

Hello!

Well, I can see this becoming useful, but the problem is depending on executing the compiler to do the preprocessing. On Windows for instance the user might be using MSVC to compile stuff and might not even have MinGW installed. And I don't even know if MSVC has support to do that preprocessing for us. Worse, the user might not have a compiler set up.

For this to be nicely integrated we would need a way of parsing those files manually to follow the macro resolving process. Maybe this could be integrated as an add-on on next versions or conditionally compiled. The problem then would be incoherent behaviour on different platforms.

I do think this can be a nice addition but we need to find a a workaround for these problems. Thanks a lot for your contribution, if DoUML is alive is of course because of its users.

[jeremysalwen]

Hi Leonardo!

Thanks for responding so quickly. I actually was thinking about a potential solution to the above problems. If we linked to cpplib (from gcc), we could portably use this functionality without the user having to set up gcc on their own. (I have looked into msvc, and they do not offer the -dM functionality). If you or someone else could help me integrate it into the GUI, I'd be happy to commit some time to make the cpplib backend work properly.

[jeremysalwen]

Hi Leonardo, I have done some work to include a modified mcpp source in Douml, and created pull request #74