CODEWITHSUNDEEP
c#c++parsingcompiler-constructioncompilation
drzoidberg
drzoidberg

Reputation: 59

Parse .h header files into c# data structures in runtime

I'm trying to write a C# library to manipulate my C/C++ header files.. I want to be able to read and parse the headers file and manipulate function prototypes and data structures in C#. I'm trying to avoid writing a C Parser, due to all code brances caused by #ifdefs and stuff like that.

I've tryed playing around with EnvDTE, but couldn't find any decent documentation. Any ideas how can I do it?

Edit - Thank you for the answers... Here are some more details about my project: I'm writing a ptrace-like tool for windows using the debugging API's, which enable me to trace my already compiled binaries and see which windows API's are being called. I also want to see which parameter is given in each call and what return values are given, so I need to know the definition of the API's. I also want to know the defition for my own libraries (hence, the header parsing approach). I thought of 3 solutions: * Parsing the header files * Parsing the PDB files (I wrote a prototype using DIA SDK, but unfortionatly, the symbols PDB contained only general info about the API's and not the real prototypes with the parameters and return values) * Crawling over the MSDN online library (automaticly or manualy)

Is there any better way for getting the names and types for windows API's and my libraries in runtime in c#?

Upvotes: 4

Views: 3962

Answers (2)

Ira Baxter
Ira Baxter

Reputation: 95430

Parsing C (even "just" headers) is hard; the language is more complex than people remember, and then there's the preprocessor, and finally the problem of doing something with the parse. C++ includes essentially all of C, and with C++11 here the problem is even worse.

People can often hack a 98% solution for a limited set of inputs, often with regexes in Perl or some other string hackery. If that works for you, then fine. Usually what happens is that 2% causes the hacked parser to choke or to produce the wrong answer, and then you get to debug the result and hand hack the 98% solution output.

Hacked solutions tend to fail pretty badly on real header files, which seem to concentrate weirdness in macros and conditionals (sometimes even to the point of mixing different dialects of C and C++ in the conditional arms). See a typical Microsoft .h file as an example. This appears to be what OP wants to process. Preprocessing gets rid of part of the problem, and now you get to encounter the real complexity of C and/or C++. You won't get a 98% solution for real header files even with preprocessing; you need typedefs and therefore name and type resolution, too. You might "parse" FOO X; that tells you that X is of type FOO... oops, what's that? Only a symbol table knows for sure.

GCCXML does all this preprocessing, parsing, and symbol table construction ... for the GCC dialect of C. Microsoft's dialect is different, and I don't think GCCXML can handle it.

A more general tool is our DMS Software Reengineering Toolkit, with its C front end; there's also a C++ front end (yes, they're different; C and C++ aren't the same language by a long shot). These process a wide variety of C dialects (both MS and GCC when configured properly), does macro/conditional expansion, builds an AST and a symbol table (does that name and type resolution stuff correctly).

You can add customization to extract the information you want, by crawling over the symbol table structures produced. You'll have to export what you want to C# (e.g. generate your C# classes), since DMS isn't implemented in a .net language.

Upvotes: 4

Marco van de Voort
Marco van de Voort

Reputation: 26401

In the most general case, header files are only usable, not convertable.

This due the possibility of preprocessor (#define) use of macros, fragments of structures constants etc which only get meaning when used in context.

Examples

  • anything with ## in macros

or 

//header
#define mystructconstant "bla","bla"

// in using .c
char test[10][2] ={mystructconstant};

but you can't simply discard all macros, since then you won't process the very common calling convention macros

etc etc.

So header parsing and conversion is mostly only possible for semi automated use (manually run cleaned up headers through it) or for reasonably clean and consistent headers (like e.g. the older MS SDK headers)

Since the general case is so hard, there isn't much readily available. Everybody crafts something quick and dirty for its own headers.

The only more general tool that I know is SWIG.

Upvotes: 0

Related Questions