An interesting Parser problem

We are planning to make an intelligent text editor (Why is not
important, we have to do it.)


The text editor would show declarations, definitions, function calls
etc in a logical grouping and would also support intelligent text
editing for eg. It would change the name of a variable "foo" in a
higher scope but other variables with same name "foo" in other scopes
present will not be affected. eg.


{ // higher scope
int foo;
foo = 1;
func (foo);


    { // lower scope
          int foo;
    }
}




So we need to construct a parse tree of the input. But after editing,
we want to conserve the comments and white space as much as possible
so that the user does not see drastic changes to original code.


One approach is to store to file name and offset information of each
token in the parse tree. During decompiling, text between two offsets
is copied as such from original file if its not edited. If edited,
then the new text is used.


So the first issue is to find the offset of each token in lex (yacc ?)
This should also handle if some include file construct like "include
abc.xyz" is encountered. In such a case, filename and offset from new
file should be returned. Is there any other tricky case possible ?

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