Can't set BP in middle of line

[Michelle Long]

On Tuesday, 20 November 2018 at 15:11:56 UTC, Stefan Koch wrote:
> On Sunday, 4 November 2018 at 21:17:32 UTC, Michelle Long wrote:
>> On Sunday, 4 November 2018 at 08:27:34 UTC, Rainer Schuetze 
>> wrote:
>>> [...]
>>
>>
>> Is it then possible to simply split a line internally to 
>> handle it?
>>
>> [...]
>
> Debug information is mapped to machine-code on a source line by 
> source line basis.
>
> Therefore it's indeed nontrivial to do this.


Why would that be non-trivial?

semantically there is nothing different between

statement; statement;

and

statement;
statement;

to say that there is a difference to the compiler is not true.

To say it is non-trivial does not mean it is. You have to at 
least prove it with some reasonable logic because the facts do 
not support your claim.


Whatever mapping takes place, one just needs to propagate the 
column info along with the line. It may be non-trivial to 
implement in the compiler because of the design, but it is not a 
hard problem, in fact, it should be quite easy.


In fact, if the compiler simply broke every statement in to it's 
own line, by adding a new line to each statement(after every `;`) 
and memorized that mapping then it could be inverted to get the 
desired behavior... that is almost a trivial solution, so to say 
it is non-trivial simply does not jive and you will have to be 
more specific why.

For example, one could write a pre-parser that records the line 
and column mapping of statements, converts all multi-statement 
lines into multi-line statements. Compile, then unmap whatever 
the compiler says:

statement1; statement2; statement3;

Record line/col

0/0 0/12 0/24

convert

statement1;
statement2;
statement3;

0/0
1/0
2/0

map

0/0 -> 0/0
0/12 -> 1/0
0/24 -> 2/0

Then the mapping can be inverted after compilation.

E.g., If there is an error on line 2 it is looked up in the 
mapping

2/0 -> 0/24.

And so the error is actually at line 0/24 in the original 
sort(before newlines added).

It's quite simple. So you are simply wrong. One could write such 
a preprocessor and get the mapping and such and it would work 
fine. All it would require is to properly parse D code code to 
get the end of statements ';', insert a new line, and determine 
the mapping and for the debugger then to invert the map when line 
info is presented.

Because it is trivial to do, except for the D language 
processing(which the dmd parser should handle without problem and 
why it could be done in dmd transparently pre and post), it 
probably should be looked in to.

It's easy to say something is true or false... but it doesn't 
make it so. I've demonstrated a feasible solution.

Many people thought it was impossible to do X and they were 
proven wrong. Have you learned your lesson? We can at least then 
spend the time in finding an optimal way to do this so we all 
benefit from it.