I believe there are ways to deduce where to put the semicolons. This can be deduced from the tokens that begins and ends lines.
Getting rid of semicolons is not that simple. For instance
procedure aproc(var a; d, e, f : Boolean);
when the entire statement is syntactically correct, it's not too hard to figure out where there should be a semicolon but, if there is a syntax error then it's a completely different story. For instance
procedure aproc(var a d, e, f : Boolean);
parameter "a" is in both cases untyped and if the semicolon is missing between the "a" and "d", most Pascal compilers don't even try to emit the correct error message because the resulting statement is syntactically ambiguous. "a" may be an untyped parameter, in which case there should be a semicolon between "a" and "d". if the problem is that the comma is missing, the compiler _assumes_ that "d" is a data type and says it expected a colon ":" (which is incorrect in this case since "d" is not a data type) when it could have easily been that the comma is the missing element.
For a preprocessor to have _some_ chance of accurately placing semicolons in the source, it would have to be a complete parser (one that would have to be _smarter_ than the one implemented in the compiler.) It would have to know that if "d" is a data type, either a colon between "a" and "d" or a semicolon after "a" are required. There is no way for the parser (no matter how smart it may be) to figure out which case is applicable because there isn't enough
auxiliary syntactic information in the statement to make the determination (without using type information.)
Your "semicolon paster" would end up declaring untyped parameters every time there is a comma missing between "var" parameters resulting in one parameter being untyped and the remainder being passed by value instead of reference and, the worst part is, the programmer would not have a clue that the missing comma resulted in a definition with a completely different meaning than what he/she intended.
And that doesn't include the additional problems caused by the possibility that the programmer forgot the "var" keyword (which is required to declare untyped parameter but not typed ones.)
It is also worth noting that while parsing Pascal is usually reasonably fast, your preprocessor, if it were a full parser, it would definitely result in perceptibly slower compile times.