about a MSXBASIC compiler?

I think you need to use a stack for the FOR statements. Then when you call NEXT you'll go from the top of the stack to the bottom and search for a match to the argument of the NEXT statement.
When you find a match you'll just discard any more recent entries in the stack.

For example if you do:

10 FORI=1TO5
20 FORJ=1TO10
30 PRINTJ;
40 IFJ=2THENNEXTIELSENEXT
50 NEXTJ

This program will (I think) print:

1212121212

and get a NEXT without FOR error on line 50 because the FORJ is removed from the FOR stack by the NEXTI call

OK. I've already tought to use a stack. to improve the speed i do not create a highlevel-sw implemented stack, but instead i try to use at max the processor support (its stack).

The same applies to gosub return (what kind of orrible thing... )

THIS MEANS: if the programmer is a beast that do things like jumping into gosub blocks without gosub, or use a for next loop like the above, if the program works correctly in msxbasic, also (i hope) run in it's compiled form. However, with those orrible things (like the above), if this doesn't work 100% correctly or crash, i think would be a great thing to learn programming and rewrite some parts in a much more cleaner way

So, do not expect things like array index checks, gosub without return checks, and so on... If you want those , stay in msxbasic, please. My goal is to achieve efficiency.

Another thing to keep in mind is that you can't directly translate

FOR I=1 to 5

to

for (i = 1; i <=5; i++)

because there isn't a direct mapping between c-types and Basic types. In Basic you need to have the types runtime changable, for example:

10 DEFSTRA-Z
20 A="Value: "
30 PRINT A
40 DEFINTA-Z
50 PRINT A

will output:

Value: 0

Would be easier to implement "newer" BASIC statements?
Like the While , Case , Do While ...

In the MSX-BASIC specific case, is this one of the implementations that is possible to re-adjust the value of the variable that control the loop? Some old BASIC program will use this feature for controlling the loop simulating a "Do While" statement. Not every interpreter will handle this as a correct manner ...

In my first implementation I used a processor based stack pointer, however it soon became rather unmanagable due to ints, floats and strings all being differing sizes. So in the redesign I opted for basic software stack with each stack entry using 6 bytes, and had intended to speed this up (if I hadn't canned the whole project) using alignment at a later stage.

TBH I'm rather interested to see how you convert expressions etc to z80, as I admittedly no idea how a modern compiler would do it. I opted for the

LD Whatever
Call FetchInt
LD Somethingelse
Call FetchFloat
Call Add
LD ResultVar
Call StoreFloat.

Which is seemingly dozens times faster than MSX basic but still nowhere near what a hand written piece of code would be.

In my first implementation I used a processor based stack pointer, however it soon became rather unmanagable due to ints, floats and strings all being differing sizes. So in the redesign I opted for basic software stack with each stack entry using 6 bytes, and had intended to speed this up (if I hadn't canned the whole project) using alignment at a later stage.

TBH I'm rather interested to see how you convert expressions etc to z80, as I admittedly no idea how a modern compiler would do it. I opted for the

LD Whatever
Call FetchInt
LD Somethingelse
Call FetchFloat
Call Add
LD ResultVar
Call StoreFloat.

Which is seemingly dozens times faster than MSX basic but still nowhere near what a hand written piece of code would be.

hey!, this is similar of what does virtual machine do. a stack based schema for compute expressions. Like java and M$ CLR do.

(Really when the jitter emit the code those stack based architecure turn into register based one....)