CODEWITHSUNDEEP
c++cparsinggcc
zeitue
zeitue

Reputation: 1683

gcc for parsing code

I would like to know how to use GCC as a library to parse C/C++/Java/Objective C/Ada code for my program. I want to bypass prepocessing and prefix all the functions that are user written with a prefix My. like so Print(); becomes MyPrint(); I also wish to do this with the variables.

Upvotes: 6

Views: 5195

Answers (6)

fghj
fghj

Reputation: 9394

You can look here:
http://codesynthesis.com/~boris/blog/2010/05/03/parsing-cxx-with-gcc-plugin-part-1/

This is description of how to use gcc plugin interface to parse C++ code. Other language should be handled in the same manner.

Also you can try pork from mozilla:
https://wiki.mozilla.org/Pork

When I tried it (pork), I spend hour or so to fix compile problems, but then I can write scripts like this:

rewrite SyncPrimitiveUpgrade {
  type PRLock* => Mutex*
  call PR_NewLock() => new Mutex()
  call PR_Lock(lock) => lock->Lock()
  call PR_Unlock(lock) => lock->Unlock()
  call PR_DestroyLock(lock) => delete lock
}

so it found all type PRLock and replate it with Mutex, also it search call of functions like PR_NewLock and replace it with "new Mutex".

Upvotes: 4

Necrolis
Necrolis

Reputation: 26171

forget about GCC, its made as a compiler's parser, not an analysis parser, you'd do way better using something like libclang, a C interface to clang, which can process both C & C++

Upvotes: 2

Ira Baxter
Ira Baxter

Reputation: 95324

Our DMS Software Reengineering Toolkit can parse C, C++, Java and Ada code (not Objective C at this time) in a wide variety of dialects and carry out transformations on the code. DMS's C and C++ front ends include a preprocessor, so you can you can cause preprocessing before you parse.

I'm probably don't understand what you want to do, because it seems strange to rename every function and (global?) variable with a "My...." prefix. But you could do that with some DMS rules (a rough sketch of renames of user functions for GCC3:

domain C~GCC3.

rule rewrite_function_names(t: type_designator, i: IDENTIFIER, p: parameter_list, s: statements):
      function_header->functionheader
"\t \i(\p) { \s } " -> "\t \renamed\(\i\) (\p) { \s }" ;

and a helper function "renames" that takes a tree node containing an identifer, and returns a tree node with the renamed identifier.

Because DMS patterns only match against the parse trees, you won't get any false positives.

You'd need some additional patterns to handle various different syntax cases within each langauge (e.g, for C, "void" return type, because "void" isn't a type designator in the syntax, and global variable declarations), and different rules for different languages (Ada's syntax is not the same as that of C).

This might seem like big hammer for your task, but if you really insist on doing this for a variety of languages in a reliable way, it seems hard to avoid the problem of getting decent parsers for all those languages. (And if you are really going to do this for all these languages, DMS can be taught to handle ObjectiveC the same we we have taught it to handle the other langauges).

Your alternative is some kind of string hacking solution, which might work 95% of the time. If you can live with that, then Perl or something similar is likely your answer.

Upvotes: 2

Basile Starynkevitch
Basile Starynkevitch

Reputation: 1

First, GCC is not a library, and is not structured to be one (in contrast to LLVM).

Why (i.e. what for) do you want to parse C, C++, Ada source code?

I would consider (assuming a GCC 4.6 version) extending GCC either thru plugins written in C, or preferably using MELT, a high level domain specific language to extend GCC (disclaimer: I am the main author of MELT).

But using GCC as a library is not realistic at all.

I really think that for what you want to achieve, MELT is the right tool. However, it is poorly documented. Please use the [email protected] list to ask questions.

And be aware that extending GCC does take some amount of work (more than a week perhaps), because you need to partly understand the GCC internal representations.

Upvotes: 2

undur_gongor
undur_gongor

Reputation: 15954

For C, you cannot do that reliably. If you skip preprocessing you will -- in general -- not have valid C code to be parsed. E.g.

#define FOO
#define BAR
#define BAZ

FOO void BAR qux BAZ(void) { }

How is the parser supposed to recognize this a function definition of qux without doing the preprocessing?

Upvotes: 2

sarnold
sarnold

Reputation: 104020

You might wish to investigate the sparse C parser. It understands a lot of C (all the C used in the Linux kernel sources, which is a fairly good subset of legal ANSI-C and GNU-C extensions) and provides a few sample compiler backends to provide a lint-like static analysis tool for type checking.

While the code looks very clean and thorough, your task might be easier done via another mechanism -- the example.c included with the sparse source that demonstrates a compiler is 1955 lines long.

Upvotes: 2

Related Questions