I have some old software (in a language that's not dead but is dead to me ;-)) that implements a basic pattern-matching and -rewriting system for source
code. I am considering resurrecting this
code, translating it into a modern language, and open-sourcing the project as a refactoring power-tool. Before I go much further, I want to know if anything like this exists already (my google-fu is fanning air on this tonight).
Here's how it works:
the pattern-matching part matches source-code patterns spanning multiple lines of
code using a template with binding variables,
the pattern-rewriting part uses a template to rewrite the matched
code, inserting the contents of the bound variables from the matching template
matching and rewriting templates are associated (1:1) by a simple (unconditional) rewrite rule
the software operates on the abstract syntax tree (AST) of the input application, and outputs a modified AST which can then be regenerated into new source
code
for example, suppose we find a bunch of while-loops that really should be for-loops. The following template will match the while-loop pattern:
Template oldLoopPtrn
int @cnt@ = 0;
while (@cnt@ < @max@)
{
… @body@
++@cnt@;
}
End_Template
while the following template will specify the output rewrite pattern:
Template newLoopPtrn
for(int @cnt@ = 0; @cnt@ < @max@; @cnt@++)
{
@body@
}
End_Template
and a simple rule to associate them
Rule oldLoopPtrn --> newLoopPtrn
so
code that looks like this
int i=0;
while(i<arrlen)
{
printf("element %d: %f\n",i,arr[i]);
++i;
}
gets automatically rewritten to look like this
for(int i = 0; i < arrlen; i++)
{
printf("element %d: %f\n",i,arr[i]);
}
The closest thing I've seen like this is some of the code-refactoring tools, but they seem to be geared towards interactive rewriting of selected snippets, not wholesale automated changes.
I believe that this kind of tool could supercharge refactoring, and would work on multiple languages (even HTML/CSS). I also believe that converting and polishing the
code base would be a huge project that I simply cannot do alone in any reasonable amount of time.
So, anything like this out there already? If not, any obvious features (besides rewrite-rule conditions) to consider?
EDIT: The one feature of this system that I like very much is that the template patterns are fairly obvious and easy to read because they're written in the same language as the target source
code, not in some esoteric mutated regex/BNF format.
