C structure analyzer ("Reflection" in C?)

Hi,
        I'm dealing with a 3rd party API (The Eurex exchange "Values" API)
that uses a large number of C structures. The exchange supplies C
header files that describe structures which define the format of the
input and output messages. These header files provide structures that
define the message format of blocks of bytes that are sent to, and
received from, the exchange.


        Does anybody know of a tool that I could use that converts the C
structure definitions into some other source file that has each data
member name, byte offset, size etc so that I could make a program to
dynamically compose these "structures"?


        For example, if it had been done entirely in Java, then I could
use "Reflection" to analyse the methods and properties and create a
dynamic interface.


        The annoying thing is, I know that somewhere in VC++ it has all
of this and more because you can browse all of the data structures in
a program from within the debugger.


        Does anyone know of a way to get VC++ to dump this information
into some sort of "C source" file that can be included elsewhere?


        My ideal is to be able allow the user to edit the structures
dynamically and then have my program use the information to package up
the resultant data so that it can be sent to the exchange...


        Ideally, I give this hypothetical program this:


        #include <eucb_fieldsizes.h> // Defines PASSWORD_LEN, LOGIN_LEN,
REQUEST_ID_LEN etc.
        struct Authorization {
                char password[PASSWORD_LEN];
                char login[LOGIN_LEN];
        };


        struct Message {
                char request_id[REQUEST_ID_LEN];
                Authorization authorization_data;
        };






        And it generates something like this:








        struct datainfo {
                      const char *name;
                      const char *member;
                      const char *member_type;
                      int offset_in_bytes,
                      int size_in_bytes
        };


        // P is parent structure type
        // F is the first member name
        // M is member name for the offset
        // T is the type of the member
        #define OFFSET(P,F,M) ((unsigned long)&((P*)0)->M) - ((unsigned
long)&((P*)->F)


        #define SIZEOF(P,M) (unsigned long)sizeof(((P*)0)->M))


        #define FIELD(P,M,T,F) #P,#M,#T,OFFSET(P,F,M), SIZEOF(P,M)


        struct datainfo all_structures[] = {
                FIELD(Message,request_id,CHAR,request_id,request_id),
                FIELD(Message,authorization_data,Authorization,request_id),
                FIELD(Authorization,password,CHAR,password),
                FIELD(Authorization,login,CHAR,password)
        }




        which after the preprocessor is done would look like:




        struct datainfo all_structures[] = {
                "Message", "request_id", "CHAR", 0, 10,
                "Message", "authorization_data", "Authorization", 10, 20,
                "Authorization", "password", "CHAR", 0, 10,
                "Authorization", "login", "CHAR", 10, 10
        };


        The use of the macros etc. would mean that implicit alignments made
by the compiler would also have the desired effect.


        I could run the header files through this program, generate an
"all_structures.h" file that I could include, and then my program can
dynamically use the structures instead...


        OK, I hope you get the idea...


        The C Exploration Tools (CXT:
http://providenet.softseek.com/Programming/C/Review_17840_index.shtml
) comes close, and I could probably muck around about with perl to
take it's output with various options and generate what I want - but
maybe somebody knows of a better, more direct solution...

Return to the comp.compilers page.
Search the comp.compilers archives again.