Typical C with C Preprocessor refactoring

Question

Hi,

I'm working on a refactoring tool for C with preprocessor support... I don't know the kind of refactoring involved in large C projects and I would like to know what people actually do when refactoring C code (and preprocessor directives)

I'd like to know also if some features that would be really interesting are not present in any tool and so the refactoring has to be done completely manually... I've seen for instance that Xref could not refactor macros that are used as iterators (don't know exactly what that means though)...

thanks

Answer 1

For C:

• Parameters to struct
• Extract function / Extract Macro

For C++:

• Generating a class template from a class and type(s) would be nice.

Good luck. Refactoring C/C++ sounds painful.

Answer 2

I will tell you honestly that there are no good tools for refactoring C++ like there are for Java. Most of it will be painful search and replace, but this depends on the actual task. Look at Netbeans and Eclipse C++ plugins.

I've seen for instance that Xref could not refactor macros that are used as iterators (don't know exactly what that means though)

To be honest, you might be in over your head - consider if you are the right person for this task.

Answer 3

Huge topic!

• The stuff I need to clean up is contorted nests of #ifdefs. A refactoring tool would understand when conditional stuff appears in argument lists (function declaration or definitions), and improve that.

• If it was really good, it would recognize that

  #if defined(SysA) || defined(SysB) || ... || defined(SysJ)
  

  was really equivalent to:

  #if !defined(SysK) && !defined(SysL)
  

  If you managed that, I'd be amazed.

• It would allow me to specify 'this macro is now defined - which code is visible' (meaning, visible to the compiler); it would also allow me to choose to see the code that is invisible.

• It would handle a system spread across over 100 top-level directories, with varying levels of sub-directories under those. It would handle tens of thousands of files, with lengths of 20K lines in places.

• It would identify where macro definitions come from makefiles instead of header files (aargh!).

Answer 4

Macros can often get quite complex, so I wouldn't try supporting much more than simple renaming.

Answer 5

If you can handle reliable renaming of various types, variables and macros over a big project with an arbitrarily complex directory hierarchy, I want to use your product.

Answer 6

Well, since it is part of the preprocessor... #include refactoring is a huge huge topic and I'm not aware of any tools that do it really well.

Trivial problems a tool could tackle:

• Enforcing consistent case and backslash usage in #includes
• Enforce a consistent header guarding convention, automatically add redundant external guards, etc.

Harder problems a tool could tackle:

• Finding and removing spurious includes.
• Suggest the use of predeclarations wherever practical.

For macros... perhaps some sort of scoping would be interesting, where if you #define a macro inside a block, the tool would automatically #undef it at the end of a block. Other quick things I can think of:

• A quick analysis on macro safety could be helpful as a lot of people still don't know to use do { } while (0) and other techniques.
• Alternately, find and flag spots where expressions with side-effects are passed as macro arguments. This could possibly be really helpful for things like... asserts with unintentional side-effects.

Answer 7

Anybody interested in this (specific to C), might want to take a look at the coccinelle tool:

Coccinelle is a program matching and transformation engine which provides the language SmPL (Semantic Patch Language) for specifying desired matches and transformations in C code. Coccinelle was initially targeted towards performing collateral evolutions in Linux. Such evolutions comprise the changes that are needed in client code in response to evolutions in library APIs, and may include modifications such as renaming a function, adding a function argument whose value is somehow context-dependent, and reorganizing a data structure. Beyond collateral evolutions, Coccinelle is successfully used (by us and others) for finding and fixing bugs in systems code.