Because I also coded some stuff in AMOS on Amiga: How about optimised INCR and DECR commands for variables? This can be easyly optimised because Z80 knows INC and DEC commands, and variable=variable+1 is maybe much slower.
INCR variable incrases the value by one. This will be very handy, I think .

As mentioned on WOS:
A idea for the future version: How about the compiler generating a text file with memory map (not very complex... or with selectable level of detail) I think, something like:
25000-45678 : Main Program
45679-52111 : ASM: Label GRAPHICSDATA
52112-59876 : ASM: Label LevelData
59877-60521 : Variables
or:
25000 : Main Program
45679 : ASM: Label GRAPHICSDATA
52112 : ASM: Label LevelData
59877 : Variables
Level of Detail:
0=Only Program and Variables
1=like 0, but additionaly ASM Labels
2=like 1, but additionaly Basic Labels
3=like 2, but adresses of every used variable added (HiSoft Basic Compiler does this too, this will make it easier to alter or read variables of compiled programs from BASIC Loader for example)

Using a switch like -m level, -M "Filename.txt" or similar (I do not know how the parser works, maybe this can be joined into a single switch)
Memory map can then be parsed by the editor, or the user can check the details.

Hi Boriel,

Changes from Version 1.1.7 to 1.1.9

• ! Fixed a bug for constant string slicing, so
  "0909"(A TO B) now works. Thanks to britlion.
  
• ! Expanded grammar to allow something like "0909"(f)
  or "0909"() which are also allowed in Sinclair Basic. Thanks to britlion.
  
• ! When used expressions like "0909"(f) (like above) might corrupt
  HEAP memory, leading to a program crash. Fixed. Thanks, britlion
  
• ! Fixed a wrong number conversion (type CAST) from signed integers
  to floating point numbers which might cause wrong (random) results.
  
• ! '%' suffix was being ignored.
  
• ! Global string variables were not optimized unless declared
  with '$' suffix. Fixed.

• Bitwise instructions for AND, OR, XOR, NOT
  
• CLEAR to fill memory areas
  
• READ, DATA and RESTORE
  
• SAVE & LOAD

I was playing with some complex code from the "One Liners" stuff. The following program behaves completely differently in basic as opposed to going through the compiler. Actually, it crashes when run compiled. (I tried several different types for f and g). Oddly, at the first PLOT, there appears some other changes to the screen - a few bytes of corruption. Something weird is happening there. There are more brackets than I need - mostly in an attempt to make sure the math functions are coming out clearly. Try it in BASIN and then compile it.

I know the functions are unnecessarily complex. That's the nature of the one liner type code. Nonetheless, it ought to behave when compiled just like the interpreted version. Shouldn't it?

What's new since 1.1.4:

• + Added the ELSEIF construct to the IF THEN ELSE sentence
  
• + Added more optimizations in some jumps
  
• + Added the USR function (both for Strings and Floats). Yes, you can now use USR "a" to get the address of the UDG table (instead of PEEK Uinteger 23675), and also can do RANDOMIZE USR 40000 (if you want to call a legacy machine-code routine; other than that it's useless).
  
• * Optimized some print string generated code (now it's smaller)
  
• ! Fixed many optimization bugs (almost five). Thanks to LCD
  
• ! Fixed ChangeLog file
  
• - Internal refactored code (somewhat)
  
• ! BOLD and ITALIC could not be used as permament attributes,
  only as temporary ones. Now they are allowed as permament.
  
• * Some more syntax compatibility with Sinclair BASIC. Expressions
  like F$(5), F$() or F$(TO) are now allowed. So expressions like PRINT ;;; are.
  
• ! single PRINT sentences were not working (they should print a
  newline).
  
• * Minor grammar corrections.
  
• ! Using a suffix like '$' in a function declaration was being
  ignored. Now this also works ok.
  
• + Added suport for PRINT , (Thanks to britlion and LCD for the
  suggestions and bug detection)
  
• * Fixed a potential optimization bug for SHR and SHL

• Bitwise instructions for AND, OR, XOR, NOT
  
• CLEAR to fill memory areas
  
• READ, DATA and RESTORE
  
• SAVE & LOAD

There are lots of things in the compiler that are mentioned obliquely in changelogs.

Please - at least get the list of reserved words up to date so that we know something is there.

Please, document DIM! This keyword is used in so many different ways - to set types, to dimension arrays, to set constants and to block fill arrays with =>

We're a little in the dark generally - and willing to work with that - but I think I'd like to request documentation and examples for DIM be top of the pile!

Why does

Big issue: I notice print doesn't support commas.

Print "1","2" doesn't line up in columns. It won't even compile!

Print "1"+CHR$(6)+"2" does compile, but the print routine seems to ignore the tab.

I'm not sure how to work around this for spectrum programs that format text out in columns, or use commas to hop to the next line.



Optimization freak (I am. If I can save one assembler instruction, that's at least a byte saved!)

I notice that:

PRINT "1";
PRINT "2"

and PRINT "1";"2"

Produce exactly the same assembler code! Bravo. But

PRINT "1"+"2" is quite a lot shorter - the compiler sees it can combine the strings into one label.

Similarly:

PRINT INK1;"BLUE";INK 2;"RED"

is quite a lot longer in assembler than:

PRINT CHR$(16)+CHR$(1)+"BLUE"+CHR$(16)+CHR$(2)+"RED"

Your print routine parses both the above lines identically. The second, while far less decipherable to a human), to the compiler is a whole 14 bytes shorter in the assembler. Given how common print and combined color codes are in code, I suspect there is a notable size optimization that could be made in compiled code.


Off this post's topic:
The other one I noticed would be not storing a variable in a register if we don't need to: