Hello, I would like to suggest that in the future you pay more attention to backwards computability. There have been at least 4 instances where you broke the compiler with regard to being able to compile legacy code. I have > 500K lines of older code which works perfectly well and should not be impacted by what I regard as cosmetic changes to the allowed syntax. The main reason I choose to use gcc was that I didn't have to worry about different compilers doing different things and allowing or disallowing different syntax options.
Many of these incompatibilities have had to do with the treatment of static subroutines. The latest break down (whose inability to be backwards compatible is apparently due to unit-at-a-time-mode) is not allowing static declarations of functions within the module where the function is used. I have no objection to making things like this result in new warnings, as long as I can turn the warning off if I want, but making them result in errors is absolutely wrong. This is the third time you have done this with static functions, each time making the most expedient path to a solution stop working. Another instance had to do with disallowing extra text in # directives. Frankly, I don't care what standards say is no longer acceptable syntax. If I have something that works, I expect it to continue to work. What's next? Are you going to start imposing your source code formatting standards? Stop emulating Microsoft, who has little regard for maintaining backwards computability and start emulating Sun who is generally very good at this. Regards, George White
